projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] v4l: s5p-fimc: support for dmabuf exporting
[deliverable/linux.git] / drivers / media / platform / s5p-tv / mixer_video.c
CommitLineData
fef1c8d0
TS		 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
f5c99037
SK		 14#define pr_fmt(fmt) "s5p-tv (mixer): " fmt
15
fef1c8d0
TS		 16#include "mixer.h"
17
18#include <media/v4l2-ioctl.h>
19#include <linux/videodev2.h>
20#include <linux/mm.h>
fc8ac777 21#include <linux/module.h>
fef1c8d0
TS		 22#include <linux/timer.h>
23#include <media/videobuf2-dma-contig.h>
24
25static int find_reg_callback(struct device *dev, void *p)
26{
27 struct v4l2_subdev **sd = p;
28
29 *sd = dev_get_drvdata(dev);
30 /* non-zero value stops iteration */
31 return 1;
32}
33
34static struct v4l2_subdev *find_and_register_subdev(
35 struct mxr_device *mdev, char *module_name)
36{
37 struct device_driver *drv;
38 struct v4l2_subdev *sd = NULL;
39 int ret;
40
41 /* TODO: add waiting until probe is finished */
42 drv = driver_find(module_name, &platform_bus_type);
43 if (!drv) {
44 mxr_warn(mdev, "module %s is missing\n", module_name);
45 return NULL;
46 }
47 /* driver refcnt is increased, it is safe to iterate over devices */
48 ret = driver_for_each_device(drv, NULL, &sd, find_reg_callback);
49 /* ret == 0 means that find_reg_callback was never executed */
50 if (sd == NULL) {
51 mxr_warn(mdev, "module %s provides no subdev!\n", module_name);
52 goto done;
53 }
54 /* v4l2_device_register_subdev detects if sd is NULL */
55 ret = v4l2_device_register_subdev(&mdev->v4l2_dev, sd);
56 if (ret) {
57 mxr_warn(mdev, "failed to register subdev %s\n", sd->name);
58 sd = NULL;
59 }
60
61done:
fef1c8d0
TS		 62 return sd;
63}
64
65int __devinit mxr_acquire_video(struct mxr_device *mdev,
66 struct mxr_output_conf *output_conf, int output_count)
67{
68 struct device *dev = mdev->dev;
69 struct v4l2_device *v4l2_dev = &mdev->v4l2_dev;
70 int i;
71 int ret = 0;
72 struct v4l2_subdev *sd;
73
74 strlcpy(v4l2_dev->name, dev_name(mdev->dev), sizeof(v4l2_dev->name));
75 /* prepare context for V4L2 device */
76 ret = v4l2_device_register(dev, v4l2_dev);
77 if (ret) {
78 mxr_err(mdev, "could not register v4l2 device.\n");
79 goto fail;
80 }
81
82 mdev->alloc_ctx = vb2_dma_contig_init_ctx(mdev->dev);
83 if (IS_ERR_OR_NULL(mdev->alloc_ctx)) {
84 mxr_err(mdev, "could not acquire vb2 allocator\n");
85 goto fail_v4l2_dev;
86 }
87
88 /* registering outputs */
89 mdev->output_cnt = 0;
90 for (i = 0; i < output_count; ++i) {
91 struct mxr_output_conf *conf = &output_conf[i];
92 struct mxr_output *out;
93
94 sd = find_and_register_subdev(mdev, conf->module_name);
95 /* trying to register next output */
96 if (sd == NULL)
97 continue;
98 out = kzalloc(sizeof *out, GFP_KERNEL);
99 if (out == NULL) {
100 mxr_err(mdev, "no memory for '%s'\n",
101 conf->output_name);
102 ret = -ENOMEM;
103 /* registered subdevs are removed in fail_v4l2_dev */
104 goto fail_output;
105 }
106 strlcpy(out->name, conf->output_name, sizeof(out->name));
107 out->sd = sd;
108 out->cookie = conf->cookie;
109 mdev->output[mdev->output_cnt++] = out;
110 mxr_info(mdev, "added output '%s' from module '%s'\n",
111 conf->output_name, conf->module_name);
112 /* checking if maximal number of outputs is reached */
113 if (mdev->output_cnt >= MXR_MAX_OUTPUTS)
114 break;
115 }
116
117 if (mdev->output_cnt == 0) {
118 mxr_err(mdev, "failed to register any output\n");
119 ret = -ENODEV;
120 /* skipping fail_output because there is nothing to free */
121 goto fail_vb2_allocator;
122 }
123
124 return 0;
125
126fail_output:
127 /* kfree is NULL-safe */
128 for (i = 0; i < mdev->output_cnt; ++i)
129 kfree(mdev->output[i]);
130 memset(mdev->output, 0, sizeof mdev->output);
131
132fail_vb2_allocator:
133 /* freeing allocator context */
134 vb2_dma_contig_cleanup_ctx(mdev->alloc_ctx);
135
136fail_v4l2_dev:
137 /* NOTE: automatically unregister all subdevs */
138 v4l2_device_unregister(v4l2_dev);
139
140fail:
141 return ret;
142}
143
e6364a98 144void mxr_release_video(struct mxr_device *mdev)
fef1c8d0
TS		 145{
146 int i;
147
148 /* kfree is NULL-safe */
149 for (i = 0; i < mdev->output_cnt; ++i)
150 kfree(mdev->output[i]);
151
152 vb2_dma_contig_cleanup_ctx(mdev->alloc_ctx);
153 v4l2_device_unregister(&mdev->v4l2_dev);
154}
155
156static int mxr_querycap(struct file *file, void *priv,
157 struct v4l2_capability *cap)
158{
159 struct mxr_layer *layer = video_drvdata(file);
160
161 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
162
163 strlcpy(cap->driver, MXR_DRIVER_NAME, sizeof cap->driver);
164 strlcpy(cap->card, layer->vfd.name, sizeof cap->card);
165 sprintf(cap->bus_info, "%d", layer->idx);
7208507e
SN		 166 cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_OUTPUT_MPLANE;
167 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
fef1c8d0
TS		 168
169 return 0;
170}
171
0d066d3f 172static void mxr_geometry_dump(struct mxr_device *mdev, struct mxr_geometry *geo)
fef1c8d0 173{
0d066d3f
TS		 174 mxr_dbg(mdev, "src.full_size = (%u, %u)\n",
175 geo->src.full_width, geo->src.full_height);
176 mxr_dbg(mdev, "src.size = (%u, %u)\n",
177 geo->src.width, geo->src.height);
178 mxr_dbg(mdev, "src.offset = (%u, %u)\n",
179 geo->src.x_offset, geo->src.y_offset);
180 mxr_dbg(mdev, "dst.full_size = (%u, %u)\n",
181 geo->dst.full_width, geo->dst.full_height);
182 mxr_dbg(mdev, "dst.size = (%u, %u)\n",
183 geo->dst.width, geo->dst.height);
184 mxr_dbg(mdev, "dst.offset = (%u, %u)\n",
185 geo->dst.x_offset, geo->dst.y_offset);
186 mxr_dbg(mdev, "ratio = (%u, %u)\n",
187 geo->x_ratio, geo->y_ratio);
fef1c8d0
TS		 188}
189
190static void mxr_layer_default_geo(struct mxr_layer *layer)
191{
192 struct mxr_device *mdev = layer->mdev;
193 struct v4l2_mbus_framefmt mbus_fmt;
194
195 memset(&layer->geo, 0, sizeof layer->geo);
196
197 mxr_get_mbus_fmt(mdev, &mbus_fmt);
198
199 layer->geo.dst.full_width = mbus_fmt.width;
200 layer->geo.dst.full_height = mbus_fmt.height;
201 layer->geo.dst.width = layer->geo.dst.full_width;
202 layer->geo.dst.height = layer->geo.dst.full_height;
203 layer->geo.dst.field = mbus_fmt.field;
204
205 layer->geo.src.full_width = mbus_fmt.width;
206 layer->geo.src.full_height = mbus_fmt.height;
207 layer->geo.src.width = layer->geo.src.full_width;
208 layer->geo.src.height = layer->geo.src.full_height;
209
0d066d3f
TS		 210 mxr_geometry_dump(mdev, &layer->geo);
211 layer->ops.fix_geometry(layer, MXR_GEOMETRY_SINK, 0);
212 mxr_geometry_dump(mdev, &layer->geo);
fef1c8d0
TS		 213}
214
0d066d3f 215static void mxr_layer_update_output(struct mxr_layer *layer)
fef1c8d0 216{
0d066d3f
TS		 217 struct mxr_device *mdev = layer->mdev;
218 struct v4l2_mbus_framefmt mbus_fmt;
219
220 mxr_get_mbus_fmt(mdev, &mbus_fmt);
221 /* checking if update is needed */
222 if (layer->geo.dst.full_width == mbus_fmt.width &&
223 layer->geo.dst.full_height == mbus_fmt.width)
224 return;
fef1c8d0 225
0d066d3f
TS		 226 layer->geo.dst.full_width = mbus_fmt.width;
227 layer->geo.dst.full_height = mbus_fmt.height;
228 layer->geo.dst.field = mbus_fmt.field;
229 layer->ops.fix_geometry(layer, MXR_GEOMETRY_SINK, 0);
230
231 mxr_geometry_dump(mdev, &layer->geo);
232}
fef1c8d0
TS		 233
234static const struct mxr_format *find_format_by_fourcc(
235 struct mxr_layer *layer, unsigned long fourcc);
236static const struct mxr_format *find_format_by_index(
237 struct mxr_layer *layer, unsigned long index);
238
239static int mxr_enum_fmt(struct file *file, void *priv,
240 struct v4l2_fmtdesc *f)
241{
242 struct mxr_layer *layer = video_drvdata(file);
243 struct mxr_device *mdev = layer->mdev;
244 const struct mxr_format *fmt;
245
246 mxr_dbg(mdev, "%s\n", __func__);
247 fmt = find_format_by_index(layer, f->index);
248 if (fmt == NULL)
249 return -EINVAL;
250
251 strlcpy(f->description, fmt->name, sizeof(f->description));
252 f->pixelformat = fmt->fourcc;
253
254 return 0;
255}
256
fef1c8d0
TS		 257static unsigned int divup(unsigned int divident, unsigned int divisor)
258{
259 return (divident + divisor - 1) / divisor;
260}
261
262unsigned long mxr_get_plane_size(const struct mxr_block *blk,
263 unsigned int width, unsigned int height)
264{
265 unsigned int bl_width = divup(width, blk->width);
266 unsigned int bl_height = divup(height, blk->height);
267
268 return bl_width * bl_height * blk->size;
269}
270
271static void mxr_mplane_fill(struct v4l2_plane_pix_format *planes,
272 const struct mxr_format *fmt, u32 width, u32 height)
273{
274 int i;
275
0d066d3f
TS		 276 /* checking if nothing to fill */
277 if (!planes)
278 return;
279
fef1c8d0
TS		 280 memset(planes, 0, sizeof(*planes) * fmt->num_subframes);
281 for (i = 0; i < fmt->num_planes; ++i) {
282 struct v4l2_plane_pix_format *plane = planes
283 + fmt->plane2subframe[i];
284 const struct mxr_block *blk = &fmt->plane[i];
285 u32 bl_width = divup(width, blk->width);
286 u32 bl_height = divup(height, blk->height);
287 u32 sizeimage = bl_width * bl_height * blk->size;
288 u16 bytesperline = bl_width * blk->size / blk->height;
289
290 plane->sizeimage += sizeimage;
291 plane->bytesperline = max(plane->bytesperline, bytesperline);
292 }
293}
294
295static int mxr_g_fmt(struct file *file, void *priv,
296 struct v4l2_format *f)
297{
298 struct mxr_layer *layer = video_drvdata(file);
299 struct v4l2_pix_format_mplane *pix = &f->fmt.pix_mp;
300
301 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
302
303 pix->width = layer->geo.src.full_width;
304 pix->height = layer->geo.src.full_height;
305 pix->field = V4L2_FIELD_NONE;
306 pix->pixelformat = layer->fmt->fourcc;
307 pix->colorspace = layer->fmt->colorspace;
308 mxr_mplane_fill(pix->plane_fmt, layer->fmt, pix->width, pix->height);
309
310 return 0;
311}
312
0d066d3f
TS		 313static int mxr_s_fmt(struct file *file, void *priv,
314 struct v4l2_format *f)
fef1c8d0
TS		 315{
316 struct mxr_layer *layer = video_drvdata(file);
0d066d3f
TS		 317 const struct mxr_format *fmt;
318 struct v4l2_pix_format_mplane *pix;
319 struct mxr_device *mdev = layer->mdev;
320 struct mxr_geometry *geo = &layer->geo;
fef1c8d0 321
0d066d3f
TS		 322 mxr_dbg(mdev, "%s:%d\n", __func__, __LINE__);
323
324 pix = &f->fmt.pix_mp;
325 fmt = find_format_by_fourcc(layer, pix->pixelformat);
326 if (fmt == NULL) {
327 mxr_warn(mdev, "not recognized fourcc: %08x\n",
328 pix->pixelformat);
fef1c8d0 329 return -EINVAL;
0d066d3f
TS		 330 }
331 layer->fmt = fmt;
332 /* set source size to highest accepted value */
333 geo->src.full_width = max(geo->dst.full_width, pix->width);
334 geo->src.full_height = max(geo->dst.full_height, pix->height);
335 layer->ops.fix_geometry(layer, MXR_GEOMETRY_SOURCE, 0);
336 mxr_geometry_dump(mdev, &layer->geo);
337 /* set cropping to total visible screen */
338 geo->src.width = pix->width;
339 geo->src.height = pix->height;
340 geo->src.x_offset = 0;
341 geo->src.y_offset = 0;
342 /* assure consistency of geometry */
343 layer->ops.fix_geometry(layer, MXR_GEOMETRY_CROP, MXR_NO_OFFSET);
344 mxr_geometry_dump(mdev, &layer->geo);
345 /* set full size to lowest possible value */
346 geo->src.full_width = 0;
347 geo->src.full_height = 0;
348 layer->ops.fix_geometry(layer, MXR_GEOMETRY_SOURCE, 0);
349 mxr_geometry_dump(mdev, &layer->geo);
350
351 /* returning results */
352 mxr_g_fmt(file, priv, f);
353
fef1c8d0
TS		 354 return 0;
355}
356
0d066d3f
TS		 357static int mxr_g_selection(struct file *file, void *fh,
358 struct v4l2_selection *s)
fef1c8d0
TS		 359{
360 struct mxr_layer *layer = video_drvdata(file);
0d066d3f 361 struct mxr_geometry *geo = &layer->geo;
fef1c8d0
TS		 362
363 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
0d066d3f
TS		 364
365 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
366 s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
367 return -EINVAL;
368
369 switch (s->target) {
c1334823 370 case V4L2_SEL_TGT_CROP:
0d066d3f
TS		 371 s->r.left = geo->src.x_offset;
372 s->r.top = geo->src.y_offset;
373 s->r.width = geo->src.width;
374 s->r.height = geo->src.height;
375 break;
376 case V4L2_SEL_TGT_CROP_DEFAULT:
377 case V4L2_SEL_TGT_CROP_BOUNDS:
378 s->r.left = 0;
379 s->r.top = 0;
380 s->r.width = geo->src.full_width;
381 s->r.height = geo->src.full_height;
382 break;
c1334823 383 case V4L2_SEL_TGT_COMPOSE:
0d066d3f
TS		 384 case V4L2_SEL_TGT_COMPOSE_PADDED:
385 s->r.left = geo->dst.x_offset;
386 s->r.top = geo->dst.y_offset;
387 s->r.width = geo->dst.width;
388 s->r.height = geo->dst.height;
389 break;
390 case V4L2_SEL_TGT_COMPOSE_DEFAULT:
391 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
392 s->r.left = 0;
393 s->r.top = 0;
394 s->r.width = geo->dst.full_width;
395 s->r.height = geo->dst.full_height;
396 break;
397 default:
fef1c8d0 398 return -EINVAL;
0d066d3f
TS		 399 }
400
fef1c8d0
TS		 401 return 0;
402}
403
0d066d3f
TS		 404/* returns 1 if rectangle 'a' is inside 'b' */
405static int mxr_is_rect_inside(struct v4l2_rect *a, struct v4l2_rect *b)
406{
407 if (a->left < b->left)
408 return 0;
409 if (a->top < b->top)
410 return 0;
411 if (a->left + a->width > b->left + b->width)
412 return 0;
413 if (a->top + a->height > b->top + b->height)
414 return 0;
415 return 1;
416}
417
418static int mxr_s_selection(struct file *file, void *fh,
419 struct v4l2_selection *s)
fef1c8d0
TS		 420{
421 struct mxr_layer *layer = video_drvdata(file);
0d066d3f
TS		 422 struct mxr_geometry *geo = &layer->geo;
423 struct mxr_crop *target = NULL;
424 enum mxr_geometry_stage stage;
425 struct mxr_geometry tmp;
426 struct v4l2_rect res;
fef1c8d0 427
0d066d3f
TS		 428 memset(&res, 0, sizeof res);
429
430 mxr_dbg(layer->mdev, "%s: rect: %dx%d@%d,%d\n", __func__,
431 s->r.width, s->r.height, s->r.left, s->r.top);
432
433 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
434 s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
fef1c8d0 435 return -EINVAL;
0d066d3f
TS		 436
437 switch (s->target) {
438 /* ignore read-only targets */
439 case V4L2_SEL_TGT_CROP_DEFAULT:
440 case V4L2_SEL_TGT_CROP_BOUNDS:
441 res.width = geo->src.full_width;
442 res.height = geo->src.full_height;
443 break;
444
445 /* ignore read-only targets */
446 case V4L2_SEL_TGT_COMPOSE_DEFAULT:
447 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
448 res.width = geo->dst.full_width;
449 res.height = geo->dst.full_height;
450 break;
451
c1334823 452 case V4L2_SEL_TGT_CROP:
0d066d3f
TS		 453 target = &geo->src;
454 stage = MXR_GEOMETRY_CROP;
455 break;
c1334823 456 case V4L2_SEL_TGT_COMPOSE:
0d066d3f
TS		 457 case V4L2_SEL_TGT_COMPOSE_PADDED:
458 target = &geo->dst;
459 stage = MXR_GEOMETRY_COMPOSE;
460 break;
461 default:
462 return -EINVAL;
463 }
464 /* apply change and update geometry if needed */
465 if (target) {
466 /* backup current geometry if setup fails */
467 memcpy(&tmp, geo, sizeof tmp);
468
469 /* apply requested selection */
470 target->x_offset = s->r.left;
471 target->y_offset = s->r.top;
472 target->width = s->r.width;
473 target->height = s->r.height;
474
475 layer->ops.fix_geometry(layer, stage, s->flags);
476
477 /* retrieve update selection rectangle */
478 res.left = target->x_offset;
479 res.top = target->y_offset;
480 res.width = target->width;
481 res.height = target->height;
482
483 mxr_geometry_dump(layer->mdev, &layer->geo);
484 }
485
486 /* checking if the rectangle satisfies constraints */
487 if ((s->flags & V4L2_SEL_FLAG_LE) && !mxr_is_rect_inside(&res, &s->r))
488 goto fail;
489 if ((s->flags & V4L2_SEL_FLAG_GE) && !mxr_is_rect_inside(&s->r, &res))
490 goto fail;
491
492 /* return result rectangle */
493 s->r = res;
494
fef1c8d0 495 return 0;
0d066d3f
TS		 496fail:
497 /* restore old geometry, which is not touched if target is NULL */
498 if (target)
499 memcpy(geo, &tmp, sizeof tmp);
500 return -ERANGE;
fef1c8d0
TS		 501}
502
503static int mxr_enum_dv_presets(struct file *file, void *fh,
504 struct v4l2_dv_enum_preset *preset)
505{
506 struct mxr_layer *layer = video_drvdata(file);
507 struct mxr_device *mdev = layer->mdev;
508 int ret;
509
510 /* lock protects from changing sd_out */
511 mutex_lock(&mdev->mutex);
512 ret = v4l2_subdev_call(to_outsd(mdev), video, enum_dv_presets, preset);
513 mutex_unlock(&mdev->mutex);
514
515 return ret ? -EINVAL : 0;
516}
517
518static int mxr_s_dv_preset(struct file *file, void *fh,
519 struct v4l2_dv_preset *preset)
520{
521 struct mxr_layer *layer = video_drvdata(file);
522 struct mxr_device *mdev = layer->mdev;
523 int ret;
524
525 /* lock protects from changing sd_out */
526 mutex_lock(&mdev->mutex);
527
528 /* preset change cannot be done while there is an entity
529 * dependant on output configuration
530 */
531 if (mdev->n_output > 0) {
532 mutex_unlock(&mdev->mutex);
533 return -EBUSY;
534 }
535
536 ret = v4l2_subdev_call(to_outsd(mdev), video, s_dv_preset, preset);
537
538 mutex_unlock(&mdev->mutex);
539
0d066d3f
TS		 540 mxr_layer_update_output(layer);
541
fef1c8d0
TS		 542 /* any failure should return EINVAL according to V4L2 doc */
543 return ret ? -EINVAL : 0;
544}
545
546static int mxr_g_dv_preset(struct file *file, void *fh,
547 struct v4l2_dv_preset *preset)
548{
549 struct mxr_layer *layer = video_drvdata(file);
550 struct mxr_device *mdev = layer->mdev;
551 int ret;
552
553 /* lock protects from changing sd_out */
554 mutex_lock(&mdev->mutex);
555 ret = v4l2_subdev_call(to_outsd(mdev), video, g_dv_preset, preset);
556 mutex_unlock(&mdev->mutex);
557
558 return ret ? -EINVAL : 0;
559}
560
561static int mxr_s_std(struct file *file, void *fh, v4l2_std_id *norm)
562{
563 struct mxr_layer *layer = video_drvdata(file);
564 struct mxr_device *mdev = layer->mdev;
565 int ret;
566
567 /* lock protects from changing sd_out */
568 mutex_lock(&mdev->mutex);
569
570 /* standard change cannot be done while there is an entity
571 * dependant on output configuration
572 */
573 if (mdev->n_output > 0) {
574 mutex_unlock(&mdev->mutex);
575 return -EBUSY;
576 }
577
578 ret = v4l2_subdev_call(to_outsd(mdev), video, s_std_output, *norm);
579
580 mutex_unlock(&mdev->mutex);
581
0d066d3f
TS		 582 mxr_layer_update_output(layer);
583
fef1c8d0
TS		 584 return ret ? -EINVAL : 0;
585}
586
587static int mxr_g_std(struct file *file, void *fh, v4l2_std_id *norm)
588{
589 struct mxr_layer *layer = video_drvdata(file);
590 struct mxr_device *mdev = layer->mdev;
591 int ret;
592
593 /* lock protects from changing sd_out */
594 mutex_lock(&mdev->mutex);
595 ret = v4l2_subdev_call(to_outsd(mdev), video, g_std_output, norm);
596 mutex_unlock(&mdev->mutex);
597
598 return ret ? -EINVAL : 0;
599}
600
601static int mxr_enum_output(struct file *file, void *fh, struct v4l2_output *a)
602{
603 struct mxr_layer *layer = video_drvdata(file);
604 struct mxr_device *mdev = layer->mdev;
605 struct mxr_output *out;
606 struct v4l2_subdev *sd;
607
608 if (a->index >= mdev->output_cnt)
609 return -EINVAL;
610 out = mdev->output[a->index];
611 BUG_ON(out == NULL);
612 sd = out->sd;
613 strlcpy(a->name, out->name, sizeof(a->name));
614
615 /* try to obtain supported tv norms */
616 v4l2_subdev_call(sd, video, g_tvnorms_output, &a->std);
617 a->capabilities = 0;
618 if (sd->ops->video && sd->ops->video->s_dv_preset)
619 a->capabilities |= V4L2_OUT_CAP_PRESETS;
620 if (sd->ops->video && sd->ops->video->s_std_output)
621 a->capabilities |= V4L2_OUT_CAP_STD;
622 a->type = V4L2_OUTPUT_TYPE_ANALOG;
623
624 return 0;
625}
626
627static int mxr_s_output(struct file *file, void *fh, unsigned int i)
628{
629 struct video_device *vfd = video_devdata(file);
630 struct mxr_layer *layer = video_drvdata(file);
631 struct mxr_device *mdev = layer->mdev;
fef1c8d0
TS		 632
633 if (i >= mdev->output_cnt || mdev->output[i] == NULL)
634 return -EINVAL;
635
636 mutex_lock(&mdev->mutex);
637 if (mdev->n_output > 0) {
0d066d3f
TS		 638 mutex_unlock(&mdev->mutex);
639 return -EBUSY;
fef1c8d0
TS		 640 }
641 mdev->current_output = i;
642 vfd->tvnorms = 0;
643 v4l2_subdev_call(to_outsd(mdev), video, g_tvnorms_output,
644 &vfd->tvnorms);
0d066d3f
TS		 645 mutex_unlock(&mdev->mutex);
646
647 /* update layers geometry */
648 mxr_layer_update_output(layer);
649
fef1c8d0
TS		 650 mxr_dbg(mdev, "tvnorms = %08llx\n", vfd->tvnorms);
651
0d066d3f 652 return 0;
fef1c8d0
TS		 653}
654
655static int mxr_g_output(struct file *file, void *fh, unsigned int *p)
656{
657 struct mxr_layer *layer = video_drvdata(file);
658 struct mxr_device *mdev = layer->mdev;
659
660 mutex_lock(&mdev->mutex);
661 *p = mdev->current_output;
662 mutex_unlock(&mdev->mutex);
663
664 return 0;
665}
666
667static int mxr_reqbufs(struct file *file, void *priv,
668 struct v4l2_requestbuffers *p)
669{
670 struct mxr_layer *layer = video_drvdata(file);
671
672 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
673 return vb2_reqbufs(&layer->vb_queue, p);
674}
675
676static int mxr_querybuf(struct file *file, void *priv, struct v4l2_buffer *p)
677{
678 struct mxr_layer *layer = video_drvdata(file);
679
680 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
681 return vb2_querybuf(&layer->vb_queue, p);
682}
683
684static int mxr_qbuf(struct file *file, void *priv, struct v4l2_buffer *p)
685{
686 struct mxr_layer *layer = video_drvdata(file);
687
688 mxr_dbg(layer->mdev, "%s:%d(%d)\n", __func__, __LINE__, p->index);
689 return vb2_qbuf(&layer->vb_queue, p);
690}
691
692static int mxr_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
693{
694 struct mxr_layer *layer = video_drvdata(file);
695
696 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
697 return vb2_dqbuf(&layer->vb_queue, p, file->f_flags & O_NONBLOCK);
698}
699
700static int mxr_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
701{
702 struct mxr_layer *layer = video_drvdata(file);
703
704 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
705 return vb2_streamon(&layer->vb_queue, i);
706}
707
708static int mxr_streamoff(struct file *file, void *priv, enum v4l2_buf_type i)
709{
710 struct mxr_layer *layer = video_drvdata(file);
711
712 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
713 return vb2_streamoff(&layer->vb_queue, i);
714}
715
716static const struct v4l2_ioctl_ops mxr_ioctl_ops = {
717 .vidioc_querycap = mxr_querycap,
718 /* format handling */
7208507e 719 .vidioc_enum_fmt_vid_out_mplane = mxr_enum_fmt,
fef1c8d0
TS		 720 .vidioc_s_fmt_vid_out_mplane = mxr_s_fmt,
721 .vidioc_g_fmt_vid_out_mplane = mxr_g_fmt,
722 /* buffer control */
723 .vidioc_reqbufs = mxr_reqbufs,
724 .vidioc_querybuf = mxr_querybuf,
725 .vidioc_qbuf = mxr_qbuf,
726 .vidioc_dqbuf = mxr_dqbuf,
727 /* Streaming control */
728 .vidioc_streamon = mxr_streamon,
729 .vidioc_streamoff = mxr_streamoff,
730 /* Preset functions */
731 .vidioc_enum_dv_presets = mxr_enum_dv_presets,
732 .vidioc_s_dv_preset = mxr_s_dv_preset,
733 .vidioc_g_dv_preset = mxr_g_dv_preset,
734 /* analog TV standard functions */
735 .vidioc_s_std = mxr_s_std,
736 .vidioc_g_std = mxr_g_std,
737 /* Output handling */
738 .vidioc_enum_output = mxr_enum_output,
739 .vidioc_s_output = mxr_s_output,
740 .vidioc_g_output = mxr_g_output,
0d066d3f
TS		 741 /* selection ioctls */
742 .vidioc_g_selection = mxr_g_selection,
743 .vidioc_s_selection = mxr_s_selection,
fef1c8d0
TS		 744};
745
746static int mxr_video_open(struct file *file)
747{
748 struct mxr_layer *layer = video_drvdata(file);
749 struct mxr_device *mdev = layer->mdev;
750 int ret = 0;
751
752 mxr_dbg(mdev, "%s:%d\n", __func__, __LINE__);
00ccdc3c
HV		 753 if (mutex_lock_interruptible(&layer->mutex))
754 return -ERESTARTSYS;
fef1c8d0
TS		 755 /* assure device probe is finished */
756 wait_for_device_probe();
757 /* creating context for file descriptor */
758 ret = v4l2_fh_open(file);
759 if (ret) {
760 mxr_err(mdev, "v4l2_fh_open failed\n");
00ccdc3c 761 goto unlock;
fef1c8d0
TS		 762 }
763
764 /* leaving if layer is already initialized */
765 if (!v4l2_fh_is_singular_file(file))
00ccdc3c 766 goto unlock;
fef1c8d0
TS		 767
768 /* FIXME: should power be enabled on open? */
769 ret = mxr_power_get(mdev);
770 if (ret) {
771 mxr_err(mdev, "power on failed\n");
772 goto fail_fh_open;
773 }
774
775 ret = vb2_queue_init(&layer->vb_queue);
776 if (ret != 0) {
777 mxr_err(mdev, "failed to initialize vb2 queue\n");
778 goto fail_power;
779 }
780 /* set default format, first on the list */
781 layer->fmt = layer->fmt_array[0];
782 /* setup default geometry */
783 mxr_layer_default_geo(layer);
00ccdc3c 784 mutex_unlock(&layer->mutex);
fef1c8d0
TS		 785
786 return 0;
787
788fail_power:
789 mxr_power_put(mdev);
790
791fail_fh_open:
792 v4l2_fh_release(file);
793
00ccdc3c
HV		 794unlock:
795 mutex_unlock(&layer->mutex);
796
fef1c8d0
TS		 797 return ret;
798}
799
800static unsigned int
801mxr_video_poll(struct file *file, struct poll_table_struct *wait)
802{
803 struct mxr_layer *layer = video_drvdata(file);
00ccdc3c 804 unsigned int res;
fef1c8d0
TS		 805
806 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
807
00ccdc3c
HV		 808 mutex_lock(&layer->mutex);
809 res = vb2_poll(&layer->vb_queue, file, wait);
810 mutex_unlock(&layer->mutex);
811 return res;
fef1c8d0
TS		 812}
813
814static int mxr_video_mmap(struct file *file, struct vm_area_struct *vma)
815{
816 struct mxr_layer *layer = video_drvdata(file);
00ccdc3c 817 int ret;
fef1c8d0
TS		 818
819 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
820
00ccdc3c
HV		 821 if (mutex_lock_interruptible(&layer->mutex))
822 return -ERESTARTSYS;
823 ret = vb2_mmap(&layer->vb_queue, vma);
824 mutex_unlock(&layer->mutex);
825 return ret;
fef1c8d0
TS		 826}
827
828static int mxr_video_release(struct file *file)
829{
830 struct mxr_layer *layer = video_drvdata(file);
831
832 mxr_dbg(layer->mdev, "%s:%d\n", __func__, __LINE__);
00ccdc3c 833 mutex_lock(&layer->mutex);
fef1c8d0
TS		 834 if (v4l2_fh_is_singular_file(file)) {
835 vb2_queue_release(&layer->vb_queue);
836 mxr_power_put(layer->mdev);
837 }
838 v4l2_fh_release(file);
00ccdc3c 839 mutex_unlock(&layer->mutex);
fef1c8d0
TS		 840 return 0;
841}
842
843static const struct v4l2_file_operations mxr_fops = {
844 .owner = THIS_MODULE,
845 .open = mxr_video_open,
846 .poll = mxr_video_poll,
847 .mmap = mxr_video_mmap,
848 .release = mxr_video_release,
849 .unlocked_ioctl = video_ioctl2,
850};
851
fc714e70
GL		 852static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *pfmt,
853 unsigned int *nbuffers, unsigned int *nplanes, unsigned int sizes[],
fef1c8d0
TS		 854 void *alloc_ctxs[])
855{
856 struct mxr_layer *layer = vb2_get_drv_priv(vq);
857 const struct mxr_format *fmt = layer->fmt;
858 int i;
859 struct mxr_device *mdev = layer->mdev;
860 struct v4l2_plane_pix_format planes[3];
861
862 mxr_dbg(mdev, "%s\n", __func__);
863 /* checking if format was configured */
864 if (fmt == NULL)
865 return -EINVAL;
866 mxr_dbg(mdev, "fmt = %s\n", fmt->name);
867 mxr_mplane_fill(planes, fmt, layer->geo.src.full_width,
868 layer->geo.src.full_height);
869
870 *nplanes = fmt->num_subframes;
871 for (i = 0; i < fmt->num_subframes; ++i) {
872 alloc_ctxs[i] = layer->mdev->alloc_ctx;
c1bf9c65 873 sizes[i] = planes[i].sizeimage;
c31e3c4b 874 mxr_dbg(mdev, "size[%d] = %08x\n", i, sizes[i]);
fef1c8d0
TS		 875 }
876
877 if (*nbuffers == 0)
878 *nbuffers = 1;
879
880 return 0;
881}
882
883static void buf_queue(struct vb2_buffer *vb)
884{
885 struct mxr_buffer *buffer = container_of(vb, struct mxr_buffer, vb);
886 struct mxr_layer *layer = vb2_get_drv_priv(vb->vb2_queue);
887 struct mxr_device *mdev = layer->mdev;
888 unsigned long flags;
fef1c8d0
TS		 889
890 spin_lock_irqsave(&layer->enq_slock, flags);
fef1c8d0
TS		 891 list_add_tail(&buffer->list, &layer->enq_list);
892 spin_unlock_irqrestore(&layer->enq_slock, flags);
fef1c8d0
TS		 893
894 mxr_dbg(mdev, "queuing buffer\n");
895}
896
897static void wait_lock(struct vb2_queue *vq)
898{
899 struct mxr_layer *layer = vb2_get_drv_priv(vq);
900
901 mxr_dbg(layer->mdev, "%s\n", __func__);
902 mutex_lock(&layer->mutex);
903}
904
905static void wait_unlock(struct vb2_queue *vq)
906{
907 struct mxr_layer *layer = vb2_get_drv_priv(vq);
908
909 mxr_dbg(layer->mdev, "%s\n", __func__);
910 mutex_unlock(&layer->mutex);
911}
912
bd323e28 913static int start_streaming(struct vb2_queue *vq, unsigned int count)
fef1c8d0
TS		 914{
915 struct mxr_layer *layer = vb2_get_drv_priv(vq);
916 struct mxr_device *mdev = layer->mdev;
917 unsigned long flags;
918
919 mxr_dbg(mdev, "%s\n", __func__);
bd323e28
MS		 920
921 if (count == 0) {
922 mxr_dbg(mdev, "no output buffers queued\n");
923 return -EINVAL;
924 }
925
fef1c8d0
TS		 926 /* block any changes in output configuration */
927 mxr_output_get(mdev);
928
0d066d3f 929 mxr_layer_update_output(layer);
fef1c8d0
TS		 930 layer->ops.format_set(layer);
931 /* enabling layer in hardware */
932 spin_lock_irqsave(&layer->enq_slock, flags);
bd323e28 933 layer->state = MXR_LAYER_STREAMING;
fef1c8d0
TS		 934 spin_unlock_irqrestore(&layer->enq_slock, flags);
935
bd323e28
MS		 936 layer->ops.stream_set(layer, MXR_ENABLE);
937 mxr_streamer_get(mdev);
938
fef1c8d0
TS		 939 return 0;
940}
941
942static void mxr_watchdog(unsigned long arg)
943{
944 struct mxr_layer *layer = (struct mxr_layer *) arg;
945 struct mxr_device *mdev = layer->mdev;
946 unsigned long flags;
947
948 mxr_err(mdev, "watchdog fired for layer %s\n", layer->vfd.name);
949
950 spin_lock_irqsave(&layer->enq_slock, flags);
951
952 if (layer->update_buf == layer->shadow_buf)
953 layer->update_buf = NULL;
954 if (layer->update_buf) {
955 vb2_buffer_done(&layer->update_buf->vb, VB2_BUF_STATE_ERROR);
956 layer->update_buf = NULL;
957 }
958 if (layer->shadow_buf) {
959 vb2_buffer_done(&layer->shadow_buf->vb, VB2_BUF_STATE_ERROR);
960 layer->shadow_buf = NULL;
961 }
962 spin_unlock_irqrestore(&layer->enq_slock, flags);
963}
964
965static int stop_streaming(struct vb2_queue *vq)
966{
967 struct mxr_layer *layer = vb2_get_drv_priv(vq);
968 struct mxr_device *mdev = layer->mdev;
969 unsigned long flags;
970 struct timer_list watchdog;
971 struct mxr_buffer *buf, *buf_tmp;
972
973 mxr_dbg(mdev, "%s\n", __func__);
974
975 spin_lock_irqsave(&layer->enq_slock, flags);
976
977 /* reset list */
978 layer->state = MXR_LAYER_STREAMING_FINISH;
979
980 /* set all buffer to be done */
981 list_for_each_entry_safe(buf, buf_tmp, &layer->enq_list, list) {
982 list_del(&buf->list);
983 vb2_buffer_done(&buf->vb, VB2_BUF_STATE_ERROR);
984 }
985
986 spin_unlock_irqrestore(&layer->enq_slock, flags);
987
988 /* give 1 seconds to complete to complete last buffers */
989 setup_timer_on_stack(&watchdog, mxr_watchdog,
990 (unsigned long)layer);
991 mod_timer(&watchdog, jiffies + msecs_to_jiffies(1000));
992
993 /* wait until all buffers are goes to done state */
994 vb2_wait_for_all_buffers(vq);
995
996 /* stop timer if all synchronization is done */
997 del_timer_sync(&watchdog);
998 destroy_timer_on_stack(&watchdog);
999
1000 /* stopping hardware */
1001 spin_lock_irqsave(&layer->enq_slock, flags);
1002 layer->state = MXR_LAYER_IDLE;
1003 spin_unlock_irqrestore(&layer->enq_slock, flags);
1004
1005 /* disabling layer in hardware */
1006 layer->ops.stream_set(layer, MXR_DISABLE);
1007 /* remove one streamer */
1008 mxr_streamer_put(mdev);
1009 /* allow changes in output configuration */
1010 mxr_output_put(mdev);
1011 return 0;
1012}
1013
1014static struct vb2_ops mxr_video_qops = {
1015 .queue_setup = queue_setup,
1016 .buf_queue = buf_queue,
1017 .wait_prepare = wait_unlock,
1018 .wait_finish = wait_lock,
1019 .start_streaming = start_streaming,
1020 .stop_streaming = stop_streaming,
1021};
1022
1023/* FIXME: try to put this functions to mxr_base_layer_create */
1024int mxr_base_layer_register(struct mxr_layer *layer)
1025{
1026 struct mxr_device *mdev = layer->mdev;
1027 int ret;
1028
1029 ret = video_register_device(&layer->vfd, VFL_TYPE_GRABBER, -1);
1030 if (ret)
1031 mxr_err(mdev, "failed to register video device\n");
1032 else
1033 mxr_info(mdev, "registered layer %s as /dev/video%d\n",
1034 layer->vfd.name, layer->vfd.num);
1035 return ret;
1036}
1037
1038void mxr_base_layer_unregister(struct mxr_layer *layer)
1039{
1040 video_unregister_device(&layer->vfd);
1041}
1042
1043void mxr_layer_release(struct mxr_layer *layer)
1044{
1045 if (layer->ops.release)
1046 layer->ops.release(layer);
1047}
1048
1049void mxr_base_layer_release(struct mxr_layer *layer)
1050{
1051 kfree(layer);
1052}
1053
1054static void mxr_vfd_release(struct video_device *vdev)
1055{
f5c99037 1056 pr_info("video device release\n");
fef1c8d0
TS		 1057}
1058
1059struct mxr_layer *mxr_base_layer_create(struct mxr_device *mdev,
1060 int idx, char *name, struct mxr_layer_ops *ops)
1061{
1062 struct mxr_layer *layer;
1063
1064 layer = kzalloc(sizeof *layer, GFP_KERNEL);
1065 if (layer == NULL) {
1066 mxr_err(mdev, "not enough memory for layer.\n");
1067 goto fail;
1068 }
1069
1070 layer->mdev = mdev;
1071 layer->idx = idx;
1072 layer->ops = *ops;
1073
1074 spin_lock_init(&layer->enq_slock);
1075 INIT_LIST_HEAD(&layer->enq_list);
1076 mutex_init(&layer->mutex);
1077
1078 layer->vfd = (struct video_device) {
1079 .minor = -1,
1080 .release = mxr_vfd_release,
1081 .fops = &mxr_fops,
954f340f 1082 .vfl_dir = VFL_DIR_TX,
fef1c8d0
TS		 1083 .ioctl_ops = &mxr_ioctl_ops,
1084 };
1085 strlcpy(layer->vfd.name, name, sizeof(layer->vfd.name));
1086 /* let framework control PRIORITY */
1087 set_bit(V4L2_FL_USE_FH_PRIO, &layer->vfd.flags);
1088
1089 video_set_drvdata(&layer->vfd, layer);
1090 layer->vfd.lock = &layer->mutex;
1091 layer->vfd.v4l2_dev = &mdev->v4l2_dev;
1092
1093 layer->vb_queue = (struct vb2_queue) {
1094 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE,
fa77521f 1095 .io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF,
fef1c8d0
TS		 1096 .drv_priv = layer,
1097 .buf_struct_size = sizeof(struct mxr_buffer),
1098 .ops = &mxr_video_qops,
1099 .mem_ops = &vb2_dma_contig_memops,
1100 };
1101
1102 return layer;
1103
1104fail:
1105 return NULL;
1106}
1107
1108static const struct mxr_format *find_format_by_fourcc(
1109 struct mxr_layer *layer, unsigned long fourcc)
1110{
1111 int i;
1112
1113 for (i = 0; i < layer->fmt_array_size; ++i)
1114 if (layer->fmt_array[i]->fourcc == fourcc)
1115 return layer->fmt_array[i];
1116 return NULL;
1117}
1118
1119static const struct mxr_format *find_format_by_index(
1120 struct mxr_layer *layer, unsigned long index)
1121{
1122 if (index >= layer->fmt_array_size)
1123 return NULL;
1124 return layer->fmt_array[index];
1125}
1126
Linux kernel - Deliverables
This page took 0.156467 seconds and 5 git commands to generate.