drivers/media/platform/coda/coda-common.c

   1 /*
   2  * Coda multi-standard codec IP
   3  *
   4  * Copyright (C) 2012 Vista Silicon S.L.
   5  *    Javier Martin, <javier.martin@vista-silicon.com>
   6  *    Xavier Duret
   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 by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  */
  13
  14 #include <linux/clk.h>
  15 #include <linux/debugfs.h>
  16 #include <linux/delay.h>
  17 #include <linux/firmware.h>
  18 #include <linux/genalloc.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/io.h>
  21 #include <linux/irq.h>
  22 #include <linux/kfifo.h>
  23 #include <linux/module.h>
  24 #include <linux/of_device.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/pm_runtime.h>
  27 #include <linux/slab.h>
  28 #include <linux/videodev2.h>
  29 #include <linux/of.h>
  30 #include <linux/platform_data/coda.h>
  31 #include <linux/reset.h>
  32
  33 #include <media/v4l2-ctrls.h>
  34 #include <media/v4l2-device.h>
  35 #include <media/v4l2-event.h>
  36 #include <media/v4l2-ioctl.h>
  37 #include <media/v4l2-mem2mem.h>
  38 #include <media/videobuf2-core.h>
  39 #include <media/videobuf2-dma-contig.h>
  40
  41 #include "coda.h"
  42 #include "coda_regs.h"
  43
  44 #define CODA_NAME               "coda"
  45
  46 #define CODADX6_MAX_INSTANCES   4
  47
  48 #define CODA_PARA_BUF_SIZE      (10 * 1024)
  49 #define CODA_ISRAM_SIZE (2048 * 2)
  50
  51 #define MIN_W 176
  52 #define MIN_H 144
  53
  54 #define S_ALIGN         1 /* multiple of 2 */
  55 #define W_ALIGN         1 /* multiple of 2 */
  56 #define H_ALIGN         1 /* multiple of 2 */
  57
  58 #define fh_to_ctx(__fh) container_of(__fh, struct coda_ctx, fh)
  59
  60 int coda_debug;
  61 module_param(coda_debug, int, 0644);
  62 MODULE_PARM_DESC(coda_debug, "Debug level (0-1)");
  63
  64 struct coda_fmt {
  65         char *name;
  66         u32 fourcc;
  67 };
  68
  69 void coda_write(struct coda_dev *dev, u32 data, u32 reg)
  70 {
  71         v4l2_dbg(1, coda_debug, &dev->v4l2_dev,
  72                  "%s: data=0x%x, reg=0x%x\n", __func__, data, reg);
  73         writel(data, dev->regs_base + reg);
  74 }
  75
  76 unsigned int coda_read(struct coda_dev *dev, u32 reg)
  77 {
  78         u32 data;
  79         data = readl(dev->regs_base + reg);
  80         v4l2_dbg(1, coda_debug, &dev->v4l2_dev,
  81                  "%s: data=0x%x, reg=0x%x\n", __func__, data, reg);
  82         return data;
  83 }
  84
  85 /*
  86  * Array of all formats supported by any version of Coda:
  87  */
  88 static const struct coda_fmt coda_formats[] = {
  89         {
  90                 .name = "YUV 4:2:0 Planar, YCbCr",
  91                 .fourcc = V4L2_PIX_FMT_YUV420,
  92         },
  93         {
  94                 .name = "YUV 4:2:0 Planar, YCrCb",
  95                 .fourcc = V4L2_PIX_FMT_YVU420,
  96         },
  97         {
  98                 .name = "H264 Encoded Stream",
  99                 .fourcc = V4L2_PIX_FMT_H264,
 100         },
 101         {
 102                 .name = "MPEG4 Encoded Stream",
 103                 .fourcc = V4L2_PIX_FMT_MPEG4,
 104         },
 105 };
 106
 107 #define CODA_CODEC(mode, src_fourcc, dst_fourcc, max_w, max_h) \
 108         { mode, src_fourcc, dst_fourcc, max_w, max_h }
 109
 110 /*
 111  * Arrays of codecs supported by each given version of Coda:
 112  *  i.MX27 -> codadx6
 113  *  i.MX5x -> coda7
 114  *  i.MX6  -> coda960
 115  * Use V4L2_PIX_FMT_YUV420 as placeholder for all supported YUV 4:2:0 variants
 116  */
 117 static const struct coda_codec codadx6_codecs[] = {
 118         CODA_CODEC(CODADX6_MODE_ENCODE_H264, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_H264,  720, 576),
 119         CODA_CODEC(CODADX6_MODE_ENCODE_MP4,  V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_MPEG4, 720, 576),
 120 };
 121
 122 static const struct coda_codec coda7_codecs[] = {
 123         CODA_CODEC(CODA7_MODE_ENCODE_H264, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_H264,   1280, 720),
 124         CODA_CODEC(CODA7_MODE_ENCODE_MP4,  V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_MPEG4,  1280, 720),
 125         CODA_CODEC(CODA7_MODE_DECODE_H264, V4L2_PIX_FMT_H264,   V4L2_PIX_FMT_YUV420, 1920, 1080),
 126         CODA_CODEC(CODA7_MODE_DECODE_MP4,  V4L2_PIX_FMT_MPEG4,  V4L2_PIX_FMT_YUV420, 1920, 1080),
 127 };
 128
 129 static const struct coda_codec coda9_codecs[] = {
 130         CODA_CODEC(CODA9_MODE_ENCODE_H264, V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_H264,   1920, 1080),
 131         CODA_CODEC(CODA9_MODE_ENCODE_MP4,  V4L2_PIX_FMT_YUV420, V4L2_PIX_FMT_MPEG4,  1920, 1080),
 132         CODA_CODEC(CODA9_MODE_DECODE_H264, V4L2_PIX_FMT_H264,   V4L2_PIX_FMT_YUV420, 1920, 1080),
 133         CODA_CODEC(CODA9_MODE_DECODE_MP4,  V4L2_PIX_FMT_MPEG4,  V4L2_PIX_FMT_YUV420, 1920, 1080),
 134 };
 135
 136 static bool coda_format_is_yuv(u32 fourcc)
 137 {
 138         switch (fourcc) {
 139         case V4L2_PIX_FMT_YUV420:
 140         case V4L2_PIX_FMT_YVU420:
 141                 return true;
 142         default:
 143                 return false;
 144         }
 145 }
 146
 147 /*
 148  * Normalize all supported YUV 4:2:0 formats to the value used in the codec
 149  * tables.
 150  */
 151 static u32 coda_format_normalize_yuv(u32 fourcc)
 152 {
 153         return coda_format_is_yuv(fourcc) ? V4L2_PIX_FMT_YUV420 : fourcc;
 154 }
 155
 156 static const struct coda_codec *coda_find_codec(struct coda_dev *dev,
 157                                                 int src_fourcc, int dst_fourcc)
 158 {
 159         const struct coda_codec *codecs = dev->devtype->codecs;
 160         int num_codecs = dev->devtype->num_codecs;
 161         int k;
 162
 163         src_fourcc = coda_format_normalize_yuv(src_fourcc);
 164         dst_fourcc = coda_format_normalize_yuv(dst_fourcc);
 165         if (src_fourcc == dst_fourcc)
 166                 return NULL;
 167
 168         for (k = 0; k < num_codecs; k++) {
 169                 if (codecs[k].src_fourcc == src_fourcc &&
 170                     codecs[k].dst_fourcc == dst_fourcc)
 171                         break;
 172         }
 173
 174         if (k == num_codecs)
 175                 return NULL;
 176
 177         return &codecs[k];
 178 }
 179
 180 static void coda_get_max_dimensions(struct coda_dev *dev,
 181                                     const struct coda_codec *codec,
 182                                     int *max_w, int *max_h)
 183 {
 184         const struct coda_codec *codecs = dev->devtype->codecs;
 185         int num_codecs = dev->devtype->num_codecs;
 186         unsigned int w, h;
 187         int k;
 188
 189         if (codec) {
 190                 w = codec->max_w;
 191                 h = codec->max_h;
 192         } else {
 193                 for (k = 0, w = 0, h = 0; k < num_codecs; k++) {
 194                         w = max(w, codecs[k].max_w);
 195                         h = max(h, codecs[k].max_h);
 196                 }
 197         }
 198
 199         if (max_w)
 200                 *max_w = w;
 201         if (max_h)
 202                 *max_h = h;
 203 }
 204
 205 const char *coda_product_name(int product)
 206 {
 207         static char buf[9];
 208
 209         switch (product) {
 210         case CODA_DX6:
 211                 return "CodaDx6";
 212         case CODA_7541:
 213                 return "CODA7541";
 214         case CODA_960:
 215                 return "CODA960";
 216         default:
 217                 snprintf(buf, sizeof(buf), "(0x%04x)", product);
 218                 return buf;
 219         }
 220 }
 221
 222 /*
 223  * V4L2 ioctl() operations.
 224  */
 225 static int coda_querycap(struct file *file, void *priv,
 226                          struct v4l2_capability *cap)
 227 {
 228         struct coda_ctx *ctx = fh_to_ctx(priv);
 229
 230         strlcpy(cap->driver, CODA_NAME, sizeof(cap->driver));
 231         strlcpy(cap->card, coda_product_name(ctx->dev->devtype->product),
 232                 sizeof(cap->card));
 233         strlcpy(cap->bus_info, "platform:" CODA_NAME, sizeof(cap->bus_info));
 234         cap->device_caps = V4L2_CAP_VIDEO_M2M | V4L2_CAP_STREAMING;
 235         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 236
 237         return 0;
 238 }
 239
 240 static int coda_enum_fmt(struct file *file, void *priv,
 241                          struct v4l2_fmtdesc *f)
 242 {
 243         struct coda_ctx *ctx = fh_to_ctx(priv);
 244         const struct coda_codec *codecs = ctx->dev->devtype->codecs;
 245         const struct coda_fmt *formats = coda_formats;
 246         const struct coda_fmt *fmt;
 247         int num_codecs = ctx->dev->devtype->num_codecs;
 248         int num_formats = ARRAY_SIZE(coda_formats);
 249         int i, k, num = 0;
 250         bool yuv;
 251
 252         if (ctx->inst_type == CODA_INST_ENCODER)
 253                 yuv = (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT);
 254         else
 255                 yuv = (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE);
 256
 257         for (i = 0; i < num_formats; i++) {
 258                 /* Skip either raw or compressed formats */
 259                 if (yuv != coda_format_is_yuv(formats[i].fourcc))
 260                         continue;
 261                 /* All uncompressed formats are always supported */
 262                 if (yuv) {
 263                         if (num == f->index)
 264                                 break;
 265                         ++num;
 266                         continue;
 267                 }
 268                 /* Compressed formats may be supported, check the codec list */
 269                 for (k = 0; k < num_codecs; k++) {
 270                         if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
 271                             formats[i].fourcc == codecs[k].dst_fourcc)
 272                                 break;
 273                         if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
 274                             formats[i].fourcc == codecs[k].src_fourcc)
 275                                 break;
 276                 }
 277                 if (k < num_codecs) {
 278                         if (num == f->index)
 279                                 break;
 280                         ++num;
 281                 }
 282         }
 283
 284         if (i < num_formats) {
 285                 fmt = &formats[i];
 286                 strlcpy(f->description, fmt->name, sizeof(f->description));
 287                 f->pixelformat = fmt->fourcc;
 288                 if (!yuv)
 289                         f->flags |= V4L2_FMT_FLAG_COMPRESSED;
 290                 return 0;
 291         }
 292
 293         /* Format not found */
 294         return -EINVAL;
 295 }
 296
 297 static int coda_g_fmt(struct file *file, void *priv,
 298                       struct v4l2_format *f)
 299 {
 300         struct coda_q_data *q_data;
 301         struct coda_ctx *ctx = fh_to_ctx(priv);
 302
 303         q_data = get_q_data(ctx, f->type);
 304         if (!q_data)
 305                 return -EINVAL;
 306
 307         f->fmt.pix.field        = V4L2_FIELD_NONE;
 308         f->fmt.pix.pixelformat  = q_data->fourcc;
 309         f->fmt.pix.width        = q_data->width;
 310         f->fmt.pix.height       = q_data->height;
 311         f->fmt.pix.bytesperline = q_data->bytesperline;
 312
 313         f->fmt.pix.sizeimage    = q_data->sizeimage;
 314         f->fmt.pix.colorspace   = ctx->colorspace;
 315
 316         return 0;
 317 }
 318
 319 static int coda_try_fmt(struct coda_ctx *ctx, const struct coda_codec *codec,
 320                         struct v4l2_format *f)
 321 {
 322         struct coda_dev *dev = ctx->dev;
 323         struct coda_q_data *q_data;
 324         unsigned int max_w, max_h;
 325         enum v4l2_field field;
 326
 327         field = f->fmt.pix.field;
 328         if (field == V4L2_FIELD_ANY)
 329                 field = V4L2_FIELD_NONE;
 330         else if (V4L2_FIELD_NONE != field)
 331                 return -EINVAL;
 332
 333         /* V4L2 specification suggests the driver corrects the format struct
 334          * if any of the dimensions is unsupported */
 335         f->fmt.pix.field = field;
 336
 337         coda_get_max_dimensions(dev, codec, &max_w, &max_h);
 338         v4l_bound_align_image(&f->fmt.pix.width, MIN_W, max_w, W_ALIGN,
 339                               &f->fmt.pix.height, MIN_H, max_h, H_ALIGN,
 340                               S_ALIGN);
 341
 342         switch (f->fmt.pix.pixelformat) {
 343         case V4L2_PIX_FMT_YUV420:
 344         case V4L2_PIX_FMT_YVU420:
 345         case V4L2_PIX_FMT_H264:
 346         case V4L2_PIX_FMT_MPEG4:
 347         case V4L2_PIX_FMT_JPEG:
 348                 break;
 349         default:
 350                 q_data = get_q_data(ctx, f->type);
 351                 if (!q_data)
 352                         return -EINVAL;
 353                 f->fmt.pix.pixelformat = q_data->fourcc;
 354         }
 355
 356         switch (f->fmt.pix.pixelformat) {
 357         case V4L2_PIX_FMT_YUV420:
 358         case V4L2_PIX_FMT_YVU420:
 359                 /* Frame stride must be multiple of 8, but 16 for h.264 */
 360                 f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16);
 361                 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline *
 362                                         f->fmt.pix.height * 3 / 2;
 363                 break;
 364         case V4L2_PIX_FMT_H264:
 365         case V4L2_PIX_FMT_MPEG4:
 366         case V4L2_PIX_FMT_JPEG:
 367                 f->fmt.pix.bytesperline = 0;
 368                 f->fmt.pix.sizeimage = CODA_MAX_FRAME_SIZE;
 369                 break;
 370         default:
 371                 BUG();
 372         }
 373
 374         return 0;
 375 }
 376
 377 static int coda_try_fmt_vid_cap(struct file *file, void *priv,
 378                                 struct v4l2_format *f)
 379 {
 380         struct coda_ctx *ctx = fh_to_ctx(priv);
 381         const struct coda_codec *codec = NULL;
 382         struct vb2_queue *src_vq;
 383         int ret;
 384
 385         /*
 386          * If the source format is already fixed, try to find a codec that
 387          * converts to the given destination format
 388          */
 389         src_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
 390         if (vb2_is_streaming(src_vq)) {
 391                 struct coda_q_data *q_data_src;
 392
 393                 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
 394                 codec = coda_find_codec(ctx->dev, q_data_src->fourcc,
 395                                         f->fmt.pix.pixelformat);
 396                 if (!codec)
 397                         return -EINVAL;
 398
 399                 f->fmt.pix.width = q_data_src->width;
 400                 f->fmt.pix.height = q_data_src->height;
 401         } else {
 402                 /* Otherwise determine codec by encoded format, if possible */
 403                 codec = coda_find_codec(ctx->dev, V4L2_PIX_FMT_YUV420,
 404                                         f->fmt.pix.pixelformat);
 405         }
 406
 407         f->fmt.pix.colorspace = ctx->colorspace;
 408
 409         ret = coda_try_fmt(ctx, codec, f);
 410         if (ret < 0)
 411                 return ret;
 412
 413         /* The h.264 decoder only returns complete 16x16 macroblocks */
 414         if (codec && codec->src_fourcc == V4L2_PIX_FMT_H264) {
 415                 f->fmt.pix.width = f->fmt.pix.width;
 416                 f->fmt.pix.height = round_up(f->fmt.pix.height, 16);
 417                 f->fmt.pix.bytesperline = round_up(f->fmt.pix.width, 16);
 418                 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline *
 419                                        f->fmt.pix.height * 3 / 2;
 420         }
 421
 422         return 0;
 423 }
 424
 425 static int coda_try_fmt_vid_out(struct file *file, void *priv,
 426                                 struct v4l2_format *f)
 427 {
 428         struct coda_ctx *ctx = fh_to_ctx(priv);
 429         const struct coda_codec *codec;
 430
 431         /* Determine codec by encoded format, returns NULL if raw or invalid */
 432         codec = coda_find_codec(ctx->dev, f->fmt.pix.pixelformat,
 433                                 V4L2_PIX_FMT_YUV420);
 434         if (!codec && ctx->inst_type == CODA_INST_DECODER) {
 435                 codec = coda_find_codec(ctx->dev, V4L2_PIX_FMT_H264,
 436                                         V4L2_PIX_FMT_YUV420);
 437                 if (!codec)
 438                         return -EINVAL;
 439         }
 440
 441         if (!f->fmt.pix.colorspace)
 442                 f->fmt.pix.colorspace = V4L2_COLORSPACE_REC709;
 443
 444         return coda_try_fmt(ctx, codec, f);
 445 }
 446
 447 static int coda_s_fmt(struct coda_ctx *ctx, struct v4l2_format *f)
 448 {
 449         struct coda_q_data *q_data;
 450         struct vb2_queue *vq;
 451
 452         vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);
 453         if (!vq)
 454                 return -EINVAL;
 455
 456         q_data = get_q_data(ctx, f->type);
 457         if (!q_data)
 458                 return -EINVAL;
 459
 460         if (vb2_is_busy(vq)) {
 461                 v4l2_err(&ctx->dev->v4l2_dev, "%s queue busy\n", __func__);
 462                 return -EBUSY;
 463         }
 464
 465         q_data->fourcc = f->fmt.pix.pixelformat;
 466         q_data->width = f->fmt.pix.width;
 467         q_data->height = f->fmt.pix.height;
 468         q_data->bytesperline = f->fmt.pix.bytesperline;
 469         q_data->sizeimage = f->fmt.pix.sizeimage;
 470         q_data->rect.left = 0;
 471         q_data->rect.top = 0;
 472         q_data->rect.width = f->fmt.pix.width;
 473         q_data->rect.height = f->fmt.pix.height;
 474
 475         v4l2_dbg(1, coda_debug, &ctx->dev->v4l2_dev,
 476                 "Setting format for type %d, wxh: %dx%d, fmt: %d\n",
 477                 f->type, q_data->width, q_data->height, q_data->fourcc);
 478
 479         return 0;
 480 }
 481
 482 static int coda_s_fmt_vid_cap(struct file *file, void *priv,
 483                               struct v4l2_format *f)
 484 {
 485         struct coda_ctx *ctx = fh_to_ctx(priv);
 486         int ret;
 487
 488         ret = coda_try_fmt_vid_cap(file, priv, f);
 489         if (ret)
 490                 return ret;
 491
 492         return coda_s_fmt(ctx, f);
 493 }
 494
 495 static int coda_s_fmt_vid_out(struct file *file, void *priv,
 496                               struct v4l2_format *f)
 497 {
 498         struct coda_ctx *ctx = fh_to_ctx(priv);
 499         int ret;
 500
 501         ret = coda_try_fmt_vid_out(file, priv, f);
 502         if (ret)
 503                 return ret;
 504
 505         ret = coda_s_fmt(ctx, f);
 506         if (ret)
 507                 ctx->colorspace = f->fmt.pix.colorspace;
 508
 509         return ret;
 510 }
 511
 512 static int coda_qbuf(struct file *file, void *priv,
 513                      struct v4l2_buffer *buf)
 514 {
 515         struct coda_ctx *ctx = fh_to_ctx(priv);
 516
 517         return v4l2_m2m_qbuf(file, ctx->fh.m2m_ctx, buf);
 518 }
 519
 520 static bool coda_buf_is_end_of_stream(struct coda_ctx *ctx,
 521                                       struct v4l2_buffer *buf)
 522 {
 523         struct vb2_queue *src_vq;
 524
 525         src_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
 526
 527         return ((ctx->bit_stream_param & CODA_BIT_STREAM_END_FLAG) &&
 528                 (buf->sequence == (ctx->qsequence - 1)));
 529 }
 530
 531 static int coda_dqbuf(struct file *file, void *priv,
 532                       struct v4l2_buffer *buf)
 533 {
 534         struct coda_ctx *ctx = fh_to_ctx(priv);
 535         int ret;
 536
 537         ret = v4l2_m2m_dqbuf(file, ctx->fh.m2m_ctx, buf);
 538
 539         /* If this is the last capture buffer, emit an end-of-stream event */
 540         if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
 541             coda_buf_is_end_of_stream(ctx, buf)) {
 542                 const struct v4l2_event eos_event = {
 543                         .type = V4L2_EVENT_EOS
 544                 };
 545
 546                 v4l2_event_queue_fh(&ctx->fh, &eos_event);
 547         }
 548
 549         return ret;
 550 }
 551
 552 static int coda_g_selection(struct file *file, void *fh,
 553                             struct v4l2_selection *s)
 554 {
 555         struct coda_ctx *ctx = fh_to_ctx(fh);
 556         struct coda_q_data *q_data;
 557         struct v4l2_rect r, *rsel;
 558
 559         q_data = get_q_data(ctx, s->type);
 560         if (!q_data)
 561                 return -EINVAL;
 562
 563         r.left = 0;
 564         r.top = 0;
 565         r.width = q_data->width;
 566         r.height = q_data->height;
 567         rsel = &q_data->rect;
 568
 569         switch (s->target) {
 570         case V4L2_SEL_TGT_CROP_DEFAULT:
 571         case V4L2_SEL_TGT_CROP_BOUNDS:
 572                 rsel = &r;
 573                 /* fallthrough */
 574         case V4L2_SEL_TGT_CROP:
 575                 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
 576                         return -EINVAL;
 577                 break;
 578         case V4L2_SEL_TGT_COMPOSE_BOUNDS:
 579         case V4L2_SEL_TGT_COMPOSE_PADDED:
 580                 rsel = &r;
 581                 /* fallthrough */
 582         case V4L2_SEL_TGT_COMPOSE:
 583         case V4L2_SEL_TGT_COMPOSE_DEFAULT:
 584                 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 585                         return -EINVAL;
 586                 break;
 587         default:
 588                 return -EINVAL;
 589         }
 590
 591         s->r = *rsel;
 592
 593         return 0;
 594 }
 595
 596 static int coda_try_decoder_cmd(struct file *file, void *fh,
 597                                 struct v4l2_decoder_cmd *dc)
 598 {
 599         if (dc->cmd != V4L2_DEC_CMD_STOP)
 600                 return -EINVAL;
 601
 602         if (dc->flags & V4L2_DEC_CMD_STOP_TO_BLACK)
 603                 return -EINVAL;
 604
 605         if (!(dc->flags & V4L2_DEC_CMD_STOP_IMMEDIATELY) && (dc->stop.pts != 0))
 606                 return -EINVAL;
 607
 608         return 0;
 609 }
 610
 611 static int coda_decoder_cmd(struct file *file, void *fh,
 612                             struct v4l2_decoder_cmd *dc)
 613 {
 614         struct coda_ctx *ctx = fh_to_ctx(fh);
 615         int ret;
 616
 617         ret = coda_try_decoder_cmd(file, fh, dc);
 618         if (ret < 0)
 619                 return ret;
 620
 621         /* Ignore decoder stop command silently in encoder context */
 622         if (ctx->inst_type != CODA_INST_DECODER)
 623                 return 0;
 624
 625         /* Set the stream-end flag on this context */
 626         coda_bit_stream_end_flag(ctx);
 627         ctx->hold = false;
 628         v4l2_m2m_try_schedule(ctx->fh.m2m_ctx);
 629
 630         return 0;
 631 }
 632
 633 static int coda_subscribe_event(struct v4l2_fh *fh,
 634                                 const struct v4l2_event_subscription *sub)
 635 {
 636         switch (sub->type) {
 637         case V4L2_EVENT_EOS:
 638                 return v4l2_event_subscribe(fh, sub, 0, NULL);
 639         default:
 640                 return v4l2_ctrl_subscribe_event(fh, sub);
 641         }
 642 }
 643
 644 static const struct v4l2_ioctl_ops coda_ioctl_ops = {
 645         .vidioc_querycap        = coda_querycap,
 646
 647         .vidioc_enum_fmt_vid_cap = coda_enum_fmt,
 648         .vidioc_g_fmt_vid_cap   = coda_g_fmt,
 649         .vidioc_try_fmt_vid_cap = coda_try_fmt_vid_cap,
 650         .vidioc_s_fmt_vid_cap   = coda_s_fmt_vid_cap,
 651
 652         .vidioc_enum_fmt_vid_out = coda_enum_fmt,
 653         .vidioc_g_fmt_vid_out   = coda_g_fmt,
 654         .vidioc_try_fmt_vid_out = coda_try_fmt_vid_out,
 655         .vidioc_s_fmt_vid_out   = coda_s_fmt_vid_out,
 656
 657         .vidioc_reqbufs         = v4l2_m2m_ioctl_reqbufs,
 658         .vidioc_querybuf        = v4l2_m2m_ioctl_querybuf,
 659
 660         .vidioc_qbuf            = coda_qbuf,
 661         .vidioc_expbuf          = v4l2_m2m_ioctl_expbuf,
 662         .vidioc_dqbuf           = coda_dqbuf,
 663         .vidioc_create_bufs     = v4l2_m2m_ioctl_create_bufs,
 664
 665         .vidioc_streamon        = v4l2_m2m_ioctl_streamon,
 666         .vidioc_streamoff       = v4l2_m2m_ioctl_streamoff,
 667
 668         .vidioc_g_selection     = coda_g_selection,
 669
 670         .vidioc_try_decoder_cmd = coda_try_decoder_cmd,
 671         .vidioc_decoder_cmd     = coda_decoder_cmd,
 672
 673         .vidioc_subscribe_event = coda_subscribe_event,
 674         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 675 };
 676
 677 void coda_set_gdi_regs(struct coda_ctx *ctx)
 678 {
 679         struct gdi_tiled_map *tiled_map = &ctx->tiled_map;
 680         struct coda_dev *dev = ctx->dev;
 681         int i;
 682
 683         for (i = 0; i < 16; i++)
 684                 coda_write(dev, tiled_map->xy2ca_map[i],
 685                                 CODA9_GDI_XY2_CAS_0 + 4 * i);
 686         for (i = 0; i < 4; i++)
 687                 coda_write(dev, tiled_map->xy2ba_map[i],
 688                                 CODA9_GDI_XY2_BA_0 + 4 * i);
 689         for (i = 0; i < 16; i++)
 690                 coda_write(dev, tiled_map->xy2ra_map[i],
 691                                 CODA9_GDI_XY2_RAS_0 + 4 * i);
 692         coda_write(dev, tiled_map->xy2rbc_config, CODA9_GDI_XY2_RBC_CONFIG);
 693         for (i = 0; i < 32; i++)
 694                 coda_write(dev, tiled_map->rbc2axi_map[i],
 695                                 CODA9_GDI_RBC2_AXI_0 + 4 * i);
 696 }
 697
 698 /*
 699  * Mem-to-mem operations.
 700  */
 701
 702 static void coda_device_run(void *m2m_priv)
 703 {
 704         struct coda_ctx *ctx = m2m_priv;
 705         struct coda_dev *dev = ctx->dev;
 706
 707         queue_work(dev->workqueue, &ctx->pic_run_work);
 708 }
 709
 710 static void coda_pic_run_work(struct work_struct *work)
 711 {
 712         struct coda_ctx *ctx = container_of(work, struct coda_ctx, pic_run_work);
 713         struct coda_dev *dev = ctx->dev;
 714         int ret;
 715
 716         mutex_lock(&ctx->buffer_mutex);
 717         mutex_lock(&dev->coda_mutex);
 718
 719         ret = ctx->ops->prepare_run(ctx);
 720         if (ret < 0 && ctx->inst_type == CODA_INST_DECODER) {
 721                 mutex_unlock(&dev->coda_mutex);
 722                 mutex_unlock(&ctx->buffer_mutex);
 723                 /* job_finish scheduled by prepare_decode */
 724                 return;
 725         }
 726
 727         if (!wait_for_completion_timeout(&ctx->completion, msecs_to_jiffies(1000))) {
 728                 dev_err(&dev->plat_dev->dev, "CODA PIC_RUN timeout\n");
 729
 730                 ctx->hold = true;
 731
 732                 coda_hw_reset(ctx);
 733         } else if (!ctx->aborting) {
 734                 ctx->ops->finish_run(ctx);
 735         }
 736
 737         if (ctx->aborting || (!ctx->streamon_cap && !ctx->streamon_out))
 738                 queue_work(dev->workqueue, &ctx->seq_end_work);
 739
 740         mutex_unlock(&dev->coda_mutex);
 741         mutex_unlock(&ctx->buffer_mutex);
 742
 743         v4l2_m2m_job_finish(ctx->dev->m2m_dev, ctx->fh.m2m_ctx);
 744 }
 745
 746 static int coda_job_ready(void *m2m_priv)
 747 {
 748         struct coda_ctx *ctx = m2m_priv;
 749
 750         /*
 751          * For both 'P' and 'key' frame cases 1 picture
 752          * and 1 frame are needed. In the decoder case,
 753          * the compressed frame can be in the bitstream.
 754          */
 755         if (!v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx) &&
 756             ctx->inst_type != CODA_INST_DECODER) {
 757                 v4l2_dbg(1, coda_debug, &ctx->dev->v4l2_dev,
 758                          "not ready: not enough video buffers.\n");
 759                 return 0;
 760         }
 761
 762         if (!v4l2_m2m_num_dst_bufs_ready(ctx->fh.m2m_ctx)) {
 763                 v4l2_dbg(1, coda_debug, &ctx->dev->v4l2_dev,
 764                          "not ready: not enough video capture buffers.\n");
 765                 return 0;
 766         }
 767
 768         if (ctx->hold ||
 769             ((ctx->inst_type == CODA_INST_DECODER) &&
 770              (coda_get_bitstream_payload(ctx) < 512) &&
 771              !(ctx->bit_stream_param & CODA_BIT_STREAM_END_FLAG))) {
 772                 v4l2_dbg(1, coda_debug, &ctx->dev->v4l2_dev,
 773                          "%d: not ready: not enough bitstream data.\n",
 774                          ctx->idx);
 775                 return 0;
 776         }
 777
 778         if (ctx->aborting) {
 779                 v4l2_dbg(1, coda_debug, &ctx->dev->v4l2_dev,
 780                          "not ready: aborting\n");
 781                 return 0;
 782         }
 783
 784         v4l2_dbg(1, coda_debug, &ctx->dev->v4l2_dev,
 785                         "job ready\n");
 786         return 1;
 787 }
 788
 789 static void coda_job_abort(void *priv)
 790 {
 791         struct coda_ctx *ctx = priv;
 792
 793         ctx->aborting = 1;
 794
 795         v4l2_dbg(1, coda_debug, &ctx->dev->v4l2_dev,
 796                  "Aborting task\n");
 797 }
 798
 799 static void coda_lock(void *m2m_priv)
 800 {
 801         struct coda_ctx *ctx = m2m_priv;
 802         struct coda_dev *pcdev = ctx->dev;
 803         mutex_lock(&pcdev->dev_mutex);
 804 }
 805
 806 static void coda_unlock(void *m2m_priv)
 807 {
 808         struct coda_ctx *ctx = m2m_priv;
 809         struct coda_dev *pcdev = ctx->dev;
 810         mutex_unlock(&pcdev->dev_mutex);
 811 }
 812
 813 static const struct v4l2_m2m_ops coda_m2m_ops = {
 814         .device_run     = coda_device_run,
 815         .job_ready      = coda_job_ready,
 816         .job_abort      = coda_job_abort,
 817         .lock           = coda_lock,
 818         .unlock         = coda_unlock,
 819 };
 820
 821 static void coda_set_tiled_map_type(struct coda_ctx *ctx, int tiled_map_type)
 822 {
 823         struct gdi_tiled_map *tiled_map = &ctx->tiled_map;
 824         int luma_map, chro_map, i;
 825
 826         memset(tiled_map, 0, sizeof(*tiled_map));
 827
 828         luma_map = 64;
 829         chro_map = 64;
 830         tiled_map->map_type = tiled_map_type;
 831         for (i = 0; i < 16; i++)
 832                 tiled_map->xy2ca_map[i] = luma_map << 8 | chro_map;
 833         for (i = 0; i < 4; i++)
 834                 tiled_map->xy2ba_map[i] = luma_map << 8 | chro_map;
 835         for (i = 0; i < 16; i++)
 836                 tiled_map->xy2ra_map[i] = luma_map << 8 | chro_map;
 837
 838         if (tiled_map_type == GDI_LINEAR_FRAME_MAP) {
 839                 tiled_map->xy2rbc_config = 0;
 840         } else {
 841                 dev_err(&ctx->dev->plat_dev->dev, "invalid map type: %d\n",
 842                         tiled_map_type);
 843                 return;
 844         }
 845 }
 846
 847 static void set_default_params(struct coda_ctx *ctx)
 848 {
 849         u32 src_fourcc, dst_fourcc;
 850         int max_w;
 851         int max_h;
 852
 853         if (ctx->inst_type == CODA_INST_ENCODER) {
 854                 src_fourcc = V4L2_PIX_FMT_YUV420;
 855                 dst_fourcc = V4L2_PIX_FMT_H264;
 856         } else {
 857                 src_fourcc = V4L2_PIX_FMT_H264;
 858                 dst_fourcc = V4L2_PIX_FMT_YUV420;
 859         }
 860         ctx->codec = coda_find_codec(ctx->dev, src_fourcc, dst_fourcc);
 861         max_w = ctx->codec->max_w;
 862         max_h = ctx->codec->max_h;
 863
 864         ctx->params.codec_mode = ctx->codec->mode;
 865         ctx->colorspace = V4L2_COLORSPACE_REC709;
 866         ctx->params.framerate = 30;
 867         ctx->aborting = 0;
 868
 869         /* Default formats for output and input queues */
 870         ctx->q_data[V4L2_M2M_SRC].fourcc = ctx->codec->src_fourcc;
 871         ctx->q_data[V4L2_M2M_DST].fourcc = ctx->codec->dst_fourcc;
 872         ctx->q_data[V4L2_M2M_SRC].width = max_w;
 873         ctx->q_data[V4L2_M2M_SRC].height = max_h;
 874         ctx->q_data[V4L2_M2M_DST].width = max_w;
 875         ctx->q_data[V4L2_M2M_DST].height = max_h;
 876         if (ctx->codec->src_fourcc == V4L2_PIX_FMT_YUV420) {
 877                 ctx->q_data[V4L2_M2M_SRC].bytesperline = max_w;
 878                 ctx->q_data[V4L2_M2M_SRC].sizeimage = (max_w * max_h * 3) / 2;
 879                 ctx->q_data[V4L2_M2M_DST].bytesperline = 0;
 880                 ctx->q_data[V4L2_M2M_DST].sizeimage = CODA_MAX_FRAME_SIZE;
 881         } else {
 882                 ctx->q_data[V4L2_M2M_SRC].bytesperline = 0;
 883                 ctx->q_data[V4L2_M2M_SRC].sizeimage = CODA_MAX_FRAME_SIZE;
 884                 ctx->q_data[V4L2_M2M_DST].bytesperline = max_w;
 885                 ctx->q_data[V4L2_M2M_DST].sizeimage = (max_w * max_h * 3) / 2;
 886         }
 887         ctx->q_data[V4L2_M2M_SRC].rect.width = max_w;
 888         ctx->q_data[V4L2_M2M_SRC].rect.height = max_h;
 889         ctx->q_data[V4L2_M2M_DST].rect.width = max_w;
 890         ctx->q_data[V4L2_M2M_DST].rect.height = max_h;
 891
 892         if (ctx->dev->devtype->product == CODA_960)
 893                 coda_set_tiled_map_type(ctx, GDI_LINEAR_FRAME_MAP);
 894 }
 895
 896 /*
 897  * Queue operations
 898  */
 899 static int coda_queue_setup(struct vb2_queue *vq,
 900                                 const struct v4l2_format *fmt,
 901                                 unsigned int *nbuffers, unsigned int *nplanes,
 902                                 unsigned int sizes[], void *alloc_ctxs[])
 903 {
 904         struct coda_ctx *ctx = vb2_get_drv_priv(vq);
 905         struct coda_q_data *q_data;
 906         unsigned int size;
 907
 908         q_data = get_q_data(ctx, vq->type);
 909         size = q_data->sizeimage;
 910
 911         *nplanes = 1;
 912         sizes[0] = size;
 913
 914         alloc_ctxs[0] = ctx->dev->alloc_ctx;
 915
 916         v4l2_dbg(1, coda_debug, &ctx->dev->v4l2_dev,
 917                  "get %d buffer(s) of size %d each.\n", *nbuffers, size);
 918
 919         return 0;
 920 }
 921
 922 static int coda_buf_prepare(struct vb2_buffer *vb)
 923 {
 924         struct coda_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
 925         struct coda_q_data *q_data;
 926
 927         q_data = get_q_data(ctx, vb->vb2_queue->type);
 928
 929         if (vb2_plane_size(vb, 0) < q_data->sizeimage) {
 930                 v4l2_warn(&ctx->dev->v4l2_dev,
 931                           "%s data will not fit into plane (%lu < %lu)\n",
 932                           __func__, vb2_plane_size(vb, 0),
 933                           (long)q_data->sizeimage);
 934                 return -EINVAL;
 935         }
 936
 937         return 0;
 938 }
 939
 940 static void coda_buf_queue(struct vb2_buffer *vb)
 941 {
 942         struct coda_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
 943         struct coda_q_data *q_data;
 944
 945         q_data = get_q_data(ctx, vb->vb2_queue->type);
 946
 947         /*
 948          * In the decoder case, immediately try to copy the buffer into the
 949          * bitstream ringbuffer and mark it as ready to be dequeued.
 950          */
 951         if (q_data->fourcc == V4L2_PIX_FMT_H264 &&
 952             vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
 953                 /*
 954                  * For backwards compatibility, queuing an empty buffer marks
 955                  * the stream end
 956                  */
 957                 if (vb2_get_plane_payload(vb, 0) == 0)
 958                         coda_bit_stream_end_flag(ctx);
 959                 mutex_lock(&ctx->bitstream_mutex);
 960                 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vb);
 961                 if (vb2_is_streaming(vb->vb2_queue))
 962                         coda_fill_bitstream(ctx);
 963                 mutex_unlock(&ctx->bitstream_mutex);
 964         } else {
 965                 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vb);
 966         }
 967 }
 968
 969 int coda_alloc_aux_buf(struct coda_dev *dev, struct coda_aux_buf *buf,
 970                        size_t size, const char *name, struct dentry *parent)
 971 {
 972         buf->vaddr = dma_alloc_coherent(&dev->plat_dev->dev, size, &buf->paddr,
 973                                         GFP_KERNEL);
 974         if (!buf->vaddr)
 975                 return -ENOMEM;
 976
 977         buf->size = size;
 978
 979         if (name && parent) {
 980                 buf->blob.data = buf->vaddr;
 981                 buf->blob.size = size;
 982                 buf->dentry = debugfs_create_blob(name, 0644, parent, &buf->blob);
 983                 if (!buf->dentry)
 984                         dev_warn(&dev->plat_dev->dev,
 985                                  "failed to create debugfs entry %s\n", name);
 986         }
 987
 988         return 0;
 989 }
 990
 991 void coda_free_aux_buf(struct coda_dev *dev,
 992                        struct coda_aux_buf *buf)
 993 {
 994         if (buf->vaddr) {
 995                 dma_free_coherent(&dev->plat_dev->dev, buf->size,
 996                                   buf->vaddr, buf->paddr);
 997                 buf->vaddr = NULL;
 998                 buf->size = 0;
 999         }
1000         debugfs_remove(buf->dentry);
1001 }
1002
1003 static int coda_start_streaming(struct vb2_queue *q, unsigned int count)
1004 {
1005         struct coda_ctx *ctx = vb2_get_drv_priv(q);
1006         struct v4l2_device *v4l2_dev = &ctx->dev->v4l2_dev;
1007         struct coda_q_data *q_data_src, *q_data_dst;
1008         struct vb2_buffer *buf;
1009         u32 dst_fourcc;
1010         int ret = 0;
1011
1012         q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
1013         if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
1014                 if (q_data_src->fourcc == V4L2_PIX_FMT_H264) {
1015                         /* copy the buffers that where queued before streamon */
1016                         mutex_lock(&ctx->bitstream_mutex);
1017                         coda_fill_bitstream(ctx);
1018                         mutex_unlock(&ctx->bitstream_mutex);
1019
1020                         if (coda_get_bitstream_payload(ctx) < 512) {
1021                                 ret = -EINVAL;
1022                                 goto err;
1023                         }
1024                 } else {
1025                         if (count < 1) {
1026                                 ret = -EINVAL;
1027                                 goto err;
1028                         }
1029                 }
1030
1031                 ctx->streamon_out = 1;
1032         } else {
1033                 if (count < 1) {
1034                         ret = -EINVAL;
1035                         goto err;
1036                 }
1037
1038                 ctx->streamon_cap = 1;
1039         }
1040
1041         /* Don't start the coda unless both queues are on */
1042         if (!(ctx->streamon_out & ctx->streamon_cap))
1043                 return 0;
1044
1045         /* Allow decoder device_run with no new buffers queued */
1046         if (ctx->inst_type == CODA_INST_DECODER)
1047                 v4l2_m2m_set_src_buffered(ctx->fh.m2m_ctx, true);
1048
1049         ctx->gopcounter = ctx->params.gop_size - 1;
1050         q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
1051         dst_fourcc = q_data_dst->fourcc;
1052
1053         ctx->codec = coda_find_codec(ctx->dev, q_data_src->fourcc,
1054                                      q_data_dst->fourcc);
1055         if (!ctx->codec) {
1056                 v4l2_err(v4l2_dev, "couldn't tell instance type.\n");
1057                 ret = -EINVAL;
1058                 goto err;
1059         }
1060
1061         ret = ctx->ops->start_streaming(ctx);
1062         if (ctx->inst_type == CODA_INST_DECODER) {
1063                 if (ret == -EAGAIN)
1064                         return 0;
1065                 else if (ret < 0)
1066                         goto err;
1067         }
1068
1069         ctx->initialized = 1;
1070         return ret;
1071
1072 err:
1073         if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
1074                 while ((buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx)))
1075                         v4l2_m2m_buf_done(buf, VB2_BUF_STATE_DEQUEUED);
1076         } else {
1077                 while ((buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx)))
1078                         v4l2_m2m_buf_done(buf, VB2_BUF_STATE_DEQUEUED);
1079         }
1080         return ret;
1081 }
1082
1083 static void coda_stop_streaming(struct vb2_queue *q)
1084 {
1085         struct coda_ctx *ctx = vb2_get_drv_priv(q);
1086         struct coda_dev *dev = ctx->dev;
1087
1088         if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
1089                 v4l2_dbg(1, coda_debug, &dev->v4l2_dev,
1090                          "%s: output\n", __func__);
1091                 ctx->streamon_out = 0;
1092
1093                 coda_bit_stream_end_flag(ctx);
1094                 ctx->isequence = 0;
1095         } else {
1096                 v4l2_dbg(1, coda_debug, &dev->v4l2_dev,
1097                          "%s: capture\n", __func__);
1098                 ctx->streamon_cap = 0;
1099
1100                 ctx->osequence = 0;
1101                 ctx->sequence_offset = 0;
1102         }
1103
1104         if (!ctx->streamon_out && !ctx->streamon_cap) {
1105                 struct coda_timestamp *ts;
1106
1107                 while (!list_empty(&ctx->timestamp_list)) {
1108                         ts = list_first_entry(&ctx->timestamp_list,
1109                                               struct coda_timestamp, list);
1110                         list_del(&ts->list);
1111                         kfree(ts);
1112                 }
1113                 kfifo_init(&ctx->bitstream_fifo,
1114                         ctx->bitstream.vaddr, ctx->bitstream.size);
1115                 ctx->runcounter = 0;
1116         }
1117 }
1118
1119 static const struct vb2_ops coda_qops = {
1120         .queue_setup            = coda_queue_setup,
1121         .buf_prepare            = coda_buf_prepare,
1122         .buf_queue              = coda_buf_queue,
1123         .start_streaming        = coda_start_streaming,
1124         .stop_streaming         = coda_stop_streaming,
1125         .wait_prepare           = vb2_ops_wait_prepare,
1126         .wait_finish            = vb2_ops_wait_finish,
1127 };
1128
1129 static int coda_s_ctrl(struct v4l2_ctrl *ctrl)
1130 {
1131         struct coda_ctx *ctx =
1132                         container_of(ctrl->handler, struct coda_ctx, ctrls);
1133
1134         v4l2_dbg(1, coda_debug, &ctx->dev->v4l2_dev,
1135                  "s_ctrl: id = %d, val = %d\n", ctrl->id, ctrl->val);
1136
1137         switch (ctrl->id) {
1138         case V4L2_CID_HFLIP:
1139                 if (ctrl->val)
1140                         ctx->params.rot_mode |= CODA_MIR_HOR;
1141                 else
1142                         ctx->params.rot_mode &= ~CODA_MIR_HOR;
1143                 break;
1144         case V4L2_CID_VFLIP:
1145                 if (ctrl->val)
1146                         ctx->params.rot_mode |= CODA_MIR_VER;
1147                 else
1148                         ctx->params.rot_mode &= ~CODA_MIR_VER;
1149                 break;
1150         case V4L2_CID_MPEG_VIDEO_BITRATE:
1151                 ctx->params.bitrate = ctrl->val / 1000;
1152                 break;
1153         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1154                 ctx->params.gop_size = ctrl->val;
1155                 break;
1156         case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP:
1157                 ctx->params.h264_intra_qp = ctrl->val;
1158                 break;
1159         case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP:
1160                 ctx->params.h264_inter_qp = ctrl->val;
1161                 break;
1162         case V4L2_CID_MPEG_VIDEO_H264_MIN_QP:
1163                 ctx->params.h264_min_qp = ctrl->val;
1164                 break;
1165         case V4L2_CID_MPEG_VIDEO_H264_MAX_QP:
1166                 ctx->params.h264_max_qp = ctrl->val;
1167                 break;
1168         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA:
1169                 ctx->params.h264_deblk_alpha = ctrl->val;
1170                 break;
1171         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA:
1172                 ctx->params.h264_deblk_beta = ctrl->val;
1173                 break;
1174         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
1175                 ctx->params.h264_deblk_enabled = (ctrl->val ==
1176                                 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED);
1177                 break;
1178         case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP:
1179                 ctx->params.mpeg4_intra_qp = ctrl->val;
1180                 break;
1181         case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP:
1182                 ctx->params.mpeg4_inter_qp = ctrl->val;
1183                 break;
1184         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
1185                 ctx->params.slice_mode = ctrl->val;
1186                 break;
1187         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB:
1188                 ctx->params.slice_max_mb = ctrl->val;
1189                 break;
1190         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES:
1191                 ctx->params.slice_max_bits = ctrl->val * 8;
1192                 break;
1193         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
1194                 break;
1195         case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB:
1196                 ctx->params.intra_refresh = ctrl->val;
1197                 break;
1198         default:
1199                 v4l2_dbg(1, coda_debug, &ctx->dev->v4l2_dev,
1200                         "Invalid control, id=%d, val=%d\n",
1201                         ctrl->id, ctrl->val);
1202                 return -EINVAL;
1203         }
1204
1205         return 0;
1206 }
1207
1208 static const struct v4l2_ctrl_ops coda_ctrl_ops = {
1209         .s_ctrl = coda_s_ctrl,
1210 };
1211
1212 static int coda_ctrls_setup(struct coda_ctx *ctx)
1213 {
1214         v4l2_ctrl_handler_init(&ctx->ctrls, 9);
1215
1216         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
1217                 V4L2_CID_HFLIP, 0, 1, 1, 0);
1218         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
1219                 V4L2_CID_VFLIP, 0, 1, 1, 0);
1220         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
1221                 V4L2_CID_MPEG_VIDEO_BITRATE, 0, 32767000, 1, 0);
1222         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
1223                 V4L2_CID_MPEG_VIDEO_GOP_SIZE, 1, 60, 1, 16);
1224         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
1225                 V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP, 0, 51, 1, 25);
1226         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
1227                 V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP, 0, 51, 1, 25);
1228         if (ctx->dev->devtype->product != CODA_960) {
1229                 v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
1230                         V4L2_CID_MPEG_VIDEO_H264_MIN_QP, 0, 51, 1, 12);
1231         }
1232         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
1233                 V4L2_CID_MPEG_VIDEO_H264_MAX_QP, 0, 51, 1, 51);
1234         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
1235                 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA, 0, 15, 1, 0);
1236         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
1237                 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA, 0, 15, 1, 0);
1238         v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops,
1239                 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE,
1240                 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED, 0x0,
1241                 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED);
1242         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
1243                 V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP, 1, 31, 1, 2);
1244         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
1245                 V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP, 1, 31, 1, 2);
1246         v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops,
1247                 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE,
1248                 V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES, 0x0,
1249                 V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE);
1250         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
1251                 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB, 1, 0x3fffffff, 1, 1);
1252         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
1253                 V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES, 1, 0x3fffffff, 1, 500);
1254         v4l2_ctrl_new_std_menu(&ctx->ctrls, &coda_ctrl_ops,
1255                 V4L2_CID_MPEG_VIDEO_HEADER_MODE,
1256                 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME,
1257                 (1 << V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE),
1258                 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME);
1259         v4l2_ctrl_new_std(&ctx->ctrls, &coda_ctrl_ops,
1260                 V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB, 0, 1920 * 1088 / 256, 1, 0);
1261
1262         if (ctx->ctrls.error) {
1263                 v4l2_err(&ctx->dev->v4l2_dev, "control initialization error (%d)",
1264                         ctx->ctrls.error);
1265                 return -EINVAL;
1266         }
1267
1268         return v4l2_ctrl_handler_setup(&ctx->ctrls);
1269 }
1270
1271 static int coda_queue_init(struct coda_ctx *ctx, struct vb2_queue *vq)
1272 {
1273         vq->drv_priv = ctx;
1274         vq->ops = &coda_qops;
1275         vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
1276         vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
1277         vq->lock = &ctx->dev->dev_mutex;
1278
1279         return vb2_queue_init(vq);
1280 }
1281
1282 int coda_encoder_queue_init(void *priv, struct vb2_queue *src_vq,
1283                             struct vb2_queue *dst_vq)
1284 {
1285         int ret;
1286
1287         src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
1288         src_vq->io_modes = VB2_DMABUF | VB2_MMAP;
1289         src_vq->mem_ops = &vb2_dma_contig_memops;
1290
1291         ret = coda_queue_init(priv, src_vq);
1292         if (ret)
1293                 return ret;
1294
1295         dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1296         dst_vq->io_modes = VB2_DMABUF | VB2_MMAP;
1297         dst_vq->mem_ops = &vb2_dma_contig_memops;
1298
1299         return coda_queue_init(priv, dst_vq);
1300 }
1301
1302 int coda_decoder_queue_init(void *priv, struct vb2_queue *src_vq,
1303                             struct vb2_queue *dst_vq)
1304 {
1305         int ret;
1306
1307         src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
1308         src_vq->io_modes = VB2_DMABUF | VB2_MMAP;
1309         src_vq->mem_ops = &vb2_dma_contig_memops;
1310
1311         ret = coda_queue_init(priv, src_vq);
1312         if (ret)
1313                 return ret;
1314
1315         dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1316         dst_vq->io_modes = VB2_DMABUF | VB2_MMAP;
1317         dst_vq->mem_ops = &vb2_dma_contig_memops;
1318
1319         return coda_queue_init(priv, dst_vq);
1320 }
1321
1322 static int coda_next_free_instance(struct coda_dev *dev)
1323 {
1324         int idx = ffz(dev->instance_mask);
1325
1326         if ((idx < 0) ||
1327             (dev->devtype->product == CODA_DX6 && idx > CODADX6_MAX_INSTANCES))
1328                 return -EBUSY;
1329
1330         return idx;
1331 }
1332
1333 static int coda_open(struct file *file, enum coda_inst_type inst_type,
1334                      const struct coda_context_ops *ctx_ops)
1335 {
1336         struct coda_dev *dev = video_drvdata(file);
1337         struct coda_ctx *ctx = NULL;
1338         char *name;
1339         int ret;
1340         int idx;
1341
1342         ctx = kzalloc(sizeof *ctx, GFP_KERNEL);
1343         if (!ctx)
1344                 return -ENOMEM;
1345
1346         idx = coda_next_free_instance(dev);
1347         if (idx < 0) {
1348                 ret = idx;
1349                 goto err_coda_max;
1350         }
1351         set_bit(idx, &dev->instance_mask);
1352
1353         name = kasprintf(GFP_KERNEL, "context%d", idx);
1354         ctx->debugfs_entry = debugfs_create_dir(name, dev->debugfs_root);
1355         kfree(name);
1356
1357         ctx->inst_type = inst_type;
1358         ctx->ops = ctx_ops;
1359         init_completion(&ctx->completion);
1360         INIT_WORK(&ctx->pic_run_work, coda_pic_run_work);
1361         INIT_WORK(&ctx->seq_end_work, ctx->ops->seq_end_work);
1362         v4l2_fh_init(&ctx->fh, video_devdata(file));
1363         file->private_data = &ctx->fh;
1364         v4l2_fh_add(&ctx->fh);
1365         ctx->dev = dev;
1366         ctx->idx = idx;
1367         switch (dev->devtype->product) {
1368         case CODA_7541:
1369         case CODA_960:
1370                 ctx->reg_idx = 0;
1371                 break;
1372         default:
1373                 ctx->reg_idx = idx;
1374         }
1375
1376         /* Power up and upload firmware if necessary */
1377         ret = pm_runtime_get_sync(&dev->plat_dev->dev);
1378         if (ret < 0) {
1379                 v4l2_err(&dev->v4l2_dev, "failed to power up: %d\n", ret);
1380                 goto err_pm_get;
1381         }
1382
1383         ret = clk_prepare_enable(dev->clk_per);
1384         if (ret)
1385                 goto err_clk_per;
1386
1387         ret = clk_prepare_enable(dev->clk_ahb);
1388         if (ret)
1389                 goto err_clk_ahb;
1390
1391         set_default_params(ctx);
1392         ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(dev->m2m_dev, ctx,
1393                                             ctx->ops->queue_init);
1394         if (IS_ERR(ctx->fh.m2m_ctx)) {
1395                 ret = PTR_ERR(ctx->fh.m2m_ctx);
1396
1397                 v4l2_err(&dev->v4l2_dev, "%s return error (%d)\n",
1398                          __func__, ret);
1399                 goto err_ctx_init;
1400         }
1401
1402         ret = coda_ctrls_setup(ctx);
1403         if (ret) {
1404                 v4l2_err(&dev->v4l2_dev, "failed to setup coda controls\n");
1405                 goto err_ctrls_setup;
1406         }
1407
1408         ctx->fh.ctrl_handler = &ctx->ctrls;
1409
1410         ret = coda_alloc_context_buf(ctx, &ctx->parabuf, CODA_PARA_BUF_SIZE,
1411                                      "parabuf");
1412         if (ret < 0) {
1413                 v4l2_err(&dev->v4l2_dev, "failed to allocate parabuf");
1414                 goto err_dma_alloc;
1415         }
1416
1417         ctx->bitstream.size = CODA_MAX_FRAME_SIZE;
1418         ctx->bitstream.vaddr = dma_alloc_writecombine(&dev->plat_dev->dev,
1419                         ctx->bitstream.size, &ctx->bitstream.paddr, GFP_KERNEL);
1420         if (!ctx->bitstream.vaddr) {
1421                 v4l2_err(&dev->v4l2_dev, "failed to allocate bitstream ringbuffer");
1422                 ret = -ENOMEM;
1423                 goto err_dma_writecombine;
1424         }
1425         kfifo_init(&ctx->bitstream_fifo,
1426                 ctx->bitstream.vaddr, ctx->bitstream.size);
1427         mutex_init(&ctx->bitstream_mutex);
1428         mutex_init(&ctx->buffer_mutex);
1429         INIT_LIST_HEAD(&ctx->timestamp_list);
1430
1431         coda_lock(ctx);
1432         list_add(&ctx->list, &dev->instances);
1433         coda_unlock(ctx);
1434
1435         v4l2_dbg(1, coda_debug, &dev->v4l2_dev, "Created instance %d (%p)\n",
1436                  ctx->idx, ctx);
1437
1438         return 0;
1439
1440 err_dma_writecombine:
1441         if (ctx->dev->devtype->product == CODA_DX6)
1442                 coda_free_aux_buf(dev, &ctx->workbuf);
1443         coda_free_aux_buf(dev, &ctx->parabuf);
1444 err_dma_alloc:
1445         v4l2_ctrl_handler_free(&ctx->ctrls);
1446 err_ctrls_setup:
1447         v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
1448 err_ctx_init:
1449         clk_disable_unprepare(dev->clk_ahb);
1450 err_clk_ahb:
1451         clk_disable_unprepare(dev->clk_per);
1452 err_clk_per:
1453         pm_runtime_put_sync(&dev->plat_dev->dev);
1454 err_pm_get:
1455         v4l2_fh_del(&ctx->fh);
1456         v4l2_fh_exit(&ctx->fh);
1457         clear_bit(ctx->idx, &dev->instance_mask);
1458 err_coda_max:
1459         kfree(ctx);
1460         return ret;
1461 }
1462
1463 static int coda_encoder_open(struct file *file)
1464 {
1465         return coda_open(file, CODA_INST_ENCODER, &coda_bit_encode_ops);
1466 }
1467
1468 static int coda_decoder_open(struct file *file)
1469 {
1470         return coda_open(file, CODA_INST_DECODER, &coda_bit_decode_ops);
1471 }
1472
1473 static int coda_release(struct file *file)
1474 {
1475         struct coda_dev *dev = video_drvdata(file);
1476         struct coda_ctx *ctx = fh_to_ctx(file->private_data);
1477
1478         v4l2_dbg(1, coda_debug, &dev->v4l2_dev, "Releasing instance %p\n",
1479                  ctx);
1480
1481         debugfs_remove_recursive(ctx->debugfs_entry);
1482
1483         /* If this instance is running, call .job_abort and wait for it to end */
1484         v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
1485
1486         /* In case the instance was not running, we still need to call SEQ_END */
1487         if (ctx->initialized) {
1488                 queue_work(dev->workqueue, &ctx->seq_end_work);
1489                 flush_work(&ctx->seq_end_work);
1490         }
1491
1492         coda_lock(ctx);
1493         list_del(&ctx->list);
1494         coda_unlock(ctx);
1495
1496         dma_free_writecombine(&dev->plat_dev->dev, ctx->bitstream.size,
1497                 ctx->bitstream.vaddr, ctx->bitstream.paddr);
1498         if (ctx->dev->devtype->product == CODA_DX6)
1499                 coda_free_aux_buf(dev, &ctx->workbuf);
1500
1501         coda_free_aux_buf(dev, &ctx->parabuf);
1502         v4l2_ctrl_handler_free(&ctx->ctrls);
1503         clk_disable_unprepare(dev->clk_ahb);
1504         clk_disable_unprepare(dev->clk_per);
1505         pm_runtime_put_sync(&dev->plat_dev->dev);
1506         v4l2_fh_del(&ctx->fh);
1507         v4l2_fh_exit(&ctx->fh);
1508         clear_bit(ctx->idx, &dev->instance_mask);
1509         if (ctx->ops->release)
1510                 ctx->ops->release(ctx);
1511         kfree(ctx);
1512
1513         return 0;
1514 }
1515
1516 static const struct v4l2_file_operations coda_encoder_fops = {
1517         .owner          = THIS_MODULE,
1518         .open           = coda_encoder_open,
1519         .release        = coda_release,
1520         .poll           = v4l2_m2m_fop_poll,
1521         .unlocked_ioctl = video_ioctl2,
1522         .mmap           = v4l2_m2m_fop_mmap,
1523 };
1524
1525 static const struct v4l2_file_operations coda_decoder_fops = {
1526         .owner          = THIS_MODULE,
1527         .open           = coda_decoder_open,
1528         .release        = coda_release,
1529         .poll           = v4l2_m2m_fop_poll,
1530         .unlocked_ioctl = video_ioctl2,
1531         .mmap           = v4l2_m2m_fop_mmap,
1532 };
1533
1534 static int coda_hw_init(struct coda_dev *dev)
1535 {
1536         u32 data;
1537         u16 *p;
1538         int i, ret;
1539
1540         ret = clk_prepare_enable(dev->clk_per);
1541         if (ret)
1542                 goto err_clk_per;
1543
1544         ret = clk_prepare_enable(dev->clk_ahb);
1545         if (ret)
1546                 goto err_clk_ahb;
1547
1548         if (dev->rstc)
1549                 reset_control_reset(dev->rstc);
1550
1551         /*
1552          * Copy the first CODA_ISRAM_SIZE in the internal SRAM.
1553          * The 16-bit chars in the code buffer are in memory access
1554          * order, re-sort them to CODA order for register download.
1555          * Data in this SRAM survives a reboot.
1556          */
1557         p = (u16 *)dev->codebuf.vaddr;
1558         if (dev->devtype->product == CODA_DX6) {
1559                 for (i = 0; i < (CODA_ISRAM_SIZE / 2); i++)  {
1560                         data = CODA_DOWN_ADDRESS_SET(i) |
1561                                 CODA_DOWN_DATA_SET(p[i ^ 1]);
1562                         coda_write(dev, data, CODA_REG_BIT_CODE_DOWN);
1563                 }
1564         } else {
1565                 for (i = 0; i < (CODA_ISRAM_SIZE / 2); i++) {
1566                         data = CODA_DOWN_ADDRESS_SET(i) |
1567                                 CODA_DOWN_DATA_SET(p[round_down(i, 4) +
1568                                                         3 - (i % 4)]);
1569                         coda_write(dev, data, CODA_REG_BIT_CODE_DOWN);
1570                 }
1571         }
1572
1573         /* Clear registers */
1574         for (i = 0; i < 64; i++)
1575                 coda_write(dev, 0, CODA_REG_BIT_CODE_BUF_ADDR + i * 4);
1576
1577         /* Tell the BIT where to find everything it needs */
1578         if (dev->devtype->product == CODA_960 ||
1579             dev->devtype->product == CODA_7541) {
1580                 coda_write(dev, dev->tempbuf.paddr,
1581                                 CODA_REG_BIT_TEMP_BUF_ADDR);
1582                 coda_write(dev, 0, CODA_REG_BIT_BIT_STREAM_PARAM);
1583         } else {
1584                 coda_write(dev, dev->workbuf.paddr,
1585                               CODA_REG_BIT_WORK_BUF_ADDR);
1586         }
1587         coda_write(dev, dev->codebuf.paddr,
1588                       CODA_REG_BIT_CODE_BUF_ADDR);
1589         coda_write(dev, 0, CODA_REG_BIT_CODE_RUN);
1590
1591         /* Set default values */
1592         switch (dev->devtype->product) {
1593         case CODA_DX6:
1594                 coda_write(dev, CODADX6_STREAM_BUF_PIC_FLUSH, CODA_REG_BIT_STREAM_CTRL);
1595                 break;
1596         default:
1597                 coda_write(dev, CODA7_STREAM_BUF_PIC_FLUSH, CODA_REG_BIT_STREAM_CTRL);
1598         }
1599         if (dev->devtype->product == CODA_960)
1600                 coda_write(dev, 1 << 12, CODA_REG_BIT_FRAME_MEM_CTRL);
1601         else
1602                 coda_write(dev, 0, CODA_REG_BIT_FRAME_MEM_CTRL);
1603
1604         if (dev->devtype->product != CODA_DX6)
1605                 coda_write(dev, 0, CODA7_REG_BIT_AXI_SRAM_USE);
1606
1607         coda_write(dev, CODA_INT_INTERRUPT_ENABLE,
1608                       CODA_REG_BIT_INT_ENABLE);
1609
1610         /* Reset VPU and start processor */
1611         data = coda_read(dev, CODA_REG_BIT_CODE_RESET);
1612         data |= CODA_REG_RESET_ENABLE;
1613         coda_write(dev, data, CODA_REG_BIT_CODE_RESET);
1614         udelay(10);
1615         data &= ~CODA_REG_RESET_ENABLE;
1616         coda_write(dev, data, CODA_REG_BIT_CODE_RESET);
1617         coda_write(dev, CODA_REG_RUN_ENABLE, CODA_REG_BIT_CODE_RUN);
1618
1619         clk_disable_unprepare(dev->clk_ahb);
1620         clk_disable_unprepare(dev->clk_per);
1621
1622         return 0;
1623
1624 err_clk_ahb:
1625         clk_disable_unprepare(dev->clk_per);
1626 err_clk_per:
1627         return ret;
1628 }
1629
1630 static int coda_register_device(struct coda_dev *dev, struct video_device *vfd)
1631 {
1632         vfd->release    = video_device_release_empty,
1633         vfd->lock       = &dev->dev_mutex;
1634         vfd->v4l2_dev   = &dev->v4l2_dev;
1635         vfd->vfl_dir    = VFL_DIR_M2M;
1636         video_set_drvdata(vfd, dev);
1637
1638         return video_register_device(vfd, VFL_TYPE_GRABBER, 0);
1639 }
1640
1641 static void coda_fw_callback(const struct firmware *fw, void *context)
1642 {
1643         struct coda_dev *dev = context;
1644         struct platform_device *pdev = dev->plat_dev;
1645         int ret;
1646
1647         if (!fw) {
1648                 v4l2_err(&dev->v4l2_dev, "firmware request failed\n");
1649                 return;
1650         }
1651
1652         /* allocate auxiliary per-device code buffer for the BIT processor */
1653         ret = coda_alloc_aux_buf(dev, &dev->codebuf, fw->size, "codebuf",
1654                                  dev->debugfs_root);
1655         if (ret < 0) {
1656                 dev_err(&pdev->dev, "failed to allocate code buffer\n");
1657                 return;
1658         }
1659
1660         /* Copy the whole firmware image to the code buffer */
1661         memcpy(dev->codebuf.vaddr, fw->data, fw->size);
1662         release_firmware(fw);
1663
1664         if (pm_runtime_enabled(&pdev->dev) && pdev->dev.pm_domain) {
1665                 /*
1666                  * Enabling power temporarily will cause coda_hw_init to be
1667                  * called via coda_runtime_resume by the pm domain.
1668                  */
1669                 ret = pm_runtime_get_sync(&dev->plat_dev->dev);
1670                 if (ret < 0) {
1671                         v4l2_err(&dev->v4l2_dev, "failed to power on: %d\n",
1672                                  ret);
1673                         return;
1674                 }
1675
1676                 ret = coda_check_firmware(dev);
1677                 if (ret < 0)
1678                         return;
1679
1680                 pm_runtime_put_sync(&dev->plat_dev->dev);
1681         } else {
1682                 /*
1683                  * If runtime pm is disabled or pm_domain is not set,
1684                  * initialize once manually.
1685                  */
1686                 ret = coda_hw_init(dev);
1687                 if (ret < 0) {
1688                         v4l2_err(&dev->v4l2_dev, "HW initialization failed\n");
1689                         return;
1690                 }
1691
1692                 ret = coda_check_firmware(dev);
1693                 if (ret < 0)
1694                         return;
1695         }
1696
1697         dev->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
1698         if (IS_ERR(dev->alloc_ctx)) {
1699                 v4l2_err(&dev->v4l2_dev, "Failed to alloc vb2 context\n");
1700                 return;
1701         }
1702
1703         dev->m2m_dev = v4l2_m2m_init(&coda_m2m_ops);
1704         if (IS_ERR(dev->m2m_dev)) {
1705                 v4l2_err(&dev->v4l2_dev, "Failed to init mem2mem device\n");
1706                 goto rel_ctx;
1707         }
1708
1709         dev->vfd[0].fops      = &coda_encoder_fops,
1710         dev->vfd[0].ioctl_ops = &coda_ioctl_ops;
1711         snprintf(dev->vfd[0].name, sizeof(dev->vfd[0].name), "coda-encoder");
1712         ret = coda_register_device(dev, &dev->vfd[0]);
1713         if (ret) {
1714                 v4l2_err(&dev->v4l2_dev,
1715                          "Failed to register encoder video device\n");
1716                 goto rel_m2m;
1717         }
1718
1719         dev->vfd[1].fops      = &coda_decoder_fops,
1720         dev->vfd[1].ioctl_ops = &coda_ioctl_ops;
1721         snprintf(dev->vfd[1].name, sizeof(dev->vfd[1].name), "coda-decoder");
1722         ret = coda_register_device(dev, &dev->vfd[1]);
1723         if (ret) {
1724                 v4l2_err(&dev->v4l2_dev,
1725                          "Failed to register decoder video device\n");
1726                 goto rel_m2m;
1727         }
1728
1729         v4l2_info(&dev->v4l2_dev, "codec registered as /dev/video[%d-%d]\n",
1730                   dev->vfd[0].num, dev->vfd[1].num);
1731
1732         return;
1733
1734 rel_m2m:
1735         v4l2_m2m_release(dev->m2m_dev);
1736 rel_ctx:
1737         vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);
1738 }
1739
1740 static int coda_firmware_request(struct coda_dev *dev)
1741 {
1742         char *fw = dev->devtype->firmware;
1743
1744         dev_dbg(&dev->plat_dev->dev, "requesting firmware '%s' for %s\n", fw,
1745                 coda_product_name(dev->devtype->product));
1746
1747         return request_firmware_nowait(THIS_MODULE, true,
1748                 fw, &dev->plat_dev->dev, GFP_KERNEL, dev, coda_fw_callback);
1749 }
1750
1751 enum coda_platform {
1752         CODA_IMX27,
1753         CODA_IMX53,
1754         CODA_IMX6Q,
1755         CODA_IMX6DL,
1756 };
1757
1758 static const struct coda_devtype coda_devdata[] = {
1759         [CODA_IMX27] = {
1760                 .firmware     = "v4l-codadx6-imx27.bin",
1761                 .product      = CODA_DX6,
1762                 .codecs       = codadx6_codecs,
1763                 .num_codecs   = ARRAY_SIZE(codadx6_codecs),
1764                 .workbuf_size = 288 * 1024 + FMO_SLICE_SAVE_BUF_SIZE * 8 * 1024,
1765                 .iram_size    = 0xb000,
1766         },
1767         [CODA_IMX53] = {
1768                 .firmware     = "v4l-coda7541-imx53.bin",
1769                 .product      = CODA_7541,
1770                 .codecs       = coda7_codecs,
1771                 .num_codecs   = ARRAY_SIZE(coda7_codecs),
1772                 .workbuf_size = 128 * 1024,
1773                 .tempbuf_size = 304 * 1024,
1774                 .iram_size    = 0x14000,
1775         },
1776         [CODA_IMX6Q] = {
1777                 .firmware     = "v4l-coda960-imx6q.bin",
1778                 .product      = CODA_960,
1779                 .codecs       = coda9_codecs,
1780                 .num_codecs   = ARRAY_SIZE(coda9_codecs),
1781                 .workbuf_size = 80 * 1024,
1782                 .tempbuf_size = 204 * 1024,
1783                 .iram_size    = 0x21000,
1784         },
1785         [CODA_IMX6DL] = {
1786                 .firmware     = "v4l-coda960-imx6dl.bin",
1787                 .product      = CODA_960,
1788                 .codecs       = coda9_codecs,
1789                 .num_codecs   = ARRAY_SIZE(coda9_codecs),
1790                 .workbuf_size = 80 * 1024,
1791                 .tempbuf_size = 204 * 1024,
1792                 .iram_size    = 0x20000,
1793         },
1794 };
1795
1796 static struct platform_device_id coda_platform_ids[] = {
1797         { .name = "coda-imx27", .driver_data = CODA_IMX27 },
1798         { .name = "coda-imx53", .driver_data = CODA_IMX53 },
1799         { /* sentinel */ }
1800 };
1801 MODULE_DEVICE_TABLE(platform, coda_platform_ids);
1802
1803 #ifdef CONFIG_OF
1804 static const struct of_device_id coda_dt_ids[] = {
1805         { .compatible = "fsl,imx27-vpu", .data = &coda_devdata[CODA_IMX27] },
1806         { .compatible = "fsl,imx53-vpu", .data = &coda_devdata[CODA_IMX53] },
1807         { .compatible = "fsl,imx6q-vpu", .data = &coda_devdata[CODA_IMX6Q] },
1808         { .compatible = "fsl,imx6dl-vpu", .data = &coda_devdata[CODA_IMX6DL] },
1809         { /* sentinel */ }
1810 };
1811 MODULE_DEVICE_TABLE(of, coda_dt_ids);
1812 #endif
1813
1814 static int coda_probe(struct platform_device *pdev)
1815 {
1816         const struct of_device_id *of_id =
1817                         of_match_device(of_match_ptr(coda_dt_ids), &pdev->dev);
1818         const struct platform_device_id *pdev_id;
1819         struct coda_platform_data *pdata = pdev->dev.platform_data;
1820         struct device_node *np = pdev->dev.of_node;
1821         struct gen_pool *pool;
1822         struct coda_dev *dev;
1823         struct resource *res;
1824         int ret, irq;
1825
1826         dev = devm_kzalloc(&pdev->dev, sizeof *dev, GFP_KERNEL);
1827         if (!dev) {
1828                 dev_err(&pdev->dev, "Not enough memory for %s\n",
1829                         CODA_NAME);
1830                 return -ENOMEM;
1831         }
1832
1833         spin_lock_init(&dev->irqlock);
1834         INIT_LIST_HEAD(&dev->instances);
1835
1836         dev->plat_dev = pdev;
1837         dev->clk_per = devm_clk_get(&pdev->dev, "per");
1838         if (IS_ERR(dev->clk_per)) {
1839                 dev_err(&pdev->dev, "Could not get per clock\n");
1840                 return PTR_ERR(dev->clk_per);
1841         }
1842
1843         dev->clk_ahb = devm_clk_get(&pdev->dev, "ahb");
1844         if (IS_ERR(dev->clk_ahb)) {
1845                 dev_err(&pdev->dev, "Could not get ahb clock\n");
1846                 return PTR_ERR(dev->clk_ahb);
1847         }
1848
1849         /* Get  memory for physical registers */
1850         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1851         dev->regs_base = devm_ioremap_resource(&pdev->dev, res);
1852         if (IS_ERR(dev->regs_base))
1853                 return PTR_ERR(dev->regs_base);
1854
1855         /* IRQ */
1856         irq = platform_get_irq_byname(pdev, "bit");
1857         if (irq < 0)
1858                 irq = platform_get_irq(pdev, 0);
1859         if (irq < 0) {
1860                 dev_err(&pdev->dev, "failed to get irq resource\n");
1861                 return irq;
1862         }
1863
1864         ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, coda_irq_handler,
1865                         IRQF_ONESHOT, dev_name(&pdev->dev), dev);
1866         if (ret < 0) {
1867                 dev_err(&pdev->dev, "failed to request irq: %d\n", ret);
1868                 return ret;
1869         }
1870
1871         dev->rstc = devm_reset_control_get_optional(&pdev->dev, NULL);
1872         if (IS_ERR(dev->rstc)) {
1873                 ret = PTR_ERR(dev->rstc);
1874                 if (ret == -ENOENT || ret == -ENOSYS) {
1875                         dev->rstc = NULL;
1876                 } else {
1877                         dev_err(&pdev->dev, "failed get reset control: %d\n", ret);
1878                         return ret;
1879                 }
1880         }
1881
1882         /* Get IRAM pool from device tree or platform data */
1883         pool = of_get_named_gen_pool(np, "iram", 0);
1884         if (!pool && pdata)
1885                 pool = dev_get_gen_pool(pdata->iram_dev);
1886         if (!pool) {
1887                 dev_err(&pdev->dev, "iram pool not available\n");
1888                 return -ENOMEM;
1889         }
1890         dev->iram_pool = pool;
1891
1892         ret = v4l2_device_register(&pdev->dev, &dev->v4l2_dev);
1893         if (ret)
1894                 return ret;
1895
1896         mutex_init(&dev->dev_mutex);
1897         mutex_init(&dev->coda_mutex);
1898
1899         pdev_id = of_id ? of_id->data : platform_get_device_id(pdev);
1900
1901         if (of_id) {
1902                 dev->devtype = of_id->data;
1903         } else if (pdev_id) {
1904                 dev->devtype = &coda_devdata[pdev_id->driver_data];
1905         } else {
1906                 v4l2_device_unregister(&dev->v4l2_dev);
1907                 return -EINVAL;
1908         }
1909
1910         dev->debugfs_root = debugfs_create_dir("coda", NULL);
1911         if (!dev->debugfs_root)
1912                 dev_warn(&pdev->dev, "failed to create debugfs root\n");
1913
1914         /* allocate auxiliary per-device buffers for the BIT processor */
1915         if (dev->devtype->product == CODA_DX6) {
1916                 ret = coda_alloc_aux_buf(dev, &dev->workbuf,
1917                                          dev->devtype->workbuf_size, "workbuf",
1918                                          dev->debugfs_root);
1919                 if (ret < 0) {
1920                         dev_err(&pdev->dev, "failed to allocate work buffer\n");
1921                         v4l2_device_unregister(&dev->v4l2_dev);
1922                         return ret;
1923                 }
1924         }
1925
1926         if (dev->devtype->tempbuf_size) {
1927                 ret = coda_alloc_aux_buf(dev, &dev->tempbuf,
1928                                          dev->devtype->tempbuf_size, "tempbuf",
1929                                          dev->debugfs_root);
1930                 if (ret < 0) {
1931                         dev_err(&pdev->dev, "failed to allocate temp buffer\n");
1932                         v4l2_device_unregister(&dev->v4l2_dev);
1933                         return ret;
1934                 }
1935         }
1936
1937         dev->iram.size = dev->devtype->iram_size;
1938         dev->iram.vaddr = gen_pool_dma_alloc(dev->iram_pool, dev->iram.size,
1939                                              &dev->iram.paddr);
1940         if (!dev->iram.vaddr) {
1941                 dev_err(&pdev->dev, "unable to alloc iram\n");
1942                 return -ENOMEM;
1943         }
1944
1945         dev->iram.blob.data = dev->iram.vaddr;
1946         dev->iram.blob.size = dev->iram.size;
1947         dev->iram.dentry = debugfs_create_blob("iram", 0644, dev->debugfs_root,
1948                                                &dev->iram.blob);
1949
1950         dev->workqueue = alloc_workqueue("coda", WQ_UNBOUND | WQ_MEM_RECLAIM, 1);
1951         if (!dev->workqueue) {
1952                 dev_err(&pdev->dev, "unable to alloc workqueue\n");
1953                 return -ENOMEM;
1954         }
1955
1956         platform_set_drvdata(pdev, dev);
1957
1958         pm_runtime_enable(&pdev->dev);
1959
1960         return coda_firmware_request(dev);
1961 }
1962
1963 static int coda_remove(struct platform_device *pdev)
1964 {
1965         struct coda_dev *dev = platform_get_drvdata(pdev);
1966
1967         video_unregister_device(&dev->vfd[0]);
1968         video_unregister_device(&dev->vfd[1]);
1969         if (dev->m2m_dev)
1970                 v4l2_m2m_release(dev->m2m_dev);
1971         pm_runtime_disable(&pdev->dev);
1972         if (dev->alloc_ctx)
1973                 vb2_dma_contig_cleanup_ctx(dev->alloc_ctx);
1974         v4l2_device_unregister(&dev->v4l2_dev);
1975         destroy_workqueue(dev->workqueue);
1976         if (dev->iram.vaddr)
1977                 gen_pool_free(dev->iram_pool, (unsigned long)dev->iram.vaddr,
1978                               dev->iram.size);
1979         coda_free_aux_buf(dev, &dev->codebuf);
1980         coda_free_aux_buf(dev, &dev->tempbuf);
1981         coda_free_aux_buf(dev, &dev->workbuf);
1982         debugfs_remove_recursive(dev->debugfs_root);
1983         return 0;
1984 }
1985
1986 #ifdef CONFIG_PM_RUNTIME
1987 static int coda_runtime_resume(struct device *dev)
1988 {
1989         struct coda_dev *cdev = dev_get_drvdata(dev);
1990         int ret = 0;
1991
1992         if (dev->pm_domain && cdev->codebuf.vaddr) {
1993                 ret = coda_hw_init(cdev);
1994                 if (ret)
1995                         v4l2_err(&cdev->v4l2_dev, "HW initialization failed\n");
1996         }
1997
1998         return ret;
1999 }
2000 #endif
2001
2002 static const struct dev_pm_ops coda_pm_ops = {
2003         SET_RUNTIME_PM_OPS(NULL, coda_runtime_resume, NULL)
2004 };
2005
2006 static struct platform_driver coda_driver = {
2007         .probe  = coda_probe,
2008         .remove = coda_remove,
2009         .driver = {
2010                 .name   = CODA_NAME,
2011                 .owner  = THIS_MODULE,
2012                 .of_match_table = of_match_ptr(coda_dt_ids),
2013                 .pm     = &coda_pm_ops,
2014         },
2015         .id_table = coda_platform_ids,
2016 };
2017
2018 module_platform_driver(coda_driver);
2019
2020 MODULE_LICENSE("GPL");
2021 MODULE_AUTHOR("Javier Martin <javier.martin@vista-silicon.com>");
2022 MODULE_DESCRIPTION("Coda multi-standard codec V4L2 driver");