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/platform_device.h>
23 #include <linux/timer.h>
24 #include <media/videobuf2-dma-contig.h>
26 static int find_reg_callback(struct device
*dev
, void *p
)
28 struct v4l2_subdev
**sd
= p
;
30 *sd
= dev_get_drvdata(dev
);
31 /* non-zero value stops iteration */
35 static struct v4l2_subdev
*find_and_register_subdev(
36 struct mxr_device
*mdev
, char *module_name
)
38 struct device_driver
*drv
;
39 struct v4l2_subdev
*sd
= NULL
;
42 /* TODO: add waiting until probe is finished */
43 drv
= driver_find(module_name
, &platform_bus_type
);
45 mxr_warn(mdev
, "module %s is missing\n", module_name
);
48 /* driver refcnt is increased, it is safe to iterate over devices */
49 ret
= driver_for_each_device(drv
, NULL
, &sd
, find_reg_callback
);
50 /* ret == 0 means that find_reg_callback was never executed */
52 mxr_warn(mdev
, "module %s provides no subdev!\n", module_name
);
55 /* v4l2_device_register_subdev detects if sd is NULL */
56 ret
= v4l2_device_register_subdev(&mdev
->v4l2_dev
, sd
);
58 mxr_warn(mdev
, "failed to register subdev %s\n", sd
->name
);
66 int mxr_acquire_video(struct mxr_device
*mdev
,
67 struct mxr_output_conf
*output_conf
, int output_count
)
69 struct device
*dev
= mdev
->dev
;
70 struct v4l2_device
*v4l2_dev
= &mdev
->v4l2_dev
;
73 struct v4l2_subdev
*sd
;
75 strlcpy(v4l2_dev
->name
, dev_name(mdev
->dev
), sizeof(v4l2_dev
->name
));
76 /* prepare context for V4L2 device */
77 ret
= v4l2_device_register(dev
, v4l2_dev
);
79 mxr_err(mdev
, "could not register v4l2 device.\n");
83 mdev
->alloc_ctx
= vb2_dma_contig_init_ctx(mdev
->dev
);
84 if (IS_ERR(mdev
->alloc_ctx
)) {
85 mxr_err(mdev
, "could not acquire vb2 allocator\n");
86 ret
= PTR_ERR(mdev
->alloc_ctx
);
90 /* registering outputs */
92 for (i
= 0; i
< output_count
; ++i
) {
93 struct mxr_output_conf
*conf
= &output_conf
[i
];
94 struct mxr_output
*out
;
96 sd
= find_and_register_subdev(mdev
, conf
->module_name
);
97 /* trying to register next output */
100 out
= kzalloc(sizeof(*out
), GFP_KERNEL
);
102 mxr_err(mdev
, "no memory for '%s'\n",
105 /* registered subdevs are removed in fail_v4l2_dev */
108 strlcpy(out
->name
, conf
->output_name
, sizeof(out
->name
));
110 out
->cookie
= conf
->cookie
;
111 mdev
->output
[mdev
->output_cnt
++] = out
;
112 mxr_info(mdev
, "added output '%s' from module '%s'\n",
113 conf
->output_name
, conf
->module_name
);
114 /* checking if maximal number of outputs is reached */
115 if (mdev
->output_cnt
>= MXR_MAX_OUTPUTS
)
119 if (mdev
->output_cnt
== 0) {
120 mxr_err(mdev
, "failed to register any output\n");
122 /* skipping fail_output because there is nothing to free */
123 goto fail_vb2_allocator
;
129 /* kfree is NULL-safe */
130 for (i
= 0; i
< mdev
->output_cnt
; ++i
)
131 kfree(mdev
->output
[i
]);
132 memset(mdev
->output
, 0, sizeof(mdev
->output
));
135 /* freeing allocator context */
136 vb2_dma_contig_cleanup_ctx(mdev
->alloc_ctx
);
139 /* NOTE: automatically unregister all subdevs */
140 v4l2_device_unregister(v4l2_dev
);
146 void mxr_release_video(struct mxr_device
*mdev
)
150 /* kfree is NULL-safe */
151 for (i
= 0; i
< mdev
->output_cnt
; ++i
)
152 kfree(mdev
->output
[i
]);
154 vb2_dma_contig_cleanup_ctx(mdev
->alloc_ctx
);
155 v4l2_device_unregister(&mdev
->v4l2_dev
);
158 static int mxr_querycap(struct file
*file
, void *priv
,
159 struct v4l2_capability
*cap
)
161 struct mxr_layer
*layer
= video_drvdata(file
);
163 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
165 strlcpy(cap
->driver
, MXR_DRIVER_NAME
, sizeof(cap
->driver
));
166 strlcpy(cap
->card
, layer
->vfd
.name
, sizeof(cap
->card
));
167 sprintf(cap
->bus_info
, "%d", layer
->idx
);
168 cap
->device_caps
= V4L2_CAP_STREAMING
| V4L2_CAP_VIDEO_OUTPUT_MPLANE
;
169 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
174 static void mxr_geometry_dump(struct mxr_device
*mdev
, struct mxr_geometry
*geo
)
176 mxr_dbg(mdev
, "src.full_size = (%u, %u)\n",
177 geo
->src
.full_width
, geo
->src
.full_height
);
178 mxr_dbg(mdev
, "src.size = (%u, %u)\n",
179 geo
->src
.width
, geo
->src
.height
);
180 mxr_dbg(mdev
, "src.offset = (%u, %u)\n",
181 geo
->src
.x_offset
, geo
->src
.y_offset
);
182 mxr_dbg(mdev
, "dst.full_size = (%u, %u)\n",
183 geo
->dst
.full_width
, geo
->dst
.full_height
);
184 mxr_dbg(mdev
, "dst.size = (%u, %u)\n",
185 geo
->dst
.width
, geo
->dst
.height
);
186 mxr_dbg(mdev
, "dst.offset = (%u, %u)\n",
187 geo
->dst
.x_offset
, geo
->dst
.y_offset
);
188 mxr_dbg(mdev
, "ratio = (%u, %u)\n",
189 geo
->x_ratio
, geo
->y_ratio
);
192 static void mxr_layer_default_geo(struct mxr_layer
*layer
)
194 struct mxr_device
*mdev
= layer
->mdev
;
195 struct v4l2_mbus_framefmt mbus_fmt
;
197 memset(&layer
->geo
, 0, sizeof(layer
->geo
));
199 mxr_get_mbus_fmt(mdev
, &mbus_fmt
);
201 layer
->geo
.dst
.full_width
= mbus_fmt
.width
;
202 layer
->geo
.dst
.full_height
= mbus_fmt
.height
;
203 layer
->geo
.dst
.width
= layer
->geo
.dst
.full_width
;
204 layer
->geo
.dst
.height
= layer
->geo
.dst
.full_height
;
205 layer
->geo
.dst
.field
= mbus_fmt
.field
;
207 layer
->geo
.src
.full_width
= mbus_fmt
.width
;
208 layer
->geo
.src
.full_height
= mbus_fmt
.height
;
209 layer
->geo
.src
.width
= layer
->geo
.src
.full_width
;
210 layer
->geo
.src
.height
= layer
->geo
.src
.full_height
;
212 mxr_geometry_dump(mdev
, &layer
->geo
);
213 layer
->ops
.fix_geometry(layer
, MXR_GEOMETRY_SINK
, 0);
214 mxr_geometry_dump(mdev
, &layer
->geo
);
217 static void mxr_layer_update_output(struct mxr_layer
*layer
)
219 struct mxr_device
*mdev
= layer
->mdev
;
220 struct v4l2_mbus_framefmt mbus_fmt
;
222 mxr_get_mbus_fmt(mdev
, &mbus_fmt
);
223 /* checking if update is needed */
224 if (layer
->geo
.dst
.full_width
== mbus_fmt
.width
&&
225 layer
->geo
.dst
.full_height
== mbus_fmt
.width
)
228 layer
->geo
.dst
.full_width
= mbus_fmt
.width
;
229 layer
->geo
.dst
.full_height
= mbus_fmt
.height
;
230 layer
->geo
.dst
.field
= mbus_fmt
.field
;
231 layer
->ops
.fix_geometry(layer
, MXR_GEOMETRY_SINK
, 0);
233 mxr_geometry_dump(mdev
, &layer
->geo
);
236 static const struct mxr_format
*find_format_by_fourcc(
237 struct mxr_layer
*layer
, unsigned long fourcc
);
238 static const struct mxr_format
*find_format_by_index(
239 struct mxr_layer
*layer
, unsigned long index
);
241 static int mxr_enum_fmt(struct file
*file
, void *priv
,
242 struct v4l2_fmtdesc
*f
)
244 struct mxr_layer
*layer
= video_drvdata(file
);
245 struct mxr_device
*mdev
= layer
->mdev
;
246 const struct mxr_format
*fmt
;
248 mxr_dbg(mdev
, "%s\n", __func__
);
249 fmt
= find_format_by_index(layer
, f
->index
);
253 strlcpy(f
->description
, fmt
->name
, sizeof(f
->description
));
254 f
->pixelformat
= fmt
->fourcc
;
259 static unsigned int divup(unsigned int divident
, unsigned int divisor
)
261 return (divident
+ divisor
- 1) / divisor
;
264 unsigned long mxr_get_plane_size(const struct mxr_block
*blk
,
265 unsigned int width
, unsigned int height
)
267 unsigned int bl_width
= divup(width
, blk
->width
);
268 unsigned int bl_height
= divup(height
, blk
->height
);
270 return bl_width
* bl_height
* blk
->size
;
273 static void mxr_mplane_fill(struct v4l2_plane_pix_format
*planes
,
274 const struct mxr_format
*fmt
, u32 width
, u32 height
)
278 /* checking if nothing to fill */
282 memset(planes
, 0, sizeof(*planes
) * fmt
->num_subframes
);
283 for (i
= 0; i
< fmt
->num_planes
; ++i
) {
284 struct v4l2_plane_pix_format
*plane
= planes
285 + fmt
->plane2subframe
[i
];
286 const struct mxr_block
*blk
= &fmt
->plane
[i
];
287 u32 bl_width
= divup(width
, blk
->width
);
288 u32 bl_height
= divup(height
, blk
->height
);
289 u32 sizeimage
= bl_width
* bl_height
* blk
->size
;
290 u32 bytesperline
= bl_width
* blk
->size
/ blk
->height
;
292 plane
->sizeimage
+= sizeimage
;
293 plane
->bytesperline
= max(plane
->bytesperline
, bytesperline
);
297 static int mxr_g_fmt(struct file
*file
, void *priv
,
298 struct v4l2_format
*f
)
300 struct mxr_layer
*layer
= video_drvdata(file
);
301 struct v4l2_pix_format_mplane
*pix
= &f
->fmt
.pix_mp
;
303 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
305 pix
->width
= layer
->geo
.src
.full_width
;
306 pix
->height
= layer
->geo
.src
.full_height
;
307 pix
->field
= V4L2_FIELD_NONE
;
308 pix
->pixelformat
= layer
->fmt
->fourcc
;
309 pix
->colorspace
= layer
->fmt
->colorspace
;
310 mxr_mplane_fill(pix
->plane_fmt
, layer
->fmt
, pix
->width
, pix
->height
);
315 static int mxr_s_fmt(struct file
*file
, void *priv
,
316 struct v4l2_format
*f
)
318 struct mxr_layer
*layer
= video_drvdata(file
);
319 const struct mxr_format
*fmt
;
320 struct v4l2_pix_format_mplane
*pix
;
321 struct mxr_device
*mdev
= layer
->mdev
;
322 struct mxr_geometry
*geo
= &layer
->geo
;
324 mxr_dbg(mdev
, "%s:%d\n", __func__
, __LINE__
);
326 pix
= &f
->fmt
.pix_mp
;
327 fmt
= find_format_by_fourcc(layer
, pix
->pixelformat
);
329 mxr_warn(mdev
, "not recognized fourcc: %08x\n",
334 /* set source size to highest accepted value */
335 geo
->src
.full_width
= max(geo
->dst
.full_width
, pix
->width
);
336 geo
->src
.full_height
= max(geo
->dst
.full_height
, pix
->height
);
337 layer
->ops
.fix_geometry(layer
, MXR_GEOMETRY_SOURCE
, 0);
338 mxr_geometry_dump(mdev
, &layer
->geo
);
339 /* set cropping to total visible screen */
340 geo
->src
.width
= pix
->width
;
341 geo
->src
.height
= pix
->height
;
342 geo
->src
.x_offset
= 0;
343 geo
->src
.y_offset
= 0;
344 /* assure consistency of geometry */
345 layer
->ops
.fix_geometry(layer
, MXR_GEOMETRY_CROP
, MXR_NO_OFFSET
);
346 mxr_geometry_dump(mdev
, &layer
->geo
);
347 /* set full size to lowest possible value */
348 geo
->src
.full_width
= 0;
349 geo
->src
.full_height
= 0;
350 layer
->ops
.fix_geometry(layer
, MXR_GEOMETRY_SOURCE
, 0);
351 mxr_geometry_dump(mdev
, &layer
->geo
);
353 /* returning results */
354 mxr_g_fmt(file
, priv
, f
);
359 static int mxr_g_selection(struct file
*file
, void *fh
,
360 struct v4l2_selection
*s
)
362 struct mxr_layer
*layer
= video_drvdata(file
);
363 struct mxr_geometry
*geo
= &layer
->geo
;
365 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
367 if (s
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
368 s
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
372 case V4L2_SEL_TGT_CROP
:
373 s
->r
.left
= geo
->src
.x_offset
;
374 s
->r
.top
= geo
->src
.y_offset
;
375 s
->r
.width
= geo
->src
.width
;
376 s
->r
.height
= geo
->src
.height
;
378 case V4L2_SEL_TGT_CROP_DEFAULT
:
379 case V4L2_SEL_TGT_CROP_BOUNDS
:
382 s
->r
.width
= geo
->src
.full_width
;
383 s
->r
.height
= geo
->src
.full_height
;
385 case V4L2_SEL_TGT_COMPOSE
:
386 case V4L2_SEL_TGT_COMPOSE_PADDED
:
387 s
->r
.left
= geo
->dst
.x_offset
;
388 s
->r
.top
= geo
->dst
.y_offset
;
389 s
->r
.width
= geo
->dst
.width
;
390 s
->r
.height
= geo
->dst
.height
;
392 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
393 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
396 s
->r
.width
= geo
->dst
.full_width
;
397 s
->r
.height
= geo
->dst
.full_height
;
406 /* returns 1 if rectangle 'a' is inside 'b' */
407 static int mxr_is_rect_inside(struct v4l2_rect
*a
, struct v4l2_rect
*b
)
409 if (a
->left
< b
->left
)
413 if (a
->left
+ a
->width
> b
->left
+ b
->width
)
415 if (a
->top
+ a
->height
> b
->top
+ b
->height
)
420 static int mxr_s_selection(struct file
*file
, void *fh
,
421 struct v4l2_selection
*s
)
423 struct mxr_layer
*layer
= video_drvdata(file
);
424 struct mxr_geometry
*geo
= &layer
->geo
;
425 struct mxr_crop
*target
= NULL
;
426 enum mxr_geometry_stage stage
;
427 struct mxr_geometry tmp
;
428 struct v4l2_rect res
;
430 memset(&res
, 0, sizeof(res
));
432 mxr_dbg(layer
->mdev
, "%s: rect: %dx%d@%d,%d\n", __func__
,
433 s
->r
.width
, s
->r
.height
, s
->r
.left
, s
->r
.top
);
435 if (s
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
&&
436 s
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
440 /* ignore read-only targets */
441 case V4L2_SEL_TGT_CROP_DEFAULT
:
442 case V4L2_SEL_TGT_CROP_BOUNDS
:
443 res
.width
= geo
->src
.full_width
;
444 res
.height
= geo
->src
.full_height
;
447 /* ignore read-only targets */
448 case V4L2_SEL_TGT_COMPOSE_DEFAULT
:
449 case V4L2_SEL_TGT_COMPOSE_BOUNDS
:
450 res
.width
= geo
->dst
.full_width
;
451 res
.height
= geo
->dst
.full_height
;
454 case V4L2_SEL_TGT_CROP
:
456 stage
= MXR_GEOMETRY_CROP
;
458 case V4L2_SEL_TGT_COMPOSE
:
459 case V4L2_SEL_TGT_COMPOSE_PADDED
:
461 stage
= MXR_GEOMETRY_COMPOSE
;
466 /* apply change and update geometry if needed */
468 /* backup current geometry if setup fails */
469 memcpy(&tmp
, geo
, sizeof(tmp
));
471 /* apply requested selection */
472 target
->x_offset
= s
->r
.left
;
473 target
->y_offset
= s
->r
.top
;
474 target
->width
= s
->r
.width
;
475 target
->height
= s
->r
.height
;
477 layer
->ops
.fix_geometry(layer
, stage
, s
->flags
);
479 /* retrieve update selection rectangle */
480 res
.left
= target
->x_offset
;
481 res
.top
= target
->y_offset
;
482 res
.width
= target
->width
;
483 res
.height
= target
->height
;
485 mxr_geometry_dump(layer
->mdev
, &layer
->geo
);
488 /* checking if the rectangle satisfies constraints */
489 if ((s
->flags
& V4L2_SEL_FLAG_LE
) && !mxr_is_rect_inside(&res
, &s
->r
))
491 if ((s
->flags
& V4L2_SEL_FLAG_GE
) && !mxr_is_rect_inside(&s
->r
, &res
))
494 /* return result rectangle */
499 /* restore old geometry, which is not touched if target is NULL */
501 memcpy(geo
, &tmp
, sizeof(tmp
));
505 static int mxr_enum_dv_timings(struct file
*file
, void *fh
,
506 struct v4l2_enum_dv_timings
*timings
)
508 struct mxr_layer
*layer
= video_drvdata(file
);
509 struct mxr_device
*mdev
= layer
->mdev
;
514 /* lock protects from changing sd_out */
515 mutex_lock(&mdev
->mutex
);
516 ret
= v4l2_subdev_call(to_outsd(mdev
), pad
, enum_dv_timings
, timings
);
517 mutex_unlock(&mdev
->mutex
);
519 return ret
? -EINVAL
: 0;
522 static int mxr_s_dv_timings(struct file
*file
, void *fh
,
523 struct v4l2_dv_timings
*timings
)
525 struct mxr_layer
*layer
= video_drvdata(file
);
526 struct mxr_device
*mdev
= layer
->mdev
;
529 /* lock protects from changing sd_out */
530 mutex_lock(&mdev
->mutex
);
532 /* timings change cannot be done while there is an entity
533 * dependent on output configuration
535 if (mdev
->n_output
> 0) {
536 mutex_unlock(&mdev
->mutex
);
540 ret
= v4l2_subdev_call(to_outsd(mdev
), video
, s_dv_timings
, timings
);
542 mutex_unlock(&mdev
->mutex
);
544 mxr_layer_update_output(layer
);
546 /* any failure should return EINVAL according to V4L2 doc */
547 return ret
? -EINVAL
: 0;
550 static int mxr_g_dv_timings(struct file
*file
, void *fh
,
551 struct v4l2_dv_timings
*timings
)
553 struct mxr_layer
*layer
= video_drvdata(file
);
554 struct mxr_device
*mdev
= layer
->mdev
;
557 /* lock protects from changing sd_out */
558 mutex_lock(&mdev
->mutex
);
559 ret
= v4l2_subdev_call(to_outsd(mdev
), video
, g_dv_timings
, timings
);
560 mutex_unlock(&mdev
->mutex
);
562 return ret
? -EINVAL
: 0;
565 static int mxr_dv_timings_cap(struct file
*file
, void *fh
,
566 struct v4l2_dv_timings_cap
*cap
)
568 struct mxr_layer
*layer
= video_drvdata(file
);
569 struct mxr_device
*mdev
= layer
->mdev
;
574 /* lock protects from changing sd_out */
575 mutex_lock(&mdev
->mutex
);
576 ret
= v4l2_subdev_call(to_outsd(mdev
), pad
, dv_timings_cap
, cap
);
577 mutex_unlock(&mdev
->mutex
);
579 return ret
? -EINVAL
: 0;
582 static int mxr_s_std(struct file
*file
, void *fh
, v4l2_std_id norm
)
584 struct mxr_layer
*layer
= video_drvdata(file
);
585 struct mxr_device
*mdev
= layer
->mdev
;
588 /* lock protects from changing sd_out */
589 mutex_lock(&mdev
->mutex
);
591 /* standard change cannot be done while there is an entity
592 * dependent on output configuration
594 if (mdev
->n_output
> 0) {
595 mutex_unlock(&mdev
->mutex
);
599 ret
= v4l2_subdev_call(to_outsd(mdev
), video
, s_std_output
, norm
);
601 mutex_unlock(&mdev
->mutex
);
603 mxr_layer_update_output(layer
);
605 return ret
? -EINVAL
: 0;
608 static int mxr_g_std(struct file
*file
, void *fh
, v4l2_std_id
*norm
)
610 struct mxr_layer
*layer
= video_drvdata(file
);
611 struct mxr_device
*mdev
= layer
->mdev
;
614 /* lock protects from changing sd_out */
615 mutex_lock(&mdev
->mutex
);
616 ret
= v4l2_subdev_call(to_outsd(mdev
), video
, g_std_output
, norm
);
617 mutex_unlock(&mdev
->mutex
);
619 return ret
? -EINVAL
: 0;
622 static int mxr_enum_output(struct file
*file
, void *fh
, struct v4l2_output
*a
)
624 struct mxr_layer
*layer
= video_drvdata(file
);
625 struct mxr_device
*mdev
= layer
->mdev
;
626 struct mxr_output
*out
;
627 struct v4l2_subdev
*sd
;
629 if (a
->index
>= mdev
->output_cnt
)
631 out
= mdev
->output
[a
->index
];
634 strlcpy(a
->name
, out
->name
, sizeof(a
->name
));
636 /* try to obtain supported tv norms */
637 v4l2_subdev_call(sd
, video
, g_tvnorms_output
, &a
->std
);
639 if (sd
->ops
->video
&& sd
->ops
->video
->s_dv_timings
)
640 a
->capabilities
|= V4L2_OUT_CAP_DV_TIMINGS
;
641 if (sd
->ops
->video
&& sd
->ops
->video
->s_std_output
)
642 a
->capabilities
|= V4L2_OUT_CAP_STD
;
643 a
->type
= V4L2_OUTPUT_TYPE_ANALOG
;
648 static int mxr_s_output(struct file
*file
, void *fh
, unsigned int i
)
650 struct video_device
*vfd
= video_devdata(file
);
651 struct mxr_layer
*layer
= video_drvdata(file
);
652 struct mxr_device
*mdev
= layer
->mdev
;
654 if (i
>= mdev
->output_cnt
|| mdev
->output
[i
] == NULL
)
657 mutex_lock(&mdev
->mutex
);
658 if (mdev
->n_output
> 0) {
659 mutex_unlock(&mdev
->mutex
);
662 mdev
->current_output
= i
;
664 v4l2_subdev_call(to_outsd(mdev
), video
, g_tvnorms_output
,
666 mutex_unlock(&mdev
->mutex
);
668 /* update layers geometry */
669 mxr_layer_update_output(layer
);
671 mxr_dbg(mdev
, "tvnorms = %08llx\n", vfd
->tvnorms
);
676 static int mxr_g_output(struct file
*file
, void *fh
, unsigned int *p
)
678 struct mxr_layer
*layer
= video_drvdata(file
);
679 struct mxr_device
*mdev
= layer
->mdev
;
681 mutex_lock(&mdev
->mutex
);
682 *p
= mdev
->current_output
;
683 mutex_unlock(&mdev
->mutex
);
688 static int mxr_reqbufs(struct file
*file
, void *priv
,
689 struct v4l2_requestbuffers
*p
)
691 struct mxr_layer
*layer
= video_drvdata(file
);
693 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
694 return vb2_reqbufs(&layer
->vb_queue
, p
);
697 static int mxr_querybuf(struct file
*file
, void *priv
, struct v4l2_buffer
*p
)
699 struct mxr_layer
*layer
= video_drvdata(file
);
701 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
702 return vb2_querybuf(&layer
->vb_queue
, p
);
705 static int mxr_qbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*p
)
707 struct mxr_layer
*layer
= video_drvdata(file
);
709 mxr_dbg(layer
->mdev
, "%s:%d(%d)\n", __func__
, __LINE__
, p
->index
);
710 return vb2_qbuf(&layer
->vb_queue
, p
);
713 static int mxr_dqbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*p
)
715 struct mxr_layer
*layer
= video_drvdata(file
);
717 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
718 return vb2_dqbuf(&layer
->vb_queue
, p
, file
->f_flags
& O_NONBLOCK
);
721 static int mxr_expbuf(struct file
*file
, void *priv
,
722 struct v4l2_exportbuffer
*eb
)
724 struct mxr_layer
*layer
= video_drvdata(file
);
726 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
727 return vb2_expbuf(&layer
->vb_queue
, eb
);
730 static int mxr_streamon(struct file
*file
, void *priv
, enum v4l2_buf_type i
)
732 struct mxr_layer
*layer
= video_drvdata(file
);
734 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
735 return vb2_streamon(&layer
->vb_queue
, i
);
738 static int mxr_streamoff(struct file
*file
, void *priv
, enum v4l2_buf_type i
)
740 struct mxr_layer
*layer
= video_drvdata(file
);
742 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
743 return vb2_streamoff(&layer
->vb_queue
, i
);
746 static const struct v4l2_ioctl_ops mxr_ioctl_ops
= {
747 .vidioc_querycap
= mxr_querycap
,
748 /* format handling */
749 .vidioc_enum_fmt_vid_out_mplane
= mxr_enum_fmt
,
750 .vidioc_s_fmt_vid_out_mplane
= mxr_s_fmt
,
751 .vidioc_g_fmt_vid_out_mplane
= mxr_g_fmt
,
753 .vidioc_reqbufs
= mxr_reqbufs
,
754 .vidioc_querybuf
= mxr_querybuf
,
755 .vidioc_qbuf
= mxr_qbuf
,
756 .vidioc_dqbuf
= mxr_dqbuf
,
757 .vidioc_expbuf
= mxr_expbuf
,
758 /* Streaming control */
759 .vidioc_streamon
= mxr_streamon
,
760 .vidioc_streamoff
= mxr_streamoff
,
761 /* DV Timings functions */
762 .vidioc_enum_dv_timings
= mxr_enum_dv_timings
,
763 .vidioc_s_dv_timings
= mxr_s_dv_timings
,
764 .vidioc_g_dv_timings
= mxr_g_dv_timings
,
765 .vidioc_dv_timings_cap
= mxr_dv_timings_cap
,
766 /* analog TV standard functions */
767 .vidioc_s_std
= mxr_s_std
,
768 .vidioc_g_std
= mxr_g_std
,
769 /* Output handling */
770 .vidioc_enum_output
= mxr_enum_output
,
771 .vidioc_s_output
= mxr_s_output
,
772 .vidioc_g_output
= mxr_g_output
,
773 /* selection ioctls */
774 .vidioc_g_selection
= mxr_g_selection
,
775 .vidioc_s_selection
= mxr_s_selection
,
778 static int mxr_video_open(struct file
*file
)
780 struct mxr_layer
*layer
= video_drvdata(file
);
781 struct mxr_device
*mdev
= layer
->mdev
;
784 mxr_dbg(mdev
, "%s:%d\n", __func__
, __LINE__
);
785 if (mutex_lock_interruptible(&layer
->mutex
))
787 /* assure device probe is finished */
788 wait_for_device_probe();
789 /* creating context for file descriptor */
790 ret
= v4l2_fh_open(file
);
792 mxr_err(mdev
, "v4l2_fh_open failed\n");
796 /* leaving if layer is already initialized */
797 if (!v4l2_fh_is_singular_file(file
))
800 /* FIXME: should power be enabled on open? */
801 ret
= mxr_power_get(mdev
);
803 mxr_err(mdev
, "power on failed\n");
807 ret
= vb2_queue_init(&layer
->vb_queue
);
809 mxr_err(mdev
, "failed to initialize vb2 queue\n");
812 /* set default format, first on the list */
813 layer
->fmt
= layer
->fmt_array
[0];
814 /* setup default geometry */
815 mxr_layer_default_geo(layer
);
816 mutex_unlock(&layer
->mutex
);
824 v4l2_fh_release(file
);
827 mutex_unlock(&layer
->mutex
);
833 mxr_video_poll(struct file
*file
, struct poll_table_struct
*wait
)
835 struct mxr_layer
*layer
= video_drvdata(file
);
838 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
840 mutex_lock(&layer
->mutex
);
841 res
= vb2_poll(&layer
->vb_queue
, file
, wait
);
842 mutex_unlock(&layer
->mutex
);
846 static int mxr_video_mmap(struct file
*file
, struct vm_area_struct
*vma
)
848 struct mxr_layer
*layer
= video_drvdata(file
);
851 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
853 if (mutex_lock_interruptible(&layer
->mutex
))
855 ret
= vb2_mmap(&layer
->vb_queue
, vma
);
856 mutex_unlock(&layer
->mutex
);
860 static int mxr_video_release(struct file
*file
)
862 struct mxr_layer
*layer
= video_drvdata(file
);
864 mxr_dbg(layer
->mdev
, "%s:%d\n", __func__
, __LINE__
);
865 mutex_lock(&layer
->mutex
);
866 if (v4l2_fh_is_singular_file(file
)) {
867 vb2_queue_release(&layer
->vb_queue
);
868 mxr_power_put(layer
->mdev
);
870 v4l2_fh_release(file
);
871 mutex_unlock(&layer
->mutex
);
875 static const struct v4l2_file_operations mxr_fops
= {
876 .owner
= THIS_MODULE
,
877 .open
= mxr_video_open
,
878 .poll
= mxr_video_poll
,
879 .mmap
= mxr_video_mmap
,
880 .release
= mxr_video_release
,
881 .unlocked_ioctl
= video_ioctl2
,
884 static int queue_setup(struct vb2_queue
*vq
,
885 unsigned int *nbuffers
, unsigned int *nplanes
, unsigned int sizes
[],
888 struct mxr_layer
*layer
= vb2_get_drv_priv(vq
);
889 const struct mxr_format
*fmt
= layer
->fmt
;
891 struct mxr_device
*mdev
= layer
->mdev
;
892 struct v4l2_plane_pix_format planes
[3];
894 mxr_dbg(mdev
, "%s\n", __func__
);
895 /* checking if format was configured */
898 mxr_dbg(mdev
, "fmt = %s\n", fmt
->name
);
899 mxr_mplane_fill(planes
, fmt
, layer
->geo
.src
.full_width
,
900 layer
->geo
.src
.full_height
);
902 *nplanes
= fmt
->num_subframes
;
903 for (i
= 0; i
< fmt
->num_subframes
; ++i
) {
904 alloc_ctxs
[i
] = layer
->mdev
->alloc_ctx
;
905 sizes
[i
] = planes
[i
].sizeimage
;
906 mxr_dbg(mdev
, "size[%d] = %08x\n", i
, sizes
[i
]);
915 static void buf_queue(struct vb2_buffer
*vb
)
917 struct vb2_v4l2_buffer
*vbuf
= to_vb2_v4l2_buffer(vb
);
918 struct mxr_buffer
*buffer
= container_of(vbuf
, struct mxr_buffer
, vb
);
919 struct mxr_layer
*layer
= vb2_get_drv_priv(vb
->vb2_queue
);
920 struct mxr_device
*mdev
= layer
->mdev
;
923 spin_lock_irqsave(&layer
->enq_slock
, flags
);
924 list_add_tail(&buffer
->list
, &layer
->enq_list
);
925 spin_unlock_irqrestore(&layer
->enq_slock
, flags
);
927 mxr_dbg(mdev
, "queuing buffer\n");
930 static int start_streaming(struct vb2_queue
*vq
, unsigned int count
)
932 struct mxr_layer
*layer
= vb2_get_drv_priv(vq
);
933 struct mxr_device
*mdev
= layer
->mdev
;
936 mxr_dbg(mdev
, "%s\n", __func__
);
938 /* block any changes in output configuration */
939 mxr_output_get(mdev
);
941 mxr_layer_update_output(layer
);
942 layer
->ops
.format_set(layer
);
943 /* enabling layer in hardware */
944 spin_lock_irqsave(&layer
->enq_slock
, flags
);
945 layer
->state
= MXR_LAYER_STREAMING
;
946 spin_unlock_irqrestore(&layer
->enq_slock
, flags
);
948 layer
->ops
.stream_set(layer
, MXR_ENABLE
);
949 mxr_streamer_get(mdev
);
954 static void mxr_watchdog(unsigned long arg
)
956 struct mxr_layer
*layer
= (struct mxr_layer
*) arg
;
957 struct mxr_device
*mdev
= layer
->mdev
;
960 mxr_err(mdev
, "watchdog fired for layer %s\n", layer
->vfd
.name
);
962 spin_lock_irqsave(&layer
->enq_slock
, flags
);
964 if (layer
->update_buf
== layer
->shadow_buf
)
965 layer
->update_buf
= NULL
;
966 if (layer
->update_buf
) {
967 vb2_buffer_done(&layer
->update_buf
->vb
.vb2_buf
,
968 VB2_BUF_STATE_ERROR
);
969 layer
->update_buf
= NULL
;
971 if (layer
->shadow_buf
) {
972 vb2_buffer_done(&layer
->shadow_buf
->vb
.vb2_buf
,
973 VB2_BUF_STATE_ERROR
);
974 layer
->shadow_buf
= NULL
;
976 spin_unlock_irqrestore(&layer
->enq_slock
, flags
);
979 static void stop_streaming(struct vb2_queue
*vq
)
981 struct mxr_layer
*layer
= vb2_get_drv_priv(vq
);
982 struct mxr_device
*mdev
= layer
->mdev
;
984 struct timer_list watchdog
;
985 struct mxr_buffer
*buf
, *buf_tmp
;
987 mxr_dbg(mdev
, "%s\n", __func__
);
989 spin_lock_irqsave(&layer
->enq_slock
, flags
);
992 layer
->state
= MXR_LAYER_STREAMING_FINISH
;
994 /* set all buffer to be done */
995 list_for_each_entry_safe(buf
, buf_tmp
, &layer
->enq_list
, list
) {
996 list_del(&buf
->list
);
997 vb2_buffer_done(&buf
->vb
.vb2_buf
, VB2_BUF_STATE_ERROR
);
1000 spin_unlock_irqrestore(&layer
->enq_slock
, flags
);
1002 /* give 1 seconds to complete to complete last buffers */
1003 setup_timer_on_stack(&watchdog
, mxr_watchdog
,
1004 (unsigned long)layer
);
1005 mod_timer(&watchdog
, jiffies
+ msecs_to_jiffies(1000));
1007 /* wait until all buffers are goes to done state */
1008 vb2_wait_for_all_buffers(vq
);
1010 /* stop timer if all synchronization is done */
1011 del_timer_sync(&watchdog
);
1012 destroy_timer_on_stack(&watchdog
);
1014 /* stopping hardware */
1015 spin_lock_irqsave(&layer
->enq_slock
, flags
);
1016 layer
->state
= MXR_LAYER_IDLE
;
1017 spin_unlock_irqrestore(&layer
->enq_slock
, flags
);
1019 /* disabling layer in hardware */
1020 layer
->ops
.stream_set(layer
, MXR_DISABLE
);
1021 /* remove one streamer */
1022 mxr_streamer_put(mdev
);
1023 /* allow changes in output configuration */
1024 mxr_output_put(mdev
);
1027 static struct vb2_ops mxr_video_qops
= {
1028 .queue_setup
= queue_setup
,
1029 .buf_queue
= buf_queue
,
1030 .wait_prepare
= vb2_ops_wait_prepare
,
1031 .wait_finish
= vb2_ops_wait_finish
,
1032 .start_streaming
= start_streaming
,
1033 .stop_streaming
= stop_streaming
,
1036 /* FIXME: try to put this functions to mxr_base_layer_create */
1037 int mxr_base_layer_register(struct mxr_layer
*layer
)
1039 struct mxr_device
*mdev
= layer
->mdev
;
1042 ret
= video_register_device(&layer
->vfd
, VFL_TYPE_GRABBER
, -1);
1044 mxr_err(mdev
, "failed to register video device\n");
1046 mxr_info(mdev
, "registered layer %s as /dev/video%d\n",
1047 layer
->vfd
.name
, layer
->vfd
.num
);
1051 void mxr_base_layer_unregister(struct mxr_layer
*layer
)
1053 video_unregister_device(&layer
->vfd
);
1056 void mxr_layer_release(struct mxr_layer
*layer
)
1058 if (layer
->ops
.release
)
1059 layer
->ops
.release(layer
);
1062 void mxr_base_layer_release(struct mxr_layer
*layer
)
1067 static void mxr_vfd_release(struct video_device
*vdev
)
1069 pr_info("video device release\n");
1072 struct mxr_layer
*mxr_base_layer_create(struct mxr_device
*mdev
,
1073 int idx
, char *name
, struct mxr_layer_ops
*ops
)
1075 struct mxr_layer
*layer
;
1077 layer
= kzalloc(sizeof(*layer
), GFP_KERNEL
);
1078 if (layer
== NULL
) {
1079 mxr_err(mdev
, "not enough memory for layer.\n");
1087 spin_lock_init(&layer
->enq_slock
);
1088 INIT_LIST_HEAD(&layer
->enq_list
);
1089 mutex_init(&layer
->mutex
);
1091 layer
->vfd
= (struct video_device
) {
1093 .release
= mxr_vfd_release
,
1095 .vfl_dir
= VFL_DIR_TX
,
1096 .ioctl_ops
= &mxr_ioctl_ops
,
1098 strlcpy(layer
->vfd
.name
, name
, sizeof(layer
->vfd
.name
));
1100 video_set_drvdata(&layer
->vfd
, layer
);
1101 layer
->vfd
.lock
= &layer
->mutex
;
1102 layer
->vfd
.v4l2_dev
= &mdev
->v4l2_dev
;
1104 layer
->vb_queue
= (struct vb2_queue
) {
1105 .type
= V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
,
1106 .io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_DMABUF
,
1108 .buf_struct_size
= sizeof(struct mxr_buffer
),
1109 .ops
= &mxr_video_qops
,
1110 .min_buffers_needed
= 1,
1111 .mem_ops
= &vb2_dma_contig_memops
,
1112 .lock
= &layer
->mutex
,
1121 static const struct mxr_format
*find_format_by_fourcc(
1122 struct mxr_layer
*layer
, unsigned long fourcc
)
1126 for (i
= 0; i
< layer
->fmt_array_size
; ++i
)
1127 if (layer
->fmt_array
[i
]->fourcc
== fourcc
)
1128 return layer
->fmt_array
[i
];
1132 static const struct mxr_format
*find_format_by_index(
1133 struct mxr_layer
*layer
, unsigned long index
)
1135 if (index
>= layer
->fmt_array_size
)
1137 return layer
->fmt_array
[index
];