2 * Samsung TV Mixer driver
4 * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
6 * Tomasz Stanislawski, <t.stanislaws@samsung.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published
10 * by the Free Software Foundation. either version 2 of the License,
11 * or (at your option) any later version
14 #define pr_fmt(fmt) "s5p-tv (mixer): " fmt
18 #include <media/v4l2-ioctl.h>
19 #include <linux/videodev2.h>
21 #include <linux/module.h>
22 #include <linux/timer.h>
23 #include <media/videobuf2-dma-contig.h>
25 static int find_reg_callback(struct device
*dev
, void *p
)
27 struct v4l2_subdev
**sd
= p
;
29 *sd
= dev_get_drvdata(dev
);
30 /* non-zero value stops iteration */
34 static struct v4l2_subdev
*find_and_register_subdev(
35 struct mxr_device
*mdev
, char *module_name
)
37 struct device_driver
*drv
;
38 struct v4l2_subdev
*sd
= NULL
;
41 /* TODO: add waiting until probe is finished */
42 drv
= driver_find(module_name
, &platform_bus_type
);
44 mxr_warn(mdev
, "module %s is missing\n", module_name
);
47 /* driver refcnt is increased, it is safe to iterate over devices */
48 ret
= driver_for_each_device(drv
, NULL
, &sd
, find_reg_callback
);
49 /* ret == 0 means that find_reg_callback was never executed */
51 mxr_warn(mdev
, "module %s provides no subdev!\n", module_name
);
54 /* v4l2_device_register_subdev detects if sd is NULL */
55 ret
= v4l2_device_register_subdev(&mdev
->v4l2_dev
, sd
);
57 mxr_warn(mdev
, "failed to register subdev %s\n", sd
->name
);
65 int mxr_acquire_video(struct mxr_device
*mdev
,
66 struct mxr_output_conf
*output_conf
, int output_count
)
68 struct device
*dev
= mdev
->dev
;
69 struct v4l2_device
*v4l2_dev
= &mdev
->v4l2_dev
;
72 struct v4l2_subdev
*sd
;
74 strlcpy(v4l2_dev
->name
, dev_name(mdev
->dev
), sizeof(v4l2_dev
->name
));
75 /* prepare context for V4L2 device */
76 ret
= v4l2_device_register(dev
, v4l2_dev
);
78 mxr_err(mdev
, "could not register v4l2 device.\n");
82 mdev
->alloc_ctx
= vb2_dma_contig_init_ctx(mdev
->dev
);
83 if (IS_ERR_OR_NULL(mdev
->alloc_ctx
)) {
84 mxr_err(mdev
, "could not acquire vb2 allocator\n");
88 /* registering outputs */
90 for (i
= 0; i
< output_count
; ++i
) {
91 struct mxr_output_conf
*conf
= &output_conf
[i
];
92 struct mxr_output
*out
;
94 sd
= find_and_register_subdev(mdev
, conf
->module_name
);
95 /* trying to register next output */
98 out
= kzalloc(sizeof *out
, GFP_KERNEL
);
100 mxr_err(mdev
, "no memory for '%s'\n",
103 /* registered subdevs are removed in fail_v4l2_dev */
106 strlcpy(out
->name
, conf
->output_name
, sizeof(out
->name
));
108 out
->cookie
= conf
->cookie
;
109 mdev
->output
[mdev
->output_cnt
++] = out
;
110 mxr_info(mdev
, "added output '%s' from module '%s'\n",
111 conf
->output_name
, conf
->module_name
);
112 /* checking if maximal number of outputs is reached */
113 if (mdev
->output_cnt
>= MXR_MAX_OUTPUTS
)
117 if (mdev
->output_cnt
== 0) {
118 mxr_err(mdev
, "failed to register any output\n");
120 /* skipping fail_output because there is nothing to free */
121 goto fail_vb2_allocator
;
127 /* kfree is NULL-safe */
128 for (i
= 0; i
< mdev
->output_cnt
; ++i
)
129 kfree(mdev
->output
[i
]);
130 memset(mdev
->output
, 0, sizeof mdev
->output
);
133 /* freeing allocator context */
134 vb2_dma_contig_cleanup_ctx(mdev
->alloc_ctx
);
137 /* NOTE: automatically unregister all subdevs */
138 v4l2_device_unregister(v4l2_dev
);
144 void mxr_release_video(struct mxr_device
*mdev
)
148 /* kfree is NULL-safe */
149 for (i
= 0; i
< mdev
->output_cnt
; ++i
)
150 kfree(mdev
->output
[i
]);
152 vb2_dma_contig_cleanup_ctx(mdev
->alloc_ctx
);
153 v4l2_device_unregister(&mdev
->v4l2_dev
);
156 static int mxr_querycap(struct file
*file
, void *priv
,
157 struct v4l2_capability
*cap
)
159 struct mxr_layer
*layer
= video_drvdata(file
);
161 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
163 strlcpy(cap
->driver
, MXR_DRIVER_NAME
, sizeof cap
->driver
);
164 strlcpy(cap
->card
, layer
->vfd
.name
, sizeof cap
->card
);
165 sprintf(cap
->bus_info
, "%d", layer
->idx
);
166 cap
->device_caps
= V4L2_CAP_STREAMING
| V4L2_CAP_VIDEO_OUTPUT_MPLANE
;
167 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
172 static void mxr_geometry_dump(struct mxr_device
*mdev
, struct mxr_geometry
*geo
)
174 mxr_dbg(mdev
, "src.full_size = (%u, %u)\n",
175 geo
->src
.full_width
, geo
->src
.full_height
);
176 mxr_dbg(mdev
, "src.size = (%u, %u)\n",
177 geo
->src
.width
, geo
->src
.height
);
178 mxr_dbg(mdev
, "src.offset = (%u, %u)\n",
179 geo
->src
.x_offset
, geo
->src
.y_offset
);
180 mxr_dbg(mdev
, "dst.full_size = (%u, %u)\n",
181 geo
->dst
.full_width
, geo
->dst
.full_height
);
182 mxr_dbg(mdev
, "dst.size = (%u, %u)\n",
183 geo
->dst
.width
, geo
->dst
.height
);
184 mxr_dbg(mdev
, "dst.offset = (%u, %u)\n",
185 geo
->dst
.x_offset
, geo
->dst
.y_offset
);
186 mxr_dbg(mdev
, "ratio = (%u, %u)\n",
187 geo
->x_ratio
, geo
->y_ratio
);
190 static void mxr_layer_default_geo(struct mxr_layer
*layer
)
192 struct mxr_device
*mdev
= layer
->mdev
;
193 struct v4l2_mbus_framefmt mbus_fmt
;
195 memset(&layer
->geo
, 0, sizeof layer
->geo
);
197 mxr_get_mbus_fmt(mdev
, &mbus_fmt
);
199 layer
->geo
.dst
.full_width
= mbus_fmt
.width
;
200 layer
->geo
.dst
.full_height
= mbus_fmt
.height
;
201 layer
->geo
.dst
.width
= layer
->geo
.dst
.full_width
;
202 layer
->geo
.dst
.height
= layer
->geo
.dst
.full_height
;
203 layer
->geo
.dst
.field
= mbus_fmt
.field
;
205 layer
->geo
.src
.full_width
= mbus_fmt
.width
;
206 layer
->geo
.src
.full_height
= mbus_fmt
.height
;
207 layer
->geo
.src
.width
= layer
->geo
.src
.full_width
;
208 layer
->geo
.src
.height
= layer
->geo
.src
.full_height
;
210 mxr_geometry_dump(mdev
, &layer
->geo
);
211 layer
->ops
.fix_geometry(layer
, MXR_GEOMETRY_SINK
, 0);
212 mxr_geometry_dump(mdev
, &layer
->geo
);
215 static void mxr_layer_update_output(struct mxr_layer
*layer
)
217 struct mxr_device
*mdev
= layer
->mdev
;
218 struct v4l2_mbus_framefmt mbus_fmt
;
220 mxr_get_mbus_fmt(mdev
, &mbus_fmt
);
221 /* checking if update is needed */
222 if (layer
->geo
.dst
.full_width
== mbus_fmt
.width
&&
223 layer
->geo
.dst
.full_height
== mbus_fmt
.width
)
226 layer
->geo
.dst
.full_width
= mbus_fmt
.width
;
227 layer
->geo
.dst
.full_height
= mbus_fmt
.height
;
228 layer
->geo
.dst
.field
= mbus_fmt
.field
;
229 layer
->ops
.fix_geometry(layer
, MXR_GEOMETRY_SINK
, 0);
231 mxr_geometry_dump(mdev
, &layer
->geo
);
234 static const struct mxr_format
*find_format_by_fourcc(
235 struct mxr_layer
*layer
, unsigned long fourcc
);
236 static const struct mxr_format
*find_format_by_index(
237 struct mxr_layer
*layer
, unsigned long index
);
239 static int mxr_enum_fmt(struct file
*file
, void *priv
,
240 struct v4l2_fmtdesc
*f
)
242 struct mxr_layer
*layer
= video_drvdata(file
);
243 struct mxr_device
*mdev
= layer
->mdev
;
244 const struct mxr_format
*fmt
;
246 mxr_dbg(mdev
, "%s\n", __func__
);
247 fmt
= find_format_by_index(layer
, f
->index
);
251 strlcpy(f
->description
, fmt
->name
, sizeof(f
->description
));
252 f
->pixelformat
= fmt
->fourcc
;
257 static unsigned int divup(unsigned int divident
, unsigned int divisor
)
259 return (divident
+ divisor
- 1) / divisor
;
262 unsigned long mxr_get_plane_size(const struct mxr_block
*blk
,
263 unsigned int width
, unsigned int height
)
265 unsigned int bl_width
= divup(width
, blk
->width
);
266 unsigned int bl_height
= divup(height
, blk
->height
);
268 return bl_width
* bl_height
* blk
->size
;
271 static void mxr_mplane_fill(struct v4l2_plane_pix_format
*planes
,
272 const struct mxr_format
*fmt
, u32 width
, u32 height
)
276 /* checking if nothing to fill */
280 memset(planes
, 0, sizeof(*planes
) * fmt
->num_subframes
);
281 for (i
= 0; i
< fmt
->num_planes
; ++i
) {
282 struct v4l2_plane_pix_format
*plane
= planes
283 + fmt
->plane2subframe
[i
];
284 const struct mxr_block
*blk
= &fmt
->plane
[i
];
285 u32 bl_width
= divup(width
, blk
->width
);
286 u32 bl_height
= divup(height
, blk
->height
);
287 u32 sizeimage
= bl_width
* bl_height
* blk
->size
;
288 u16 bytesperline
= bl_width
* blk
->size
/ blk
->height
;
290 plane
->sizeimage
+= sizeimage
;
291 plane
->bytesperline
= max(plane
->bytesperline
, bytesperline
);
295 static int mxr_g_fmt(struct file
*file
, void *priv
,
296 struct v4l2_format
*f
)
298 struct mxr_layer
*layer
= video_drvdata(file
);
299 struct v4l2_pix_format_mplane
*pix
= &f
->fmt
.pix_mp
;
301 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
303 pix
->width
= layer
->geo
.src
.full_width
;
304 pix
->height
= layer
->geo
.src
.full_height
;
305 pix
->field
= V4L2_FIELD_NONE
;
306 pix
->pixelformat
= layer
->fmt
->fourcc
;
307 pix
->colorspace
= layer
->fmt
->colorspace
;
308 mxr_mplane_fill(pix
->plane_fmt
, layer
->fmt
, pix
->width
, pix
->height
);
313 static int mxr_s_fmt(struct file
*file
, void *priv
,
314 struct v4l2_format
*f
)
316 struct mxr_layer
*layer
= video_drvdata(file
);
317 const struct mxr_format
*fmt
;
318 struct v4l2_pix_format_mplane
*pix
;
319 struct mxr_device
*mdev
= layer
->mdev
;
320 struct mxr_geometry
*geo
= &layer
->geo
;
322 mxr_dbg(mdev
, "%s:%d\n", __func__
, __LINE__
);
324 pix
= &f
->fmt
.pix_mp
;
325 fmt
= find_format_by_fourcc(layer
, pix
->pixelformat
);
327 mxr_warn(mdev
, "not recognized fourcc: %08x\n",
332 /* set source size to highest accepted value */
333 geo
->src
.full_width
= max(geo
->dst
.full_width
, pix
->width
);
334 geo
->src
.full_height
= max(geo
->dst
.full_height
, pix
->height
);
335 layer
->ops
.fix_geometry(layer
, MXR_GEOMETRY_SOURCE
, 0);
336 mxr_geometry_dump(mdev
, &layer
->geo
);
337 /* set cropping to total visible screen */
338 geo
->src
.width
= pix
->width
;
339 geo
->src
.height
= pix
->height
;
340 geo
->src
.x_offset
= 0;
341 geo
->src
.y_offset
= 0;
342 /* assure consistency of geometry */
343 layer
->ops
.fix_geometry(layer
, MXR_GEOMETRY_CROP
, MXR_NO_OFFSET
);
344 mxr_geometry_dump(mdev
, &layer
->geo
);
345 /* set full size to lowest possible value */
346 geo
->src
.full_width
= 0;
347 geo
->src
.full_height
= 0;
348 layer
->ops
.fix_geometry(layer
, MXR_GEOMETRY_SOURCE
, 0);
349 mxr_geometry_dump(mdev
, &layer
->geo
);
351 /* returning results */
352 mxr_g_fmt(file
, priv
, f
);
357 static int mxr_g_selection(struct file
*file
, void *fh
,
358 struct v4l2_selection
*s
)
360 struct mxr_layer
*layer
= video_drvdata(file
);
361 struct mxr_geometry
*geo
= &layer
->geo
;
363 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
365 if (s
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
366 s
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
370 case V4L2_SEL_TGT_CROP
:
371 s
->r
.left
= geo
->src
.x_offset
;
372 s
->r
.top
= geo
->src
.y_offset
;
373 s
->r
.width
= geo
->src
.width
;
374 s
->r
.height
= geo
->src
.height
;
376 case V4L2_SEL_TGT_CROP_DEFAULT
:
377 case V4L2_SEL_TGT_CROP_BOUNDS
:
380 s
->r
.width
= geo
->src
.full_width
;
381 s
->r
.height
= geo
->src
.full_height
;
383 case V4L2_SEL_TGT_COMPOSE
:
384 case V4L2_SEL_TGT_COMPOSE_PADDED
:
385 s
->r
.left
= geo
->dst
.x_offset
;
386 s
->r
.top
= geo
->dst
.y_offset
;
387 s
->r
.width
= geo
->dst
.width
;
388 s
->r
.height
= geo
->dst
.height
;
390 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
391 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
394 s
->r
.width
= geo
->dst
.full_width
;
395 s
->r
.height
= geo
->dst
.full_height
;
404 /* returns 1 if rectangle 'a' is inside 'b' */
405 static int mxr_is_rect_inside(struct v4l2_rect
*a
, struct v4l2_rect
*b
)
407 if (a
->left
< b
->left
)
411 if (a
->left
+ a
->width
> b
->left
+ b
->width
)
413 if (a
->top
+ a
->height
> b
->top
+ b
->height
)
418 static int mxr_s_selection(struct file
*file
, void *fh
,
419 struct v4l2_selection
*s
)
421 struct mxr_layer
*layer
= video_drvdata(file
);
422 struct mxr_geometry
*geo
= &layer
->geo
;
423 struct mxr_crop
*target
= NULL
;
424 enum mxr_geometry_stage stage
;
425 struct mxr_geometry tmp
;
426 struct v4l2_rect res
;
428 memset(&res
, 0, sizeof res
);
430 mxr_dbg(layer
->mdev
, "%s: rect: %dx%d@%d,%d\n", __func__
,
431 s
->r
.width
, s
->r
.height
, s
->r
.left
, s
->r
.top
);
433 if (s
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
434 s
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
438 /* ignore read-only targets */
439 case V4L2_SEL_TGT_CROP_DEFAULT
:
440 case V4L2_SEL_TGT_CROP_BOUNDS
:
441 res
.width
= geo
->src
.full_width
;
442 res
.height
= geo
->src
.full_height
;
445 /* ignore read-only targets */
446 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
447 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
448 res
.width
= geo
->dst
.full_width
;
449 res
.height
= geo
->dst
.full_height
;
452 case V4L2_SEL_TGT_CROP
:
454 stage
= MXR_GEOMETRY_CROP
;
456 case V4L2_SEL_TGT_COMPOSE
:
457 case V4L2_SEL_TGT_COMPOSE_PADDED
:
459 stage
= MXR_GEOMETRY_COMPOSE
;
464 /* apply change and update geometry if needed */
466 /* backup current geometry if setup fails */
467 memcpy(&tmp
, geo
, sizeof tmp
);
469 /* apply requested selection */
470 target
->x_offset
= s
->r
.left
;
471 target
->y_offset
= s
->r
.top
;
472 target
->width
= s
->r
.width
;
473 target
->height
= s
->r
.height
;
475 layer
->ops
.fix_geometry(layer
, stage
, s
->flags
);
477 /* retrieve update selection rectangle */
478 res
.left
= target
->x_offset
;
479 res
.top
= target
->y_offset
;
480 res
.width
= target
->width
;
481 res
.height
= target
->height
;
483 mxr_geometry_dump(layer
->mdev
, &layer
->geo
);
486 /* checking if the rectangle satisfies constraints */
487 if ((s
->flags
& V4L2_SEL_FLAG_LE
) && !mxr_is_rect_inside(&res
, &s
->r
))
489 if ((s
->flags
& V4L2_SEL_FLAG_GE
) && !mxr_is_rect_inside(&s
->r
, &res
))
492 /* return result rectangle */
497 /* restore old geometry, which is not touched if target is NULL */
499 memcpy(geo
, &tmp
, sizeof tmp
);
503 static int mxr_enum_dv_presets(struct file
*file
, void *fh
,
504 struct v4l2_dv_enum_preset
*preset
)
506 struct mxr_layer
*layer
= video_drvdata(file
);
507 struct mxr_device
*mdev
= layer
->mdev
;
510 /* lock protects from changing sd_out */
511 mutex_lock(&mdev
->mutex
);
512 ret
= v4l2_subdev_call(to_outsd(mdev
), video
, enum_dv_presets
, preset
);
513 mutex_unlock(&mdev
->mutex
);
515 return ret
? -EINVAL
: 0;
518 static int mxr_s_dv_preset(struct file
*file
, void *fh
,
519 struct v4l2_dv_preset
*preset
)
521 struct mxr_layer
*layer
= video_drvdata(file
);
522 struct mxr_device
*mdev
= layer
->mdev
;
525 /* lock protects from changing sd_out */
526 mutex_lock(&mdev
->mutex
);
528 /* preset change cannot be done while there is an entity
529 * dependant on output configuration
531 if (mdev
->n_output
> 0) {
532 mutex_unlock(&mdev
->mutex
);
536 ret
= v4l2_subdev_call(to_outsd(mdev
), video
, s_dv_preset
, preset
);
538 mutex_unlock(&mdev
->mutex
);
540 mxr_layer_update_output(layer
);
542 /* any failure should return EINVAL according to V4L2 doc */
543 return ret
? -EINVAL
: 0;
546 static int mxr_g_dv_preset(struct file
*file
, void *fh
,
547 struct v4l2_dv_preset
*preset
)
549 struct mxr_layer
*layer
= video_drvdata(file
);
550 struct mxr_device
*mdev
= layer
->mdev
;
553 /* lock protects from changing sd_out */
554 mutex_lock(&mdev
->mutex
);
555 ret
= v4l2_subdev_call(to_outsd(mdev
), video
, g_dv_preset
, preset
);
556 mutex_unlock(&mdev
->mutex
);
558 return ret
? -EINVAL
: 0;
561 static int mxr_s_std(struct file
*file
, void *fh
, v4l2_std_id
*norm
)
563 struct mxr_layer
*layer
= video_drvdata(file
);
564 struct mxr_device
*mdev
= layer
->mdev
;
567 /* lock protects from changing sd_out */
568 mutex_lock(&mdev
->mutex
);
570 /* standard change cannot be done while there is an entity
571 * dependant on output configuration
573 if (mdev
->n_output
> 0) {
574 mutex_unlock(&mdev
->mutex
);
578 ret
= v4l2_subdev_call(to_outsd(mdev
), video
, s_std_output
, *norm
);
580 mutex_unlock(&mdev
->mutex
);
582 mxr_layer_update_output(layer
);
584 return ret
? -EINVAL
: 0;
587 static int mxr_g_std(struct file
*file
, void *fh
, v4l2_std_id
*norm
)
589 struct mxr_layer
*layer
= video_drvdata(file
);
590 struct mxr_device
*mdev
= layer
->mdev
;
593 /* lock protects from changing sd_out */
594 mutex_lock(&mdev
->mutex
);
595 ret
= v4l2_subdev_call(to_outsd(mdev
), video
, g_std_output
, norm
);
596 mutex_unlock(&mdev
->mutex
);
598 return ret
? -EINVAL
: 0;
601 static int mxr_enum_output(struct file
*file
, void *fh
, struct v4l2_output
*a
)
603 struct mxr_layer
*layer
= video_drvdata(file
);
604 struct mxr_device
*mdev
= layer
->mdev
;
605 struct mxr_output
*out
;
606 struct v4l2_subdev
*sd
;
608 if (a
->index
>= mdev
->output_cnt
)
610 out
= mdev
->output
[a
->index
];
613 strlcpy(a
->name
, out
->name
, sizeof(a
->name
));
615 /* try to obtain supported tv norms */
616 v4l2_subdev_call(sd
, video
, g_tvnorms_output
, &a
->std
);
618 if (sd
->ops
->video
&& sd
->ops
->video
->s_dv_preset
)
619 a
->capabilities
|= V4L2_OUT_CAP_PRESETS
;
620 if (sd
->ops
->video
&& sd
->ops
->video
->s_std_output
)
621 a
->capabilities
|= V4L2_OUT_CAP_STD
;
622 a
->type
= V4L2_OUTPUT_TYPE_ANALOG
;
627 static int mxr_s_output(struct file
*file
, void *fh
, unsigned int i
)
629 struct video_device
*vfd
= video_devdata(file
);
630 struct mxr_layer
*layer
= video_drvdata(file
);
631 struct mxr_device
*mdev
= layer
->mdev
;
633 if (i
>= mdev
->output_cnt
|| mdev
->output
[i
] == NULL
)
636 mutex_lock(&mdev
->mutex
);
637 if (mdev
->n_output
> 0) {
638 mutex_unlock(&mdev
->mutex
);
641 mdev
->current_output
= i
;
643 v4l2_subdev_call(to_outsd(mdev
), video
, g_tvnorms_output
,
645 mutex_unlock(&mdev
->mutex
);
647 /* update layers geometry */
648 mxr_layer_update_output(layer
);
650 mxr_dbg(mdev
, "tvnorms = %08llx\n", vfd
->tvnorms
);
655 static int mxr_g_output(struct file
*file
, void *fh
, unsigned int *p
)
657 struct mxr_layer
*layer
= video_drvdata(file
);
658 struct mxr_device
*mdev
= layer
->mdev
;
660 mutex_lock(&mdev
->mutex
);
661 *p
= mdev
->current_output
;
662 mutex_unlock(&mdev
->mutex
);
667 static int mxr_reqbufs(struct file
*file
, void *priv
,
668 struct v4l2_requestbuffers
*p
)
670 struct mxr_layer
*layer
= video_drvdata(file
);
672 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
673 return vb2_reqbufs(&layer
->vb_queue
, p
);
676 static int mxr_querybuf(struct file
*file
, void *priv
, struct v4l2_buffer
*p
)
678 struct mxr_layer
*layer
= video_drvdata(file
);
680 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
681 return vb2_querybuf(&layer
->vb_queue
, p
);
684 static int mxr_qbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*p
)
686 struct mxr_layer
*layer
= video_drvdata(file
);
688 mxr_dbg(layer
->mdev
, "%s:%d(%d)\n", __func__
, __LINE__
, p
->index
);
689 return vb2_qbuf(&layer
->vb_queue
, p
);
692 static int mxr_dqbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*p
)
694 struct mxr_layer
*layer
= video_drvdata(file
);
696 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
697 return vb2_dqbuf(&layer
->vb_queue
, p
, file
->f_flags
& O_NONBLOCK
);
700 static int mxr_expbuf(struct file
*file
, void *priv
,
701 struct v4l2_exportbuffer
*eb
)
703 struct mxr_layer
*layer
= video_drvdata(file
);
705 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
706 return vb2_expbuf(&layer
->vb_queue
, eb
);
709 static int mxr_streamon(struct file
*file
, void *priv
, enum v4l2_buf_type i
)
711 struct mxr_layer
*layer
= video_drvdata(file
);
713 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
714 return vb2_streamon(&layer
->vb_queue
, i
);
717 static int mxr_streamoff(struct file
*file
, void *priv
, enum v4l2_buf_type i
)
719 struct mxr_layer
*layer
= video_drvdata(file
);
721 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
722 return vb2_streamoff(&layer
->vb_queue
, i
);
725 static const struct v4l2_ioctl_ops mxr_ioctl_ops
= {
726 .vidioc_querycap
= mxr_querycap
,
727 /* format handling */
728 .vidioc_enum_fmt_vid_out_mplane
= mxr_enum_fmt
,
729 .vidioc_s_fmt_vid_out_mplane
= mxr_s_fmt
,
730 .vidioc_g_fmt_vid_out_mplane
= mxr_g_fmt
,
732 .vidioc_reqbufs
= mxr_reqbufs
,
733 .vidioc_querybuf
= mxr_querybuf
,
734 .vidioc_qbuf
= mxr_qbuf
,
735 .vidioc_dqbuf
= mxr_dqbuf
,
736 .vidioc_expbuf
= mxr_expbuf
,
737 /* Streaming control */
738 .vidioc_streamon
= mxr_streamon
,
739 .vidioc_streamoff
= mxr_streamoff
,
740 /* Preset functions */
741 .vidioc_enum_dv_presets
= mxr_enum_dv_presets
,
742 .vidioc_s_dv_preset
= mxr_s_dv_preset
,
743 .vidioc_g_dv_preset
= mxr_g_dv_preset
,
744 /* analog TV standard functions */
745 .vidioc_s_std
= mxr_s_std
,
746 .vidioc_g_std
= mxr_g_std
,
747 /* Output handling */
748 .vidioc_enum_output
= mxr_enum_output
,
749 .vidioc_s_output
= mxr_s_output
,
750 .vidioc_g_output
= mxr_g_output
,
751 /* selection ioctls */
752 .vidioc_g_selection
= mxr_g_selection
,
753 .vidioc_s_selection
= mxr_s_selection
,
756 static int mxr_video_open(struct file
*file
)
758 struct mxr_layer
*layer
= video_drvdata(file
);
759 struct mxr_device
*mdev
= layer
->mdev
;
762 mxr_dbg(mdev
, "%s:%d\n", __func__
, __LINE__
);
763 if (mutex_lock_interruptible(&layer
->mutex
))
765 /* assure device probe is finished */
766 wait_for_device_probe();
767 /* creating context for file descriptor */
768 ret
= v4l2_fh_open(file
);
770 mxr_err(mdev
, "v4l2_fh_open failed\n");
774 /* leaving if layer is already initialized */
775 if (!v4l2_fh_is_singular_file(file
))
778 /* FIXME: should power be enabled on open? */
779 ret
= mxr_power_get(mdev
);
781 mxr_err(mdev
, "power on failed\n");
785 ret
= vb2_queue_init(&layer
->vb_queue
);
787 mxr_err(mdev
, "failed to initialize vb2 queue\n");
790 /* set default format, first on the list */
791 layer
->fmt
= layer
->fmt_array
[0];
792 /* setup default geometry */
793 mxr_layer_default_geo(layer
);
794 mutex_unlock(&layer
->mutex
);
802 v4l2_fh_release(file
);
805 mutex_unlock(&layer
->mutex
);
811 mxr_video_poll(struct file
*file
, struct poll_table_struct
*wait
)
813 struct mxr_layer
*layer
= video_drvdata(file
);
816 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
818 mutex_lock(&layer
->mutex
);
819 res
= vb2_poll(&layer
->vb_queue
, file
, wait
);
820 mutex_unlock(&layer
->mutex
);
824 static int mxr_video_mmap(struct file
*file
, struct vm_area_struct
*vma
)
826 struct mxr_layer
*layer
= video_drvdata(file
);
829 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
831 if (mutex_lock_interruptible(&layer
->mutex
))
833 ret
= vb2_mmap(&layer
->vb_queue
, vma
);
834 mutex_unlock(&layer
->mutex
);
838 static int mxr_video_release(struct file
*file
)
840 struct mxr_layer
*layer
= video_drvdata(file
);
842 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
843 mutex_lock(&layer
->mutex
);
844 if (v4l2_fh_is_singular_file(file
)) {
845 vb2_queue_release(&layer
->vb_queue
);
846 mxr_power_put(layer
->mdev
);
848 v4l2_fh_release(file
);
849 mutex_unlock(&layer
->mutex
);
853 static const struct v4l2_file_operations mxr_fops
= {
854 .owner
= THIS_MODULE
,
855 .open
= mxr_video_open
,
856 .poll
= mxr_video_poll
,
857 .mmap
= mxr_video_mmap
,
858 .release
= mxr_video_release
,
859 .unlocked_ioctl
= video_ioctl2
,
862 static int queue_setup(struct vb2_queue
*vq
, const struct v4l2_format
*pfmt
,
863 unsigned int *nbuffers
, unsigned int *nplanes
, unsigned int sizes
[],
866 struct mxr_layer
*layer
= vb2_get_drv_priv(vq
);
867 const struct mxr_format
*fmt
= layer
->fmt
;
869 struct mxr_device
*mdev
= layer
->mdev
;
870 struct v4l2_plane_pix_format planes
[3];
872 mxr_dbg(mdev
, "%s\n", __func__
);
873 /* checking if format was configured */
876 mxr_dbg(mdev
, "fmt = %s\n", fmt
->name
);
877 mxr_mplane_fill(planes
, fmt
, layer
->geo
.src
.full_width
,
878 layer
->geo
.src
.full_height
);
880 *nplanes
= fmt
->num_subframes
;
881 for (i
= 0; i
< fmt
->num_subframes
; ++i
) {
882 alloc_ctxs
[i
] = layer
->mdev
->alloc_ctx
;
883 sizes
[i
] = planes
[i
].sizeimage
;
884 mxr_dbg(mdev
, "size[%d] = %08x\n", i
, sizes
[i
]);
893 static void buf_queue(struct vb2_buffer
*vb
)
895 struct mxr_buffer
*buffer
= container_of(vb
, struct mxr_buffer
, vb
);
896 struct mxr_layer
*layer
= vb2_get_drv_priv(vb
->vb2_queue
);
897 struct mxr_device
*mdev
= layer
->mdev
;
900 spin_lock_irqsave(&layer
->enq_slock
, flags
);
901 list_add_tail(&buffer
->list
, &layer
->enq_list
);
902 spin_unlock_irqrestore(&layer
->enq_slock
, flags
);
904 mxr_dbg(mdev
, "queuing buffer\n");
907 static void wait_lock(struct vb2_queue
*vq
)
909 struct mxr_layer
*layer
= vb2_get_drv_priv(vq
);
911 mxr_dbg(layer
->mdev
, "%s\n", __func__
);
912 mutex_lock(&layer
->mutex
);
915 static void wait_unlock(struct vb2_queue
*vq
)
917 struct mxr_layer
*layer
= vb2_get_drv_priv(vq
);
919 mxr_dbg(layer
->mdev
, "%s\n", __func__
);
920 mutex_unlock(&layer
->mutex
);
923 static int start_streaming(struct vb2_queue
*vq
, unsigned int count
)
925 struct mxr_layer
*layer
= vb2_get_drv_priv(vq
);
926 struct mxr_device
*mdev
= layer
->mdev
;
929 mxr_dbg(mdev
, "%s\n", __func__
);
932 mxr_dbg(mdev
, "no output buffers queued\n");
936 /* block any changes in output configuration */
937 mxr_output_get(mdev
);
939 mxr_layer_update_output(layer
);
940 layer
->ops
.format_set(layer
);
941 /* enabling layer in hardware */
942 spin_lock_irqsave(&layer
->enq_slock
, flags
);
943 layer
->state
= MXR_LAYER_STREAMING
;
944 spin_unlock_irqrestore(&layer
->enq_slock
, flags
);
946 layer
->ops
.stream_set(layer
, MXR_ENABLE
);
947 mxr_streamer_get(mdev
);
952 static void mxr_watchdog(unsigned long arg
)
954 struct mxr_layer
*layer
= (struct mxr_layer
*) arg
;
955 struct mxr_device
*mdev
= layer
->mdev
;
958 mxr_err(mdev
, "watchdog fired for layer %s\n", layer
->vfd
.name
);
960 spin_lock_irqsave(&layer
->enq_slock
, flags
);
962 if (layer
->update_buf
== layer
->shadow_buf
)
963 layer
->update_buf
= NULL
;
964 if (layer
->update_buf
) {
965 vb2_buffer_done(&layer
->update_buf
->vb
, VB2_BUF_STATE_ERROR
);
966 layer
->update_buf
= NULL
;
968 if (layer
->shadow_buf
) {
969 vb2_buffer_done(&layer
->shadow_buf
->vb
, VB2_BUF_STATE_ERROR
);
970 layer
->shadow_buf
= NULL
;
972 spin_unlock_irqrestore(&layer
->enq_slock
, flags
);
975 static int stop_streaming(struct vb2_queue
*vq
)
977 struct mxr_layer
*layer
= vb2_get_drv_priv(vq
);
978 struct mxr_device
*mdev
= layer
->mdev
;
980 struct timer_list watchdog
;
981 struct mxr_buffer
*buf
, *buf_tmp
;
983 mxr_dbg(mdev
, "%s\n", __func__
);
985 spin_lock_irqsave(&layer
->enq_slock
, flags
);
988 layer
->state
= MXR_LAYER_STREAMING_FINISH
;
990 /* set all buffer to be done */
991 list_for_each_entry_safe(buf
, buf_tmp
, &layer
->enq_list
, list
) {
992 list_del(&buf
->list
);
993 vb2_buffer_done(&buf
->vb
, VB2_BUF_STATE_ERROR
);
996 spin_unlock_irqrestore(&layer
->enq_slock
, flags
);
998 /* give 1 seconds to complete to complete last buffers */
999 setup_timer_on_stack(&watchdog
, mxr_watchdog
,
1000 (unsigned long)layer
);
1001 mod_timer(&watchdog
, jiffies
+ msecs_to_jiffies(1000));
1003 /* wait until all buffers are goes to done state */
1004 vb2_wait_for_all_buffers(vq
);
1006 /* stop timer if all synchronization is done */
1007 del_timer_sync(&watchdog
);
1008 destroy_timer_on_stack(&watchdog
);
1010 /* stopping hardware */
1011 spin_lock_irqsave(&layer
->enq_slock
, flags
);
1012 layer
->state
= MXR_LAYER_IDLE
;
1013 spin_unlock_irqrestore(&layer
->enq_slock
, flags
);
1015 /* disabling layer in hardware */
1016 layer
->ops
.stream_set(layer
, MXR_DISABLE
);
1017 /* remove one streamer */
1018 mxr_streamer_put(mdev
);
1019 /* allow changes in output configuration */
1020 mxr_output_put(mdev
);
1024 static struct vb2_ops mxr_video_qops
= {
1025 .queue_setup
= queue_setup
,
1026 .buf_queue
= buf_queue
,
1027 .wait_prepare
= wait_unlock
,
1028 .wait_finish
= wait_lock
,
1029 .start_streaming
= start_streaming
,
1030 .stop_streaming
= stop_streaming
,
1033 /* FIXME: try to put this functions to mxr_base_layer_create */
1034 int mxr_base_layer_register(struct mxr_layer
*layer
)
1036 struct mxr_device
*mdev
= layer
->mdev
;
1039 ret
= video_register_device(&layer
->vfd
, VFL_TYPE_GRABBER
, -1);
1041 mxr_err(mdev
, "failed to register video device\n");
1043 mxr_info(mdev
, "registered layer %s as /dev/video%d\n",
1044 layer
->vfd
.name
, layer
->vfd
.num
);
1048 void mxr_base_layer_unregister(struct mxr_layer
*layer
)
1050 video_unregister_device(&layer
->vfd
);
1053 void mxr_layer_release(struct mxr_layer
*layer
)
1055 if (layer
->ops
.release
)
1056 layer
->ops
.release(layer
);
1059 void mxr_base_layer_release(struct mxr_layer
*layer
)
1064 static void mxr_vfd_release(struct video_device
*vdev
)
1066 pr_info("video device release\n");
1069 struct mxr_layer
*mxr_base_layer_create(struct mxr_device
*mdev
,
1070 int idx
, char *name
, struct mxr_layer_ops
*ops
)
1072 struct mxr_layer
*layer
;
1074 layer
= kzalloc(sizeof *layer
, GFP_KERNEL
);
1075 if (layer
== NULL
) {
1076 mxr_err(mdev
, "not enough memory for layer.\n");
1084 spin_lock_init(&layer
->enq_slock
);
1085 INIT_LIST_HEAD(&layer
->enq_list
);
1086 mutex_init(&layer
->mutex
);
1088 layer
->vfd
= (struct video_device
) {
1090 .release
= mxr_vfd_release
,
1092 .vfl_dir
= VFL_DIR_TX
,
1093 .ioctl_ops
= &mxr_ioctl_ops
,
1095 strlcpy(layer
->vfd
.name
, name
, sizeof(layer
->vfd
.name
));
1096 /* let framework control PRIORITY */
1097 set_bit(V4L2_FL_USE_FH_PRIO
, &layer
->vfd
.flags
);
1099 video_set_drvdata(&layer
->vfd
, layer
);
1100 layer
->vfd
.lock
= &layer
->mutex
;
1101 layer
->vfd
.v4l2_dev
= &mdev
->v4l2_dev
;
1103 layer
->vb_queue
= (struct vb2_queue
) {
1104 .type
= V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
,
1105 .io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
,
1107 .buf_struct_size
= sizeof(struct mxr_buffer
),
1108 .ops
= &mxr_video_qops
,
1109 .mem_ops
= &vb2_dma_contig_memops
,
1118 static const struct mxr_format
*find_format_by_fourcc(
1119 struct mxr_layer
*layer
, unsigned long fourcc
)
1123 for (i
= 0; i
< layer
->fmt_array_size
; ++i
)
1124 if (layer
->fmt_array
[i
]->fourcc
== fourcc
)
1125 return layer
->fmt_array
[i
];
1129 static const struct mxr_format
*find_format_by_index(
1130 struct mxr_layer
*layer
, unsigned long index
)
1132 if (index
>= layer
->fmt_array_size
)
1134 return layer
->fmt_array
[index
];