linux/drivers/media/platform/sh_veu.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * sh-mobile VEU mem2mem driver
   4 *
   5 * Copyright (C) 2012 Renesas Electronics Corporation
   6 * Author: Guennadi Liakhovetski, <g.liakhovetski@gmx.de>
   7 * Copyright (C) 2008 Magnus Damm
   8 */
   9
  10#include <linux/err.h>
  11#include <linux/fs.h>
  12#include <linux/kernel.h>
  13#include <linux/module.h>
  14#include <linux/interrupt.h>
  15#include <linux/io.h>
  16#include <linux/platform_device.h>
  17#include <linux/pm_runtime.h>
  18#include <linux/slab.h>
  19#include <linux/types.h>
  20#include <linux/videodev2.h>
  21
  22#include <media/v4l2-dev.h>
  23#include <media/v4l2-device.h>
  24#include <media/v4l2-ioctl.h>
  25#include <media/v4l2-mem2mem.h>
  26#include <media/v4l2-image-sizes.h>
  27#include <media/videobuf2-dma-contig.h>
  28
  29#define VEU_STR 0x00 /* start register */
  30#define VEU_SWR 0x10 /* src: line length */
  31#define VEU_SSR 0x14 /* src: image size */
  32#define VEU_SAYR 0x18 /* src: y/rgb plane address */
  33#define VEU_SACR 0x1c /* src: c plane address */
  34#define VEU_BSSR 0x20 /* bundle mode register */
  35#define VEU_EDWR 0x30 /* dst: line length */
  36#define VEU_DAYR 0x34 /* dst: y/rgb plane address */
  37#define VEU_DACR 0x38 /* dst: c plane address */
  38#define VEU_TRCR 0x50 /* transform control */
  39#define VEU_RFCR 0x54 /* resize scale */
  40#define VEU_RFSR 0x58 /* resize clip */
  41#define VEU_ENHR 0x5c /* enhance */
  42#define VEU_FMCR 0x70 /* filter mode */
  43#define VEU_VTCR 0x74 /* lowpass vertical */
  44#define VEU_HTCR 0x78 /* lowpass horizontal */
  45#define VEU_APCR 0x80 /* color match */
  46#define VEU_ECCR 0x84 /* color replace */
  47#define VEU_AFXR 0x90 /* fixed mode */
  48#define VEU_SWPR 0x94 /* swap */
  49#define VEU_EIER 0xa0 /* interrupt mask */
  50#define VEU_EVTR 0xa4 /* interrupt event */
  51#define VEU_STAR 0xb0 /* status */
  52#define VEU_BSRR 0xb4 /* reset */
  53
  54#define VEU_MCR00 0x200 /* color conversion matrix coefficient 00 */
  55#define VEU_MCR01 0x204 /* color conversion matrix coefficient 01 */
  56#define VEU_MCR02 0x208 /* color conversion matrix coefficient 02 */
  57#define VEU_MCR10 0x20c /* color conversion matrix coefficient 10 */
  58#define VEU_MCR11 0x210 /* color conversion matrix coefficient 11 */
  59#define VEU_MCR12 0x214 /* color conversion matrix coefficient 12 */
  60#define VEU_MCR20 0x218 /* color conversion matrix coefficient 20 */
  61#define VEU_MCR21 0x21c /* color conversion matrix coefficient 21 */
  62#define VEU_MCR22 0x220 /* color conversion matrix coefficient 22 */
  63#define VEU_COFFR 0x224 /* color conversion offset */
  64#define VEU_CBR   0x228 /* color conversion clip */
  65
  66/*
  67 * 4092x4092 max size is the normal case. In some cases it can be reduced to
  68 * 2048x2048, in other cases it can be 4092x8188 or even 8188x8188.
  69 */
  70#define MAX_W 4092
  71#define MAX_H 4092
  72#define MIN_W 8
  73#define MIN_H 8
  74#define ALIGN_W 4
  75
  76/* 3 buffers of 2048 x 1536 - 3 megapixels @ 16bpp */
  77#define VIDEO_MEM_LIMIT ALIGN(2048 * 1536 * 2 * 3, 1024 * 1024)
  78
  79#define MEM2MEM_DEF_TRANSLEN 1
  80
  81struct sh_veu_dev;
  82
  83struct sh_veu_file {
  84        struct sh_veu_dev *veu_dev;
  85        bool cfg_needed;
  86};
  87
  88struct sh_veu_format {
  89        char *name;
  90        u32 fourcc;
  91        unsigned int depth;
  92        unsigned int ydepth;
  93};
  94
  95/* video data format */
  96struct sh_veu_vfmt {
  97        /* Replace with v4l2_rect */
  98        struct v4l2_rect                frame;
  99        unsigned int                    bytesperline;
 100        unsigned int                    offset_y;
 101        unsigned int                    offset_c;
 102        const struct sh_veu_format      *fmt;
 103};
 104
 105struct sh_veu_dev {
 106        struct v4l2_device v4l2_dev;
 107        struct video_device vdev;
 108        struct v4l2_m2m_dev *m2m_dev;
 109        struct device *dev;
 110        struct v4l2_m2m_ctx *m2m_ctx;
 111        struct sh_veu_vfmt vfmt_out;
 112        struct sh_veu_vfmt vfmt_in;
 113        /* Only single user per direction so far */
 114        struct sh_veu_file *capture;
 115        struct sh_veu_file *output;
 116        struct mutex fop_lock;
 117        void __iomem *base;
 118        spinlock_t lock;
 119        bool is_2h;
 120        unsigned int xaction;
 121        bool aborting;
 122};
 123
 124enum sh_veu_fmt_idx {
 125        SH_VEU_FMT_NV12,
 126        SH_VEU_FMT_NV16,
 127        SH_VEU_FMT_NV24,
 128        SH_VEU_FMT_RGB332,
 129        SH_VEU_FMT_RGB444,
 130        SH_VEU_FMT_RGB565,
 131        SH_VEU_FMT_RGB666,
 132        SH_VEU_FMT_RGB24,
 133};
 134
 135#define DEFAULT_IN_WIDTH        VGA_WIDTH
 136#define DEFAULT_IN_HEIGHT       VGA_HEIGHT
 137#define DEFAULT_IN_FMTIDX       SH_VEU_FMT_NV12
 138#define DEFAULT_OUT_WIDTH       VGA_WIDTH
 139#define DEFAULT_OUT_HEIGHT      VGA_HEIGHT
 140#define DEFAULT_OUT_FMTIDX      SH_VEU_FMT_RGB565
 141
 142/*
 143 * Alignment: Y-plane should be 4-byte aligned for NV12 and NV16, and 8-byte
 144 * aligned for NV24.
 145 */
 146static const struct sh_veu_format sh_veu_fmt[] = {
 147        [SH_VEU_FMT_NV12]   = { .ydepth = 8, .depth = 12, .name = "NV12", .fourcc = V4L2_PIX_FMT_NV12 },
 148        [SH_VEU_FMT_NV16]   = { .ydepth = 8, .depth = 16, .name = "NV16", .fourcc = V4L2_PIX_FMT_NV16 },
 149        [SH_VEU_FMT_NV24]   = { .ydepth = 8, .depth = 24, .name = "NV24", .fourcc = V4L2_PIX_FMT_NV24 },
 150        [SH_VEU_FMT_RGB332] = { .ydepth = 8, .depth = 8, .name = "RGB332", .fourcc = V4L2_PIX_FMT_RGB332 },
 151        [SH_VEU_FMT_RGB444] = { .ydepth = 16, .depth = 16, .name = "RGB444", .fourcc = V4L2_PIX_FMT_RGB444 },
 152        [SH_VEU_FMT_RGB565] = { .ydepth = 16, .depth = 16, .name = "RGB565", .fourcc = V4L2_PIX_FMT_RGB565 },
 153        [SH_VEU_FMT_RGB666] = { .ydepth = 32, .depth = 32, .name = "BGR666", .fourcc = V4L2_PIX_FMT_BGR666 },
 154        [SH_VEU_FMT_RGB24]  = { .ydepth = 24, .depth = 24, .name = "RGB24", .fourcc = V4L2_PIX_FMT_RGB24 },
 155};
 156
 157#define DEFAULT_IN_VFMT (struct sh_veu_vfmt){                                           \
 158        .frame = {                                                                      \
 159                .width = VGA_WIDTH,                                                     \
 160                .height = VGA_HEIGHT,                                                   \
 161        },                                                                              \
 162        .bytesperline = (VGA_WIDTH * sh_veu_fmt[DEFAULT_IN_FMTIDX].ydepth) >> 3,        \
 163        .fmt = &sh_veu_fmt[DEFAULT_IN_FMTIDX],                                          \
 164}
 165
 166#define DEFAULT_OUT_VFMT (struct sh_veu_vfmt){                                          \
 167        .frame = {                                                                      \
 168                .width = VGA_WIDTH,                                                     \
 169                .height = VGA_HEIGHT,                                                   \
 170        },                                                                              \
 171        .bytesperline = (VGA_WIDTH * sh_veu_fmt[DEFAULT_OUT_FMTIDX].ydepth) >> 3,       \
 172        .fmt = &sh_veu_fmt[DEFAULT_OUT_FMTIDX],                                         \
 173}
 174
 175/*
 176 * TODO: add support for further output formats:
 177 *      SH_VEU_FMT_NV12,
 178 *      SH_VEU_FMT_NV16,
 179 *      SH_VEU_FMT_NV24,
 180 *      SH_VEU_FMT_RGB332,
 181 *      SH_VEU_FMT_RGB444,
 182 *      SH_VEU_FMT_RGB666,
 183 *      SH_VEU_FMT_RGB24,
 184 */
 185
 186static const int sh_veu_fmt_out[] = {
 187        SH_VEU_FMT_RGB565,
 188};
 189
 190/*
 191 * TODO: add support for further input formats:
 192 *      SH_VEU_FMT_NV16,
 193 *      SH_VEU_FMT_NV24,
 194 *      SH_VEU_FMT_RGB565,
 195 *      SH_VEU_FMT_RGB666,
 196 *      SH_VEU_FMT_RGB24,
 197 */
 198static const int sh_veu_fmt_in[] = {
 199        SH_VEU_FMT_NV12,
 200};
 201
 202static enum v4l2_colorspace sh_veu_4cc2cspace(u32 fourcc)
 203{
 204        switch (fourcc) {
 205        default:
 206                BUG();
 207        case V4L2_PIX_FMT_NV12:
 208        case V4L2_PIX_FMT_NV16:
 209        case V4L2_PIX_FMT_NV24:
 210                return V4L2_COLORSPACE_SMPTE170M;
 211        case V4L2_PIX_FMT_RGB332:
 212        case V4L2_PIX_FMT_RGB444:
 213        case V4L2_PIX_FMT_RGB565:
 214        case V4L2_PIX_FMT_BGR666:
 215        case V4L2_PIX_FMT_RGB24:
 216                return V4L2_COLORSPACE_SRGB;
 217        }
 218}
 219
 220static u32 sh_veu_reg_read(struct sh_veu_dev *veu, unsigned int reg)
 221{
 222        return ioread32(veu->base + reg);
 223}
 224
 225static void sh_veu_reg_write(struct sh_veu_dev *veu, unsigned int reg,
 226                             u32 value)
 227{
 228        iowrite32(value, veu->base + reg);
 229}
 230
 231                /* ========== mem2mem callbacks ========== */
 232
 233static void sh_veu_job_abort(void *priv)
 234{
 235        struct sh_veu_dev *veu = priv;
 236
 237        /* Will cancel the transaction in the next interrupt handler */
 238        veu->aborting = true;
 239}
 240
 241static void sh_veu_process(struct sh_veu_dev *veu,
 242                           struct vb2_buffer *src_buf,
 243                           struct vb2_buffer *dst_buf)
 244{
 245        dma_addr_t addr = vb2_dma_contig_plane_dma_addr(dst_buf, 0);
 246
 247        sh_veu_reg_write(veu, VEU_DAYR, addr + veu->vfmt_out.offset_y);
 248        sh_veu_reg_write(veu, VEU_DACR, veu->vfmt_out.offset_c ?
 249                         addr + veu->vfmt_out.offset_c : 0);
 250        dev_dbg(veu->dev, "%s(): dst base %lx, y: %x, c: %x\n", __func__,
 251                (unsigned long)addr,
 252                veu->vfmt_out.offset_y, veu->vfmt_out.offset_c);
 253
 254        addr = vb2_dma_contig_plane_dma_addr(src_buf, 0);
 255        sh_veu_reg_write(veu, VEU_SAYR, addr + veu->vfmt_in.offset_y);
 256        sh_veu_reg_write(veu, VEU_SACR, veu->vfmt_in.offset_c ?
 257                         addr + veu->vfmt_in.offset_c : 0);
 258        dev_dbg(veu->dev, "%s(): src base %lx, y: %x, c: %x\n", __func__,
 259                (unsigned long)addr,
 260                veu->vfmt_in.offset_y, veu->vfmt_in.offset_c);
 261
 262        sh_veu_reg_write(veu, VEU_STR, 1);
 263
 264        sh_veu_reg_write(veu, VEU_EIER, 1); /* enable interrupt in VEU */
 265}
 266
 267/*
 268 * sh_veu_device_run() - prepares and starts the device
 269 *
 270 * This will be called by the framework when it decides to schedule a particular
 271 * instance.
 272 */
 273static void sh_veu_device_run(void *priv)
 274{
 275        struct sh_veu_dev *veu = priv;
 276        struct vb2_v4l2_buffer *src_buf, *dst_buf;
 277
 278        src_buf = v4l2_m2m_next_src_buf(veu->m2m_ctx);
 279        dst_buf = v4l2_m2m_next_dst_buf(veu->m2m_ctx);
 280
 281        if (src_buf && dst_buf)
 282                sh_veu_process(veu, &src_buf->vb2_buf, &dst_buf->vb2_buf);
 283}
 284
 285                /* ========== video ioctls ========== */
 286
 287static bool sh_veu_is_streamer(struct sh_veu_dev *veu, struct sh_veu_file *veu_file,
 288                               enum v4l2_buf_type type)
 289{
 290        return (type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
 291                veu_file == veu->capture) ||
 292                (type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
 293                 veu_file == veu->output);
 294}
 295
 296static int sh_veu_queue_init(void *priv, struct vb2_queue *src_vq,
 297                             struct vb2_queue *dst_vq);
 298
 299/*
 300 * It is not unusual to have video nodes open()ed multiple times. While some
 301 * V4L2 operations are non-intrusive, like querying formats and various
 302 * parameters, others, like setting formats, starting and stopping streaming,
 303 * queuing and dequeuing buffers, directly affect hardware configuration and /
 304 * or execution. This function verifies availability of the requested interface
 305 * and, if available, reserves it for the requesting user.
 306 */
 307static int sh_veu_stream_init(struct sh_veu_dev *veu, struct sh_veu_file *veu_file,
 308                              enum v4l2_buf_type type)
 309{
 310        struct sh_veu_file **stream;
 311
 312        switch (type) {
 313        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 314                stream = &veu->capture;
 315                break;
 316        case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 317                stream = &veu->output;
 318                break;
 319        default:
 320                return -EINVAL;
 321        }
 322
 323        if (*stream == veu_file)
 324                return 0;
 325
 326        if (*stream)
 327                return -EBUSY;
 328
 329        *stream = veu_file;
 330
 331        return 0;
 332}
 333
 334static int sh_veu_context_init(struct sh_veu_dev *veu)
 335{
 336        if (veu->m2m_ctx)
 337                return 0;
 338
 339        veu->m2m_ctx = v4l2_m2m_ctx_init(veu->m2m_dev, veu,
 340                                         sh_veu_queue_init);
 341
 342        return PTR_ERR_OR_ZERO(veu->m2m_ctx);
 343}
 344
 345static int sh_veu_querycap(struct file *file, void *priv,
 346                           struct v4l2_capability *cap)
 347{
 348        strscpy(cap->driver, "sh-veu", sizeof(cap->driver));
 349        strscpy(cap->card, "sh-mobile VEU", sizeof(cap->card));
 350        strscpy(cap->bus_info, "platform:sh-veu", sizeof(cap->bus_info));
 351        cap->device_caps = V4L2_CAP_VIDEO_M2M | V4L2_CAP_STREAMING;
 352        cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 353
 354        return 0;
 355}
 356
 357static int sh_veu_enum_fmt(struct v4l2_fmtdesc *f, const int *fmt, int fmt_num)
 358{
 359        if (f->index >= fmt_num)
 360                return -EINVAL;
 361
 362        strscpy(f->description, sh_veu_fmt[fmt[f->index]].name,
 363                sizeof(f->description));
 364        f->pixelformat = sh_veu_fmt[fmt[f->index]].fourcc;
 365        return 0;
 366}
 367
 368static int sh_veu_enum_fmt_vid_cap(struct file *file, void *priv,
 369                                   struct v4l2_fmtdesc *f)
 370{
 371        return sh_veu_enum_fmt(f, sh_veu_fmt_out, ARRAY_SIZE(sh_veu_fmt_out));
 372}
 373
 374static int sh_veu_enum_fmt_vid_out(struct file *file, void *priv,
 375                                   struct v4l2_fmtdesc *f)
 376{
 377        return sh_veu_enum_fmt(f, sh_veu_fmt_in, ARRAY_SIZE(sh_veu_fmt_in));
 378}
 379
 380static struct sh_veu_vfmt *sh_veu_get_vfmt(struct sh_veu_dev *veu,
 381                                           enum v4l2_buf_type type)
 382{
 383        switch (type) {
 384        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 385                return &veu->vfmt_out;
 386        case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 387                return &veu->vfmt_in;
 388        default:
 389                return NULL;
 390        }
 391}
 392
 393static int sh_veu_g_fmt(struct sh_veu_file *veu_file, struct v4l2_format *f)
 394{
 395        struct v4l2_pix_format *pix = &f->fmt.pix;
 396        struct sh_veu_dev *veu = veu_file->veu_dev;
 397        struct sh_veu_vfmt *vfmt;
 398
 399        vfmt = sh_veu_get_vfmt(veu, f->type);
 400
 401        pix->width              = vfmt->frame.width;
 402        pix->height             = vfmt->frame.height;
 403        pix->field              = V4L2_FIELD_NONE;
 404        pix->pixelformat        = vfmt->fmt->fourcc;
 405        pix->colorspace         = sh_veu_4cc2cspace(pix->pixelformat);
 406        pix->bytesperline       = vfmt->bytesperline;
 407        pix->sizeimage          = vfmt->bytesperline * pix->height *
 408                vfmt->fmt->depth / vfmt->fmt->ydepth;
 409        dev_dbg(veu->dev, "%s(): type: %d, size %u @ %ux%u, fmt %x\n", __func__,
 410                f->type, pix->sizeimage, pix->width, pix->height, pix->pixelformat);
 411
 412        return 0;
 413}
 414
 415static int sh_veu_g_fmt_vid_out(struct file *file, void *priv,
 416                                struct v4l2_format *f)
 417{
 418        return sh_veu_g_fmt(priv, f);
 419}
 420
 421static int sh_veu_g_fmt_vid_cap(struct file *file, void *priv,
 422                                struct v4l2_format *f)
 423{
 424        return sh_veu_g_fmt(priv, f);
 425}
 426
 427static int sh_veu_try_fmt(struct v4l2_format *f, const struct sh_veu_format *fmt)
 428{
 429        struct v4l2_pix_format *pix = &f->fmt.pix;
 430        unsigned int y_bytes_used;
 431
 432        /*
 433         * V4L2 specification suggests, that the driver should correct the
 434         * format struct if any of the dimensions is unsupported
 435         */
 436        switch (pix->field) {
 437        default:
 438        case V4L2_FIELD_ANY:
 439                pix->field = V4L2_FIELD_NONE;
 440                /* fall through: continue handling V4L2_FIELD_NONE */
 441        case V4L2_FIELD_NONE:
 442                break;
 443        }
 444
 445        v4l_bound_align_image(&pix->width, MIN_W, MAX_W, ALIGN_W,
 446                              &pix->height, MIN_H, MAX_H, 0, 0);
 447
 448        y_bytes_used = (pix->width * fmt->ydepth) >> 3;
 449
 450        if (pix->bytesperline < y_bytes_used)
 451                pix->bytesperline = y_bytes_used;
 452        pix->sizeimage = pix->height * pix->bytesperline * fmt->depth / fmt->ydepth;
 453
 454        pix->pixelformat        = fmt->fourcc;
 455        pix->colorspace         = sh_veu_4cc2cspace(pix->pixelformat);
 456
 457        pr_debug("%s(): type: %d, size %u\n", __func__, f->type, pix->sizeimage);
 458
 459        return 0;
 460}
 461
 462static const struct sh_veu_format *sh_veu_find_fmt(const struct v4l2_format *f)
 463{
 464        const int *fmt;
 465        int i, n, dflt;
 466
 467        pr_debug("%s(%d;%d)\n", __func__, f->type, f->fmt.pix.field);
 468
 469        switch (f->type) {
 470        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 471                fmt = sh_veu_fmt_out;
 472                n = ARRAY_SIZE(sh_veu_fmt_out);
 473                dflt = DEFAULT_OUT_FMTIDX;
 474                break;
 475        case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 476        default:
 477                fmt = sh_veu_fmt_in;
 478                n = ARRAY_SIZE(sh_veu_fmt_in);
 479                dflt = DEFAULT_IN_FMTIDX;
 480                break;
 481        }
 482
 483        for (i = 0; i < n; i++)
 484                if (sh_veu_fmt[fmt[i]].fourcc == f->fmt.pix.pixelformat)
 485                        return &sh_veu_fmt[fmt[i]];
 486
 487        return &sh_veu_fmt[dflt];
 488}
 489
 490static int sh_veu_try_fmt_vid_cap(struct file *file, void *priv,
 491                                  struct v4l2_format *f)
 492{
 493        const struct sh_veu_format *fmt;
 494
 495        fmt = sh_veu_find_fmt(f);
 496        if (!fmt)
 497                /* wrong buffer type */
 498                return -EINVAL;
 499
 500        return sh_veu_try_fmt(f, fmt);
 501}
 502
 503static int sh_veu_try_fmt_vid_out(struct file *file, void *priv,
 504                                  struct v4l2_format *f)
 505{
 506        const struct sh_veu_format *fmt;
 507
 508        fmt = sh_veu_find_fmt(f);
 509        if (!fmt)
 510                /* wrong buffer type */
 511                return -EINVAL;
 512
 513        return sh_veu_try_fmt(f, fmt);
 514}
 515
 516static void sh_veu_colour_offset(struct sh_veu_dev *veu, struct sh_veu_vfmt *vfmt)
 517{
 518        /* dst_left and dst_top validity will be verified in CROP / COMPOSE */
 519        unsigned int left = vfmt->frame.left & ~0x03;
 520        unsigned int top = vfmt->frame.top;
 521        dma_addr_t offset = (dma_addr_t)top * veu->vfmt_out.bytesperline +
 522                        (((dma_addr_t)left * veu->vfmt_out.fmt->depth) >> 3);
 523        unsigned int y_line;
 524
 525        vfmt->offset_y = offset;
 526
 527        switch (vfmt->fmt->fourcc) {
 528        case V4L2_PIX_FMT_NV12:
 529        case V4L2_PIX_FMT_NV16:
 530        case V4L2_PIX_FMT_NV24:
 531                y_line = ALIGN(vfmt->frame.width, 16);
 532                vfmt->offset_c = offset + y_line * vfmt->frame.height;
 533                break;
 534        case V4L2_PIX_FMT_RGB332:
 535        case V4L2_PIX_FMT_RGB444:
 536        case V4L2_PIX_FMT_RGB565:
 537        case V4L2_PIX_FMT_BGR666:
 538        case V4L2_PIX_FMT_RGB24:
 539                vfmt->offset_c = 0;
 540                break;
 541        default:
 542                BUG();
 543        }
 544}
 545
 546static int sh_veu_s_fmt(struct sh_veu_file *veu_file, struct v4l2_format *f)
 547{
 548        struct v4l2_pix_format *pix = &f->fmt.pix;
 549        struct sh_veu_dev *veu = veu_file->veu_dev;
 550        struct sh_veu_vfmt *vfmt;
 551        struct vb2_queue *vq;
 552        int ret = sh_veu_context_init(veu);
 553        if (ret < 0)
 554                return ret;
 555
 556        vq = v4l2_m2m_get_vq(veu->m2m_ctx, f->type);
 557        if (!vq)
 558                return -EINVAL;
 559
 560        if (vb2_is_busy(vq)) {
 561                v4l2_err(&veu_file->veu_dev->v4l2_dev, "%s queue busy\n", __func__);
 562                return -EBUSY;
 563        }
 564
 565        vfmt = sh_veu_get_vfmt(veu, f->type);
 566        /* called after try_fmt(), hence vfmt != NULL. Implicit BUG_ON() below */
 567
 568        vfmt->fmt               = sh_veu_find_fmt(f);
 569        /* vfmt->fmt != NULL following the same argument as above */
 570        vfmt->frame.width       = pix->width;
 571        vfmt->frame.height      = pix->height;
 572        vfmt->bytesperline      = pix->bytesperline;
 573
 574        sh_veu_colour_offset(veu, vfmt);
 575
 576        /*
 577         * We could also verify and require configuration only if any parameters
 578         * actually have changed, but it is unlikely, that the user requests the
 579         * same configuration several times without closing the device.
 580         */
 581        veu_file->cfg_needed = true;
 582
 583        dev_dbg(veu->dev,
 584                "Setting format for type %d, wxh: %dx%d, fmt: %x\n",
 585                f->type, pix->width, pix->height, vfmt->fmt->fourcc);
 586
 587        return 0;
 588}
 589
 590static int sh_veu_s_fmt_vid_cap(struct file *file, void *priv,
 591                                struct v4l2_format *f)
 592{
 593        int ret = sh_veu_try_fmt_vid_cap(file, priv, f);
 594        if (ret)
 595                return ret;
 596
 597        return sh_veu_s_fmt(priv, f);
 598}
 599
 600static int sh_veu_s_fmt_vid_out(struct file *file, void *priv,
 601                                struct v4l2_format *f)
 602{
 603        int ret = sh_veu_try_fmt_vid_out(file, priv, f);
 604        if (ret)
 605                return ret;
 606
 607        return sh_veu_s_fmt(priv, f);
 608}
 609
 610static int sh_veu_reqbufs(struct file *file, void *priv,
 611                          struct v4l2_requestbuffers *reqbufs)
 612{
 613        struct sh_veu_file *veu_file = priv;
 614        struct sh_veu_dev *veu = veu_file->veu_dev;
 615        int ret = sh_veu_context_init(veu);
 616        if (ret < 0)
 617                return ret;
 618
 619        ret = sh_veu_stream_init(veu, veu_file, reqbufs->type);
 620        if (ret < 0)
 621                return ret;
 622
 623        return v4l2_m2m_reqbufs(file, veu->m2m_ctx, reqbufs);
 624}
 625
 626static int sh_veu_querybuf(struct file *file, void *priv,
 627                           struct v4l2_buffer *buf)
 628{
 629        struct sh_veu_file *veu_file = priv;
 630
 631        if (!sh_veu_is_streamer(veu_file->veu_dev, veu_file, buf->type))
 632                return -EBUSY;
 633
 634        return v4l2_m2m_querybuf(file, veu_file->veu_dev->m2m_ctx, buf);
 635}
 636
 637static int sh_veu_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
 638{
 639        struct sh_veu_file *veu_file = priv;
 640
 641        dev_dbg(veu_file->veu_dev->dev, "%s(%d)\n", __func__, buf->type);
 642        if (!sh_veu_is_streamer(veu_file->veu_dev, veu_file, buf->type))
 643                return -EBUSY;
 644
 645        return v4l2_m2m_qbuf(file, veu_file->veu_dev->m2m_ctx, buf);
 646}
 647
 648static int sh_veu_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
 649{
 650        struct sh_veu_file *veu_file = priv;
 651
 652        dev_dbg(veu_file->veu_dev->dev, "%s(%d)\n", __func__, buf->type);
 653        if (!sh_veu_is_streamer(veu_file->veu_dev, veu_file, buf->type))
 654                return -EBUSY;
 655
 656        return v4l2_m2m_dqbuf(file, veu_file->veu_dev->m2m_ctx, buf);
 657}
 658
 659static void sh_veu_calc_scale(struct sh_veu_dev *veu,
 660                              int size_in, int size_out, int crop_out,
 661                              u32 *mant, u32 *frac, u32 *rep)
 662{
 663        u32 fixpoint;
 664
 665        /* calculate FRAC and MANT */
 666        *rep = *mant = *frac = 0;
 667
 668        if (size_in == size_out) {
 669                if (crop_out != size_out)
 670                        *mant = 1; /* needed for cropping */
 671                return;
 672        }
 673
 674        /* VEU2H special upscale */
 675        if (veu->is_2h && size_out > size_in) {
 676                u32 fixpoint = (4096 * size_in) / size_out;
 677                *mant = fixpoint / 4096;
 678                *frac = (fixpoint - (*mant * 4096)) & ~0x07;
 679
 680                switch (*frac) {
 681                case 0x800:
 682                        *rep = 1;
 683                        break;
 684                case 0x400:
 685                        *rep = 3;
 686                        break;
 687                case 0x200:
 688                        *rep = 7;
 689                        break;
 690                }
 691                if (*rep)
 692                        return;
 693        }
 694
 695        fixpoint = (4096 * (size_in - 1)) / (size_out + 1);
 696        *mant = fixpoint / 4096;
 697        *frac = fixpoint - (*mant * 4096);
 698
 699        if (*frac & 0x07) {
 700                /*
 701                 * FIXME: do we really have to round down twice in the
 702                 * up-scaling case?
 703                 */
 704                *frac &= ~0x07;
 705                if (size_out > size_in)
 706                        *frac -= 8; /* round down if scaling up */
 707                else
 708                        *frac += 8; /* round up if scaling down */
 709        }
 710}
 711
 712static unsigned long sh_veu_scale_v(struct sh_veu_dev *veu,
 713                                    int size_in, int size_out, int crop_out)
 714{
 715        u32 mant, frac, value, rep;
 716
 717        sh_veu_calc_scale(veu, size_in, size_out, crop_out, &mant, &frac, &rep);
 718
 719        /* set scale */
 720        value = (sh_veu_reg_read(veu, VEU_RFCR) & ~0xffff0000) |
 721                (((mant << 12) | frac) << 16);
 722
 723        sh_veu_reg_write(veu, VEU_RFCR, value);
 724
 725        /* set clip */
 726        value = (sh_veu_reg_read(veu, VEU_RFSR) & ~0xffff0000) |
 727                (((rep << 12) | crop_out) << 16);
 728
 729        sh_veu_reg_write(veu, VEU_RFSR, value);
 730
 731        return ALIGN((size_in * crop_out) / size_out, 4);
 732}
 733
 734static unsigned long sh_veu_scale_h(struct sh_veu_dev *veu,
 735                                    int size_in, int size_out, int crop_out)
 736{
 737        u32 mant, frac, value, rep;
 738
 739        sh_veu_calc_scale(veu, size_in, size_out, crop_out, &mant, &frac, &rep);
 740
 741        /* set scale */
 742        value = (sh_veu_reg_read(veu, VEU_RFCR) & ~0xffff) |
 743                (mant << 12) | frac;
 744
 745        sh_veu_reg_write(veu, VEU_RFCR, value);
 746
 747        /* set clip */
 748        value = (sh_veu_reg_read(veu, VEU_RFSR) & ~0xffff) |
 749                (rep << 12) | crop_out;
 750
 751        sh_veu_reg_write(veu, VEU_RFSR, value);
 752
 753        return ALIGN((size_in * crop_out) / size_out, 4);
 754}
 755
 756static void sh_veu_configure(struct sh_veu_dev *veu)
 757{
 758        u32 src_width, src_stride, src_height;
 759        u32 dst_width, dst_stride, dst_height;
 760        u32 real_w, real_h;
 761
 762        /* reset VEU */
 763        sh_veu_reg_write(veu, VEU_BSRR, 0x100);
 764
 765        src_width = veu->vfmt_in.frame.width;
 766        src_height = veu->vfmt_in.frame.height;
 767        src_stride = ALIGN(veu->vfmt_in.frame.width, 16);
 768
 769        dst_width = real_w = veu->vfmt_out.frame.width;
 770        dst_height = real_h = veu->vfmt_out.frame.height;
 771        /* Datasheet is unclear - whether it's always number of bytes or not */
 772        dst_stride = veu->vfmt_out.bytesperline;
 773
 774        /*
 775         * So far real_w == dst_width && real_h == dst_height, but it wasn't
 776         * necessarily the case in the original vidix driver, so, it may change
 777         * here in the future too.
 778         */
 779        src_width = sh_veu_scale_h(veu, src_width, real_w, dst_width);
 780        src_height = sh_veu_scale_v(veu, src_height, real_h, dst_height);
 781
 782        sh_veu_reg_write(veu, VEU_SWR, src_stride);
 783        sh_veu_reg_write(veu, VEU_SSR, src_width | (src_height << 16));
 784        sh_veu_reg_write(veu, VEU_BSSR, 0); /* not using bundle mode */
 785
 786        sh_veu_reg_write(veu, VEU_EDWR, dst_stride);
 787        sh_veu_reg_write(veu, VEU_DACR, 0); /* unused for RGB */
 788
 789        sh_veu_reg_write(veu, VEU_SWPR, 0x67);
 790        sh_veu_reg_write(veu, VEU_TRCR, (6 << 16) | (0 << 14) | 2 | 4);
 791
 792        if (veu->is_2h) {
 793                sh_veu_reg_write(veu, VEU_MCR00, 0x0cc5);
 794                sh_veu_reg_write(veu, VEU_MCR01, 0x0950);
 795                sh_veu_reg_write(veu, VEU_MCR02, 0x0000);
 796
 797                sh_veu_reg_write(veu, VEU_MCR10, 0x397f);
 798                sh_veu_reg_write(veu, VEU_MCR11, 0x0950);
 799                sh_veu_reg_write(veu, VEU_MCR12, 0x3ccd);
 800
 801                sh_veu_reg_write(veu, VEU_MCR20, 0x0000);
 802                sh_veu_reg_write(veu, VEU_MCR21, 0x0950);
 803                sh_veu_reg_write(veu, VEU_MCR22, 0x1023);
 804
 805                sh_veu_reg_write(veu, VEU_COFFR, 0x00800010);
 806        }
 807}
 808
 809static int sh_veu_streamon(struct file *file, void *priv,
 810                           enum v4l2_buf_type type)
 811{
 812        struct sh_veu_file *veu_file = priv;
 813
 814        if (!sh_veu_is_streamer(veu_file->veu_dev, veu_file, type))
 815                return -EBUSY;
 816
 817        if (veu_file->cfg_needed) {
 818                struct sh_veu_dev *veu = veu_file->veu_dev;
 819                veu_file->cfg_needed = false;
 820                sh_veu_configure(veu_file->veu_dev);
 821                veu->xaction = 0;
 822                veu->aborting = false;
 823        }
 824
 825        return v4l2_m2m_streamon(file, veu_file->veu_dev->m2m_ctx, type);
 826}
 827
 828static int sh_veu_streamoff(struct file *file, void *priv,
 829                            enum v4l2_buf_type type)
 830{
 831        struct sh_veu_file *veu_file = priv;
 832
 833        if (!sh_veu_is_streamer(veu_file->veu_dev, veu_file, type))
 834                return -EBUSY;
 835
 836        return v4l2_m2m_streamoff(file, veu_file->veu_dev->m2m_ctx, type);
 837}
 838
 839static const struct v4l2_ioctl_ops sh_veu_ioctl_ops = {
 840        .vidioc_querycap        = sh_veu_querycap,
 841
 842        .vidioc_enum_fmt_vid_cap = sh_veu_enum_fmt_vid_cap,
 843        .vidioc_g_fmt_vid_cap   = sh_veu_g_fmt_vid_cap,
 844        .vidioc_try_fmt_vid_cap = sh_veu_try_fmt_vid_cap,
 845        .vidioc_s_fmt_vid_cap   = sh_veu_s_fmt_vid_cap,
 846
 847        .vidioc_enum_fmt_vid_out = sh_veu_enum_fmt_vid_out,
 848        .vidioc_g_fmt_vid_out   = sh_veu_g_fmt_vid_out,
 849        .vidioc_try_fmt_vid_out = sh_veu_try_fmt_vid_out,
 850        .vidioc_s_fmt_vid_out   = sh_veu_s_fmt_vid_out,
 851
 852        .vidioc_reqbufs         = sh_veu_reqbufs,
 853        .vidioc_querybuf        = sh_veu_querybuf,
 854
 855        .vidioc_qbuf            = sh_veu_qbuf,
 856        .vidioc_dqbuf           = sh_veu_dqbuf,
 857
 858        .vidioc_streamon        = sh_veu_streamon,
 859        .vidioc_streamoff       = sh_veu_streamoff,
 860};
 861
 862                /* ========== Queue operations ========== */
 863
 864static int sh_veu_queue_setup(struct vb2_queue *vq,
 865                              unsigned int *nbuffers, unsigned int *nplanes,
 866                              unsigned int sizes[], struct device *alloc_devs[])
 867{
 868        struct sh_veu_dev *veu = vb2_get_drv_priv(vq);
 869        struct sh_veu_vfmt *vfmt = sh_veu_get_vfmt(veu, vq->type);
 870        unsigned int count = *nbuffers;
 871        unsigned int size = vfmt->bytesperline * vfmt->frame.height *
 872                vfmt->fmt->depth / vfmt->fmt->ydepth;
 873
 874        if (count < 2)
 875                *nbuffers = count = 2;
 876
 877        if (size * count > VIDEO_MEM_LIMIT) {
 878                count = VIDEO_MEM_LIMIT / size;
 879                *nbuffers = count;
 880        }
 881
 882        if (*nplanes)
 883                return sizes[0] < size ? -EINVAL : 0;
 884
 885        *nplanes = 1;
 886        sizes[0] = size;
 887
 888        dev_dbg(veu->dev, "get %d buffer(s) of size %d each.\n", count, size);
 889
 890        return 0;
 891}
 892
 893static int sh_veu_buf_prepare(struct vb2_buffer *vb)
 894{
 895        struct sh_veu_dev *veu = vb2_get_drv_priv(vb->vb2_queue);
 896        struct sh_veu_vfmt *vfmt;
 897        unsigned int sizeimage;
 898
 899        vfmt = sh_veu_get_vfmt(veu, vb->vb2_queue->type);
 900        sizeimage = vfmt->bytesperline * vfmt->frame.height *
 901                vfmt->fmt->depth / vfmt->fmt->ydepth;
 902
 903        if (vb2_plane_size(vb, 0) < sizeimage) {
 904                dev_dbg(veu->dev, "%s data will not fit into plane (%lu < %u)\n",
 905                        __func__, vb2_plane_size(vb, 0), sizeimage);
 906                return -EINVAL;
 907        }
 908
 909        vb2_set_plane_payload(vb, 0, sizeimage);
 910
 911        return 0;
 912}
 913
 914static void sh_veu_buf_queue(struct vb2_buffer *vb)
 915{
 916        struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 917        struct sh_veu_dev *veu = vb2_get_drv_priv(vb->vb2_queue);
 918        dev_dbg(veu->dev, "%s(%d)\n", __func__, vb->type);
 919        v4l2_m2m_buf_queue(veu->m2m_ctx, vbuf);
 920}
 921
 922static const struct vb2_ops sh_veu_qops = {
 923        .queue_setup     = sh_veu_queue_setup,
 924        .buf_prepare     = sh_veu_buf_prepare,
 925        .buf_queue       = sh_veu_buf_queue,
 926        .wait_prepare    = vb2_ops_wait_prepare,
 927        .wait_finish     = vb2_ops_wait_finish,
 928};
 929
 930static int sh_veu_queue_init(void *priv, struct vb2_queue *src_vq,
 931                             struct vb2_queue *dst_vq)
 932{
 933        struct sh_veu_dev *veu = priv;
 934        int ret;
 935
 936        memset(src_vq, 0, sizeof(*src_vq));
 937        src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
 938        src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
 939        src_vq->drv_priv = veu;
 940        src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
 941        src_vq->ops = &sh_veu_qops;
 942        src_vq->mem_ops = &vb2_dma_contig_memops;
 943        src_vq->lock = &veu->fop_lock;
 944        src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
 945        src_vq->dev = veu->v4l2_dev.dev;
 946
 947        ret = vb2_queue_init(src_vq);
 948        if (ret < 0)
 949                return ret;
 950
 951        memset(dst_vq, 0, sizeof(*dst_vq));
 952        dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 953        dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;
 954        dst_vq->drv_priv = veu;
 955        dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
 956        dst_vq->ops = &sh_veu_qops;
 957        dst_vq->mem_ops = &vb2_dma_contig_memops;
 958        dst_vq->lock = &veu->fop_lock;
 959        dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
 960        dst_vq->dev = veu->v4l2_dev.dev;
 961
 962        return vb2_queue_init(dst_vq);
 963}
 964
 965                /* ========== File operations ========== */
 966
 967static int sh_veu_open(struct file *file)
 968{
 969        struct sh_veu_dev *veu = video_drvdata(file);
 970        struct sh_veu_file *veu_file;
 971
 972        veu_file = kzalloc(sizeof(*veu_file), GFP_KERNEL);
 973        if (!veu_file)
 974                return -ENOMEM;
 975
 976        veu_file->veu_dev = veu;
 977        veu_file->cfg_needed = true;
 978
 979        file->private_data = veu_file;
 980
 981        pm_runtime_get_sync(veu->dev);
 982
 983        dev_dbg(veu->dev, "Created instance %p\n", veu_file);
 984
 985        return 0;
 986}
 987
 988static int sh_veu_release(struct file *file)
 989{
 990        struct sh_veu_dev *veu = video_drvdata(file);
 991        struct sh_veu_file *veu_file = file->private_data;
 992
 993        dev_dbg(veu->dev, "Releasing instance %p\n", veu_file);
 994
 995        if (veu_file == veu->capture) {
 996                veu->capture = NULL;
 997                vb2_queue_release(v4l2_m2m_get_vq(veu->m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE));
 998        }
 999
1000        if (veu_file == veu->output) {
1001                veu->output = NULL;
1002                vb2_queue_release(v4l2_m2m_get_vq(veu->m2m_ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT));
1003        }
1004
1005        if (!veu->output && !veu->capture && veu->m2m_ctx) {
1006                v4l2_m2m_ctx_release(veu->m2m_ctx);
1007                veu->m2m_ctx = NULL;
1008        }
1009
1010        pm_runtime_put(veu->dev);
1011
1012        kfree(veu_file);
1013
1014        return 0;
1015}
1016
1017static __poll_t sh_veu_poll(struct file *file,
1018                                struct poll_table_struct *wait)
1019{
1020        struct sh_veu_file *veu_file = file->private_data;
1021
1022        return v4l2_m2m_poll(file, veu_file->veu_dev->m2m_ctx, wait);
1023}
1024
1025static int sh_veu_mmap(struct file *file, struct vm_area_struct *vma)
1026{
1027        struct sh_veu_file *veu_file = file->private_data;
1028
1029        return v4l2_m2m_mmap(file, veu_file->veu_dev->m2m_ctx, vma);
1030}
1031
1032static const struct v4l2_file_operations sh_veu_fops = {
1033        .owner          = THIS_MODULE,
1034        .open           = sh_veu_open,
1035        .release        = sh_veu_release,
1036        .poll           = sh_veu_poll,
1037        .unlocked_ioctl = video_ioctl2,
1038        .mmap           = sh_veu_mmap,
1039};
1040
1041static const struct video_device sh_veu_videodev = {
1042        .name           = "sh-veu",
1043        .fops           = &sh_veu_fops,
1044        .ioctl_ops      = &sh_veu_ioctl_ops,
1045        .minor          = -1,
1046        .release        = video_device_release_empty,
1047        .vfl_dir        = VFL_DIR_M2M,
1048};
1049
1050static const struct v4l2_m2m_ops sh_veu_m2m_ops = {
1051        .device_run     = sh_veu_device_run,
1052        .job_abort      = sh_veu_job_abort,
1053};
1054
1055static irqreturn_t sh_veu_bh(int irq, void *dev_id)
1056{
1057        struct sh_veu_dev *veu = dev_id;
1058
1059        if (veu->xaction == MEM2MEM_DEF_TRANSLEN || veu->aborting) {
1060                v4l2_m2m_job_finish(veu->m2m_dev, veu->m2m_ctx);
1061                veu->xaction = 0;
1062        } else {
1063                sh_veu_device_run(veu);
1064        }
1065
1066        return IRQ_HANDLED;
1067}
1068
1069static irqreturn_t sh_veu_isr(int irq, void *dev_id)
1070{
1071        struct sh_veu_dev *veu = dev_id;
1072        struct vb2_v4l2_buffer *dst;
1073        struct vb2_v4l2_buffer *src;
1074        u32 status = sh_veu_reg_read(veu, VEU_EVTR);
1075
1076        /* bundle read mode not used */
1077        if (!(status & 1))
1078                return IRQ_NONE;
1079
1080        /* disable interrupt in VEU */
1081        sh_veu_reg_write(veu, VEU_EIER, 0);
1082        /* halt operation */
1083        sh_veu_reg_write(veu, VEU_STR, 0);
1084        /* ack int, write 0 to clear bits */
1085        sh_veu_reg_write(veu, VEU_EVTR, status & ~1);
1086
1087        /* conversion completed */
1088        dst = v4l2_m2m_dst_buf_remove(veu->m2m_ctx);
1089        src = v4l2_m2m_src_buf_remove(veu->m2m_ctx);
1090        if (!src || !dst)
1091                return IRQ_NONE;
1092
1093        dst->vb2_buf.timestamp = src->vb2_buf.timestamp;
1094        dst->flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
1095        dst->flags |=
1096                src->flags & V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
1097        dst->timecode = src->timecode;
1098
1099        spin_lock(&veu->lock);
1100        v4l2_m2m_buf_done(src, VB2_BUF_STATE_DONE);
1101        v4l2_m2m_buf_done(dst, VB2_BUF_STATE_DONE);
1102        spin_unlock(&veu->lock);
1103
1104        veu->xaction++;
1105
1106        return IRQ_WAKE_THREAD;
1107}
1108
1109static int sh_veu_probe(struct platform_device *pdev)
1110{
1111        struct sh_veu_dev *veu;
1112        struct resource *reg_res;
1113        struct video_device *vdev;
1114        int irq, ret;
1115
1116        reg_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1117        irq = platform_get_irq(pdev, 0);
1118
1119        if (!reg_res || irq <= 0) {
1120                dev_err(&pdev->dev, "Insufficient VEU platform information.\n");
1121                return -ENODEV;
1122        }
1123
1124        veu = devm_kzalloc(&pdev->dev, sizeof(*veu), GFP_KERNEL);
1125        if (!veu)
1126                return -ENOMEM;
1127
1128        veu->is_2h = resource_size(reg_res) == 0x22c;
1129
1130        veu->base = devm_ioremap_resource(&pdev->dev, reg_res);
1131        if (IS_ERR(veu->base))
1132                return PTR_ERR(veu->base);
1133
1134        ret = devm_request_threaded_irq(&pdev->dev, irq, sh_veu_isr, sh_veu_bh,
1135                                        0, "veu", veu);
1136        if (ret < 0)
1137                return ret;
1138
1139        ret = v4l2_device_register(&pdev->dev, &veu->v4l2_dev);
1140        if (ret < 0) {
1141                dev_err(&pdev->dev, "Error registering v4l2 device\n");
1142                return ret;
1143        }
1144
1145        vdev = &veu->vdev;
1146
1147        *vdev = sh_veu_videodev;
1148        vdev->v4l2_dev = &veu->v4l2_dev;
1149        spin_lock_init(&veu->lock);
1150        mutex_init(&veu->fop_lock);
1151        vdev->lock = &veu->fop_lock;
1152
1153        video_set_drvdata(vdev, veu);
1154
1155        veu->dev        = &pdev->dev;
1156        veu->vfmt_out   = DEFAULT_OUT_VFMT;
1157        veu->vfmt_in    = DEFAULT_IN_VFMT;
1158
1159        veu->m2m_dev = v4l2_m2m_init(&sh_veu_m2m_ops);
1160        if (IS_ERR(veu->m2m_dev)) {
1161                ret = PTR_ERR(veu->m2m_dev);
1162                v4l2_err(&veu->v4l2_dev, "Failed to init mem2mem device: %d\n", ret);
1163                goto em2minit;
1164        }
1165
1166        pm_runtime_enable(&pdev->dev);
1167        pm_runtime_resume(&pdev->dev);
1168
1169        ret = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
1170        pm_runtime_suspend(&pdev->dev);
1171        if (ret < 0)
1172                goto evidreg;
1173
1174        return ret;
1175
1176evidreg:
1177        pm_runtime_disable(&pdev->dev);
1178        v4l2_m2m_release(veu->m2m_dev);
1179em2minit:
1180        v4l2_device_unregister(&veu->v4l2_dev);
1181        return ret;
1182}
1183
1184static int sh_veu_remove(struct platform_device *pdev)
1185{
1186        struct v4l2_device *v4l2_dev = platform_get_drvdata(pdev);
1187        struct sh_veu_dev *veu = container_of(v4l2_dev,
1188                                              struct sh_veu_dev, v4l2_dev);
1189
1190        video_unregister_device(&veu->vdev);
1191        pm_runtime_disable(&pdev->dev);
1192        v4l2_m2m_release(veu->m2m_dev);
1193        v4l2_device_unregister(&veu->v4l2_dev);
1194
1195        return 0;
1196}
1197
1198static struct platform_driver __refdata sh_veu_pdrv = {
1199        .remove         = sh_veu_remove,
1200        .driver         = {
1201                .name   = "sh_veu",
1202        },
1203};
1204
1205module_platform_driver_probe(sh_veu_pdrv, sh_veu_probe);
1206
1207MODULE_DESCRIPTION("sh-mobile VEU mem2mem driver");
1208MODULE_AUTHOR("Guennadi Liakhovetski, <g.liakhovetski@gmx.de>");
1209MODULE_LICENSE("GPL v2");
1210