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>
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 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 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
->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 memset(src_vq
, 0, sizeof(*src_vq
));
155 src_vq
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
156 src_vq
->io_modes
= VB2_MMAP
| VB2_USERPTR
;
157 src_vq
->drv_priv
= ctx
;
158 src_vq
->ops
= &g2d_qops
;
159 src_vq
->mem_ops
= &vb2_dma_contig_memops
;
160 src_vq
->buf_struct_size
= sizeof(struct v4l2_m2m_buffer
);
162 ret
= vb2_queue_init(src_vq
);
166 memset(dst_vq
, 0, sizeof(*dst_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
);
174 return vb2_queue_init(dst_vq
);
177 static int g2d_s_ctrl(struct v4l2_ctrl
*ctrl
)
179 struct g2d_ctx
*ctx
= container_of(ctrl
->handler
, struct g2d_ctx
,
182 case V4L2_CID_COLORFX
:
183 if (ctrl
->val
== V4L2_COLORFX_NEGATIVE
)
184 ctx
->rop
= ROP4_INVERT
;
186 ctx
->rop
= ROP4_COPY
;
188 v4l2_err(&ctx
->dev
->v4l2_dev
, "unknown control\n");
194 static const struct v4l2_ctrl_ops g2d_ctrl_ops
= {
195 .s_ctrl
= g2d_s_ctrl
,
198 int g2d_setup_ctrls(struct g2d_ctx
*ctx
)
200 struct g2d_dev
*dev
= ctx
->dev
;
202 v4l2_ctrl_handler_init(&ctx
->ctrl_handler
, 1);
203 if (ctx
->ctrl_handler
.error
) {
204 v4l2_err(&dev
->v4l2_dev
, "v4l2_ctrl_handler_init failed\n");
205 return ctx
->ctrl_handler
.error
;
208 v4l2_ctrl_new_std_menu(
212 V4L2_COLORFX_NEGATIVE
,
213 ~((1 << V4L2_COLORFX_NONE
) | (1 << V4L2_COLORFX_NEGATIVE
)),
216 if (ctx
->ctrl_handler
.error
) {
217 v4l2_err(&dev
->v4l2_dev
, "v4l2_ctrl_handler_init failed\n");
218 return ctx
->ctrl_handler
.error
;
224 static int g2d_open(struct file
*file
)
226 struct g2d_dev
*dev
= video_drvdata(file
);
227 struct g2d_ctx
*ctx
= NULL
;
230 ctx
= kzalloc(sizeof(*ctx
), GFP_KERNEL
);
234 /* Set default formats */
236 ctx
->out
= def_frame
;
238 ctx
->m2m_ctx
= v4l2_m2m_ctx_init(dev
->m2m_dev
, ctx
, &queue_init
);
239 if (IS_ERR(ctx
->m2m_ctx
)) {
240 ret
= PTR_ERR(ctx
->m2m_ctx
);
244 v4l2_fh_init(&ctx
->fh
, video_devdata(file
));
245 file
->private_data
= &ctx
->fh
;
246 v4l2_fh_add(&ctx
->fh
);
248 g2d_setup_ctrls(ctx
);
250 /* Write the default values to the ctx struct */
251 v4l2_ctrl_handler_setup(&ctx
->ctrl_handler
);
253 ctx
->fh
.ctrl_handler
= &ctx
->ctrl_handler
;
255 v4l2_info(&dev
->v4l2_dev
, "instance opened\n");
259 static int g2d_release(struct file
*file
)
261 struct g2d_dev
*dev
= video_drvdata(file
);
262 struct g2d_ctx
*ctx
= fh2ctx(file
->private_data
);
264 v4l2_ctrl_handler_free(&ctx
->ctrl_handler
);
265 v4l2_fh_del(&ctx
->fh
);
266 v4l2_fh_exit(&ctx
->fh
);
268 v4l2_info(&dev
->v4l2_dev
, "instance closed\n");
273 static int vidioc_querycap(struct file
*file
, void *priv
,
274 struct v4l2_capability
*cap
)
276 strncpy(cap
->driver
, G2D_NAME
, sizeof(cap
->driver
) - 1);
277 strncpy(cap
->card
, G2D_NAME
, sizeof(cap
->card
) - 1);
278 cap
->bus_info
[0] = 0;
279 cap
->version
= KERNEL_VERSION(1, 0, 0);
280 cap
->capabilities
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_VIDEO_OUTPUT
281 | V4L2_CAP_STREAMING
;
285 static int vidioc_enum_fmt(struct file
*file
, void *prv
, struct v4l2_fmtdesc
*f
)
288 if (f
->index
>= NUM_FORMATS
)
290 fmt
= &formats
[f
->index
];
291 f
->pixelformat
= fmt
->fourcc
;
292 strncpy(f
->description
, fmt
->name
, sizeof(f
->description
) - 1);
296 static int vidioc_g_fmt(struct file
*file
, void *prv
, struct v4l2_format
*f
)
298 struct g2d_ctx
*ctx
= prv
;
299 struct vb2_queue
*vq
;
300 struct g2d_frame
*frm
;
302 vq
= v4l2_m2m_get_vq(ctx
->m2m_ctx
, f
->type
);
305 frm
= get_frame(ctx
, f
->type
);
309 f
->fmt
.pix
.width
= frm
->width
;
310 f
->fmt
.pix
.height
= frm
->height
;
311 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
312 f
->fmt
.pix
.pixelformat
= frm
->fmt
->fourcc
;
313 f
->fmt
.pix
.bytesperline
= (frm
->width
* frm
->fmt
->depth
) >> 3;
314 f
->fmt
.pix
.sizeimage
= frm
->size
;
318 static int vidioc_try_fmt(struct file
*file
, void *prv
, struct v4l2_format
*f
)
321 enum v4l2_field
*field
;
327 field
= &f
->fmt
.pix
.field
;
328 if (*field
== V4L2_FIELD_ANY
)
329 *field
= V4L2_FIELD_NONE
;
330 else if (*field
!= V4L2_FIELD_NONE
)
333 if (f
->fmt
.pix
.width
> MAX_WIDTH
)
334 f
->fmt
.pix
.width
= MAX_WIDTH
;
335 if (f
->fmt
.pix
.height
> MAX_HEIGHT
)
336 f
->fmt
.pix
.height
= MAX_HEIGHT
;
338 if (f
->fmt
.pix
.width
< 1)
339 f
->fmt
.pix
.width
= 1;
340 if (f
->fmt
.pix
.height
< 1)
341 f
->fmt
.pix
.height
= 1;
343 f
->fmt
.pix
.bytesperline
= (f
->fmt
.pix
.width
* fmt
->depth
) >> 3;
344 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
348 static int vidioc_s_fmt(struct file
*file
, void *prv
, struct v4l2_format
*f
)
350 struct g2d_ctx
*ctx
= prv
;
351 struct g2d_dev
*dev
= ctx
->dev
;
352 struct vb2_queue
*vq
;
353 struct g2d_frame
*frm
;
357 /* Adjust all values accordingly to the hardware capabilities
358 * and chosen format. */
359 ret
= vidioc_try_fmt(file
, prv
, f
);
362 vq
= v4l2_m2m_get_vq(ctx
->m2m_ctx
, f
->type
);
363 if (vb2_is_busy(vq
)) {
364 v4l2_err(&dev
->v4l2_dev
, "queue (%d) bust\n", f
->type
);
367 frm
= get_frame(ctx
, f
->type
);
373 frm
->width
= f
->fmt
.pix
.width
;
374 frm
->height
= f
->fmt
.pix
.height
;
375 frm
->size
= f
->fmt
.pix
.sizeimage
;
376 /* Reset crop settings */
379 frm
->c_width
= frm
->width
;
380 frm
->c_height
= frm
->height
;
381 frm
->right
= frm
->width
;
382 frm
->bottom
= frm
->height
;
384 frm
->stride
= f
->fmt
.pix
.bytesperline
;
388 static unsigned int g2d_poll(struct file
*file
, struct poll_table_struct
*wait
)
390 struct g2d_ctx
*ctx
= fh2ctx(file
->private_data
);
391 return v4l2_m2m_poll(file
, ctx
->m2m_ctx
, wait
);
394 static int g2d_mmap(struct file
*file
, struct vm_area_struct
*vma
)
396 struct g2d_ctx
*ctx
= fh2ctx(file
->private_data
);
397 return v4l2_m2m_mmap(file
, ctx
->m2m_ctx
, vma
);
400 static int vidioc_reqbufs(struct file
*file
, void *priv
,
401 struct v4l2_requestbuffers
*reqbufs
)
403 struct g2d_ctx
*ctx
= priv
;
404 return v4l2_m2m_reqbufs(file
, ctx
->m2m_ctx
, reqbufs
);
407 static int vidioc_querybuf(struct file
*file
, void *priv
,
408 struct v4l2_buffer
*buf
)
410 struct g2d_ctx
*ctx
= priv
;
411 return v4l2_m2m_querybuf(file
, ctx
->m2m_ctx
, buf
);
414 static int vidioc_qbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*buf
)
416 struct g2d_ctx
*ctx
= priv
;
417 return v4l2_m2m_qbuf(file
, ctx
->m2m_ctx
, buf
);
420 static int vidioc_dqbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*buf
)
422 struct g2d_ctx
*ctx
= priv
;
423 return v4l2_m2m_dqbuf(file
, ctx
->m2m_ctx
, buf
);
427 static int vidioc_streamon(struct file
*file
, void *priv
,
428 enum v4l2_buf_type type
)
430 struct g2d_ctx
*ctx
= priv
;
431 return v4l2_m2m_streamon(file
, ctx
->m2m_ctx
, type
);
434 static int vidioc_streamoff(struct file
*file
, void *priv
,
435 enum v4l2_buf_type type
)
437 struct g2d_ctx
*ctx
= priv
;
438 return v4l2_m2m_streamoff(file
, ctx
->m2m_ctx
, type
);
441 static int vidioc_cropcap(struct file
*file
, void *priv
,
442 struct v4l2_cropcap
*cr
)
444 struct g2d_ctx
*ctx
= priv
;
447 f
= get_frame(ctx
, cr
->type
);
453 cr
->bounds
.width
= f
->width
;
454 cr
->bounds
.height
= f
->height
;
455 cr
->defrect
= cr
->bounds
;
459 static int vidioc_g_crop(struct file
*file
, void *prv
, struct v4l2_crop
*cr
)
461 struct g2d_ctx
*ctx
= prv
;
464 f
= get_frame(ctx
, cr
->type
);
468 cr
->c
.left
= f
->o_height
;
469 cr
->c
.top
= f
->o_width
;
470 cr
->c
.width
= f
->c_width
;
471 cr
->c
.height
= f
->c_height
;
475 static int vidioc_try_crop(struct file
*file
, void *prv
, struct v4l2_crop
*cr
)
477 struct g2d_ctx
*ctx
= prv
;
478 struct g2d_dev
*dev
= ctx
->dev
;
481 f
= get_frame(ctx
, cr
->type
);
485 if (cr
->c
.top
< 0 || cr
->c
.left
< 0) {
486 v4l2_err(&dev
->v4l2_dev
,
487 "doesn't support negative values for top & left\n");
494 static int vidioc_s_crop(struct file
*file
, void *prv
, struct v4l2_crop
*cr
)
496 struct g2d_ctx
*ctx
= prv
;
500 ret
= vidioc_try_crop(file
, prv
, cr
);
503 f
= get_frame(ctx
, cr
->type
);
507 f
->c_width
= cr
->c
.width
;
508 f
->c_height
= cr
->c
.height
;
509 f
->o_width
= cr
->c
.left
;
510 f
->o_height
= cr
->c
.top
;
511 f
->bottom
= f
->o_height
+ f
->c_height
;
512 f
->right
= f
->o_width
+ f
->c_width
;
516 static void g2d_lock(void *prv
)
518 struct g2d_ctx
*ctx
= prv
;
519 struct g2d_dev
*dev
= ctx
->dev
;
520 mutex_lock(&dev
->mutex
);
523 static void g2d_unlock(void *prv
)
525 struct g2d_ctx
*ctx
= prv
;
526 struct g2d_dev
*dev
= ctx
->dev
;
527 mutex_unlock(&dev
->mutex
);
530 static void job_abort(void *prv
)
532 struct g2d_ctx
*ctx
= prv
;
533 struct g2d_dev
*dev
= ctx
->dev
;
536 if (dev
->curr
== 0) /* No job currently running */
539 ret
= wait_event_timeout(dev
->irq_queue
,
541 msecs_to_jiffies(G2D_TIMEOUT
));
544 static void device_run(void *prv
)
546 struct g2d_ctx
*ctx
= prv
;
547 struct g2d_dev
*dev
= ctx
->dev
;
548 struct vb2_buffer
*src
, *dst
;
553 src
= v4l2_m2m_next_src_buf(ctx
->m2m_ctx
);
554 dst
= v4l2_m2m_next_dst_buf(ctx
->m2m_ctx
);
556 clk_enable(dev
->gate
);
559 g2d_set_src_size(dev
, &ctx
->in
);
560 g2d_set_src_addr(dev
, vb2_dma_contig_plane_dma_addr(src
, 0));
562 g2d_set_dst_size(dev
, &ctx
->out
);
563 g2d_set_dst_addr(dev
, vb2_dma_contig_plane_dma_addr(dst
, 0));
565 g2d_set_rop4(dev
, ctx
->rop
);
566 if (ctx
->in
.c_width
!= ctx
->out
.c_width
||
567 ctx
->in
.c_height
!= ctx
->out
.c_height
)
568 cmd
|= g2d_cmd_stretch(1);
569 g2d_set_cmd(dev
, cmd
);
573 static irqreturn_t
g2d_isr(int irq
, void *prv
)
575 struct g2d_dev
*dev
= prv
;
576 struct g2d_ctx
*ctx
= dev
->curr
;
577 struct vb2_buffer
*src
, *dst
;
580 clk_disable(dev
->gate
);
584 src
= v4l2_m2m_src_buf_remove(ctx
->m2m_ctx
);
585 dst
= v4l2_m2m_dst_buf_remove(ctx
->m2m_ctx
);
590 v4l2_m2m_buf_done(src
, VB2_BUF_STATE_DONE
);
591 v4l2_m2m_buf_done(dst
, VB2_BUF_STATE_DONE
);
592 v4l2_m2m_job_finish(dev
->m2m_dev
, ctx
->m2m_ctx
);
595 wake_up(&dev
->irq_queue
);
599 static const struct v4l2_file_operations g2d_fops
= {
600 .owner
= THIS_MODULE
,
602 .release
= g2d_release
,
604 .unlocked_ioctl
= video_ioctl2
,
608 static const struct v4l2_ioctl_ops g2d_ioctl_ops
= {
609 .vidioc_querycap
= vidioc_querycap
,
611 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt
,
612 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt
,
613 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt
,
614 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt
,
616 .vidioc_enum_fmt_vid_out
= vidioc_enum_fmt
,
617 .vidioc_g_fmt_vid_out
= vidioc_g_fmt
,
618 .vidioc_try_fmt_vid_out
= vidioc_try_fmt
,
619 .vidioc_s_fmt_vid_out
= vidioc_s_fmt
,
621 .vidioc_reqbufs
= vidioc_reqbufs
,
622 .vidioc_querybuf
= vidioc_querybuf
,
624 .vidioc_qbuf
= vidioc_qbuf
,
625 .vidioc_dqbuf
= vidioc_dqbuf
,
627 .vidioc_streamon
= vidioc_streamon
,
628 .vidioc_streamoff
= vidioc_streamoff
,
630 .vidioc_g_crop
= vidioc_g_crop
,
631 .vidioc_s_crop
= vidioc_s_crop
,
632 .vidioc_cropcap
= vidioc_cropcap
,
635 static struct video_device g2d_videodev
= {
638 .ioctl_ops
= &g2d_ioctl_ops
,
640 .release
= video_device_release
,
643 static struct v4l2_m2m_ops g2d_m2m_ops
= {
644 .device_run
= device_run
,
645 .job_abort
= job_abort
,
647 .unlock
= g2d_unlock
,
650 static int g2d_probe(struct platform_device
*pdev
)
653 struct video_device
*vfd
;
654 struct resource
*res
;
657 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
660 spin_lock_init(&dev
->irqlock
);
661 mutex_init(&dev
->mutex
);
662 atomic_set(&dev
->num_inst
, 0);
663 init_waitqueue_head(&dev
->irq_queue
);
665 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
667 dev_err(&pdev
->dev
, "failed to find registers\n");
672 dev
->res_regs
= request_mem_region(res
->start
, resource_size(res
),
673 dev_name(&pdev
->dev
));
675 if (!dev
->res_regs
) {
676 dev_err(&pdev
->dev
, "failed to obtain register region\n");
681 dev
->regs
= ioremap(res
->start
, resource_size(res
));
683 dev_err(&pdev
->dev
, "failed to map registers\n");
688 dev
->clk
= clk_get(&pdev
->dev
, "sclk_fimg2d");
689 if (IS_ERR_OR_NULL(dev
->clk
)) {
690 dev_err(&pdev
->dev
, "failed to get g2d clock\n");
695 dev
->gate
= clk_get(&pdev
->dev
, "fimg2d");
696 if (IS_ERR_OR_NULL(dev
->gate
)) {
697 dev_err(&pdev
->dev
, "failed to get g2d clock gate\n");
702 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
704 dev_err(&pdev
->dev
, "failed to find IRQ\n");
709 dev
->irq
= res
->start
;
711 ret
= request_irq(dev
->irq
, g2d_isr
, 0, pdev
->name
, dev
);
713 dev_err(&pdev
->dev
, "failed to install IRQ\n");
717 dev
->alloc_ctx
= vb2_dma_contig_init_ctx(&pdev
->dev
);
718 if (IS_ERR(dev
->alloc_ctx
)) {
719 ret
= PTR_ERR(dev
->alloc_ctx
);
723 ret
= v4l2_device_register(&pdev
->dev
, &dev
->v4l2_dev
);
725 goto alloc_ctx_cleanup
;
726 vfd
= video_device_alloc();
728 v4l2_err(&dev
->v4l2_dev
, "Failed to allocate video device\n");
733 vfd
->lock
= &dev
->mutex
;
734 ret
= video_register_device(vfd
, VFL_TYPE_GRABBER
, 0);
736 v4l2_err(&dev
->v4l2_dev
, "Failed to register video device\n");
739 video_set_drvdata(vfd
, dev
);
740 snprintf(vfd
->name
, sizeof(vfd
->name
), "%s", g2d_videodev
.name
);
742 v4l2_info(&dev
->v4l2_dev
, "device registered as /dev/video%d\n",
744 platform_set_drvdata(pdev
, dev
);
745 dev
->m2m_dev
= v4l2_m2m_init(&g2d_m2m_ops
);
746 if (IS_ERR(dev
->m2m_dev
)) {
747 v4l2_err(&dev
->v4l2_dev
, "Failed to init mem2mem device\n");
748 ret
= PTR_ERR(dev
->m2m_dev
);
749 goto unreg_video_dev
;
752 def_frame
.stride
= (def_frame
.width
* def_frame
.fmt
->depth
) >> 3;
757 video_unregister_device(dev
->vfd
);
759 video_device_release(vfd
);
761 v4l2_device_unregister(&dev
->v4l2_dev
);
763 vb2_dma_contig_cleanup_ctx(dev
->alloc_ctx
);
765 free_irq(dev
->irq
, dev
);
773 release_resource(dev
->res_regs
);
779 static int g2d_remove(struct platform_device
*pdev
)
781 struct g2d_dev
*dev
= (struct g2d_dev
*)platform_get_drvdata(pdev
);
783 v4l2_info(&dev
->v4l2_dev
, "Removing " G2D_NAME
);
784 v4l2_m2m_release(dev
->m2m_dev
);
785 video_unregister_device(dev
->vfd
);
786 v4l2_device_unregister(&dev
->v4l2_dev
);
787 vb2_dma_contig_cleanup_ctx(dev
->alloc_ctx
);
788 free_irq(dev
->irq
, dev
);
792 release_resource(dev
->res_regs
);
797 static struct platform_driver g2d_pdrv
= {
799 .remove
= g2d_remove
,
802 .owner
= THIS_MODULE
,
806 static void __exit
g2d_exit(void)
808 platform_driver_unregister(&g2d_pdrv
);
811 static int __init
g2d_init(void)
815 ret
= platform_driver_register(&g2d_pdrv
);
819 module_init(g2d_init
);
820 module_exit(g2d_exit
);
822 MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>");
823 MODULE_DESCRIPTION("S5P G2D 2d graphics accelerator driver");
824 MODULE_LICENSE("GPL");