Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
gsc-m2m.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2011 - 2012 Samsung Electronics Co., Ltd.
3  * http://www.samsung.com
4  *
5  * Samsung EXYNOS5 SoC series G-Scaler driver
6  *
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.
11  */
12 
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>
23 #include <linux/io.h>
24 #include <linux/slab.h>
25 #include <linux/clk.h>
26 
27 #include <media/v4l2-ioctl.h>
28 
29 #include "gsc-core.h"
30 
31 static int gsc_m2m_ctx_stop_req(struct gsc_ctx *ctx)
32 {
33  struct gsc_ctx *curr_ctx;
34  struct gsc_dev *gsc = ctx->gsc_dev;
35  int ret;
36 
37  curr_ctx = v4l2_m2m_get_curr_priv(gsc->m2m.m2m_dev);
38  if (!gsc_m2m_pending(gsc) || (curr_ctx != ctx))
39  return 0;
40 
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),
45 
46  return ret == 0 ? -ETIMEDOUT : ret;
47 }
48 
49 static int gsc_m2m_start_streaming(struct vb2_queue *q, unsigned int count)
50 {
51  struct gsc_ctx *ctx = q->drv_priv;
52  int ret;
53 
54  ret = pm_runtime_get_sync(&ctx->gsc_dev->pdev->dev);
55  return ret > 0 ? 0 : ret;
56 }
57 
58 static int gsc_m2m_stop_streaming(struct vb2_queue *q)
59 {
60  struct gsc_ctx *ctx = q->drv_priv;
61  int ret;
62 
63  ret = gsc_m2m_ctx_stop_req(ctx);
64  if (ret == -ETIMEDOUT)
66 
67  pm_runtime_put(&ctx->gsc_dev->pdev->dev);
68 
69  return 0;
70 }
71 
72 void gsc_m2m_job_finish(struct gsc_ctx *ctx, int vb_state)
73 {
74  struct vb2_buffer *src_vb, *dst_vb;
75 
76  if (!ctx || !ctx->m2m_ctx)
77  return;
78 
79  src_vb = v4l2_m2m_src_buf_remove(ctx->m2m_ctx);
80  dst_vb = v4l2_m2m_dst_buf_remove(ctx->m2m_ctx);
81 
82  if (src_vb && dst_vb) {
83  v4l2_m2m_buf_done(src_vb, vb_state);
84  v4l2_m2m_buf_done(dst_vb, vb_state);
85 
86  v4l2_m2m_job_finish(ctx->gsc_dev->m2m.m2m_dev,
87  ctx->m2m_ctx);
88  }
89 }
90 
91 
92 static void gsc_m2m_job_abort(void *priv)
93 {
94  struct gsc_ctx *ctx = priv;
95  int ret;
96 
97  ret = gsc_m2m_ctx_stop_req(ctx);
98  if (ret == -ETIMEDOUT)
100 }
101 
102 static int gsc_fill_addr(struct gsc_ctx *ctx)
103 {
104  struct gsc_frame *s_frame, *d_frame;
105  struct vb2_buffer *vb = NULL;
106  int ret;
107 
108  s_frame = &ctx->s_frame;
109  d_frame = &ctx->d_frame;
110 
111  vb = v4l2_m2m_next_src_buf(ctx->m2m_ctx);
112  ret = gsc_prepare_addr(ctx, vb, s_frame, &s_frame->addr);
113  if (ret)
114  return ret;
115 
116  vb = v4l2_m2m_next_dst_buf(ctx->m2m_ctx);
117  return gsc_prepare_addr(ctx, vb, d_frame, &d_frame->addr);
118 }
119 
120 static void gsc_m2m_device_run(void *priv)
121 {
122  struct gsc_ctx *ctx = priv;
123  struct gsc_dev *gsc;
124  unsigned long flags;
125  u32 ret;
126  bool is_set = false;
127 
128  if (WARN(!ctx, "null hardware context\n"))
129  return;
130 
131  gsc = ctx->gsc_dev;
132  spin_lock_irqsave(&gsc->slock, flags);
133 
134  set_bit(ST_M2M_PEND, &gsc->state);
135 
136  /* Reconfigure hardware if the context has changed. */
137  if (gsc->m2m.ctx != ctx) {
138  pr_debug("gsc->m2m.ctx = 0x%p, current_ctx = 0x%p",
139  gsc->m2m.ctx, ctx);
140  ctx->state |= GSC_PARAMS;
141  gsc->m2m.ctx = ctx;
142  }
143 
144  is_set = (ctx->state & GSC_CTX_STOP_REQ) ? 1 : 0;
145  ctx->state &= ~GSC_CTX_STOP_REQ;
146  if (is_set) {
147  wake_up(&gsc->irq_queue);
148  goto put_device;
149  }
150 
151  ret = gsc_fill_addr(ctx);
152  if (ret) {
153  pr_err("Wrong address");
154  goto put_device;
155  }
156 
157  gsc_set_prefbuf(gsc, &ctx->s_frame);
160 
161  if (ctx->state & GSC_PARAMS) {
164  gsc_hw_set_frm_done_irq_mask(gsc, false);
165  gsc_hw_set_gsc_irq_enable(gsc, true);
166 
167  if (gsc_set_scaler_info(ctx)) {
168  pr_err("Scaler setup error");
169  goto put_device;
170  }
171 
173  gsc_hw_set_in_size(ctx);
175 
177  gsc_hw_set_out_size(ctx);
179 
182  gsc_hw_set_rotation(ctx);
184  }
185 
186  /* update shadow registers */
188 
189  ctx->state &= ~GSC_PARAMS;
190  gsc_hw_enable_control(gsc, true);
191 
192  spin_unlock_irqrestore(&gsc->slock, flags);
193  return;
194 
195 put_device:
196  ctx->state &= ~GSC_PARAMS;
197  spin_unlock_irqrestore(&gsc->slock, flags);
198 }
199 
200 static int gsc_m2m_queue_setup(struct vb2_queue *vq,
201  const struct v4l2_format *fmt,
202  unsigned int *num_buffers, unsigned int *num_planes,
203  unsigned int sizes[], void *allocators[])
204 {
205  struct gsc_ctx *ctx = vb2_get_drv_priv(vq);
206  struct gsc_frame *frame;
207  int i;
208 
209  frame = ctx_get_frame(ctx, vq->type);
210  if (IS_ERR(frame))
211  return PTR_ERR(frame);
212 
213  if (!frame->fmt)
214  return -EINVAL;
215 
216  *num_planes = frame->fmt->num_planes;
217  for (i = 0; i < frame->fmt->num_planes; i++) {
218  sizes[i] = frame->payload[i];
219  allocators[i] = ctx->gsc_dev->alloc_ctx;
220  }
221  return 0;
222 }
223 
224 static int gsc_m2m_buf_prepare(struct vb2_buffer *vb)
225 {
226  struct gsc_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
227  struct gsc_frame *frame;
228  int i;
229 
230  frame = ctx_get_frame(ctx, vb->vb2_queue->type);
231  if (IS_ERR(frame))
232  return PTR_ERR(frame);
233 
234  if (!V4L2_TYPE_IS_OUTPUT(vb->vb2_queue->type)) {
235  for (i = 0; i < frame->fmt->num_planes; i++)
236  vb2_set_plane_payload(vb, i, frame->payload[i]);
237  }
238 
239  return 0;
240 }
241 
242 static void gsc_m2m_buf_queue(struct vb2_buffer *vb)
243 {
244  struct gsc_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
245 
246  pr_debug("ctx: %p, ctx->state: 0x%x", ctx, ctx->state);
247 
248  if (ctx->m2m_ctx)
249  v4l2_m2m_buf_queue(ctx->m2m_ctx, vb);
250 }
251 
252 static struct vb2_ops gsc_m2m_qops = {
253  .queue_setup = gsc_m2m_queue_setup,
254  .buf_prepare = gsc_m2m_buf_prepare,
255  .buf_queue = gsc_m2m_buf_queue,
256  .wait_prepare = gsc_unlock,
257  .wait_finish = gsc_lock,
258  .stop_streaming = gsc_m2m_stop_streaming,
259  .start_streaming = gsc_m2m_start_streaming,
260 };
261 
262 static int gsc_m2m_querycap(struct file *file, void *fh,
263  struct v4l2_capability *cap)
264 {
265  struct gsc_ctx *ctx = fh_to_ctx(fh);
266  struct gsc_dev *gsc = ctx->gsc_dev;
267 
268  strlcpy(cap->driver, gsc->pdev->name, sizeof(cap->driver));
269  strlcpy(cap->card, gsc->pdev->name, sizeof(cap->card));
270  strlcpy(cap->bus_info, "platform", sizeof(cap->bus_info));
273 
275  return 0;
276 }
277 
278 static int gsc_m2m_enum_fmt_mplane(struct file *file, void *priv,
279  struct v4l2_fmtdesc *f)
280 {
281  return gsc_enum_fmt_mplane(f);
282 }
283 
284 static int gsc_m2m_g_fmt_mplane(struct file *file, void *fh,
285  struct v4l2_format *f)
286 {
287  struct gsc_ctx *ctx = fh_to_ctx(fh);
288 
289  return gsc_g_fmt_mplane(ctx, f);
290 }
291 
292 static int gsc_m2m_try_fmt_mplane(struct file *file, void *fh,
293  struct v4l2_format *f)
294 {
295  struct gsc_ctx *ctx = fh_to_ctx(fh);
296 
297  return gsc_try_fmt_mplane(ctx, f);
298 }
299 
300 static int gsc_m2m_s_fmt_mplane(struct file *file, void *fh,
301  struct v4l2_format *f)
302 {
303  struct gsc_ctx *ctx = fh_to_ctx(fh);
304  struct vb2_queue *vq;
305  struct gsc_frame *frame;
306  struct v4l2_pix_format_mplane *pix;
307  int i, ret = 0;
308 
309  ret = gsc_m2m_try_fmt_mplane(file, fh, f);
310  if (ret)
311  return ret;
312 
313  vq = v4l2_m2m_get_vq(ctx->m2m_ctx, f->type);
314 
315  if (vb2_is_streaming(vq)) {
316  pr_err("queue (%d) busy", f->type);
317  return -EBUSY;
318  }
319 
320  if (V4L2_TYPE_IS_OUTPUT(f->type))
321  frame = &ctx->s_frame;
322  else
323  frame = &ctx->d_frame;
324 
325  pix = &f->fmt.pix_mp;
326  frame->fmt = find_fmt(&pix->pixelformat, NULL, 0);
327  frame->colorspace = pix->colorspace;
328  if (!frame->fmt)
329  return -EINVAL;
330 
331  for (i = 0; i < frame->fmt->num_planes; i++)
332  frame->payload[i] = pix->plane_fmt[i].sizeimage;
333 
334  gsc_set_frame_size(frame, pix->width, pix->height);
335 
337  gsc_ctx_state_lock_set(GSC_PARAMS | GSC_DST_FMT, ctx);
338  else
339  gsc_ctx_state_lock_set(GSC_PARAMS | GSC_SRC_FMT, ctx);
340 
341  pr_debug("f_w: %d, f_h: %d", frame->f_width, frame->f_height);
342 
343  return 0;
344 }
345 
346 static int gsc_m2m_reqbufs(struct file *file, void *fh,
347  struct v4l2_requestbuffers *reqbufs)
348 {
349  struct gsc_ctx *ctx = fh_to_ctx(fh);
350  struct gsc_dev *gsc = ctx->gsc_dev;
351  struct gsc_frame *frame;
352  u32 max_cnt;
353 
354  max_cnt = (reqbufs->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) ?
355  gsc->variant->in_buf_cnt : gsc->variant->out_buf_cnt;
356  if (reqbufs->count > max_cnt) {
357  return -EINVAL;
358  } else if (reqbufs->count == 0) {
359  if (reqbufs->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
360  gsc_ctx_state_lock_clear(GSC_SRC_FMT, ctx);
361  else
362  gsc_ctx_state_lock_clear(GSC_DST_FMT, ctx);
363  }
364 
365  frame = ctx_get_frame(ctx, reqbufs->type);
366 
367  return v4l2_m2m_reqbufs(file, ctx->m2m_ctx, reqbufs);
368 }
369 
370 static int gsc_m2m_querybuf(struct file *file, void *fh,
371  struct v4l2_buffer *buf)
372 {
373  struct gsc_ctx *ctx = fh_to_ctx(fh);
374  return v4l2_m2m_querybuf(file, ctx->m2m_ctx, buf);
375 }
376 
377 static int gsc_m2m_qbuf(struct file *file, void *fh,
378  struct v4l2_buffer *buf)
379 {
380  struct gsc_ctx *ctx = fh_to_ctx(fh);
381  return v4l2_m2m_qbuf(file, ctx->m2m_ctx, buf);
382 }
383 
384 static int gsc_m2m_dqbuf(struct file *file, void *fh,
385  struct v4l2_buffer *buf)
386 {
387  struct gsc_ctx *ctx = fh_to_ctx(fh);
388  return v4l2_m2m_dqbuf(file, ctx->m2m_ctx, buf);
389 }
390 
391 static int gsc_m2m_streamon(struct file *file, void *fh,
392  enum v4l2_buf_type type)
393 {
394  struct gsc_ctx *ctx = fh_to_ctx(fh);
395 
396  /* The source and target color format need to be set */
397  if (V4L2_TYPE_IS_OUTPUT(type)) {
398  if (!gsc_ctx_state_is_set(GSC_SRC_FMT, ctx))
399  return -EINVAL;
400  } else if (!gsc_ctx_state_is_set(GSC_DST_FMT, ctx)) {
401  return -EINVAL;
402  }
403 
404  return v4l2_m2m_streamon(file, ctx->m2m_ctx, type);
405 }
406 
407 static int gsc_m2m_streamoff(struct file *file, void *fh,
408  enum v4l2_buf_type type)
409 {
410  struct gsc_ctx *ctx = fh_to_ctx(fh);
411  return v4l2_m2m_streamoff(file, ctx->m2m_ctx, type);
412 }
413 
414 /* Return 1 if rectangle a is enclosed in rectangle b, or 0 otherwise. */
415 static int is_rectangle_enclosed(struct v4l2_rect *a, struct v4l2_rect *b)
416 {
417  if (a->left < b->left || a->top < b->top)
418  return 0;
419 
420  if (a->left + a->width > b->left + b->width)
421  return 0;
422 
423  if (a->top + a->height > b->top + b->height)
424  return 0;
425 
426  return 1;
427 }
428 
429 static int gsc_m2m_g_selection(struct file *file, void *fh,
430  struct v4l2_selection *s)
431 {
432  struct gsc_frame *frame;
433  struct gsc_ctx *ctx = fh_to_ctx(fh);
434 
437  return -EINVAL;
438 
439  frame = ctx_get_frame(ctx, s->type);
440  if (IS_ERR(frame))
441  return PTR_ERR(frame);
442 
443  switch (s->target) {
448  s->r.left = 0;
449  s->r.top = 0;
450  s->r.width = frame->f_width;
451  s->r.height = frame->f_height;
452  return 0;
453 
455  case V4L2_SEL_TGT_CROP:
456  s->r.left = frame->crop.left;
457  s->r.top = frame->crop.top;
458  s->r.width = frame->crop.width;
459  s->r.height = frame->crop.height;
460  return 0;
461  }
462 
463  return -EINVAL;
464 }
465 
466 static int gsc_m2m_s_selection(struct file *file, void *fh,
467  struct v4l2_selection *s)
468 {
469  struct gsc_frame *frame;
470  struct gsc_ctx *ctx = fh_to_ctx(fh);
471  struct v4l2_crop cr;
472  struct gsc_variant *variant = ctx->gsc_dev->variant;
473  int ret;
474 
475  cr.type = s->type;
476  cr.c = s->r;
477 
480  return -EINVAL;
481 
482  ret = gsc_try_crop(ctx, &cr);
483  if (ret)
484  return ret;
485 
486  if (s->flags & V4L2_SEL_FLAG_LE &&
487  !is_rectangle_enclosed(&cr.c, &s->r))
488  return -ERANGE;
489 
490  if (s->flags & V4L2_SEL_FLAG_GE &&
491  !is_rectangle_enclosed(&s->r, &cr.c))
492  return -ERANGE;
493 
494  s->r = cr.c;
495 
496  switch (s->target) {
500  frame = &ctx->s_frame;
501  break;
502 
504  case V4L2_SEL_TGT_CROP:
506  frame = &ctx->d_frame;
507  break;
508 
509  default:
510  return -EINVAL;
511  }
512 
513  /* Check to see if scaling ratio is within supported range */
514  if (gsc_ctx_state_is_set(GSC_DST_FMT | GSC_SRC_FMT, ctx)) {
516  ret = gsc_check_scaler_ratio(variant, cr.c.width,
517  cr.c.height, ctx->d_frame.crop.width,
518  ctx->d_frame.crop.height,
519  ctx->gsc_ctrls.rotate->val, ctx->out_path);
520  } else {
521  ret = gsc_check_scaler_ratio(variant,
522  ctx->s_frame.crop.width,
523  ctx->s_frame.crop.height, cr.c.width,
524  cr.c.height, ctx->gsc_ctrls.rotate->val,
525  ctx->out_path);
526  }
527 
528  if (ret) {
529  pr_err("Out of scaler range");
530  return -EINVAL;
531  }
532  }
533 
534  frame->crop = cr.c;
535 
536  gsc_ctx_state_lock_set(GSC_PARAMS, ctx);
537  return 0;
538 }
539 
540 static const struct v4l2_ioctl_ops gsc_m2m_ioctl_ops = {
541  .vidioc_querycap = gsc_m2m_querycap,
542  .vidioc_enum_fmt_vid_cap_mplane = gsc_m2m_enum_fmt_mplane,
543  .vidioc_enum_fmt_vid_out_mplane = gsc_m2m_enum_fmt_mplane,
544  .vidioc_g_fmt_vid_cap_mplane = gsc_m2m_g_fmt_mplane,
545  .vidioc_g_fmt_vid_out_mplane = gsc_m2m_g_fmt_mplane,
546  .vidioc_try_fmt_vid_cap_mplane = gsc_m2m_try_fmt_mplane,
547  .vidioc_try_fmt_vid_out_mplane = gsc_m2m_try_fmt_mplane,
548  .vidioc_s_fmt_vid_cap_mplane = gsc_m2m_s_fmt_mplane,
549  .vidioc_s_fmt_vid_out_mplane = gsc_m2m_s_fmt_mplane,
550  .vidioc_reqbufs = gsc_m2m_reqbufs,
551  .vidioc_querybuf = gsc_m2m_querybuf,
552  .vidioc_qbuf = gsc_m2m_qbuf,
553  .vidioc_dqbuf = gsc_m2m_dqbuf,
554  .vidioc_streamon = gsc_m2m_streamon,
555  .vidioc_streamoff = gsc_m2m_streamoff,
556  .vidioc_g_selection = gsc_m2m_g_selection,
557  .vidioc_s_selection = gsc_m2m_s_selection
558 };
559 
560 static int queue_init(void *priv, struct vb2_queue *src_vq,
561  struct vb2_queue *dst_vq)
562 {
563  struct gsc_ctx *ctx = priv;
564  int ret;
565 
566  memset(src_vq, 0, sizeof(*src_vq));
568  src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
569  src_vq->drv_priv = ctx;
570  src_vq->ops = &gsc_m2m_qops;
571  src_vq->mem_ops = &vb2_dma_contig_memops;
572  src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
573 
574  ret = vb2_queue_init(src_vq);
575  if (ret)
576  return ret;
577 
578  memset(dst_vq, 0, sizeof(*dst_vq));
580  dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;
581  dst_vq->drv_priv = ctx;
582  dst_vq->ops = &gsc_m2m_qops;
583  dst_vq->mem_ops = &vb2_dma_contig_memops;
584  dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
585 
586  return vb2_queue_init(dst_vq);
587 }
588 
589 static int gsc_m2m_open(struct file *file)
590 {
591  struct gsc_dev *gsc = video_drvdata(file);
592  struct gsc_ctx *ctx = NULL;
593  int ret;
594 
595  pr_debug("pid: %d, state: 0x%lx", task_pid_nr(current), gsc->state);
596 
597  if (mutex_lock_interruptible(&gsc->lock))
598  return -ERESTARTSYS;
599 
600  ctx = kzalloc(sizeof (*ctx), GFP_KERNEL);
601  if (!ctx) {
602  ret = -ENOMEM;
603  goto unlock;
604  }
605 
606  v4l2_fh_init(&ctx->fh, gsc->m2m.vfd);
607  ret = gsc_ctrls_create(ctx);
608  if (ret)
609  goto error_fh;
610 
611  /* Use separate control handler per file handle */
612  ctx->fh.ctrl_handler = &ctx->ctrl_handler;
613  file->private_data = &ctx->fh;
614  v4l2_fh_add(&ctx->fh);
615 
616  ctx->gsc_dev = gsc;
617  /* Default color format */
618  ctx->s_frame.fmt = get_format(0);
619  ctx->d_frame.fmt = get_format(0);
620  /* Setup the device context for mem2mem mode. */
621  ctx->state = GSC_CTX_M2M;
622  ctx->flags = 0;
623  ctx->in_path = GSC_DMA;
624  ctx->out_path = GSC_DMA;
625 
626  ctx->m2m_ctx = v4l2_m2m_ctx_init(gsc->m2m.m2m_dev, ctx, queue_init);
627  if (IS_ERR(ctx->m2m_ctx)) {
628  pr_err("Failed to initialize m2m context");
629  ret = PTR_ERR(ctx->m2m_ctx);
630  goto error_ctrls;
631  }
632 
633  if (gsc->m2m.refcnt++ == 0)
634  set_bit(ST_M2M_OPEN, &gsc->state);
635 
636  pr_debug("gsc m2m driver is opened, ctx(0x%p)", ctx);
637 
638  mutex_unlock(&gsc->lock);
639  return 0;
640 
641 error_ctrls:
642  gsc_ctrls_delete(ctx);
643 error_fh:
644  v4l2_fh_del(&ctx->fh);
645  v4l2_fh_exit(&ctx->fh);
646  kfree(ctx);
647 unlock:
648  mutex_unlock(&gsc->lock);
649  return ret;
650 }
651 
652 static int gsc_m2m_release(struct file *file)
653 {
654  struct gsc_ctx *ctx = fh_to_ctx(file->private_data);
655  struct gsc_dev *gsc = ctx->gsc_dev;
656 
657  pr_debug("pid: %d, state: 0x%lx, refcnt= %d",
658  task_pid_nr(current), gsc->state, gsc->m2m.refcnt);
659 
660  mutex_lock(&gsc->lock);
661 
663  gsc_ctrls_delete(ctx);
664  v4l2_fh_del(&ctx->fh);
665  v4l2_fh_exit(&ctx->fh);
666 
667  if (--gsc->m2m.refcnt <= 0)
668  clear_bit(ST_M2M_OPEN, &gsc->state);
669  kfree(ctx);
670 
671  mutex_unlock(&gsc->lock);
672  return 0;
673 }
674 
675 static unsigned int gsc_m2m_poll(struct file *file,
676  struct poll_table_struct *wait)
677 {
678  struct gsc_ctx *ctx = fh_to_ctx(file->private_data);
679  struct gsc_dev *gsc = ctx->gsc_dev;
680  int ret;
681 
682  if (mutex_lock_interruptible(&gsc->lock))
683  return -ERESTARTSYS;
684 
685  ret = v4l2_m2m_poll(file, ctx->m2m_ctx, wait);
686  mutex_unlock(&gsc->lock);
687 
688  return ret;
689 }
690 
691 static int gsc_m2m_mmap(struct file *file, struct vm_area_struct *vma)
692 {
693  struct gsc_ctx *ctx = fh_to_ctx(file->private_data);
694  struct gsc_dev *gsc = ctx->gsc_dev;
695  int ret;
696 
697  if (mutex_lock_interruptible(&gsc->lock))
698  return -ERESTARTSYS;
699 
700  ret = v4l2_m2m_mmap(file, ctx->m2m_ctx, vma);
701  mutex_unlock(&gsc->lock);
702 
703  return ret;
704 }
705 
706 static const struct v4l2_file_operations gsc_m2m_fops = {
707  .owner = THIS_MODULE,
708  .open = gsc_m2m_open,
709  .release = gsc_m2m_release,
710  .poll = gsc_m2m_poll,
711  .unlocked_ioctl = video_ioctl2,
712  .mmap = gsc_m2m_mmap,
713 };
714 
715 static struct v4l2_m2m_ops gsc_m2m_ops = {
716  .device_run = gsc_m2m_device_run,
717  .job_abort = gsc_m2m_job_abort,
718 };
719 
721 {
722  struct platform_device *pdev;
723  int ret;
724 
725  if (!gsc)
726  return -ENODEV;
727 
728  pdev = gsc->pdev;
729 
730  gsc->vdev.fops = &gsc_m2m_fops;
731  gsc->vdev.ioctl_ops = &gsc_m2m_ioctl_ops;
732  gsc->vdev.release = video_device_release_empty;
733  gsc->vdev.lock = &gsc->lock;
734  gsc->vdev.vfl_dir = VFL_DIR_M2M;
735  snprintf(gsc->vdev.name, sizeof(gsc->vdev.name), "%s.%d:m2m",
736  GSC_MODULE_NAME, gsc->id);
737 
738  video_set_drvdata(&gsc->vdev, gsc);
739 
740  gsc->m2m.vfd = &gsc->vdev;
741  gsc->m2m.m2m_dev = v4l2_m2m_init(&gsc_m2m_ops);
742  if (IS_ERR(gsc->m2m.m2m_dev)) {
743  dev_err(&pdev->dev, "failed to initialize v4l2-m2m device\n");
744  ret = PTR_ERR(gsc->m2m.m2m_dev);
745  goto err_m2m_r1;
746  }
747 
748  ret = video_register_device(&gsc->vdev, VFL_TYPE_GRABBER, -1);
749  if (ret) {
750  dev_err(&pdev->dev,
751  "%s(): failed to register video device\n", __func__);
752  goto err_m2m_r2;
753  }
754 
755  pr_debug("gsc m2m driver registered as /dev/video%d", gsc->vdev.num);
756  return 0;
757 
758 err_m2m_r2:
759  v4l2_m2m_release(gsc->m2m.m2m_dev);
760 err_m2m_r1:
761  video_device_release(gsc->m2m.vfd);
762 
763  return ret;
764 }
765 
767 {
768  if (gsc)
769  v4l2_m2m_release(gsc->m2m.m2m_dev);
770 }