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