1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/module.h>
14#include <linux/fs.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>
21#include <linux/of.h>
22
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>
29
30#include "g2d.h"
31#include "g2d-regs.h"
32
33#define fh2ctx(__fh) container_of(__fh, struct g2d_ctx, fh)
34
35static struct g2d_fmt formats[] = {
36 {
37 .name = "XRGB_8888",
38 .fourcc = V4L2_PIX_FMT_RGB32,
39 .depth = 32,
40 .hw = COLOR_MODE(ORDER_XRGB, MODE_XRGB_8888),
41 },
42 {
43 .name = "RGB_565",
44 .fourcc = V4L2_PIX_FMT_RGB565X,
45 .depth = 16,
46 .hw = COLOR_MODE(ORDER_XRGB, MODE_RGB_565),
47 },
48 {
49 .name = "XRGB_1555",
50 .fourcc = V4L2_PIX_FMT_RGB555X,
51 .depth = 16,
52 .hw = COLOR_MODE(ORDER_XRGB, MODE_XRGB_1555),
53 },
54 {
55 .name = "XRGB_4444",
56 .fourcc = V4L2_PIX_FMT_RGB444,
57 .depth = 16,
58 .hw = COLOR_MODE(ORDER_XRGB, MODE_XRGB_4444),
59 },
60 {
61 .name = "PACKED_RGB_888",
62 .fourcc = V4L2_PIX_FMT_RGB24,
63 .depth = 24,
64 .hw = COLOR_MODE(ORDER_XRGB, MODE_PACKED_RGB_888),
65 },
66};
67#define NUM_FORMATS ARRAY_SIZE(formats)
68
69static struct g2d_frame def_frame = {
70 .width = DEFAULT_WIDTH,
71 .height = DEFAULT_HEIGHT,
72 .c_width = DEFAULT_WIDTH,
73 .c_height = DEFAULT_HEIGHT,
74 .o_width = 0,
75 .o_height = 0,
76 .fmt = &formats[0],
77 .right = DEFAULT_WIDTH,
78 .bottom = DEFAULT_HEIGHT,
79};
80
81static struct g2d_fmt *find_fmt(struct v4l2_format *f)
82{
83 unsigned int i;
84 for (i = 0; i < NUM_FORMATS; i++) {
85 if (formats[i].fourcc == f->fmt.pix.pixelformat)
86 return &formats[i];
87 }
88 return NULL;
89}
90
91
92static struct g2d_frame *get_frame(struct g2d_ctx *ctx,
93 enum v4l2_buf_type type)
94{
95 switch (type) {
96 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
97 return &ctx->in;
98 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
99 return &ctx->out;
100 default:
101 return ERR_PTR(-EINVAL);
102 }
103}
104
105static 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[])
108{
109 struct g2d_ctx *ctx = vb2_get_drv_priv(vq);
110 struct g2d_frame *f = get_frame(ctx, vq->type);
111
112 if (IS_ERR(f))
113 return PTR_ERR(f);
114
115 sizes[0] = f->size;
116 *nplanes = 1;
117 alloc_ctxs[0] = ctx->dev->alloc_ctx;
118
119 if (*nbuffers == 0)
120 *nbuffers = 1;
121
122 return 0;
123}
124
125static int g2d_buf_prepare(struct vb2_buffer *vb)
126{
127 struct g2d_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
128 struct g2d_frame *f = get_frame(ctx, vb->vb2_queue->type);
129
130 if (IS_ERR(f))
131 return PTR_ERR(f);
132 vb2_set_plane_payload(vb, 0, f->size);
133 return 0;
134}
135
136static void g2d_buf_queue(struct vb2_buffer *vb)
137{
138 struct g2d_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
139 v4l2_m2m_buf_queue(ctx->m2m_ctx, vb);
140}
141
142
143static struct vb2_ops g2d_qops = {
144 .queue_setup = g2d_queue_setup,
145 .buf_prepare = g2d_buf_prepare,
146 .buf_queue = g2d_buf_queue,
147};
148
149static int queue_init(void *priv, struct vb2_queue *src_vq,
150 struct vb2_queue *dst_vq)
151{
152 struct g2d_ctx *ctx = priv;
153 int ret;
154
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);
161 src_vq->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_COPY;
162
163 ret = vb2_queue_init(src_vq);
164 if (ret)
165 return ret;
166
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_type = V4L2_BUF_FLAG_TIMESTAMP_COPY;
174
175 return vb2_queue_init(dst_vq);
176}
177
178static int g2d_s_ctrl(struct v4l2_ctrl *ctrl)
179{
180 struct g2d_ctx *ctx = container_of(ctrl->handler, struct g2d_ctx,
181 ctrl_handler);
182 unsigned long flags;
183
184 spin_lock_irqsave(&ctx->dev->ctrl_lock, flags);
185 switch (ctrl->id) {
186 case V4L2_CID_COLORFX:
187 if (ctrl->val == V4L2_COLORFX_NEGATIVE)
188 ctx->rop = ROP4_INVERT;
189 else
190 ctx->rop = ROP4_COPY;
191 break;
192
193 case V4L2_CID_HFLIP:
194 ctx->flip = ctx->ctrl_hflip->val | (ctx->ctrl_vflip->val << 1);
195 break;
196
197 }
198 spin_unlock_irqrestore(&ctx->dev->ctrl_lock, flags);
199 return 0;
200}
201
202static const struct v4l2_ctrl_ops g2d_ctrl_ops = {
203 .s_ctrl = g2d_s_ctrl,
204};
205
206static int g2d_setup_ctrls(struct g2d_ctx *ctx)
207{
208 struct g2d_dev *dev = ctx->dev;
209
210 v4l2_ctrl_handler_init(&ctx->ctrl_handler, 3);
211
212 ctx->ctrl_hflip = v4l2_ctrl_new_std(&ctx->ctrl_handler, &g2d_ctrl_ops,
213 V4L2_CID_HFLIP, 0, 1, 1, 0);
214
215 ctx->ctrl_vflip = v4l2_ctrl_new_std(&ctx->ctrl_handler, &g2d_ctrl_ops,
216 V4L2_CID_VFLIP, 0, 1, 1, 0);
217
218 v4l2_ctrl_new_std_menu(
219 &ctx->ctrl_handler,
220 &g2d_ctrl_ops,
221 V4L2_CID_COLORFX,
222 V4L2_COLORFX_NEGATIVE,
223 ~((1 << V4L2_COLORFX_NONE) | (1 << V4L2_COLORFX_NEGATIVE)),
224 V4L2_COLORFX_NONE);
225
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);
230 return err;
231 }
232
233 v4l2_ctrl_cluster(2, &ctx->ctrl_hflip);
234
235 return 0;
236}
237
238static int g2d_open(struct file *file)
239{
240 struct g2d_dev *dev = video_drvdata(file);
241 struct g2d_ctx *ctx = NULL;
242 int ret = 0;
243
244 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
245 if (!ctx)
246 return -ENOMEM;
247 ctx->dev = dev;
248
249 ctx->in = def_frame;
250 ctx->out = def_frame;
251
252 if (mutex_lock_interruptible(&dev->mutex)) {
253 kfree(ctx);
254 return -ERESTARTSYS;
255 }
256 ctx->m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev, ctx, &queue_init);
257 if (IS_ERR(ctx->m2m_ctx)) {
258 ret = PTR_ERR(ctx->m2m_ctx);
259 mutex_unlock(&dev->mutex);
260 kfree(ctx);
261 return ret;
262 }
263 v4l2_fh_init(&ctx->fh, video_devdata(file));
264 file->private_data = &ctx->fh;
265 v4l2_fh_add(&ctx->fh);
266
267 g2d_setup_ctrls(ctx);
268
269
270 v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
271
272 ctx->fh.ctrl_handler = &ctx->ctrl_handler;
273 mutex_unlock(&dev->mutex);
274
275 v4l2_info(&dev->v4l2_dev, "instance opened\n");
276 return 0;
277}
278
279static int g2d_release(struct file *file)
280{
281 struct g2d_dev *dev = video_drvdata(file);
282 struct g2d_ctx *ctx = fh2ctx(file->private_data);
283
284 v4l2_ctrl_handler_free(&ctx->ctrl_handler);
285 v4l2_fh_del(&ctx->fh);
286 v4l2_fh_exit(&ctx->fh);
287 kfree(ctx);
288 v4l2_info(&dev->v4l2_dev, "instance closed\n");
289 return 0;
290}
291
292
293static int vidioc_querycap(struct file *file, void *priv,
294 struct v4l2_capability *cap)
295{
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->version = KERNEL_VERSION(1, 0, 0);
300
301
302
303
304
305 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT |
306 V4L2_CAP_VIDEO_M2M | V4L2_CAP_STREAMING;
307 return 0;
308}
309
310static int vidioc_enum_fmt(struct file *file, void *prv, struct v4l2_fmtdesc *f)
311{
312 struct g2d_fmt *fmt;
313 if (f->index >= NUM_FORMATS)
314 return -EINVAL;
315 fmt = &formats[f->index];
316 f->pixelformat = fmt->fourcc;
317 strncpy(f->description, fmt->name, sizeof(f->description) - 1);
318 return 0;
319}
320
321static int vidioc_g_fmt(struct file *file, void *prv, struct v4l2_format *f)
322{
323 struct g2d_ctx *ctx = prv;
324 struct vb2_queue *vq;
325 struct g2d_frame *frm;
326
327 vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);
328 if (!vq)
329 return -EINVAL;
330 frm = get_frame(ctx, f->type);
331 if (IS_ERR(frm))
332 return PTR_ERR(frm);
333
334 f->fmt.pix.width = frm->width;
335 f->fmt.pix.height = frm->height;
336 f->fmt.pix.field = V4L2_FIELD_NONE;
337 f->fmt.pix.pixelformat = frm->fmt->fourcc;
338 f->fmt.pix.bytesperline = (frm->width * frm->fmt->depth) >> 3;
339 f->fmt.pix.sizeimage = frm->size;
340 return 0;
341}
342
343static int vidioc_try_fmt(struct file *file, void *prv, struct v4l2_format *f)
344{
345 struct g2d_fmt *fmt;
346 enum v4l2_field *field;
347
348 fmt = find_fmt(f);
349 if (!fmt)
350 return -EINVAL;
351
352 field = &f->fmt.pix.field;
353 if (*field == V4L2_FIELD_ANY)
354 *field = V4L2_FIELD_NONE;
355 else if (*field != V4L2_FIELD_NONE)
356 return -EINVAL;
357
358 if (f->fmt.pix.width > MAX_WIDTH)
359 f->fmt.pix.width = MAX_WIDTH;
360 if (f->fmt.pix.height > MAX_HEIGHT)
361 f->fmt.pix.height = MAX_HEIGHT;
362
363 if (f->fmt.pix.width < 1)
364 f->fmt.pix.width = 1;
365 if (f->fmt.pix.height < 1)
366 f->fmt.pix.height = 1;
367
368 f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
369 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
370 return 0;
371}
372
373static int vidioc_s_fmt(struct file *file, void *prv, struct v4l2_format *f)
374{
375 struct g2d_ctx *ctx = prv;
376 struct g2d_dev *dev = ctx->dev;
377 struct vb2_queue *vq;
378 struct g2d_frame *frm;
379 struct g2d_fmt *fmt;
380 int ret = 0;
381
382
383
384 ret = vidioc_try_fmt(file, prv, f);
385 if (ret)
386 return ret;
387 vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);
388 if (vb2_is_busy(vq)) {
389 v4l2_err(&dev->v4l2_dev, "queue (%d) bust\n", f->type);
390 return -EBUSY;
391 }
392 frm = get_frame(ctx, f->type);
393 if (IS_ERR(frm))
394 return PTR_ERR(frm);
395 fmt = find_fmt(f);
396 if (!fmt)
397 return -EINVAL;
398 frm->width = f->fmt.pix.width;
399 frm->height = f->fmt.pix.height;
400 frm->size = f->fmt.pix.sizeimage;
401
402 frm->o_width = 0;
403 frm->o_height = 0;
404 frm->c_width = frm->width;
405 frm->c_height = frm->height;
406 frm->right = frm->width;
407 frm->bottom = frm->height;
408 frm->fmt = fmt;
409 frm->stride = f->fmt.pix.bytesperline;
410 return 0;
411}
412
413static unsigned int g2d_poll(struct file *file, struct poll_table_struct *wait)
414{
415 struct g2d_ctx *ctx = fh2ctx(file->private_data);
416 struct g2d_dev *dev = ctx->dev;
417 unsigned int res;
418
419 mutex_lock(&dev->mutex);
420 res = v4l2_m2m_poll(file, ctx->m2m_ctx, wait);
421 mutex_unlock(&dev->mutex);
422 return res;
423}
424
425static int g2d_mmap(struct file *file, struct vm_area_struct *vma)
426{
427 struct g2d_ctx *ctx = fh2ctx(file->private_data);
428 struct g2d_dev *dev = ctx->dev;
429 int ret;
430
431 if (mutex_lock_interruptible(&dev->mutex))
432 return -ERESTARTSYS;
433 ret = v4l2_m2m_mmap(file, ctx->m2m_ctx, vma);
434 mutex_unlock(&dev->mutex);
435 return ret;
436}
437
438static int vidioc_reqbufs(struct file *file, void *priv,
439 struct v4l2_requestbuffers *reqbufs)
440{
441 struct g2d_ctx *ctx = priv;
442 return v4l2_m2m_reqbufs(file, ctx->m2m_ctx, reqbufs);
443}
444
445static int vidioc_querybuf(struct file *file, void *priv,
446 struct v4l2_buffer *buf)
447{
448 struct g2d_ctx *ctx = priv;
449 return v4l2_m2m_querybuf(file, ctx->m2m_ctx, buf);
450}
451
452static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
453{
454 struct g2d_ctx *ctx = priv;
455 return v4l2_m2m_qbuf(file, ctx->m2m_ctx, buf);
456}
457
458static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
459{
460 struct g2d_ctx *ctx = priv;
461 return v4l2_m2m_dqbuf(file, ctx->m2m_ctx, buf);
462}
463
464
465static int vidioc_streamon(struct file *file, void *priv,
466 enum v4l2_buf_type type)
467{
468 struct g2d_ctx *ctx = priv;
469 return v4l2_m2m_streamon(file, ctx->m2m_ctx, type);
470}
471
472static int vidioc_streamoff(struct file *file, void *priv,
473 enum v4l2_buf_type type)
474{
475 struct g2d_ctx *ctx = priv;
476 return v4l2_m2m_streamoff(file, ctx->m2m_ctx, type);
477}
478
479static int vidioc_cropcap(struct file *file, void *priv,
480 struct v4l2_cropcap *cr)
481{
482 struct g2d_ctx *ctx = priv;
483 struct g2d_frame *f;
484
485 f = get_frame(ctx, cr->type);
486 if (IS_ERR(f))
487 return PTR_ERR(f);
488
489 cr->bounds.left = 0;
490 cr->bounds.top = 0;
491 cr->bounds.width = f->width;
492 cr->bounds.height = f->height;
493 cr->defrect = cr->bounds;
494 return 0;
495}
496
497static int vidioc_g_crop(struct file *file, void *prv, struct v4l2_crop *cr)
498{
499 struct g2d_ctx *ctx = prv;
500 struct g2d_frame *f;
501
502 f = get_frame(ctx, cr->type);
503 if (IS_ERR(f))
504 return PTR_ERR(f);
505
506 cr->c.left = f->o_height;
507 cr->c.top = f->o_width;
508 cr->c.width = f->c_width;
509 cr->c.height = f->c_height;
510 return 0;
511}
512
513static int vidioc_try_crop(struct file *file, void *prv, const struct v4l2_crop *cr)
514{
515 struct g2d_ctx *ctx = prv;
516 struct g2d_dev *dev = ctx->dev;
517 struct g2d_frame *f;
518
519 f = get_frame(ctx, cr->type);
520 if (IS_ERR(f))
521 return PTR_ERR(f);
522
523 if (cr->c.top < 0 || cr->c.left < 0) {
524 v4l2_err(&dev->v4l2_dev,
525 "doesn't support negative values for top & left\n");
526 return -EINVAL;
527 }
528
529 return 0;
530}
531
532static int vidioc_s_crop(struct file *file, void *prv, const struct v4l2_crop *cr)
533{
534 struct g2d_ctx *ctx = prv;
535 struct g2d_frame *f;
536 int ret;
537
538 ret = vidioc_try_crop(file, prv, cr);
539 if (ret)
540 return ret;
541 f = get_frame(ctx, cr->type);
542 if (IS_ERR(f))
543 return PTR_ERR(f);
544
545 f->c_width = cr->c.width;
546 f->c_height = cr->c.height;
547 f->o_width = cr->c.left;
548 f->o_height = cr->c.top;
549 f->bottom = f->o_height + f->c_height;
550 f->right = f->o_width + f->c_width;
551 return 0;
552}
553
554static void g2d_lock(void *prv)
555{
556 struct g2d_ctx *ctx = prv;
557 struct g2d_dev *dev = ctx->dev;
558 mutex_lock(&dev->mutex);
559}
560
561static void g2d_unlock(void *prv)
562{
563 struct g2d_ctx *ctx = prv;
564 struct g2d_dev *dev = ctx->dev;
565 mutex_unlock(&dev->mutex);
566}
567
568static void job_abort(void *prv)
569{
570 struct g2d_ctx *ctx = prv;
571 struct g2d_dev *dev = ctx->dev;
572 int ret;
573
574 if (dev->curr == NULL)
575 return;
576
577 ret = wait_event_timeout(dev->irq_queue,
578 dev->curr == NULL,
579 msecs_to_jiffies(G2D_TIMEOUT));
580}
581
582static void device_run(void *prv)
583{
584 struct g2d_ctx *ctx = prv;
585 struct g2d_dev *dev = ctx->dev;
586 struct vb2_buffer *src, *dst;
587 unsigned long flags;
588 u32 cmd = 0;
589
590 dev->curr = ctx;
591
592 src = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
593 dst = v4l2_m2m_next_dst_buf(ctx->m2m_ctx);
594
595 clk_enable(dev->gate);
596 g2d_reset(dev);
597
598 spin_lock_irqsave(&dev->ctrl_lock, flags);
599
600 g2d_set_src_size(dev, &ctx->in);
601 g2d_set_src_addr(dev, vb2_dma_contig_plane_dma_addr(src, 0));
602
603 g2d_set_dst_size(dev, &ctx->out);
604 g2d_set_dst_addr(dev, vb2_dma_contig_plane_dma_addr(dst, 0));
605
606 g2d_set_rop4(dev, ctx->rop);
607 g2d_set_flip(dev, ctx->flip);
608
609 if (ctx->in.c_width != ctx->out.c_width ||
610 ctx->in.c_height != ctx->out.c_height) {
611 if (dev->variant->hw_rev == TYPE_G2D_3X)
612 cmd |= CMD_V3_ENABLE_STRETCH;
613 else
614 g2d_set_v41_stretch(dev, &ctx->in, &ctx->out);
615 }
616
617 g2d_set_cmd(dev, cmd);
618 g2d_start(dev);
619
620 spin_unlock_irqrestore(&dev->ctrl_lock, flags);
621}
622
623static irqreturn_t g2d_isr(int irq, void *prv)
624{
625 struct g2d_dev *dev = prv;
626 struct g2d_ctx *ctx = dev->curr;
627 struct vb2_buffer *src, *dst;
628
629 g2d_clear_int(dev);
630 clk_disable(dev->gate);
631
632 BUG_ON(ctx == NULL);
633
634 src = v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
635 dst = v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);
636
637 BUG_ON(src == NULL);
638 BUG_ON(dst == NULL);
639
640 dst->v4l2_buf.timecode = src->v4l2_buf.timecode;
641 dst->v4l2_buf.timestamp = src->v4l2_buf.timestamp;
642
643 v4l2_m2m_buf_done(src, VB2_BUF_STATE_DONE);
644 v4l2_m2m_buf_done(dst, VB2_BUF_STATE_DONE);
645 v4l2_m2m_job_finish(dev->m2m_dev, ctx->m2m_ctx);
646
647 dev->curr = NULL;
648 wake_up(&dev->irq_queue);
649 return IRQ_HANDLED;
650}
651
652static const struct v4l2_file_operations g2d_fops = {
653 .owner = THIS_MODULE,
654 .open = g2d_open,
655 .release = g2d_release,
656 .poll = g2d_poll,
657 .unlocked_ioctl = video_ioctl2,
658 .mmap = g2d_mmap,
659};
660
661static const struct v4l2_ioctl_ops g2d_ioctl_ops = {
662 .vidioc_querycap = vidioc_querycap,
663
664 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt,
665 .vidioc_g_fmt_vid_cap = vidioc_g_fmt,
666 .vidioc_try_fmt_vid_cap = vidioc_try_fmt,
667 .vidioc_s_fmt_vid_cap = vidioc_s_fmt,
668
669 .vidioc_enum_fmt_vid_out = vidioc_enum_fmt,
670 .vidioc_g_fmt_vid_out = vidioc_g_fmt,
671 .vidioc_try_fmt_vid_out = vidioc_try_fmt,
672 .vidioc_s_fmt_vid_out = vidioc_s_fmt,
673
674 .vidioc_reqbufs = vidioc_reqbufs,
675 .vidioc_querybuf = vidioc_querybuf,
676
677 .vidioc_qbuf = vidioc_qbuf,
678 .vidioc_dqbuf = vidioc_dqbuf,
679
680 .vidioc_streamon = vidioc_streamon,
681 .vidioc_streamoff = vidioc_streamoff,
682
683 .vidioc_g_crop = vidioc_g_crop,
684 .vidioc_s_crop = vidioc_s_crop,
685 .vidioc_cropcap = vidioc_cropcap,
686};
687
688static struct video_device g2d_videodev = {
689 .name = G2D_NAME,
690 .fops = &g2d_fops,
691 .ioctl_ops = &g2d_ioctl_ops,
692 .minor = -1,
693 .release = video_device_release,
694 .vfl_dir = VFL_DIR_M2M,
695};
696
697static struct v4l2_m2m_ops g2d_m2m_ops = {
698 .device_run = device_run,
699 .job_abort = job_abort,
700 .lock = g2d_lock,
701 .unlock = g2d_unlock,
702};
703
704static const struct of_device_id exynos_g2d_match[];
705
706static int g2d_probe(struct platform_device *pdev)
707{
708 struct g2d_dev *dev;
709 struct video_device *vfd;
710 struct resource *res;
711 const struct of_device_id *of_id;
712 int ret = 0;
713
714 dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
715 if (!dev)
716 return -ENOMEM;
717
718 spin_lock_init(&dev->ctrl_lock);
719 mutex_init(&dev->mutex);
720 atomic_set(&dev->num_inst, 0);
721 init_waitqueue_head(&dev->irq_queue);
722
723 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
724
725 dev->regs = devm_ioremap_resource(&pdev->dev, res);
726 if (IS_ERR(dev->regs))
727 return PTR_ERR(dev->regs);
728
729 dev->clk = clk_get(&pdev->dev, "sclk_fimg2d");
730 if (IS_ERR(dev->clk)) {
731 dev_err(&pdev->dev, "failed to get g2d clock\n");
732 return -ENXIO;
733 }
734
735 ret = clk_prepare(dev->clk);
736 if (ret) {
737 dev_err(&pdev->dev, "failed to prepare g2d clock\n");
738 goto put_clk;
739 }
740
741 dev->gate = clk_get(&pdev->dev, "fimg2d");
742 if (IS_ERR(dev->gate)) {
743 dev_err(&pdev->dev, "failed to get g2d clock gate\n");
744 ret = -ENXIO;
745 goto unprep_clk;
746 }
747
748 ret = clk_prepare(dev->gate);
749 if (ret) {
750 dev_err(&pdev->dev, "failed to prepare g2d clock gate\n");
751 goto put_clk_gate;
752 }
753
754 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
755 if (!res) {
756 dev_err(&pdev->dev, "failed to find IRQ\n");
757 ret = -ENXIO;
758 goto unprep_clk_gate;
759 }
760
761 dev->irq = res->start;
762
763 ret = devm_request_irq(&pdev->dev, dev->irq, g2d_isr,
764 0, pdev->name, dev);
765 if (ret) {
766 dev_err(&pdev->dev, "failed to install IRQ\n");
767 goto put_clk_gate;
768 }
769
770 dev->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
771 if (IS_ERR(dev->alloc_ctx)) {
772 ret = PTR_ERR(dev->alloc_ctx);
773 goto unprep_clk_gate;
774 }
775
776 ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
777 if (ret)
778 goto alloc_ctx_cleanup;
779 vfd = video_device_alloc();
780 if (!vfd) {
781 v4l2_err(&dev->v4l2_dev, "Failed to allocate video device\n");
782 ret = -ENOMEM;
783 goto unreg_v4l2_dev;
784 }
785 *vfd = g2d_videodev;
786 vfd->lock = &dev->mutex;
787 vfd->v4l2_dev = &dev->v4l2_dev;
788 ret = video_register_device(vfd, VFL_TYPE_GRABBER, 0);
789 if (ret) {
790 v4l2_err(&dev->v4l2_dev, "Failed to register video device\n");
791 goto rel_vdev;
792 }
793 video_set_drvdata(vfd, dev);
794 snprintf(vfd->name, sizeof(vfd->name), "%s", g2d_videodev.name);
795 dev->vfd = vfd;
796 v4l2_info(&dev->v4l2_dev, "device registered as /dev/video%d\n",
797 vfd->num);
798 platform_set_drvdata(pdev, dev);
799 dev->m2m_dev = v4l2_m2m_init(&g2d_m2m_ops);
800 if (IS_ERR(dev->m2m_dev)) {
801 v4l2_err(&dev->v4l2_dev, "Failed to init mem2mem device\n");
802 ret = PTR_ERR(dev->m2m_dev);
803 goto unreg_video_dev;
804 }
805
806 def_frame.stride = (def_frame.width * def_frame.fmt->depth) >> 3;
807
808 if (!pdev->dev.of_node) {
809 dev->variant = g2d_get_drv_data(pdev);
810 } else {
811 of_id = of_match_node(exynos_g2d_match, pdev->dev.of_node);
812 if (!of_id) {
813 ret = -ENODEV;
814 goto unreg_video_dev;
815 }
816 dev->variant = (struct g2d_variant *)of_id->data;
817 }
818
819 return 0;
820
821unreg_video_dev:
822 video_unregister_device(dev->vfd);
823rel_vdev:
824 video_device_release(vfd);
825unreg_v4l2_dev:
826 v4l2_device_unregister(&dev->v4l2_dev);
827alloc_ctx_cleanup:
828 vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);
829unprep_clk_gate:
830 clk_unprepare(dev->gate);
831put_clk_gate:
832 clk_put(dev->gate);
833unprep_clk:
834 clk_unprepare(dev->clk);
835put_clk:
836 clk_put(dev->clk);
837
838 return ret;
839}
840
841static int g2d_remove(struct platform_device *pdev)
842{
843 struct g2d_dev *dev = (struct g2d_dev *)platform_get_drvdata(pdev);
844
845 v4l2_info(&dev->v4l2_dev, "Removing " G2D_NAME);
846 v4l2_m2m_release(dev->m2m_dev);
847 video_unregister_device(dev->vfd);
848 v4l2_device_unregister(&dev->v4l2_dev);
849 vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);
850 clk_unprepare(dev->gate);
851 clk_put(dev->gate);
852 clk_unprepare(dev->clk);
853 clk_put(dev->clk);
854 return 0;
855}
856
857static struct g2d_variant g2d_drvdata_v3x = {
858 .hw_rev = TYPE_G2D_3X,
859};
860
861static struct g2d_variant g2d_drvdata_v4x = {
862 .hw_rev = TYPE_G2D_4X,
863};
864
865static const struct of_device_id exynos_g2d_match[] = {
866 {
867 .compatible = "samsung,s5pv210-g2d",
868 .data = &g2d_drvdata_v3x,
869 }, {
870 .compatible = "samsung,exynos4212-g2d",
871 .data = &g2d_drvdata_v4x,
872 },
873 {},
874};
875MODULE_DEVICE_TABLE(of, exynos_g2d_match);
876
877static struct platform_device_id g2d_driver_ids[] = {
878 {
879 .name = "s5p-g2d",
880 .driver_data = (unsigned long)&g2d_drvdata_v3x,
881 }, {
882 .name = "s5p-g2d-v4x",
883 .driver_data = (unsigned long)&g2d_drvdata_v4x,
884 },
885 {},
886};
887MODULE_DEVICE_TABLE(platform, g2d_driver_ids);
888
889static struct platform_driver g2d_pdrv = {
890 .probe = g2d_probe,
891 .remove = g2d_remove,
892 .id_table = g2d_driver_ids,
893 .driver = {
894 .name = G2D_NAME,
895 .owner = THIS_MODULE,
896 .of_match_table = exynos_g2d_match,
897 },
898};
899
900module_platform_driver(g2d_pdrv);
901
902MODULE_AUTHOR("Kamil Debski <k.debski@samsung.com>");
903MODULE_DESCRIPTION("S5P G2D 2d graphics accelerator driver");
904MODULE_LICENSE("GPL");
905
