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_OR_NULL(mdev->alloc_ctx)) {
85 mxr_err(mdev, "could not acquire vb2 allocator\n");
89 /* registering outputs */
91 for (i = 0; i < output_count; ++i) {
92 struct mxr_output_conf *conf = &output_conf[i];
93 struct mxr_output *out;
95 sd = find_and_register_subdev(mdev, conf->module_name);
96 /* trying to register next output */
99 out = kzalloc(sizeof(*out), GFP_KERNEL);
101 mxr_err(mdev, "no memory for '%s'\n",
104 /* registered subdevs are removed in fail_v4l2_dev */
107 strlcpy(out->name, conf->output_name, sizeof(out->name));
109 out->cookie = conf->cookie;
110 mdev->output[mdev->output_cnt++] = out;
111 mxr_info(mdev, "added output '%s' from module '%s'\n",
112 conf->output_name, conf->module_name);
113 /* checking if maximal number of outputs is reached */
114 if (mdev->output_cnt >= MXR_MAX_OUTPUTS)
118 if (mdev->output_cnt == 0) {
119 mxr_err(mdev, "failed to register any output\n");
121 /* skipping fail_output because there is nothing to free */
122 goto fail_vb2_allocator;
128 /* kfree is NULL-safe */
129 for (i = 0; i < mdev->output_cnt; ++i)
130 kfree(mdev->output[i]);
131 memset(mdev->output, 0, sizeof(mdev->output));
134 /* freeing allocator context */
135 vb2_dma_contig_cleanup_ctx(mdev->alloc_ctx);
138 /* NOTE: automatically unregister all subdevs */
139 v4l2_device_unregister(v4l2_dev);
145 void mxr_release_video(struct mxr_device *mdev)
149 /* kfree is NULL-safe */
150 for (i = 0; i < mdev->output_cnt; ++i)
151 kfree(mdev->output[i]);
153 vb2_dma_contig_cleanup_ctx(mdev->alloc_ctx);
154 v4l2_device_unregister(&mdev->v4l2_dev);
157 static int mxr_querycap(struct file *file, void *priv,
158 struct v4l2_capability *cap)
160 struct mxr_layer *layer = video_drvdata(file);
162 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
164 strlcpy(cap->driver, MXR_DRIVER_NAME, sizeof(cap->driver));
165 strlcpy(cap->card, layer->vfd.name, sizeof(cap->card));
166 sprintf(cap->bus_info, "%d", layer->idx);
167 cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_OUTPUT_MPLANE;
168 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
173 static void mxr_geometry_dump(struct mxr_device *mdev, struct mxr_geometry *geo)
175 mxr_dbg(mdev, "src.full_size = (%u, %u)\n",
176 geo->src.full_width, geo->src.full_height);
177 mxr_dbg(mdev, "src.size = (%u, %u)\n",
178 geo->src.width, geo->src.height);
179 mxr_dbg(mdev, "src.offset = (%u, %u)\n",
180 geo->src.x_offset, geo->src.y_offset);
181 mxr_dbg(mdev, "dst.full_size = (%u, %u)\n",
182 geo->dst.full_width, geo->dst.full_height);
183 mxr_dbg(mdev, "dst.size = (%u, %u)\n",
184 geo->dst.width, geo->dst.height);
185 mxr_dbg(mdev, "dst.offset = (%u, %u)\n",
186 geo->dst.x_offset, geo->dst.y_offset);
187 mxr_dbg(mdev, "ratio = (%u, %u)\n",
188 geo->x_ratio, geo->y_ratio);
191 static void mxr_layer_default_geo(struct mxr_layer *layer)
193 struct mxr_device *mdev = layer->mdev;
194 struct v4l2_mbus_framefmt mbus_fmt;
196 memset(&layer->geo, 0, sizeof(layer->geo));
198 mxr_get_mbus_fmt(mdev, &mbus_fmt);
200 layer->geo.dst.full_width = mbus_fmt.width;
201 layer->geo.dst.full_height = mbus_fmt.height;
202 layer->geo.dst.width = layer->geo.dst.full_width;
203 layer->geo.dst.height = layer->geo.dst.full_height;
204 layer->geo.dst.field = mbus_fmt.field;
206 layer->geo.src.full_width = mbus_fmt.width;
207 layer->geo.src.full_height = mbus_fmt.height;
208 layer->geo.src.width = layer->geo.src.full_width;
209 layer->geo.src.height = layer->geo.src.full_height;
211 mxr_geometry_dump(mdev, &layer->geo);
212 layer->ops.fix_geometry(layer, MXR_GEOMETRY_SINK, 0);
213 mxr_geometry_dump(mdev, &layer->geo);
216 static void mxr_layer_update_output(struct mxr_layer *layer)
218 struct mxr_device *mdev = layer->mdev;
219 struct v4l2_mbus_framefmt mbus_fmt;
221 mxr_get_mbus_fmt(mdev, &mbus_fmt);
222 /* checking if update is needed */
223 if (layer->geo.dst.full_width == mbus_fmt.width &&
224 layer->geo.dst.full_height == mbus_fmt.width)
227 layer->geo.dst.full_width = mbus_fmt.width;
228 layer->geo.dst.full_height = mbus_fmt.height;
229 layer->geo.dst.field = mbus_fmt.field;
230 layer->ops.fix_geometry(layer, MXR_GEOMETRY_SINK, 0);
232 mxr_geometry_dump(mdev, &layer->geo);
235 static const struct mxr_format *find_format_by_fourcc(
236 struct mxr_layer *layer, unsigned long fourcc);
237 static const struct mxr_format *find_format_by_index(
238 struct mxr_layer *layer, unsigned long index);
240 static int mxr_enum_fmt(struct file *file, void *priv,
241 struct v4l2_fmtdesc *f)
243 struct mxr_layer *layer = video_drvdata(file);
244 struct mxr_device *mdev = layer->mdev;
245 const struct mxr_format *fmt;
247 mxr_dbg(mdev, "%s\n", __func__);
248 fmt = find_format_by_index(layer, f->index);
252 strlcpy(f->description, fmt->name, sizeof(f->description));
253 f->pixelformat = fmt->fourcc;
258 static unsigned int divup(unsigned int divident, unsigned int divisor)
260 return (divident + divisor - 1) / divisor;
263 unsigned long mxr_get_plane_size(const struct mxr_block *blk,
264 unsigned int width, unsigned int height)
266 unsigned int bl_width = divup(width, blk->width);
267 unsigned int bl_height = divup(height, blk->height);
269 return bl_width * bl_height * blk->size;
272 static void mxr_mplane_fill(struct v4l2_plane_pix_format *planes,
273 const struct mxr_format *fmt, u32 width, u32 height)
277 /* checking if nothing to fill */
281 memset(planes, 0, sizeof(*planes) * fmt->num_subframes);
282 for (i = 0; i < fmt->num_planes; ++i) {
283 struct v4l2_plane_pix_format *plane = planes
284 + fmt->plane2subframe[i];
285 const struct mxr_block *blk = &fmt->plane[i];
286 u32 bl_width = divup(width, blk->width);
287 u32 bl_height = divup(height, blk->height);
288 u32 sizeimage = bl_width * bl_height * blk->size;
289 u16 bytesperline = bl_width * blk->size / blk->height;
291 plane->sizeimage += sizeimage;
292 plane->bytesperline = max(plane->bytesperline, bytesperline);
296 static int mxr_g_fmt(struct file *file, void *priv,
297 struct v4l2_format *f)
299 struct mxr_layer *layer = video_drvdata(file);
300 struct v4l2_pix_format_mplane *pix = &f->fmt.pix_mp;
302 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
304 pix->width = layer->geo.src.full_width;
305 pix->height = layer->geo.src.full_height;
306 pix->field = V4L2_FIELD_NONE;
307 pix->pixelformat = layer->fmt->fourcc;
308 pix->colorspace = layer->fmt->colorspace;
309 mxr_mplane_fill(pix->plane_fmt, layer->fmt, pix->width, pix->height);
314 static int mxr_s_fmt(struct file *file, void *priv,
315 struct v4l2_format *f)
317 struct mxr_layer *layer = video_drvdata(file);
318 const struct mxr_format *fmt;
319 struct v4l2_pix_format_mplane *pix;
320 struct mxr_device *mdev = layer->mdev;
321 struct mxr_geometry *geo = &layer->geo;
323 mxr_dbg(mdev, "%s:%d\n", __func__, __LINE__);
325 pix = &f->fmt.pix_mp;
326 fmt = find_format_by_fourcc(layer, pix->pixelformat);
328 mxr_warn(mdev, "not recognized fourcc: %08x\n",
333 /* set source size to highest accepted value */
334 geo->src.full_width = max(geo->dst.full_width, pix->width);
335 geo->src.full_height = max(geo->dst.full_height, pix->height);
336 layer->ops.fix_geometry(layer, MXR_GEOMETRY_SOURCE, 0);
337 mxr_geometry_dump(mdev, &layer->geo);
338 /* set cropping to total visible screen */
339 geo->src.width = pix->width;
340 geo->src.height = pix->height;
341 geo->src.x_offset = 0;
342 geo->src.y_offset = 0;
343 /* assure consistency of geometry */
344 layer->ops.fix_geometry(layer, MXR_GEOMETRY_CROP, MXR_NO_OFFSET);
345 mxr_geometry_dump(mdev, &layer->geo);
346 /* set full size to lowest possible value */
347 geo->src.full_width = 0;
348 geo->src.full_height = 0;
349 layer->ops.fix_geometry(layer, MXR_GEOMETRY_SOURCE, 0);
350 mxr_geometry_dump(mdev, &layer->geo);
352 /* returning results */
353 mxr_g_fmt(file, priv, f);
358 static int mxr_g_selection(struct file *file, void *fh,
359 struct v4l2_selection *s)
361 struct mxr_layer *layer = video_drvdata(file);
362 struct mxr_geometry *geo = &layer->geo;
364 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
366 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
367 s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
371 case V4L2_SEL_TGT_CROP:
372 s->r.left = geo->src.x_offset;
373 s->r.top = geo->src.y_offset;
374 s->r.width = geo->src.width;
375 s->r.height = geo->src.height;
377 case V4L2_SEL_TGT_CROP_DEFAULT:
378 case V4L2_SEL_TGT_CROP_BOUNDS:
381 s->r.width = geo->src.full_width;
382 s->r.height = geo->src.full_height;
384 case V4L2_SEL_TGT_COMPOSE:
385 case V4L2_SEL_TGT_COMPOSE_PADDED:
386 s->r.left = geo->dst.x_offset;
387 s->r.top = geo->dst.y_offset;
388 s->r.width = geo->dst.width;
389 s->r.height = geo->dst.height;
391 case V4L2_SEL_TGT_COMPOSE_DEFAULT:
392 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
395 s->r.width = geo->dst.full_width;
396 s->r.height = geo->dst.full_height;
405 /* returns 1 if rectangle 'a' is inside 'b' */
406 static int mxr_is_rect_inside(struct v4l2_rect *a, struct v4l2_rect *b)
408 if (a->left < b->left)
412 if (a->left + a->width > b->left + b->width)
414 if (a->top + a->height > b->top + b->height)
419 static int mxr_s_selection(struct file *file, void *fh,
420 struct v4l2_selection *s)
422 struct mxr_layer *layer = video_drvdata(file);
423 struct mxr_geometry *geo = &layer->geo;
424 struct mxr_crop *target = NULL;
425 enum mxr_geometry_stage stage;
426 struct mxr_geometry tmp;
427 struct v4l2_rect res;
429 memset(&res, 0, sizeof(res));
431 mxr_dbg(layer->mdev, "%s: rect: %dx%d@%d,%d\n", __func__,
432 s->r.width, s->r.height, s->r.left, s->r.top);
434 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
435 s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
439 /* ignore read-only targets */
440 case V4L2_SEL_TGT_CROP_DEFAULT:
441 case V4L2_SEL_TGT_CROP_BOUNDS:
442 res.width = geo->src.full_width;
443 res.height = geo->src.full_height;
446 /* ignore read-only targets */
447 case V4L2_SEL_TGT_COMPOSE_DEFAULT:
448 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
449 res.width = geo->dst.full_width;
450 res.height = geo->dst.full_height;
453 case V4L2_SEL_TGT_CROP:
455 stage = MXR_GEOMETRY_CROP;
457 case V4L2_SEL_TGT_COMPOSE:
458 case V4L2_SEL_TGT_COMPOSE_PADDED:
460 stage = MXR_GEOMETRY_COMPOSE;
465 /* apply change and update geometry if needed */
467 /* backup current geometry if setup fails */
468 memcpy(&tmp, geo, sizeof(tmp));
470 /* apply requested selection */
471 target->x_offset = s->r.left;
472 target->y_offset = s->r.top;
473 target->width = s->r.width;
474 target->height = s->r.height;
476 layer->ops.fix_geometry(layer, stage, s->flags);
478 /* retrieve update selection rectangle */
479 res.left = target->x_offset;
480 res.top = target->y_offset;
481 res.width = target->width;
482 res.height = target->height;
484 mxr_geometry_dump(layer->mdev, &layer->geo);
487 /* checking if the rectangle satisfies constraints */
488 if ((s->flags & V4L2_SEL_FLAG_LE) && !mxr_is_rect_inside(&res, &s->r))
490 if ((s->flags & V4L2_SEL_FLAG_GE) && !mxr_is_rect_inside(&s->r, &res))
493 /* return result rectangle */
498 /* restore old geometry, which is not touched if target is NULL */
500 memcpy(geo, &tmp, sizeof(tmp));
504 static int mxr_enum_dv_presets(struct file *file, void *fh,
505 struct v4l2_dv_enum_preset *preset)
507 struct mxr_layer *layer = video_drvdata(file);
508 struct mxr_device *mdev = layer->mdev;
511 /* lock protects from changing sd_out */
512 mutex_lock(&mdev->mutex);
513 ret = v4l2_subdev_call(to_outsd(mdev), video, enum_dv_presets, preset);
514 mutex_unlock(&mdev->mutex);
516 return ret ? -EINVAL : 0;
519 static int mxr_s_dv_preset(struct file *file, void *fh,
520 struct v4l2_dv_preset *preset)
522 struct mxr_layer *layer = video_drvdata(file);
523 struct mxr_device *mdev = layer->mdev;
526 /* lock protects from changing sd_out */
527 mutex_lock(&mdev->mutex);
529 /* preset change cannot be done while there is an entity
530 * dependant on output configuration
532 if (mdev->n_output > 0) {
533 mutex_unlock(&mdev->mutex);
537 ret = v4l2_subdev_call(to_outsd(mdev), video, s_dv_preset, preset);
539 mutex_unlock(&mdev->mutex);
541 mxr_layer_update_output(layer);
543 /* any failure should return EINVAL according to V4L2 doc */
544 return ret ? -EINVAL : 0;
547 static int mxr_g_dv_preset(struct file *file, void *fh,
548 struct v4l2_dv_preset *preset)
550 struct mxr_layer *layer = video_drvdata(file);
551 struct mxr_device *mdev = layer->mdev;
554 /* lock protects from changing sd_out */
555 mutex_lock(&mdev->mutex);
556 ret = v4l2_subdev_call(to_outsd(mdev), video, g_dv_preset, preset);
557 mutex_unlock(&mdev->mutex);
559 return ret ? -EINVAL : 0;
562 static int mxr_s_std(struct file *file, void *fh, v4l2_std_id *norm)
564 struct mxr_layer *layer = video_drvdata(file);
565 struct mxr_device *mdev = layer->mdev;
568 /* lock protects from changing sd_out */
569 mutex_lock(&mdev->mutex);
571 /* standard change cannot be done while there is an entity
572 * dependant on output configuration
574 if (mdev->n_output > 0) {
575 mutex_unlock(&mdev->mutex);
579 ret = v4l2_subdev_call(to_outsd(mdev), video, s_std_output, *norm);
581 mutex_unlock(&mdev->mutex);
583 mxr_layer_update_output(layer);
585 return ret ? -EINVAL : 0;
588 static int mxr_g_std(struct file *file, void *fh, v4l2_std_id *norm)
590 struct mxr_layer *layer = video_drvdata(file);
591 struct mxr_device *mdev = layer->mdev;
594 /* lock protects from changing sd_out */
595 mutex_lock(&mdev->mutex);
596 ret = v4l2_subdev_call(to_outsd(mdev), video, g_std_output, norm);
597 mutex_unlock(&mdev->mutex);
599 return ret ? -EINVAL : 0;
602 static int mxr_enum_output(struct file *file, void *fh, struct v4l2_output *a)
604 struct mxr_layer *layer = video_drvdata(file);
605 struct mxr_device *mdev = layer->mdev;
606 struct mxr_output *out;
607 struct v4l2_subdev *sd;
609 if (a->index >= mdev->output_cnt)
611 out = mdev->output[a->index];
614 strlcpy(a->name, out->name, sizeof(a->name));
616 /* try to obtain supported tv norms */
617 v4l2_subdev_call(sd, video, g_tvnorms_output, &a->std);
619 if (sd->ops->video && sd->ops->video->s_dv_preset)
620 a->capabilities |= V4L2_OUT_CAP_PRESETS;
621 if (sd->ops->video && sd->ops->video->s_std_output)
622 a->capabilities |= V4L2_OUT_CAP_STD;
623 a->type = V4L2_OUTPUT_TYPE_ANALOG;
628 static int mxr_s_output(struct file *file, void *fh, unsigned int i)
630 struct video_device *vfd = video_devdata(file);
631 struct mxr_layer *layer = video_drvdata(file);
632 struct mxr_device *mdev = layer->mdev;
634 if (i >= mdev->output_cnt || mdev->output[i] == NULL)
637 mutex_lock(&mdev->mutex);
638 if (mdev->n_output > 0) {
639 mutex_unlock(&mdev->mutex);
642 mdev->current_output = i;
644 v4l2_subdev_call(to_outsd(mdev), video, g_tvnorms_output,
646 mutex_unlock(&mdev->mutex);
648 /* update layers geometry */
649 mxr_layer_update_output(layer);
651 mxr_dbg(mdev, "tvnorms = %08llx\n", vfd->tvnorms);
656 static int mxr_g_output(struct file *file, void *fh, unsigned int *p)
658 struct mxr_layer *layer = video_drvdata(file);
659 struct mxr_device *mdev = layer->mdev;
661 mutex_lock(&mdev->mutex);
662 *p = mdev->current_output;
663 mutex_unlock(&mdev->mutex);
668 static int mxr_reqbufs(struct file *file, void *priv,
669 struct v4l2_requestbuffers *p)
671 struct mxr_layer *layer = video_drvdata(file);
673 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
674 return vb2_reqbufs(&layer->vb_queue, p);
677 static int mxr_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
679 struct mxr_layer *layer = video_drvdata(file);
681 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
682 return vb2_querybuf(&layer->vb_queue, p);
685 static int mxr_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
687 struct mxr_layer *layer = video_drvdata(file);
689 mxr_dbg(layer->mdev, "%s:%d(%d)\n", __func__, __LINE__, p->index);
690 return vb2_qbuf(&layer->vb_queue, p);
693 static int mxr_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
695 struct mxr_layer *layer = video_drvdata(file);
697 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
698 return vb2_dqbuf(&layer->vb_queue, p, file->f_flags & O_NONBLOCK);
701 static int mxr_expbuf(struct file *file, void *priv,
702 struct v4l2_exportbuffer *eb)
704 struct mxr_layer *layer = video_drvdata(file);
706 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
707 return vb2_expbuf(&layer->vb_queue, eb);
710 static int mxr_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
712 struct mxr_layer *layer = video_drvdata(file);
714 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
715 return vb2_streamon(&layer->vb_queue, i);
718 static int mxr_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
720 struct mxr_layer *layer = video_drvdata(file);
722 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
723 return vb2_streamoff(&layer->vb_queue, i);
726 static const struct v4l2_ioctl_ops mxr_ioctl_ops = {
727 .vidioc_querycap = mxr_querycap,
728 /* format handling */
729 .vidioc_enum_fmt_vid_out_mplane = mxr_enum_fmt,
730 .vidioc_s_fmt_vid_out_mplane = mxr_s_fmt,
731 .vidioc_g_fmt_vid_out_mplane = mxr_g_fmt,
733 .vidioc_reqbufs = mxr_reqbufs,
734 .vidioc_querybuf = mxr_querybuf,
735 .vidioc_qbuf = mxr_qbuf,
736 .vidioc_dqbuf = mxr_dqbuf,
737 .vidioc_expbuf = mxr_expbuf,
738 /* Streaming control */
739 .vidioc_streamon = mxr_streamon,
740 .vidioc_streamoff = mxr_streamoff,
741 /* Preset functions */
742 .vidioc_enum_dv_presets = mxr_enum_dv_presets,
743 .vidioc_s_dv_preset = mxr_s_dv_preset,
744 .vidioc_g_dv_preset = mxr_g_dv_preset,
745 /* analog TV standard functions */
746 .vidioc_s_std = mxr_s_std,
747 .vidioc_g_std = mxr_g_std,
748 /* Output handling */
749 .vidioc_enum_output = mxr_enum_output,
750 .vidioc_s_output = mxr_s_output,
751 .vidioc_g_output = mxr_g_output,
752 /* selection ioctls */
753 .vidioc_g_selection = mxr_g_selection,
754 .vidioc_s_selection = mxr_s_selection,
757 static int mxr_video_open(struct file *file)
759 struct mxr_layer *layer = video_drvdata(file);
760 struct mxr_device *mdev = layer->mdev;
763 mxr_dbg(mdev, "%s:%d\n", __func__, __LINE__);
764 if (mutex_lock_interruptible(&layer->mutex))
766 /* assure device probe is finished */
767 wait_for_device_probe();
768 /* creating context for file descriptor */
769 ret = v4l2_fh_open(file);
771 mxr_err(mdev, "v4l2_fh_open failed\n");
775 /* leaving if layer is already initialized */
776 if (!v4l2_fh_is_singular_file(file))
779 /* FIXME: should power be enabled on open? */
780 ret = mxr_power_get(mdev);
782 mxr_err(mdev, "power on failed\n");
786 ret = vb2_queue_init(&layer->vb_queue);
788 mxr_err(mdev, "failed to initialize vb2 queue\n");
791 /* set default format, first on the list */
792 layer->fmt = layer->fmt_array[0];
793 /* setup default geometry */
794 mxr_layer_default_geo(layer);
795 mutex_unlock(&layer->mutex);
803 v4l2_fh_release(file);
806 mutex_unlock(&layer->mutex);
812 mxr_video_poll(struct file *file, struct poll_table_struct *wait)
814 struct mxr_layer *layer = video_drvdata(file);
817 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
819 mutex_lock(&layer->mutex);
820 res = vb2_poll(&layer->vb_queue, file, wait);
821 mutex_unlock(&layer->mutex);
825 static int mxr_video_mmap(struct file *file, struct vm_area_struct *vma)
827 struct mxr_layer *layer = video_drvdata(file);
830 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
832 if (mutex_lock_interruptible(&layer->mutex))
834 ret = vb2_mmap(&layer->vb_queue, vma);
835 mutex_unlock(&layer->mutex);
839 static int mxr_video_release(struct file *file)
841 struct mxr_layer *layer = video_drvdata(file);
843 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
844 mutex_lock(&layer->mutex);
845 if (v4l2_fh_is_singular_file(file)) {
846 vb2_queue_release(&layer->vb_queue);
847 mxr_power_put(layer->mdev);
849 v4l2_fh_release(file);
850 mutex_unlock(&layer->mutex);
854 static const struct v4l2_file_operations mxr_fops = {
855 .owner = THIS_MODULE,
856 .open = mxr_video_open,
857 .poll = mxr_video_poll,
858 .mmap = mxr_video_mmap,
859 .release = mxr_video_release,
860 .unlocked_ioctl = video_ioctl2,
863 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *pfmt,
864 unsigned int *nbuffers, unsigned int *nplanes, unsigned int sizes[],
867 struct mxr_layer *layer = vb2_get_drv_priv(vq);
868 const struct mxr_format *fmt = layer->fmt;
870 struct mxr_device *mdev = layer->mdev;
871 struct v4l2_plane_pix_format planes[3];
873 mxr_dbg(mdev, "%s\n", __func__);
874 /* checking if format was configured */
877 mxr_dbg(mdev, "fmt = %s\n", fmt->name);
878 mxr_mplane_fill(planes, fmt, layer->geo.src.full_width,
879 layer->geo.src.full_height);
881 *nplanes = fmt->num_subframes;
882 for (i = 0; i < fmt->num_subframes; ++i) {
883 alloc_ctxs[i] = layer->mdev->alloc_ctx;
884 sizes[i] = planes[i].sizeimage;
885 mxr_dbg(mdev, "size[%d] = %08x\n", i, sizes[i]);
894 static void buf_queue(struct vb2_buffer *vb)
896 struct mxr_buffer *buffer = container_of(vb, struct mxr_buffer, vb);
897 struct mxr_layer *layer = vb2_get_drv_priv(vb->vb2_queue);
898 struct mxr_device *mdev = layer->mdev;
901 spin_lock_irqsave(&layer->enq_slock, flags);
902 list_add_tail(&buffer->list, &layer->enq_list);
903 spin_unlock_irqrestore(&layer->enq_slock, flags);
905 mxr_dbg(mdev, "queuing buffer\n");
908 static void wait_lock(struct vb2_queue *vq)
910 struct mxr_layer *layer = vb2_get_drv_priv(vq);
912 mxr_dbg(layer->mdev, "%s\n", __func__);
913 mutex_lock(&layer->mutex);
916 static void wait_unlock(struct vb2_queue *vq)
918 struct mxr_layer *layer = vb2_get_drv_priv(vq);
920 mxr_dbg(layer->mdev, "%s\n", __func__);
921 mutex_unlock(&layer->mutex);
924 static int start_streaming(struct vb2_queue *vq, unsigned int count)
926 struct mxr_layer *layer = vb2_get_drv_priv(vq);
927 struct mxr_device *mdev = layer->mdev;
930 mxr_dbg(mdev, "%s\n", __func__);
933 mxr_dbg(mdev, "no output buffers queued\n");
937 /* block any changes in output configuration */
938 mxr_output_get(mdev);
940 mxr_layer_update_output(layer);
941 layer->ops.format_set(layer);
942 /* enabling layer in hardware */
943 spin_lock_irqsave(&layer->enq_slock, flags);
944 layer->state = MXR_LAYER_STREAMING;
945 spin_unlock_irqrestore(&layer->enq_slock, flags);
947 layer->ops.stream_set(layer, MXR_ENABLE);
948 mxr_streamer_get(mdev);
953 static void mxr_watchdog(unsigned long arg)
955 struct mxr_layer *layer = (struct mxr_layer *) arg;
956 struct mxr_device *mdev = layer->mdev;
959 mxr_err(mdev, "watchdog fired for layer %s\n", layer->vfd.name);
961 spin_lock_irqsave(&layer->enq_slock, flags);
963 if (layer->update_buf == layer->shadow_buf)
964 layer->update_buf = NULL;
965 if (layer->update_buf) {
966 vb2_buffer_done(&layer->update_buf->vb, VB2_BUF_STATE_ERROR);
967 layer->update_buf = NULL;
969 if (layer->shadow_buf) {
970 vb2_buffer_done(&layer->shadow_buf->vb, VB2_BUF_STATE_ERROR);
971 layer->shadow_buf = NULL;
973 spin_unlock_irqrestore(&layer->enq_slock, flags);
976 static int stop_streaming(struct vb2_queue *vq)
978 struct mxr_layer *layer = vb2_get_drv_priv(vq);
979 struct mxr_device *mdev = layer->mdev;
981 struct timer_list watchdog;
982 struct mxr_buffer *buf, *buf_tmp;
984 mxr_dbg(mdev, "%s\n", __func__);
986 spin_lock_irqsave(&layer->enq_slock, flags);
989 layer->state = MXR_LAYER_STREAMING_FINISH;
991 /* set all buffer to be done */
992 list_for_each_entry_safe(buf, buf_tmp, &layer->enq_list, list) {
993 list_del(&buf->list);
994 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
997 spin_unlock_irqrestore(&layer->enq_slock, flags);
999 /* give 1 seconds to complete to complete last buffers */
1000 setup_timer_on_stack(&watchdog, mxr_watchdog,
1001 (unsigned long)layer);
1002 mod_timer(&watchdog, jiffies + msecs_to_jiffies(1000));
1004 /* wait until all buffers are goes to done state */
1005 vb2_wait_for_all_buffers(vq);
1007 /* stop timer if all synchronization is done */
1008 del_timer_sync(&watchdog);
1009 destroy_timer_on_stack(&watchdog);
1011 /* stopping hardware */
1012 spin_lock_irqsave(&layer->enq_slock, flags);
1013 layer->state = MXR_LAYER_IDLE;
1014 spin_unlock_irqrestore(&layer->enq_slock, flags);
1016 /* disabling layer in hardware */
1017 layer->ops.stream_set(layer, MXR_DISABLE);
1018 /* remove one streamer */
1019 mxr_streamer_put(mdev);
1020 /* allow changes in output configuration */
1021 mxr_output_put(mdev);
1025 static struct vb2_ops mxr_video_qops = {
1026 .queue_setup = queue_setup,
1027 .buf_queue = buf_queue,
1028 .wait_prepare = wait_unlock,
1029 .wait_finish = wait_lock,
1030 .start_streaming = start_streaming,
1031 .stop_streaming = stop_streaming,
1034 /* FIXME: try to put this functions to mxr_base_layer_create */
1035 int mxr_base_layer_register(struct mxr_layer *layer)
1037 struct mxr_device *mdev = layer->mdev;
1040 ret = video_register_device(&layer->vfd, VFL_TYPE_GRABBER, -1);
1042 mxr_err(mdev, "failed to register video device\n");
1044 mxr_info(mdev, "registered layer %s as /dev/video%d\n",
1045 layer->vfd.name, layer->vfd.num);
1049 void mxr_base_layer_unregister(struct mxr_layer *layer)
1051 video_unregister_device(&layer->vfd);
1054 void mxr_layer_release(struct mxr_layer *layer)
1056 if (layer->ops.release)
1057 layer->ops.release(layer);
1060 void mxr_base_layer_release(struct mxr_layer *layer)
1065 static void mxr_vfd_release(struct video_device *vdev)
1067 pr_info("video device release\n");
1070 struct mxr_layer *mxr_base_layer_create(struct mxr_device *mdev,
1071 int idx, char *name, struct mxr_layer_ops *ops)
1073 struct mxr_layer *layer;
1075 layer = kzalloc(sizeof(*layer), GFP_KERNEL);
1076 if (layer == NULL) {
1077 mxr_err(mdev, "not enough memory for layer.\n");
1085 spin_lock_init(&layer->enq_slock);
1086 INIT_LIST_HEAD(&layer->enq_list);
1087 mutex_init(&layer->mutex);
1089 layer->vfd = (struct video_device) {
1091 .release = mxr_vfd_release,
1093 .vfl_dir = VFL_DIR_TX,
1094 .ioctl_ops = &mxr_ioctl_ops,
1096 strlcpy(layer->vfd.name, name, sizeof(layer->vfd.name));
1097 /* let framework control PRIORITY */
1098 set_bit(V4L2_FL_USE_FH_PRIO, &layer->vfd.flags);
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 .mem_ops = &vb2_dma_contig_memops,
1119 static const struct mxr_format *find_format_by_fourcc(
1120 struct mxr_layer *layer, unsigned long fourcc)
1124 for (i = 0; i < layer->fmt_array_size; ++i)
1125 if (layer->fmt_array[i]->fourcc == fourcc)
1126 return layer->fmt_array[i];
1130 static const struct mxr_format *find_format_by_index(
1131 struct mxr_layer *layer, unsigned long index)
1133 if (index >= layer->fmt_array_size)
1135 return layer->fmt_array[index];