751f3b618337cea77b7eff822842f95a3ef0f8d9
[sfrench/cifs-2.6.git] / drivers / media / platform / s5p-tv / mixer_video.c
1 /*
2  * Samsung TV Mixer driver
3  *
4  * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
5  *
6  * Tomasz Stanislawski, <t.stanislaws@samsung.com>
7  *
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
12  */
13
14 #define pr_fmt(fmt) "s5p-tv (mixer): " fmt
15
16 #include "mixer.h"
17
18 #include <media/v4l2-ioctl.h>
19 #include <linux/videodev2.h>
20 #include <linux/mm.h>
21 #include <linux/module.h>
22 #include <linux/platform_device.h>
23 #include <linux/timer.h>
24 #include <media/videobuf2-dma-contig.h>
25
26 static int find_reg_callback(struct device *dev, void *p)
27 {
28         struct v4l2_subdev **sd = p;
29
30         *sd = dev_get_drvdata(dev);
31         /* non-zero value stops iteration */
32         return 1;
33 }
34
35 static struct v4l2_subdev *find_and_register_subdev(
36         struct mxr_device *mdev, char *module_name)
37 {
38         struct device_driver *drv;
39         struct v4l2_subdev *sd = NULL;
40         int ret;
41
42         /* TODO: add waiting until probe is finished */
43         drv = driver_find(module_name, &platform_bus_type);
44         if (!drv) {
45                 mxr_warn(mdev, "module %s is missing\n", module_name);
46                 return NULL;
47         }
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 */
51         if (sd == NULL) {
52                 mxr_warn(mdev, "module %s provides no subdev!\n", module_name);
53                 goto done;
54         }
55         /* v4l2_device_register_subdev detects if sd is NULL */
56         ret = v4l2_device_register_subdev(&mdev->v4l2_dev, sd);
57         if (ret) {
58                 mxr_warn(mdev, "failed to register subdev %s\n", sd->name);
59                 sd = NULL;
60         }
61
62 done:
63         return sd;
64 }
65
66 int mxr_acquire_video(struct mxr_device *mdev,
67                       struct mxr_output_conf *output_conf, int output_count)
68 {
69         struct device *dev = mdev->dev;
70         struct v4l2_device *v4l2_dev = &mdev->v4l2_dev;
71         int i;
72         int ret = 0;
73         struct v4l2_subdev *sd;
74
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);
78         if (ret) {
79                 mxr_err(mdev, "could not register v4l2 device.\n");
80                 goto fail;
81         }
82
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);
87                 goto fail_v4l2_dev;
88         }
89
90         /* registering outputs */
91         mdev->output_cnt = 0;
92         for (i = 0; i < output_count; ++i) {
93                 struct mxr_output_conf *conf = &output_conf[i];
94                 struct mxr_output *out;
95
96                 sd = find_and_register_subdev(mdev, conf->module_name);
97                 /* trying to register next output */
98                 if (sd == NULL)
99                         continue;
100                 out = kzalloc(sizeof(*out), GFP_KERNEL);
101                 if (out == NULL) {
102                         mxr_err(mdev, "no memory for '%s'\n",
103                                 conf->output_name);
104                         ret = -ENOMEM;
105                         /* registered subdevs are removed in fail_v4l2_dev */
106                         goto fail_output;
107                 }
108                 strlcpy(out->name, conf->output_name, sizeof(out->name));
109                 out->sd = sd;
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)
116                         break;
117         }
118
119         if (mdev->output_cnt == 0) {
120                 mxr_err(mdev, "failed to register any output\n");
121                 ret = -ENODEV;
122                 /* skipping fail_output because there is nothing to free */
123                 goto fail_vb2_allocator;
124         }
125
126         return 0;
127
128 fail_output:
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));
133
134 fail_vb2_allocator:
135         /* freeing allocator context */
136         vb2_dma_contig_cleanup_ctx(mdev->alloc_ctx);
137
138 fail_v4l2_dev:
139         /* NOTE: automatically unregister all subdevs */
140         v4l2_device_unregister(v4l2_dev);
141
142 fail:
143         return ret;
144 }
145
146 void mxr_release_video(struct mxr_device *mdev)
147 {
148         int i;
149
150         /* kfree is NULL-safe */
151         for (i = 0; i < mdev->output_cnt; ++i)
152                 kfree(mdev->output[i]);
153
154         vb2_dma_contig_cleanup_ctx(mdev->alloc_ctx);
155         v4l2_device_unregister(&mdev->v4l2_dev);
156 }
157
158 static int mxr_querycap(struct file *file, void *priv,
159         struct v4l2_capability *cap)
160 {
161         struct mxr_layer *layer = video_drvdata(file);
162
163         mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
164
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;
170
171         return 0;
172 }
173
174 static void mxr_geometry_dump(struct mxr_device *mdev, struct mxr_geometry *geo)
175 {
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);
190 }
191
192 static void mxr_layer_default_geo(struct mxr_layer *layer)
193 {
194         struct mxr_device *mdev = layer->mdev;
195         struct v4l2_mbus_framefmt mbus_fmt;
196
197         memset(&layer->geo, 0, sizeof(layer->geo));
198
199         mxr_get_mbus_fmt(mdev, &mbus_fmt);
200
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;
206
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;
211
212         mxr_geometry_dump(mdev, &layer->geo);
213         layer->ops.fix_geometry(layer, MXR_GEOMETRY_SINK, 0);
214         mxr_geometry_dump(mdev, &layer->geo);
215 }
216
217 static void mxr_layer_update_output(struct mxr_layer *layer)
218 {
219         struct mxr_device *mdev = layer->mdev;
220         struct v4l2_mbus_framefmt mbus_fmt;
221
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)
226                 return;
227
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);
232
233         mxr_geometry_dump(mdev, &layer->geo);
234 }
235
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);
240
241 static int mxr_enum_fmt(struct file *file, void  *priv,
242         struct v4l2_fmtdesc *f)
243 {
244         struct mxr_layer *layer = video_drvdata(file);
245         struct mxr_device *mdev = layer->mdev;
246         const struct mxr_format *fmt;
247
248         mxr_dbg(mdev, "%s\n", __func__);
249         fmt = find_format_by_index(layer, f->index);
250         if (fmt == NULL)
251                 return -EINVAL;
252
253         strlcpy(f->description, fmt->name, sizeof(f->description));
254         f->pixelformat = fmt->fourcc;
255
256         return 0;
257 }
258
259 static unsigned int divup(unsigned int divident, unsigned int divisor)
260 {
261         return (divident + divisor - 1) / divisor;
262 }
263
264 unsigned long mxr_get_plane_size(const struct mxr_block *blk,
265         unsigned int width, unsigned int height)
266 {
267         unsigned int bl_width = divup(width, blk->width);
268         unsigned int bl_height = divup(height, blk->height);
269
270         return bl_width * bl_height * blk->size;
271 }
272
273 static void mxr_mplane_fill(struct v4l2_plane_pix_format *planes,
274         const struct mxr_format *fmt, u32 width, u32 height)
275 {
276         int i;
277
278         /* checking if nothing to fill */
279         if (!planes)
280                 return;
281
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;
291
292                 plane->sizeimage += sizeimage;
293                 plane->bytesperline = max(plane->bytesperline, bytesperline);
294         }
295 }
296
297 static int mxr_g_fmt(struct file *file, void *priv,
298                              struct v4l2_format *f)
299 {
300         struct mxr_layer *layer = video_drvdata(file);
301         struct v4l2_pix_format_mplane *pix = &f->fmt.pix_mp;
302
303         mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
304
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);
311
312         return 0;
313 }
314
315 static int mxr_s_fmt(struct file *file, void *priv,
316         struct v4l2_format *f)
317 {
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;
323
324         mxr_dbg(mdev, "%s:%d\n", __func__, __LINE__);
325
326         pix = &f->fmt.pix_mp;
327         fmt = find_format_by_fourcc(layer, pix->pixelformat);
328         if (fmt == NULL) {
329                 mxr_warn(mdev, "not recognized fourcc: %08x\n",
330                         pix->pixelformat);
331                 return -EINVAL;
332         }
333         layer->fmt = fmt;
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);
352
353         /* returning results */
354         mxr_g_fmt(file, priv, f);
355
356         return 0;
357 }
358
359 static int mxr_g_selection(struct file *file, void *fh,
360         struct v4l2_selection *s)
361 {
362         struct mxr_layer *layer = video_drvdata(file);
363         struct mxr_geometry *geo = &layer->geo;
364
365         mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
366
367         if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
368                 s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
369                 return -EINVAL;
370
371         switch (s->target) {
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;
377                 break;
378         case V4L2_SEL_TGT_CROP_DEFAULT:
379         case V4L2_SEL_TGT_CROP_BOUNDS:
380                 s->r.left = 0;
381                 s->r.top = 0;
382                 s->r.width = geo->src.full_width;
383                 s->r.height = geo->src.full_height;
384                 break;
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;
391                 break;
392         case V4L2_SEL_TGT_COMPOSE_DEFAULT:
393         case V4L2_SEL_TGT_COMPOSE_BOUNDS:
394                 s->r.left = 0;
395                 s->r.top = 0;
396                 s->r.width = geo->dst.full_width;
397                 s->r.height = geo->dst.full_height;
398                 break;
399         default:
400                 return -EINVAL;
401         }
402
403         return 0;
404 }
405
406 /* returns 1 if rectangle 'a' is inside 'b' */
407 static int mxr_is_rect_inside(struct v4l2_rect *a, struct v4l2_rect *b)
408 {
409         if (a->left < b->left)
410                 return 0;
411         if (a->top < b->top)
412                 return 0;
413         if (a->left + a->width > b->left + b->width)
414                 return 0;
415         if (a->top + a->height > b->top + b->height)
416                 return 0;
417         return 1;
418 }
419
420 static int mxr_s_selection(struct file *file, void *fh,
421         struct v4l2_selection *s)
422 {
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;
429
430         memset(&res, 0, sizeof(res));
431
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);
434
435         if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
436                 s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
437                 return -EINVAL;
438
439         switch (s->target) {
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;
445                 break;
446
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;
452                 break;
453
454         case V4L2_SEL_TGT_CROP:
455                 target = &geo->src;
456                 stage = MXR_GEOMETRY_CROP;
457                 break;
458         case V4L2_SEL_TGT_COMPOSE:
459         case V4L2_SEL_TGT_COMPOSE_PADDED:
460                 target = &geo->dst;
461                 stage = MXR_GEOMETRY_COMPOSE;
462                 break;
463         default:
464                 return -EINVAL;
465         }
466         /* apply change and update geometry if needed */
467         if (target) {
468                 /* backup current geometry if setup fails */
469                 memcpy(&tmp, geo, sizeof(tmp));
470
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;
476
477                 layer->ops.fix_geometry(layer, stage, s->flags);
478
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;
484
485                 mxr_geometry_dump(layer->mdev, &layer->geo);
486         }
487
488         /* checking if the rectangle satisfies constraints */
489         if ((s->flags & V4L2_SEL_FLAG_LE) && !mxr_is_rect_inside(&res, &s->r))
490                 goto fail;
491         if ((s->flags & V4L2_SEL_FLAG_GE) && !mxr_is_rect_inside(&s->r, &res))
492                 goto fail;
493
494         /* return result rectangle */
495         s->r = res;
496
497         return 0;
498 fail:
499         /* restore old geometry, which is not touched if target is NULL */
500         if (target)
501                 memcpy(geo, &tmp, sizeof(tmp));
502         return -ERANGE;
503 }
504
505 static int mxr_enum_dv_timings(struct file *file, void *fh,
506         struct v4l2_enum_dv_timings *timings)
507 {
508         struct mxr_layer *layer = video_drvdata(file);
509         struct mxr_device *mdev = layer->mdev;
510         int ret;
511
512         timings->pad = 0;
513
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);
518
519         return ret ? -EINVAL : 0;
520 }
521
522 static int mxr_s_dv_timings(struct file *file, void *fh,
523         struct v4l2_dv_timings *timings)
524 {
525         struct mxr_layer *layer = video_drvdata(file);
526         struct mxr_device *mdev = layer->mdev;
527         int ret;
528
529         /* lock protects from changing sd_out */
530         mutex_lock(&mdev->mutex);
531
532         /* timings change cannot be done while there is an entity
533          * dependent on output configuration
534          */
535         if (mdev->n_output > 0) {
536                 mutex_unlock(&mdev->mutex);
537                 return -EBUSY;
538         }
539
540         ret = v4l2_subdev_call(to_outsd(mdev), video, s_dv_timings, timings);
541
542         mutex_unlock(&mdev->mutex);
543
544         mxr_layer_update_output(layer);
545
546         /* any failure should return EINVAL according to V4L2 doc */
547         return ret ? -EINVAL : 0;
548 }
549
550 static int mxr_g_dv_timings(struct file *file, void *fh,
551         struct v4l2_dv_timings *timings)
552 {
553         struct mxr_layer *layer = video_drvdata(file);
554         struct mxr_device *mdev = layer->mdev;
555         int ret;
556
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);
561
562         return ret ? -EINVAL : 0;
563 }
564
565 static int mxr_dv_timings_cap(struct file *file, void *fh,
566         struct v4l2_dv_timings_cap *cap)
567 {
568         struct mxr_layer *layer = video_drvdata(file);
569         struct mxr_device *mdev = layer->mdev;
570         int ret;
571
572         cap->pad = 0;
573
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);
578
579         return ret ? -EINVAL : 0;
580 }
581
582 static int mxr_s_std(struct file *file, void *fh, v4l2_std_id norm)
583 {
584         struct mxr_layer *layer = video_drvdata(file);
585         struct mxr_device *mdev = layer->mdev;
586         int ret;
587
588         /* lock protects from changing sd_out */
589         mutex_lock(&mdev->mutex);
590
591         /* standard change cannot be done while there is an entity
592          * dependent on output configuration
593          */
594         if (mdev->n_output > 0) {
595                 mutex_unlock(&mdev->mutex);
596                 return -EBUSY;
597         }
598
599         ret = v4l2_subdev_call(to_outsd(mdev), video, s_std_output, norm);
600
601         mutex_unlock(&mdev->mutex);
602
603         mxr_layer_update_output(layer);
604
605         return ret ? -EINVAL : 0;
606 }
607
608 static int mxr_g_std(struct file *file, void *fh, v4l2_std_id *norm)
609 {
610         struct mxr_layer *layer = video_drvdata(file);
611         struct mxr_device *mdev = layer->mdev;
612         int ret;
613
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);
618
619         return ret ? -EINVAL : 0;
620 }
621
622 static int mxr_enum_output(struct file *file, void *fh, struct v4l2_output *a)
623 {
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;
628
629         if (a->index >= mdev->output_cnt)
630                 return -EINVAL;
631         out = mdev->output[a->index];
632         BUG_ON(out == NULL);
633         sd = out->sd;
634         strlcpy(a->name, out->name, sizeof(a->name));
635
636         /* try to obtain supported tv norms */
637         v4l2_subdev_call(sd, video, g_tvnorms_output, &a->std);
638         a->capabilities = 0;
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;
644
645         return 0;
646 }
647
648 static int mxr_s_output(struct file *file, void *fh, unsigned int i)
649 {
650         struct video_device *vfd = video_devdata(file);
651         struct mxr_layer *layer = video_drvdata(file);
652         struct mxr_device *mdev = layer->mdev;
653
654         if (i >= mdev->output_cnt || mdev->output[i] == NULL)
655                 return -EINVAL;
656
657         mutex_lock(&mdev->mutex);
658         if (mdev->n_output > 0) {
659                 mutex_unlock(&mdev->mutex);
660                 return -EBUSY;
661         }
662         mdev->current_output = i;
663         vfd->tvnorms = 0;
664         v4l2_subdev_call(to_outsd(mdev), video, g_tvnorms_output,
665                 &vfd->tvnorms);
666         mutex_unlock(&mdev->mutex);
667
668         /* update layers geometry */
669         mxr_layer_update_output(layer);
670
671         mxr_dbg(mdev, "tvnorms = %08llx\n", vfd->tvnorms);
672
673         return 0;
674 }
675
676 static int mxr_g_output(struct file *file, void *fh, unsigned int *p)
677 {
678         struct mxr_layer *layer = video_drvdata(file);
679         struct mxr_device *mdev = layer->mdev;
680
681         mutex_lock(&mdev->mutex);
682         *p = mdev->current_output;
683         mutex_unlock(&mdev->mutex);
684
685         return 0;
686 }
687
688 static int mxr_reqbufs(struct file *file, void *priv,
689                           struct v4l2_requestbuffers *p)
690 {
691         struct mxr_layer *layer = video_drvdata(file);
692
693         mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
694         return vb2_reqbufs(&layer->vb_queue, p);
695 }
696
697 static int mxr_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
698 {
699         struct mxr_layer *layer = video_drvdata(file);
700
701         mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
702         return vb2_querybuf(&layer->vb_queue, p);
703 }
704
705 static int mxr_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
706 {
707         struct mxr_layer *layer = video_drvdata(file);
708
709         mxr_dbg(layer->mdev, "%s:%d(%d)\n", __func__, __LINE__, p->index);
710         return vb2_qbuf(&layer->vb_queue, p);
711 }
712
713 static int mxr_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
714 {
715         struct mxr_layer *layer = video_drvdata(file);
716
717         mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
718         return vb2_dqbuf(&layer->vb_queue, p, file->f_flags & O_NONBLOCK);
719 }
720
721 static int mxr_expbuf(struct file *file, void *priv,
722         struct v4l2_exportbuffer *eb)
723 {
724         struct mxr_layer *layer = video_drvdata(file);
725
726         mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
727         return vb2_expbuf(&layer->vb_queue, eb);
728 }
729
730 static int mxr_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
731 {
732         struct mxr_layer *layer = video_drvdata(file);
733
734         mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
735         return vb2_streamon(&layer->vb_queue, i);
736 }
737
738 static int mxr_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
739 {
740         struct mxr_layer *layer = video_drvdata(file);
741
742         mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
743         return vb2_streamoff(&layer->vb_queue, i);
744 }
745
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,
752         /* buffer control */
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,
776 };
777
778 static int mxr_video_open(struct file *file)
779 {
780         struct mxr_layer *layer = video_drvdata(file);
781         struct mxr_device *mdev = layer->mdev;
782         int ret = 0;
783
784         mxr_dbg(mdev, "%s:%d\n", __func__, __LINE__);
785         if (mutex_lock_interruptible(&layer->mutex))
786                 return -ERESTARTSYS;
787         /* assure device probe is finished */
788         wait_for_device_probe();
789         /* creating context for file descriptor */
790         ret = v4l2_fh_open(file);
791         if (ret) {
792                 mxr_err(mdev, "v4l2_fh_open failed\n");
793                 goto unlock;
794         }
795
796         /* leaving if layer is already initialized */
797         if (!v4l2_fh_is_singular_file(file))
798                 goto unlock;
799
800         /* FIXME: should power be enabled on open? */
801         ret = mxr_power_get(mdev);
802         if (ret) {
803                 mxr_err(mdev, "power on failed\n");
804                 goto fail_fh_open;
805         }
806
807         ret = vb2_queue_init(&layer->vb_queue);
808         if (ret != 0) {
809                 mxr_err(mdev, "failed to initialize vb2 queue\n");
810                 goto fail_power;
811         }
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);
817
818         return 0;
819
820 fail_power:
821         mxr_power_put(mdev);
822
823 fail_fh_open:
824         v4l2_fh_release(file);
825
826 unlock:
827         mutex_unlock(&layer->mutex);
828
829         return ret;
830 }
831
832 static unsigned int
833 mxr_video_poll(struct file *file, struct poll_table_struct *wait)
834 {
835         struct mxr_layer *layer = video_drvdata(file);
836         unsigned int res;
837
838         mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
839
840         mutex_lock(&layer->mutex);
841         res = vb2_poll(&layer->vb_queue, file, wait);
842         mutex_unlock(&layer->mutex);
843         return res;
844 }
845
846 static int mxr_video_mmap(struct file *file, struct vm_area_struct *vma)
847 {
848         struct mxr_layer *layer = video_drvdata(file);
849         int ret;
850
851         mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
852
853         if (mutex_lock_interruptible(&layer->mutex))
854                 return -ERESTARTSYS;
855         ret = vb2_mmap(&layer->vb_queue, vma);
856         mutex_unlock(&layer->mutex);
857         return ret;
858 }
859
860 static int mxr_video_release(struct file *file)
861 {
862         struct mxr_layer *layer = video_drvdata(file);
863
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);
869         }
870         v4l2_fh_release(file);
871         mutex_unlock(&layer->mutex);
872         return 0;
873 }
874
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,
882 };
883
884 static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *pfmt,
885         unsigned int *nbuffers, unsigned int *nplanes, unsigned int sizes[],
886         void *alloc_ctxs[])
887 {
888         struct mxr_layer *layer = vb2_get_drv_priv(vq);
889         const struct mxr_format *fmt = layer->fmt;
890         int i;
891         struct mxr_device *mdev = layer->mdev;
892         struct v4l2_plane_pix_format planes[3];
893
894         mxr_dbg(mdev, "%s\n", __func__);
895         /* checking if format was configured */
896         if (fmt == NULL)
897                 return -EINVAL;
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);
901
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]);
907         }
908
909         if (*nbuffers == 0)
910                 *nbuffers = 1;
911
912         return 0;
913 }
914
915 static void buf_queue(struct vb2_buffer *vb)
916 {
917         struct mxr_buffer *buffer = container_of(vb, struct mxr_buffer, vb);
918         struct mxr_layer *layer = vb2_get_drv_priv(vb->vb2_queue);
919         struct mxr_device *mdev = layer->mdev;
920         unsigned long flags;
921
922         spin_lock_irqsave(&layer->enq_slock, flags);
923         list_add_tail(&buffer->list, &layer->enq_list);
924         spin_unlock_irqrestore(&layer->enq_slock, flags);
925
926         mxr_dbg(mdev, "queuing buffer\n");
927 }
928
929 static int start_streaming(struct vb2_queue *vq, unsigned int count)
930 {
931         struct mxr_layer *layer = vb2_get_drv_priv(vq);
932         struct mxr_device *mdev = layer->mdev;
933         unsigned long flags;
934
935         mxr_dbg(mdev, "%s\n", __func__);
936
937         /* block any changes in output configuration */
938         mxr_output_get(mdev);
939
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);
946
947         layer->ops.stream_set(layer, MXR_ENABLE);
948         mxr_streamer_get(mdev);
949
950         return 0;
951 }
952
953 static void mxr_watchdog(unsigned long arg)
954 {
955         struct mxr_layer *layer = (struct mxr_layer *) arg;
956         struct mxr_device *mdev = layer->mdev;
957         unsigned long flags;
958
959         mxr_err(mdev, "watchdog fired for layer %s\n", layer->vfd.name);
960
961         spin_lock_irqsave(&layer->enq_slock, flags);
962
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;
968         }
969         if (layer->shadow_buf) {
970                 vb2_buffer_done(&layer->shadow_buf->vb, VB2_BUF_STATE_ERROR);
971                 layer->shadow_buf = NULL;
972         }
973         spin_unlock_irqrestore(&layer->enq_slock, flags);
974 }
975
976 static void stop_streaming(struct vb2_queue *vq)
977 {
978         struct mxr_layer *layer = vb2_get_drv_priv(vq);
979         struct mxr_device *mdev = layer->mdev;
980         unsigned long flags;
981         struct timer_list watchdog;
982         struct mxr_buffer *buf, *buf_tmp;
983
984         mxr_dbg(mdev, "%s\n", __func__);
985
986         spin_lock_irqsave(&layer->enq_slock, flags);
987
988         /* reset list */
989         layer->state = MXR_LAYER_STREAMING_FINISH;
990
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);
995         }
996
997         spin_unlock_irqrestore(&layer->enq_slock, flags);
998
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));
1003
1004         /* wait until all buffers are goes to done state */
1005         vb2_wait_for_all_buffers(vq);
1006
1007         /* stop timer if all synchronization is done */
1008         del_timer_sync(&watchdog);
1009         destroy_timer_on_stack(&watchdog);
1010
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);
1015
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);
1022 }
1023
1024 static struct vb2_ops mxr_video_qops = {
1025         .queue_setup = queue_setup,
1026         .buf_queue = buf_queue,
1027         .wait_prepare = vb2_ops_wait_prepare,
1028         .wait_finish = vb2_ops_wait_finish,
1029         .start_streaming = start_streaming,
1030         .stop_streaming = stop_streaming,
1031 };
1032
1033 /* FIXME: try to put this functions to mxr_base_layer_create */
1034 int mxr_base_layer_register(struct mxr_layer *layer)
1035 {
1036         struct mxr_device *mdev = layer->mdev;
1037         int ret;
1038
1039         ret = video_register_device(&layer->vfd, VFL_TYPE_GRABBER, -1);
1040         if (ret)
1041                 mxr_err(mdev, "failed to register video device\n");
1042         else
1043                 mxr_info(mdev, "registered layer %s as /dev/video%d\n",
1044                         layer->vfd.name, layer->vfd.num);
1045         return ret;
1046 }
1047
1048 void mxr_base_layer_unregister(struct mxr_layer *layer)
1049 {
1050         video_unregister_device(&layer->vfd);
1051 }
1052
1053 void mxr_layer_release(struct mxr_layer *layer)
1054 {
1055         if (layer->ops.release)
1056                 layer->ops.release(layer);
1057 }
1058
1059 void mxr_base_layer_release(struct mxr_layer *layer)
1060 {
1061         kfree(layer);
1062 }
1063
1064 static void mxr_vfd_release(struct video_device *vdev)
1065 {
1066         pr_info("video device release\n");
1067 }
1068
1069 struct mxr_layer *mxr_base_layer_create(struct mxr_device *mdev,
1070         int idx, char *name, struct mxr_layer_ops *ops)
1071 {
1072         struct mxr_layer *layer;
1073
1074         layer = kzalloc(sizeof(*layer), GFP_KERNEL);
1075         if (layer == NULL) {
1076                 mxr_err(mdev, "not enough memory for layer.\n");
1077                 goto fail;
1078         }
1079
1080         layer->mdev = mdev;
1081         layer->idx = idx;
1082         layer->ops = *ops;
1083
1084         spin_lock_init(&layer->enq_slock);
1085         INIT_LIST_HEAD(&layer->enq_list);
1086         mutex_init(&layer->mutex);
1087
1088         layer->vfd = (struct video_device) {
1089                 .minor = -1,
1090                 .release = mxr_vfd_release,
1091                 .fops = &mxr_fops,
1092                 .vfl_dir = VFL_DIR_TX,
1093                 .ioctl_ops = &mxr_ioctl_ops,
1094         };
1095         strlcpy(layer->vfd.name, name, sizeof(layer->vfd.name));
1096
1097         video_set_drvdata(&layer->vfd, layer);
1098         layer->vfd.lock = &layer->mutex;
1099         layer->vfd.v4l2_dev = &mdev->v4l2_dev;
1100
1101         layer->vb_queue = (struct vb2_queue) {
1102                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
1103                 .io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF,
1104                 .drv_priv = layer,
1105                 .buf_struct_size = sizeof(struct mxr_buffer),
1106                 .ops = &mxr_video_qops,
1107                 .min_buffers_needed = 1,
1108                 .mem_ops = &vb2_dma_contig_memops,
1109                 .lock = &layer->mutex,
1110         };
1111
1112         return layer;
1113
1114 fail:
1115         return NULL;
1116 }
1117
1118 static const struct mxr_format *find_format_by_fourcc(
1119         struct mxr_layer *layer, unsigned long fourcc)
1120 {
1121         int i;
1122
1123         for (i = 0; i < layer->fmt_array_size; ++i)
1124                 if (layer->fmt_array[i]->fourcc == fourcc)
1125                         return layer->fmt_array[i];
1126         return NULL;
1127 }
1128
1129 static const struct mxr_format *find_format_by_index(
1130         struct mxr_layer *layer, unsigned long index)
1131 {
1132         if (index >= layer->fmt_array_size)
1133                 return NULL;
1134         return layer->fmt_array[index];
1135 }
1136