drivers/media/platform/s5p-jpeg/jpeg-core.c

   1 /* linux/drivers/media/platform/s5p-jpeg/jpeg-core.c
   2  *
   3  * Copyright (c) 2011-2014 Samsung Electronics Co., Ltd.
   4  *              http://www.samsung.com
   5  *
   6  * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
   7  * Author: Jacek Anaszewski <j.anaszewski@samsung.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14 #include <linux/clk.h>
  15 #include <linux/err.h>
  16 #include <linux/gfp.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/io.h>
  19 #include <linux/kernel.h>
  20 #include <linux/module.h>
  21 #include <linux/of.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/pm_runtime.h>
  24 #include <linux/slab.h>
  25 #include <linux/spinlock.h>
  26 #include <linux/string.h>
  27 #include <media/v4l2-event.h>
  28 #include <media/v4l2-mem2mem.h>
  29 #include <media/v4l2-ioctl.h>
  30 #include <media/videobuf2-v4l2.h>
  31 #include <media/videobuf2-dma-contig.h>
  32
  33 #include "jpeg-core.h"
  34 #include "jpeg-hw-s5p.h"
  35 #include "jpeg-hw-exynos4.h"
  36 #include "jpeg-hw-exynos3250.h"
  37 #include "jpeg-regs.h"
  38
  39 static struct s5p_jpeg_fmt sjpeg_formats[] = {
  40         {
  41                 .name           = "JPEG JFIF",
  42                 .fourcc         = V4L2_PIX_FMT_JPEG,
  43                 .flags          = SJPEG_FMT_FLAG_ENC_CAPTURE |
  44                                   SJPEG_FMT_FLAG_DEC_OUTPUT |
  45                                   SJPEG_FMT_FLAG_S5P |
  46                                   SJPEG_FMT_FLAG_EXYNOS3250 |
  47                                   SJPEG_FMT_FLAG_EXYNOS4,
  48         },
  49         {
  50                 .name           = "YUV 4:2:2 packed, YCbYCr",
  51                 .fourcc         = V4L2_PIX_FMT_YUYV,
  52                 .depth          = 16,
  53                 .colplanes      = 1,
  54                 .h_align        = 4,
  55                 .v_align        = 3,
  56                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
  57                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
  58                                   SJPEG_FMT_FLAG_S5P |
  59                                   SJPEG_FMT_NON_RGB,
  60                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
  61         },
  62         {
  63                 .name           = "YUV 4:2:2 packed, YCbYCr",
  64                 .fourcc         = V4L2_PIX_FMT_YUYV,
  65                 .depth          = 16,
  66                 .colplanes      = 1,
  67                 .h_align        = 1,
  68                 .v_align        = 0,
  69                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
  70                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
  71                                   SJPEG_FMT_FLAG_EXYNOS4 |
  72                                   SJPEG_FMT_NON_RGB,
  73                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
  74         },
  75         {
  76                 .name           = "YUV 4:2:2 packed, YCbYCr",
  77                 .fourcc         = V4L2_PIX_FMT_YUYV,
  78                 .depth          = 16,
  79                 .colplanes      = 1,
  80                 .h_align        = 2,
  81                 .v_align        = 0,
  82                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
  83                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
  84                                   SJPEG_FMT_FLAG_EXYNOS3250 |
  85                                   SJPEG_FMT_NON_RGB,
  86                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
  87         },
  88         {
  89                 .name           = "YUV 4:2:2 packed, YCrYCb",
  90                 .fourcc         = V4L2_PIX_FMT_YVYU,
  91                 .depth          = 16,
  92                 .colplanes      = 1,
  93                 .h_align        = 1,
  94                 .v_align        = 0,
  95                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
  96                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
  97                                   SJPEG_FMT_FLAG_EXYNOS4 |
  98                                   SJPEG_FMT_NON_RGB,
  99                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
 100         },
 101         {
 102                 .name           = "YUV 4:2:2 packed, YCrYCb",
 103                 .fourcc         = V4L2_PIX_FMT_YVYU,
 104                 .depth          = 16,
 105                 .colplanes      = 1,
 106                 .h_align        = 2,
 107                 .v_align        = 0,
 108                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 109                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 110                                   SJPEG_FMT_FLAG_EXYNOS3250 |
 111                                   SJPEG_FMT_NON_RGB,
 112                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
 113         },
 114         {
 115                 .name           = "YUV 4:2:2 packed, YCrYCb",
 116                 .fourcc         = V4L2_PIX_FMT_UYVY,
 117                 .depth          = 16,
 118                 .colplanes      = 1,
 119                 .h_align        = 2,
 120                 .v_align        = 0,
 121                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 122                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 123                                   SJPEG_FMT_FLAG_EXYNOS3250 |
 124                                   SJPEG_FMT_NON_RGB,
 125                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
 126         },
 127         {
 128                 .name           = "YUV 4:2:2 packed, YCrYCb",
 129                 .fourcc         = V4L2_PIX_FMT_VYUY,
 130                 .depth          = 16,
 131                 .colplanes      = 1,
 132                 .h_align        = 2,
 133                 .v_align        = 0,
 134                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 135                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 136                                   SJPEG_FMT_FLAG_EXYNOS3250 |
 137                                   SJPEG_FMT_NON_RGB,
 138                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
 139         },
 140         {
 141                 .name           = "RGB565",
 142                 .fourcc         = V4L2_PIX_FMT_RGB565,
 143                 .depth          = 16,
 144                 .colplanes      = 1,
 145                 .h_align        = 0,
 146                 .v_align        = 0,
 147                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 148                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 149                                   SJPEG_FMT_FLAG_EXYNOS4 |
 150                                   SJPEG_FMT_RGB,
 151                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
 152         },
 153         {
 154                 .name           = "RGB565",
 155                 .fourcc         = V4L2_PIX_FMT_RGB565,
 156                 .depth          = 16,
 157                 .colplanes      = 1,
 158                 .h_align        = 2,
 159                 .v_align        = 0,
 160                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 161                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 162                                   SJPEG_FMT_FLAG_EXYNOS3250 |
 163                                   SJPEG_FMT_RGB,
 164                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
 165         },
 166         {
 167                 .name           = "RGB565X",
 168                 .fourcc         = V4L2_PIX_FMT_RGB565X,
 169                 .depth          = 16,
 170                 .colplanes      = 1,
 171                 .h_align        = 2,
 172                 .v_align        = 0,
 173                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 174                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 175                                   SJPEG_FMT_FLAG_EXYNOS3250 |
 176                                   SJPEG_FMT_RGB,
 177                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
 178         },
 179         {
 180                 .name           = "RGB565",
 181                 .fourcc         = V4L2_PIX_FMT_RGB565,
 182                 .depth          = 16,
 183                 .colplanes      = 1,
 184                 .h_align        = 0,
 185                 .v_align        = 0,
 186                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 187                                   SJPEG_FMT_FLAG_S5P |
 188                                   SJPEG_FMT_RGB,
 189                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
 190         },
 191         {
 192                 .name           = "ARGB8888, 32 bpp",
 193                 .fourcc         = V4L2_PIX_FMT_RGB32,
 194                 .depth          = 32,
 195                 .colplanes      = 1,
 196                 .h_align        = 0,
 197                 .v_align        = 0,
 198                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 199                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 200                                   SJPEG_FMT_FLAG_EXYNOS4 |
 201                                   SJPEG_FMT_RGB,
 202                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
 203         },
 204         {
 205                 .name           = "ARGB8888, 32 bpp",
 206                 .fourcc         = V4L2_PIX_FMT_RGB32,
 207                 .depth          = 32,
 208                 .colplanes      = 1,
 209                 .h_align        = 2,
 210                 .v_align        = 0,
 211                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 212                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 213                                   SJPEG_FMT_FLAG_EXYNOS3250 |
 214                                   SJPEG_FMT_RGB,
 215                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
 216         },
 217         {
 218                 .name           = "YUV 4:4:4 planar, Y/CbCr",
 219                 .fourcc         = V4L2_PIX_FMT_NV24,
 220                 .depth          = 24,
 221                 .colplanes      = 2,
 222                 .h_align        = 0,
 223                 .v_align        = 0,
 224                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 225                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 226                                   SJPEG_FMT_FLAG_EXYNOS4 |
 227                                   SJPEG_FMT_NON_RGB,
 228                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
 229         },
 230         {
 231                 .name           = "YUV 4:4:4 planar, Y/CrCb",
 232                 .fourcc         = V4L2_PIX_FMT_NV42,
 233                 .depth          = 24,
 234                 .colplanes      = 2,
 235                 .h_align        = 0,
 236                 .v_align        = 0,
 237                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 238                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 239                                   SJPEG_FMT_FLAG_EXYNOS4 |
 240                                   SJPEG_FMT_NON_RGB,
 241                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
 242         },
 243         {
 244                 .name           = "YUV 4:2:2 planar, Y/CrCb",
 245                 .fourcc         = V4L2_PIX_FMT_NV61,
 246                 .depth          = 16,
 247                 .colplanes      = 2,
 248                 .h_align        = 1,
 249                 .v_align        = 0,
 250                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 251                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 252                                   SJPEG_FMT_FLAG_EXYNOS4 |
 253                                   SJPEG_FMT_NON_RGB,
 254                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
 255         },
 256         {
 257                 .name           = "YUV 4:2:2 planar, Y/CbCr",
 258                 .fourcc         = V4L2_PIX_FMT_NV16,
 259                 .depth          = 16,
 260                 .colplanes      = 2,
 261                 .h_align        = 1,
 262                 .v_align        = 0,
 263                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 264                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 265                                   SJPEG_FMT_FLAG_EXYNOS4 |
 266                                   SJPEG_FMT_NON_RGB,
 267                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
 268         },
 269         {
 270                 .name           = "YUV 4:2:0 planar, Y/CbCr",
 271                 .fourcc         = V4L2_PIX_FMT_NV12,
 272                 .depth          = 12,
 273                 .colplanes      = 2,
 274                 .h_align        = 1,
 275                 .v_align        = 1,
 276                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 277                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 278                                   SJPEG_FMT_FLAG_EXYNOS4 |
 279                                   SJPEG_FMT_NON_RGB,
 280                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_420,
 281         },
 282         {
 283                 .name           = "YUV 4:2:0 planar, Y/CbCr",
 284                 .fourcc         = V4L2_PIX_FMT_NV12,
 285                 .depth          = 12,
 286                 .colplanes      = 2,
 287                 .h_align        = 3,
 288                 .v_align        = 3,
 289                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 290                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 291                                   SJPEG_FMT_FLAG_EXYNOS3250 |
 292                                   SJPEG_FMT_NON_RGB,
 293                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_420,
 294         },
 295         {
 296                 .name           = "YUV 4:2:0 planar, Y/CbCr",
 297                 .fourcc         = V4L2_PIX_FMT_NV12,
 298                 .depth          = 12,
 299                 .colplanes      = 2,
 300                 .h_align        = 4,
 301                 .v_align        = 4,
 302                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 303                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 304                                   SJPEG_FMT_FLAG_S5P |
 305                                   SJPEG_FMT_NON_RGB,
 306                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_420,
 307         },
 308         {
 309                 .name           = "YUV 4:2:0 planar, Y/CrCb",
 310                 .fourcc         = V4L2_PIX_FMT_NV21,
 311                 .depth          = 12,
 312                 .colplanes      = 2,
 313                 .h_align        = 3,
 314                 .v_align        = 3,
 315                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 316                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 317                                   SJPEG_FMT_FLAG_EXYNOS3250 |
 318                                   SJPEG_FMT_NON_RGB,
 319                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_420,
 320         },
 321         {
 322                 .name           = "YUV 4:2:0 planar, Y/CrCb",
 323                 .fourcc         = V4L2_PIX_FMT_NV21,
 324                 .depth          = 12,
 325                 .colplanes      = 2,
 326                 .h_align        = 1,
 327                 .v_align        = 1,
 328                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 329                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 330                                   SJPEG_FMT_FLAG_EXYNOS3250 |
 331                                   SJPEG_FMT_FLAG_EXYNOS4 |
 332                                   SJPEG_FMT_NON_RGB,
 333                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_420,
 334         },
 335         {
 336                 .name           = "YUV 4:2:0 contiguous 3-planar, Y/Cb/Cr",
 337                 .fourcc         = V4L2_PIX_FMT_YUV420,
 338                 .depth          = 12,
 339                 .colplanes      = 3,
 340                 .h_align        = 1,
 341                 .v_align        = 1,
 342                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 343                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 344                                   SJPEG_FMT_FLAG_EXYNOS4 |
 345                                   SJPEG_FMT_NON_RGB,
 346                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_420,
 347         },
 348         {
 349                 .name           = "YUV 4:2:0 contiguous 3-planar, Y/Cb/Cr",
 350                 .fourcc         = V4L2_PIX_FMT_YUV420,
 351                 .depth          = 12,
 352                 .colplanes      = 3,
 353                 .h_align        = 4,
 354                 .v_align        = 4,
 355                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 356                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 357                                   SJPEG_FMT_FLAG_EXYNOS3250 |
 358                                   SJPEG_FMT_NON_RGB,
 359                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_420,
 360         },
 361         {
 362                 .name           = "Gray",
 363                 .fourcc         = V4L2_PIX_FMT_GREY,
 364                 .depth          = 8,
 365                 .colplanes      = 1,
 366                 .flags          = SJPEG_FMT_FLAG_ENC_OUTPUT |
 367                                   SJPEG_FMT_FLAG_DEC_CAPTURE |
 368                                   SJPEG_FMT_FLAG_EXYNOS4 |
 369                                   SJPEG_FMT_NON_RGB,
 370                 .subsampling    = V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY,
 371         },
 372 };
 373 #define SJPEG_NUM_FORMATS ARRAY_SIZE(sjpeg_formats)
 374
 375 static const unsigned char qtbl_luminance[4][64] = {
 376         {/*level 0 - high compression quality */
 377                 20, 16, 25, 39, 50, 46, 62, 68,
 378                 16, 18, 23, 38, 38, 53, 65, 68,
 379                 25, 23, 31, 38, 53, 65, 68, 68,
 380                 39, 38, 38, 53, 65, 68, 68, 68,
 381                 50, 38, 53, 65, 68, 68, 68, 68,
 382                 46, 53, 65, 68, 68, 68, 68, 68,
 383                 62, 65, 68, 68, 68, 68, 68, 68,
 384                 68, 68, 68, 68, 68, 68, 68, 68
 385         },
 386         {/* level 1 */
 387                 16, 11, 11, 16, 23, 27, 31, 30,
 388                 11, 12, 12, 15, 20, 23, 23, 30,
 389                 11, 12, 13, 16, 23, 26, 35, 47,
 390                 16, 15, 16, 23, 26, 37, 47, 64,
 391                 23, 20, 23, 26, 39, 51, 64, 64,
 392                 27, 23, 26, 37, 51, 64, 64, 64,
 393                 31, 23, 35, 47, 64, 64, 64, 64,
 394                 30, 30, 47, 64, 64, 64, 64, 64
 395         },
 396         {/* level 2 */
 397                 12,  8,  8, 12, 17, 21, 24, 23,
 398                  8,  9,  9, 11, 15, 19, 18, 23,
 399                  8,  9, 10, 12, 19, 20, 27, 36,
 400                 12, 11, 12, 21, 20, 28, 36, 53,
 401                 17, 15, 19, 20, 30, 39, 51, 59,
 402                 21, 19, 20, 28, 39, 51, 59, 59,
 403                 24, 18, 27, 36, 51, 59, 59, 59,
 404                 23, 23, 36, 53, 59, 59, 59, 59
 405         },
 406         {/* level 3 - low compression quality */
 407                  8,  6,  6,  8, 12, 14, 16, 17,
 408                  6,  6,  6,  8, 10, 13, 12, 15,
 409                  6,  6,  7,  8, 13, 14, 18, 24,
 410                  8,  8,  8, 14, 13, 19, 24, 35,
 411                 12, 10, 13, 13, 20, 26, 34, 39,
 412                 14, 13, 14, 19, 26, 34, 39, 39,
 413                 16, 12, 18, 24, 34, 39, 39, 39,
 414                 17, 15, 24, 35, 39, 39, 39, 39
 415         }
 416 };
 417
 418 static const unsigned char qtbl_chrominance[4][64] = {
 419         {/*level 0 - high compression quality */
 420                 21, 25, 32, 38, 54, 68, 68, 68,
 421                 25, 28, 24, 38, 54, 68, 68, 68,
 422                 32, 24, 32, 43, 66, 68, 68, 68,
 423                 38, 38, 43, 53, 68, 68, 68, 68,
 424                 54, 54, 66, 68, 68, 68, 68, 68,
 425                 68, 68, 68, 68, 68, 68, 68, 68,
 426                 68, 68, 68, 68, 68, 68, 68, 68,
 427                 68, 68, 68, 68, 68, 68, 68, 68
 428         },
 429         {/* level 1 */
 430                 17, 15, 17, 21, 20, 26, 38, 48,
 431                 15, 19, 18, 17, 20, 26, 35, 43,
 432                 17, 18, 20, 22, 26, 30, 46, 53,
 433                 21, 17, 22, 28, 30, 39, 53, 64,
 434                 20, 20, 26, 30, 39, 48, 64, 64,
 435                 26, 26, 30, 39, 48, 63, 64, 64,
 436                 38, 35, 46, 53, 64, 64, 64, 64,
 437                 48, 43, 53, 64, 64, 64, 64, 64
 438         },
 439         {/* level 2 */
 440                 13, 11, 13, 16, 20, 20, 29, 37,
 441                 11, 14, 14, 14, 16, 20, 26, 32,
 442                 13, 14, 15, 17, 20, 23, 35, 40,
 443                 16, 14, 17, 21, 23, 30, 40, 50,
 444                 20, 16, 20, 23, 30, 37, 50, 59,
 445                 20, 20, 23, 30, 37, 48, 59, 59,
 446                 29, 26, 35, 40, 50, 59, 59, 59,
 447                 37, 32, 40, 50, 59, 59, 59, 59
 448         },
 449         {/* level 3 - low compression quality */
 450                  9,  8,  9, 11, 14, 17, 19, 24,
 451                  8, 10,  9, 11, 14, 13, 17, 22,
 452                  9,  9, 13, 14, 13, 15, 23, 26,
 453                 11, 11, 14, 14, 15, 20, 26, 33,
 454                 14, 14, 13, 15, 20, 24, 33, 39,
 455                 17, 13, 15, 20, 24, 32, 39, 39,
 456                 19, 17, 23, 26, 33, 39, 39, 39,
 457                 24, 22, 26, 33, 39, 39, 39, 39
 458         }
 459 };
 460
 461 static const unsigned char hdctbl0[16] = {
 462         0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
 463 };
 464
 465 static const unsigned char hdctblg0[12] = {
 466         0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb
 467 };
 468 static const unsigned char hactbl0[16] = {
 469         0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d
 470 };
 471 static const unsigned char hactblg0[162] = {
 472         0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
 473         0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
 474         0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
 475         0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
 476         0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
 477         0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
 478         0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
 479         0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
 480         0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
 481         0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
 482         0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
 483         0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
 484         0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
 485         0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
 486         0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
 487         0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
 488         0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
 489         0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
 490         0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
 491         0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
 492         0xf9, 0xfa
 493 };
 494
 495 /*
 496  * Fourcc downgrade schema lookup tables for 422 and 420
 497  * chroma subsampling - fourcc on each position maps on the
 498  * fourcc from the table fourcc_to_dwngrd_schema_id which allows
 499  * to get the most suitable fourcc counterpart for the given
 500  * downgraded subsampling property.
 501  */
 502 static const u32 subs422_fourcc_dwngrd_schema[] = {
 503         V4L2_PIX_FMT_NV16,
 504         V4L2_PIX_FMT_NV61,
 505 };
 506
 507 static const u32 subs420_fourcc_dwngrd_schema[] = {
 508         V4L2_PIX_FMT_NV12,
 509         V4L2_PIX_FMT_NV21,
 510         V4L2_PIX_FMT_NV12,
 511         V4L2_PIX_FMT_NV21,
 512         V4L2_PIX_FMT_NV12,
 513         V4L2_PIX_FMT_NV21,
 514         V4L2_PIX_FMT_GREY,
 515         V4L2_PIX_FMT_GREY,
 516         V4L2_PIX_FMT_GREY,
 517         V4L2_PIX_FMT_GREY,
 518 };
 519
 520 /*
 521  * Lookup table for translation of a fourcc to the position
 522  * of its downgraded counterpart in the *fourcc_dwngrd_schema
 523  * tables.
 524  */
 525 static const u32 fourcc_to_dwngrd_schema_id[] = {
 526         V4L2_PIX_FMT_NV24,
 527         V4L2_PIX_FMT_NV42,
 528         V4L2_PIX_FMT_NV16,
 529         V4L2_PIX_FMT_NV61,
 530         V4L2_PIX_FMT_YUYV,
 531         V4L2_PIX_FMT_YVYU,
 532         V4L2_PIX_FMT_NV12,
 533         V4L2_PIX_FMT_NV21,
 534         V4L2_PIX_FMT_YUV420,
 535         V4L2_PIX_FMT_GREY,
 536 };
 537
 538 static int s5p_jpeg_get_dwngrd_sch_id_by_fourcc(u32 fourcc)
 539 {
 540         int i;
 541
 542         for (i = 0; i < ARRAY_SIZE(fourcc_to_dwngrd_schema_id); ++i) {
 543                 if (fourcc_to_dwngrd_schema_id[i] == fourcc)
 544                         return i;
 545         }
 546
 547         return -EINVAL;
 548 }
 549
 550 static int s5p_jpeg_adjust_fourcc_to_subsampling(
 551                                         enum v4l2_jpeg_chroma_subsampling subs,
 552                                         u32 in_fourcc,
 553                                         u32 *out_fourcc,
 554                                         struct s5p_jpeg_ctx *ctx)
 555 {
 556         int dwngrd_sch_id;
 557
 558         if (ctx->subsampling != V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY) {
 559                 dwngrd_sch_id =
 560                         s5p_jpeg_get_dwngrd_sch_id_by_fourcc(in_fourcc);
 561                 if (dwngrd_sch_id < 0)
 562                         return -EINVAL;
 563         }
 564
 565         switch (ctx->subsampling) {
 566         case V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY:
 567                 *out_fourcc = V4L2_PIX_FMT_GREY;
 568                 break;
 569         case V4L2_JPEG_CHROMA_SUBSAMPLING_420:
 570                 if (dwngrd_sch_id >
 571                                 ARRAY_SIZE(subs420_fourcc_dwngrd_schema) - 1)
 572                         return -EINVAL;
 573                 *out_fourcc = subs420_fourcc_dwngrd_schema[dwngrd_sch_id];
 574                 break;
 575         case V4L2_JPEG_CHROMA_SUBSAMPLING_422:
 576                 if (dwngrd_sch_id >
 577                                 ARRAY_SIZE(subs422_fourcc_dwngrd_schema) - 1)
 578                         return -EINVAL;
 579                 *out_fourcc = subs422_fourcc_dwngrd_schema[dwngrd_sch_id];
 580                 break;
 581         default:
 582                 *out_fourcc = V4L2_PIX_FMT_GREY;
 583                 break;
 584         }
 585
 586         return 0;
 587 }
 588
 589 static int exynos4x12_decoded_subsampling[] = {
 590         V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY,
 591         V4L2_JPEG_CHROMA_SUBSAMPLING_444,
 592         V4L2_JPEG_CHROMA_SUBSAMPLING_422,
 593         V4L2_JPEG_CHROMA_SUBSAMPLING_420,
 594 };
 595
 596 static int exynos3250_decoded_subsampling[] = {
 597         V4L2_JPEG_CHROMA_SUBSAMPLING_444,
 598         V4L2_JPEG_CHROMA_SUBSAMPLING_422,
 599         V4L2_JPEG_CHROMA_SUBSAMPLING_420,
 600         V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY,
 601         -1,
 602         -1,
 603         V4L2_JPEG_CHROMA_SUBSAMPLING_411,
 604 };
 605
 606 static inline struct s5p_jpeg_ctx *ctrl_to_ctx(struct v4l2_ctrl *c)
 607 {
 608         return container_of(c->handler, struct s5p_jpeg_ctx, ctrl_handler);
 609 }
 610
 611 static inline struct s5p_jpeg_ctx *fh_to_ctx(struct v4l2_fh *fh)
 612 {
 613         return container_of(fh, struct s5p_jpeg_ctx, fh);
 614 }
 615
 616 static int s5p_jpeg_to_user_subsampling(struct s5p_jpeg_ctx *ctx)
 617 {
 618         switch (ctx->jpeg->variant->version) {
 619         case SJPEG_S5P:
 620                 WARN_ON(ctx->subsampling > 3);
 621                 if (ctx->subsampling > 2)
 622                         return V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY;
 623                 return ctx->subsampling;
 624         case SJPEG_EXYNOS3250:
 625         case SJPEG_EXYNOS5420:
 626                 WARN_ON(ctx->subsampling > 6);
 627                 if (ctx->subsampling > 3)
 628                         return V4L2_JPEG_CHROMA_SUBSAMPLING_411;
 629                 return exynos3250_decoded_subsampling[ctx->subsampling];
 630         case SJPEG_EXYNOS4:
 631                 WARN_ON(ctx->subsampling > 3);
 632                 if (ctx->subsampling > 2)
 633                         return V4L2_JPEG_CHROMA_SUBSAMPLING_420;
 634                 return exynos4x12_decoded_subsampling[ctx->subsampling];
 635         case SJPEG_EXYNOS5433:
 636                 return ctx->subsampling; /* parsed from header */
 637         default:
 638                 WARN_ON(ctx->subsampling > 3);
 639                 return V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY;
 640         }
 641 }
 642
 643 static inline void s5p_jpeg_set_qtbl(void __iomem *regs,
 644                                      const unsigned char *qtbl,
 645                                      unsigned long tab, int len)
 646 {
 647         int i;
 648
 649         for (i = 0; i < len; i++)
 650                 writel((unsigned int)qtbl[i], regs + tab + (i * 0x04));
 651 }
 652
 653 static inline void s5p_jpeg_set_qtbl_lum(void __iomem *regs, int quality)
 654 {
 655         /* this driver fills quantisation table 0 with data for luma */
 656         s5p_jpeg_set_qtbl(regs, qtbl_luminance[quality],
 657                           S5P_JPG_QTBL_CONTENT(0),
 658                           ARRAY_SIZE(qtbl_luminance[quality]));
 659 }
 660
 661 static inline void s5p_jpeg_set_qtbl_chr(void __iomem *regs, int quality)
 662 {
 663         /* this driver fills quantisation table 1 with data for chroma */
 664         s5p_jpeg_set_qtbl(regs, qtbl_chrominance[quality],
 665                           S5P_JPG_QTBL_CONTENT(1),
 666                           ARRAY_SIZE(qtbl_chrominance[quality]));
 667 }
 668
 669 static inline void s5p_jpeg_set_htbl(void __iomem *regs,
 670                                      const unsigned char *htbl,
 671                                      unsigned long tab, int len)
 672 {
 673         int i;
 674
 675         for (i = 0; i < len; i++)
 676                 writel((unsigned int)htbl[i], regs + tab + (i * 0x04));
 677 }
 678
 679 static inline void s5p_jpeg_set_hdctbl(void __iomem *regs)
 680 {
 681         /* this driver fills table 0 for this component */
 682         s5p_jpeg_set_htbl(regs, hdctbl0, S5P_JPG_HDCTBL(0),
 683                                                 ARRAY_SIZE(hdctbl0));
 684 }
 685
 686 static inline void s5p_jpeg_set_hdctblg(void __iomem *regs)
 687 {
 688         /* this driver fills table 0 for this component */
 689         s5p_jpeg_set_htbl(regs, hdctblg0, S5P_JPG_HDCTBLG(0),
 690                                                 ARRAY_SIZE(hdctblg0));
 691 }
 692
 693 static inline void s5p_jpeg_set_hactbl(void __iomem *regs)
 694 {
 695         /* this driver fills table 0 for this component */
 696         s5p_jpeg_set_htbl(regs, hactbl0, S5P_JPG_HACTBL(0),
 697                                                 ARRAY_SIZE(hactbl0));
 698 }
 699
 700 static inline void s5p_jpeg_set_hactblg(void __iomem *regs)
 701 {
 702         /* this driver fills table 0 for this component */
 703         s5p_jpeg_set_htbl(regs, hactblg0, S5P_JPG_HACTBLG(0),
 704                                                 ARRAY_SIZE(hactblg0));
 705 }
 706
 707 static inline void exynos4_jpeg_set_tbl(void __iomem *regs,
 708                                         const unsigned char *tbl,
 709                                         unsigned long tab, int len)
 710 {
 711         int i;
 712         unsigned int dword;
 713
 714         for (i = 0; i < len; i += 4) {
 715                 dword = tbl[i] |
 716                         (tbl[i + 1] << 8) |
 717                         (tbl[i + 2] << 16) |
 718                         (tbl[i + 3] << 24);
 719                 writel(dword, regs + tab + i);
 720         }
 721 }
 722
 723 static inline void exynos4_jpeg_set_qtbl_lum(void __iomem *regs, int quality)
 724 {
 725         /* this driver fills quantisation table 0 with data for luma */
 726         exynos4_jpeg_set_tbl(regs, qtbl_luminance[quality],
 727                              EXYNOS4_QTBL_CONTENT(0),
 728                              ARRAY_SIZE(qtbl_luminance[quality]));
 729 }
 730
 731 static inline void exynos4_jpeg_set_qtbl_chr(void __iomem *regs, int quality)
 732 {
 733         /* this driver fills quantisation table 1 with data for chroma */
 734         exynos4_jpeg_set_tbl(regs, qtbl_chrominance[quality],
 735                              EXYNOS4_QTBL_CONTENT(1),
 736                              ARRAY_SIZE(qtbl_chrominance[quality]));
 737 }
 738
 739 static void exynos4_jpeg_set_huff_tbl(void __iomem *base)
 740 {
 741         exynos4_jpeg_set_tbl(base, hdctbl0, EXYNOS4_HUFF_TBL_HDCLL,
 742                                                         ARRAY_SIZE(hdctbl0));
 743         exynos4_jpeg_set_tbl(base, hdctbl0, EXYNOS4_HUFF_TBL_HDCCL,
 744                                                         ARRAY_SIZE(hdctbl0));
 745         exynos4_jpeg_set_tbl(base, hdctblg0, EXYNOS4_HUFF_TBL_HDCLV,
 746                                                         ARRAY_SIZE(hdctblg0));
 747         exynos4_jpeg_set_tbl(base, hdctblg0, EXYNOS4_HUFF_TBL_HDCCV,
 748                                                         ARRAY_SIZE(hdctblg0));
 749         exynos4_jpeg_set_tbl(base, hactbl0, EXYNOS4_HUFF_TBL_HACLL,
 750                                                         ARRAY_SIZE(hactbl0));
 751         exynos4_jpeg_set_tbl(base, hactbl0, EXYNOS4_HUFF_TBL_HACCL,
 752                                                         ARRAY_SIZE(hactbl0));
 753         exynos4_jpeg_set_tbl(base, hactblg0, EXYNOS4_HUFF_TBL_HACLV,
 754                                                         ARRAY_SIZE(hactblg0));
 755         exynos4_jpeg_set_tbl(base, hactblg0, EXYNOS4_HUFF_TBL_HACCV,
 756                                                         ARRAY_SIZE(hactblg0));
 757 }
 758
 759 static inline int __exynos4_huff_tbl(int class, int id, bool lenval)
 760 {
 761         /*
 762          * class: 0 - DC, 1 - AC
 763          * id: 0 - Y, 1 - Cb/Cr
 764          */
 765         if (class) {
 766                 if (id)
 767                         return lenval ? EXYNOS4_HUFF_TBL_HACCL :
 768                                 EXYNOS4_HUFF_TBL_HACCV;
 769                 return lenval ? EXYNOS4_HUFF_TBL_HACLL : EXYNOS4_HUFF_TBL_HACLV;
 770
 771         }
 772         /* class == 0 */
 773         if (id)
 774                 return lenval ? EXYNOS4_HUFF_TBL_HDCCL : EXYNOS4_HUFF_TBL_HDCCV;
 775
 776         return lenval ? EXYNOS4_HUFF_TBL_HDCLL : EXYNOS4_HUFF_TBL_HDCLV;
 777 }
 778
 779 static inline int exynos4_huff_tbl_len(int class, int id)
 780 {
 781         return __exynos4_huff_tbl(class, id, true);
 782 }
 783
 784 static inline int exynos4_huff_tbl_val(int class, int id)
 785 {
 786         return __exynos4_huff_tbl(class, id, false);
 787 }
 788
 789 static int get_byte(struct s5p_jpeg_buffer *buf);
 790 static int get_word_be(struct s5p_jpeg_buffer *buf, unsigned int *word);
 791 static void skip(struct s5p_jpeg_buffer *buf, long len);
 792
 793 static void exynos4_jpeg_parse_decode_h_tbl(struct s5p_jpeg_ctx *ctx)
 794 {
 795         struct s5p_jpeg *jpeg = ctx->jpeg;
 796         struct vb2_v4l2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
 797         struct s5p_jpeg_buffer jpeg_buffer;
 798         unsigned int word;
 799         int c, x, components;
 800
 801         jpeg_buffer.size = 2; /* Ls */
 802         jpeg_buffer.data =
 803                 (unsigned long)vb2_plane_vaddr(&vb->vb2_buf, 0) + ctx->out_q.sos + 2;
 804         jpeg_buffer.curr = 0;
 805
 806         word = 0;
 807
 808         if (get_word_be(&jpeg_buffer, &word))
 809                 return;
 810         jpeg_buffer.size = (long)word - 2;
 811         jpeg_buffer.data += 2;
 812         jpeg_buffer.curr = 0;
 813
 814         components = get_byte(&jpeg_buffer);
 815         if (components == -1)
 816                 return;
 817         while (components--) {
 818                 c = get_byte(&jpeg_buffer);
 819                 if (c == -1)
 820                         return;
 821                 x = get_byte(&jpeg_buffer);
 822                 if (x == -1)
 823                         return;
 824                 exynos4_jpeg_select_dec_h_tbl(jpeg->regs, c,
 825                                         (((x >> 4) & 0x1) << 1) | (x & 0x1));
 826         }
 827
 828 }
 829
 830 static void exynos4_jpeg_parse_huff_tbl(struct s5p_jpeg_ctx *ctx)
 831 {
 832         struct s5p_jpeg *jpeg = ctx->jpeg;
 833         struct vb2_v4l2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
 834         struct s5p_jpeg_buffer jpeg_buffer;
 835         unsigned int word;
 836         int c, i, n, j;
 837
 838         for (j = 0; j < ctx->out_q.dht.n; ++j) {
 839                 jpeg_buffer.size = ctx->out_q.dht.len[j];
 840                 jpeg_buffer.data = (unsigned long)vb2_plane_vaddr(&vb->vb2_buf, 0) +
 841                                    ctx->out_q.dht.marker[j];
 842                 jpeg_buffer.curr = 0;
 843
 844                 word = 0;
 845                 while (jpeg_buffer.curr < jpeg_buffer.size) {
 846                         char id, class;
 847
 848                         c = get_byte(&jpeg_buffer);
 849                         if (c == -1)
 850                                 return;
 851                         id = c & 0xf;
 852                         class = (c >> 4) & 0xf;
 853                         n = 0;
 854                         for (i = 0; i < 16; ++i) {
 855                                 c = get_byte(&jpeg_buffer);
 856                                 if (c == -1)
 857                                         return;
 858                                 word |= c << ((i % 4) * 8);
 859                                 if ((i + 1) % 4 == 0) {
 860                                         writel(word, jpeg->regs +
 861                                         exynos4_huff_tbl_len(class, id) +
 862                                         (i / 4) * 4);
 863                                         word = 0;
 864                                 }
 865                                 n += c;
 866                         }
 867                         word = 0;
 868                         for (i = 0; i < n; ++i) {
 869                                 c = get_byte(&jpeg_buffer);
 870                                 if (c == -1)
 871                                         return;
 872                                 word |= c << ((i % 4) * 8);
 873                                 if ((i + 1) % 4 == 0) {
 874                                         writel(word, jpeg->regs +
 875                                         exynos4_huff_tbl_val(class, id) +
 876                                         (i / 4) * 4);
 877                                         word = 0;
 878                                 }
 879                         }
 880                         if (i % 4) {
 881                                 writel(word, jpeg->regs +
 882                                 exynos4_huff_tbl_val(class, id) + (i / 4) * 4);
 883                         }
 884                         word = 0;
 885                 }
 886         }
 887 }
 888
 889 static void exynos4_jpeg_parse_decode_q_tbl(struct s5p_jpeg_ctx *ctx)
 890 {
 891         struct s5p_jpeg *jpeg = ctx->jpeg;
 892         struct vb2_v4l2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
 893         struct s5p_jpeg_buffer jpeg_buffer;
 894         int c, x, components;
 895
 896         jpeg_buffer.size = ctx->out_q.sof_len;
 897         jpeg_buffer.data =
 898                 (unsigned long)vb2_plane_vaddr(&vb->vb2_buf, 0) + ctx->out_q.sof;
 899         jpeg_buffer.curr = 0;
 900
 901         skip(&jpeg_buffer, 5); /* P, Y, X */
 902         components = get_byte(&jpeg_buffer);
 903         if (components == -1)
 904                 return;
 905
 906         exynos4_jpeg_set_dec_components(jpeg->regs, components);
 907
 908         while (components--) {
 909                 c = get_byte(&jpeg_buffer);
 910                 if (c == -1)
 911                         return;
 912                 skip(&jpeg_buffer, 1);
 913                 x = get_byte(&jpeg_buffer);
 914                 if (x == -1)
 915                         return;
 916                 exynos4_jpeg_select_dec_q_tbl(jpeg->regs, c, x);
 917         }
 918 }
 919
 920 static void exynos4_jpeg_parse_q_tbl(struct s5p_jpeg_ctx *ctx)
 921 {
 922         struct s5p_jpeg *jpeg = ctx->jpeg;
 923         struct vb2_v4l2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
 924         struct s5p_jpeg_buffer jpeg_buffer;
 925         unsigned int word;
 926         int c, i, j;
 927
 928         for (j = 0; j < ctx->out_q.dqt.n; ++j) {
 929                 jpeg_buffer.size = ctx->out_q.dqt.len[j];
 930                 jpeg_buffer.data = (unsigned long)vb2_plane_vaddr(&vb->vb2_buf, 0) +
 931                                    ctx->out_q.dqt.marker[j];
 932                 jpeg_buffer.curr = 0;
 933
 934                 word = 0;
 935                 while (jpeg_buffer.size - jpeg_buffer.curr >= 65) {
 936                         char id;
 937
 938                         c = get_byte(&jpeg_buffer);
 939                         if (c == -1)
 940                                 return;
 941                         id = c & 0xf;
 942                         /* nonzero means extended mode - not supported */
 943                         if ((c >> 4) & 0xf)
 944                                 return;
 945                         for (i = 0; i < 64; ++i) {
 946                                 c = get_byte(&jpeg_buffer);
 947                                 if (c == -1)
 948                                         return;
 949                                 word |= c << ((i % 4) * 8);
 950                                 if ((i + 1) % 4 == 0) {
 951                                         writel(word, jpeg->regs +
 952                                         EXYNOS4_QTBL_CONTENT(id) + (i / 4) * 4);
 953                                         word = 0;
 954                                 }
 955                         }
 956                         word = 0;
 957                 }
 958         }
 959 }
 960
 961 /*
 962  * ============================================================================
 963  * Device file operations
 964  * ============================================================================
 965  */
 966
 967 static int queue_init(void *priv, struct vb2_queue *src_vq,
 968                       struct vb2_queue *dst_vq);
 969 static struct s5p_jpeg_fmt *s5p_jpeg_find_format(struct s5p_jpeg_ctx *ctx,
 970                                 __u32 pixelformat, unsigned int fmt_type);
 971 static int s5p_jpeg_controls_create(struct s5p_jpeg_ctx *ctx);
 972
 973 static int s5p_jpeg_open(struct file *file)
 974 {
 975         struct s5p_jpeg *jpeg = video_drvdata(file);
 976         struct video_device *vfd = video_devdata(file);
 977         struct s5p_jpeg_ctx *ctx;
 978         struct s5p_jpeg_fmt *out_fmt, *cap_fmt;
 979         int ret = 0;
 980
 981         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 982         if (!ctx)
 983                 return -ENOMEM;
 984
 985         if (mutex_lock_interruptible(&jpeg->lock)) {
 986                 ret = -ERESTARTSYS;
 987                 goto free;
 988         }
 989
 990         v4l2_fh_init(&ctx->fh, vfd);
 991         /* Use separate control handler per file handle */
 992         ctx->fh.ctrl_handler = &ctx->ctrl_handler;
 993         file->private_data = &ctx->fh;
 994         v4l2_fh_add(&ctx->fh);
 995
 996         ctx->jpeg = jpeg;
 997         if (vfd == jpeg->vfd_encoder) {
 998                 ctx->mode = S5P_JPEG_ENCODE;
 999                 out_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_RGB565,
1000                                                         FMT_TYPE_OUTPUT);
1001                 cap_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_JPEG,
1002                                                         FMT_TYPE_CAPTURE);
1003         } else {
1004                 ctx->mode = S5P_JPEG_DECODE;
1005                 out_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_JPEG,
1006                                                         FMT_TYPE_OUTPUT);
1007                 cap_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_YUYV,
1008                                                         FMT_TYPE_CAPTURE);
1009                 ctx->scale_factor = EXYNOS3250_DEC_SCALE_FACTOR_8_8;
1010         }
1011
1012         ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(jpeg->m2m_dev, ctx, queue_init);
1013         if (IS_ERR(ctx->fh.m2m_ctx)) {
1014                 ret = PTR_ERR(ctx->fh.m2m_ctx);
1015                 goto error;
1016         }
1017
1018         ctx->out_q.fmt = out_fmt;
1019         ctx->cap_q.fmt = cap_fmt;
1020
1021         ret = s5p_jpeg_controls_create(ctx);
1022         if (ret < 0)
1023                 goto error;
1024
1025         mutex_unlock(&jpeg->lock);
1026         return 0;
1027
1028 error:
1029         v4l2_fh_del(&ctx->fh);
1030         v4l2_fh_exit(&ctx->fh);
1031         mutex_unlock(&jpeg->lock);
1032 free:
1033         kfree(ctx);
1034         return ret;
1035 }
1036
1037 static int s5p_jpeg_release(struct file *file)
1038 {
1039         struct s5p_jpeg *jpeg = video_drvdata(file);
1040         struct s5p_jpeg_ctx *ctx = fh_to_ctx(file->private_data);
1041
1042         mutex_lock(&jpeg->lock);
1043         v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
1044         v4l2_ctrl_handler_free(&ctx->ctrl_handler);
1045         v4l2_fh_del(&ctx->fh);
1046         v4l2_fh_exit(&ctx->fh);
1047         kfree(ctx);
1048         mutex_unlock(&jpeg->lock);
1049
1050         return 0;
1051 }
1052
1053 static const struct v4l2_file_operations s5p_jpeg_fops = {
1054         .owner          = THIS_MODULE,
1055         .open           = s5p_jpeg_open,
1056         .release        = s5p_jpeg_release,
1057         .poll           = v4l2_m2m_fop_poll,
1058         .unlocked_ioctl = video_ioctl2,
1059         .mmap           = v4l2_m2m_fop_mmap,
1060 };
1061
1062 /*
1063  * ============================================================================
1064  * video ioctl operations
1065  * ============================================================================
1066  */
1067
1068 static int get_byte(struct s5p_jpeg_buffer *buf)
1069 {
1070         if (buf->curr >= buf->size)
1071                 return -1;
1072
1073         return ((unsigned char *)buf->data)[buf->curr++];
1074 }
1075
1076 static int get_word_be(struct s5p_jpeg_buffer *buf, unsigned int *word)
1077 {
1078         unsigned int temp;
1079         int byte;
1080
1081         byte = get_byte(buf);
1082         if (byte == -1)
1083                 return -1;
1084         temp = byte << 8;
1085         byte = get_byte(buf);
1086         if (byte == -1)
1087                 return -1;
1088         *word = (unsigned int)byte | temp;
1089         return 0;
1090 }
1091
1092 static void skip(struct s5p_jpeg_buffer *buf, long len)
1093 {
1094         if (len <= 0)
1095                 return;
1096
1097         while (len--)
1098                 get_byte(buf);
1099 }
1100
1101 static bool s5p_jpeg_subsampling_decode(struct s5p_jpeg_ctx *ctx,
1102                                         unsigned int subsampling)
1103 {
1104         unsigned int version;
1105
1106         switch (subsampling) {
1107         case 0x11:
1108                 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444;
1109                 break;
1110         case 0x21:
1111                 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422;
1112                 break;
1113         case 0x22:
1114                 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420;
1115                 break;
1116         case 0x33:
1117                 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY;
1118                 break;
1119         case 0x41:
1120                 /*
1121                  * 4:1:1 subsampling only supported by 3250, 5420, and 5433
1122                  * variants
1123                  */
1124                 version = ctx->jpeg->variant->version;
1125                 if (version != SJPEG_EXYNOS3250 &&
1126                     version != SJPEG_EXYNOS5420 &&
1127                     version != SJPEG_EXYNOS5433)
1128                         return false;
1129
1130                 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_411;
1131                 break;
1132         default:
1133                 return false;
1134         }
1135
1136         return true;
1137 }
1138
1139 static bool s5p_jpeg_parse_hdr(struct s5p_jpeg_q_data *result,
1140                                unsigned long buffer, unsigned long size,
1141                                struct s5p_jpeg_ctx *ctx)
1142 {
1143         int c, components = 0, notfound, n_dht = 0, n_dqt = 0;
1144         unsigned int height = 0, width = 0, word, subsampling = 0;
1145         unsigned int sos = 0, sof = 0, sof_len = 0;
1146         unsigned int dht[S5P_JPEG_MAX_MARKER], dht_len[S5P_JPEG_MAX_MARKER];
1147         unsigned int dqt[S5P_JPEG_MAX_MARKER], dqt_len[S5P_JPEG_MAX_MARKER];
1148         long length;
1149         struct s5p_jpeg_buffer jpeg_buffer;
1150
1151         jpeg_buffer.size = size;
1152         jpeg_buffer.data = buffer;
1153         jpeg_buffer.curr = 0;
1154
1155         notfound = 1;
1156         while (notfound || !sos) {
1157                 c = get_byte(&jpeg_buffer);
1158                 if (c == -1)
1159                         return false;
1160                 if (c != 0xff)
1161                         continue;
1162                 do
1163                         c = get_byte(&jpeg_buffer);
1164                 while (c == 0xff);
1165                 if (c == -1)
1166                         return false;
1167                 if (c == 0)
1168                         continue;
1169                 length = 0;
1170                 switch (c) {
1171                 /* SOF0: baseline JPEG */
1172                 case SOF0:
1173                         if (get_word_be(&jpeg_buffer, &word))
1174                                 break;
1175                         length = (long)word - 2;
1176                         if (!length)
1177                                 return false;
1178                         sof = jpeg_buffer.curr; /* after 0xffc0 */
1179                         sof_len = length;
1180                         if (get_byte(&jpeg_buffer) == -1)
1181                                 break;
1182                         if (get_word_be(&jpeg_buffer, &height))
1183                                 break;
1184                         if (get_word_be(&jpeg_buffer, &width))
1185                                 break;
1186                         components = get_byte(&jpeg_buffer);
1187                         if (components == -1)
1188                                 break;
1189
1190                         if (components == 1) {
1191                                 subsampling = 0x33;
1192                         } else {
1193                                 skip(&jpeg_buffer, 1);
1194                                 subsampling = get_byte(&jpeg_buffer);
1195                                 skip(&jpeg_buffer, 1);
1196                         }
1197                         if (components > 3)
1198                                 return false;
1199                         skip(&jpeg_buffer, components * 2);
1200                         notfound = 0;
1201                         break;
1202
1203                 case DQT:
1204                         if (get_word_be(&jpeg_buffer, &word))
1205                                 break;
1206                         length = (long)word - 2;
1207                         if (!length)
1208                                 return false;
1209                         if (n_dqt >= S5P_JPEG_MAX_MARKER)
1210                                 return false;
1211                         dqt[n_dqt] = jpeg_buffer.curr; /* after 0xffdb */
1212                         dqt_len[n_dqt++] = length;
1213                         skip(&jpeg_buffer, length);
1214                         break;
1215
1216                 case DHT:
1217                         if (get_word_be(&jpeg_buffer, &word))
1218                                 break;
1219                         length = (long)word - 2;
1220                         if (!length)
1221                                 return false;
1222                         if (n_dht >= S5P_JPEG_MAX_MARKER)
1223                                 return false;
1224                         dht[n_dht] = jpeg_buffer.curr; /* after 0xffc4 */
1225                         dht_len[n_dht++] = length;
1226                         skip(&jpeg_buffer, length);
1227                         break;
1228
1229                 case SOS:
1230                         sos = jpeg_buffer.curr - 2; /* 0xffda */
1231                         break;
1232
1233                 /* skip payload-less markers */
1234                 case RST ... RST + 7:
1235                 case SOI:
1236                 case EOI:
1237                 case TEM:
1238                         break;
1239
1240                 /* skip uninteresting payload markers */
1241                 default:
1242                         if (get_word_be(&jpeg_buffer, &word))
1243                                 break;
1244                         length = (long)word - 2;
1245                         skip(&jpeg_buffer, length);
1246                         break;
1247                 }
1248         }
1249
1250         if (notfound || !sos || !s5p_jpeg_subsampling_decode(ctx, subsampling))
1251                 return false;
1252
1253         result->w = width;
1254         result->h = height;
1255         result->sos = sos;
1256         result->dht.n = n_dht;
1257         while (n_dht--) {
1258                 result->dht.marker[n_dht] = dht[n_dht];
1259                 result->dht.len[n_dht] = dht_len[n_dht];
1260         }
1261         result->dqt.n = n_dqt;
1262         while (n_dqt--) {
1263                 result->dqt.marker[n_dqt] = dqt[n_dqt];
1264                 result->dqt.len[n_dqt] = dqt_len[n_dqt];
1265         }
1266         result->sof = sof;
1267         result->sof_len = sof_len;
1268         result->components = components;
1269
1270         return true;
1271 }
1272
1273 static int s5p_jpeg_querycap(struct file *file, void *priv,
1274                            struct v4l2_capability *cap)
1275 {
1276         struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1277
1278         if (ctx->mode == S5P_JPEG_ENCODE) {
1279                 strlcpy(cap->driver, S5P_JPEG_M2M_NAME,
1280                         sizeof(cap->driver));
1281                 strlcpy(cap->card, S5P_JPEG_M2M_NAME " encoder",
1282                         sizeof(cap->card));
1283         } else {
1284                 strlcpy(cap->driver, S5P_JPEG_M2M_NAME,
1285                         sizeof(cap->driver));
1286                 strlcpy(cap->card, S5P_JPEG_M2M_NAME " decoder",
1287                         sizeof(cap->card));
1288         }
1289         snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
1290                  dev_name(ctx->jpeg->dev));
1291         cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M;
1292         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1293         return 0;
1294 }
1295
1296 static int enum_fmt(struct s5p_jpeg_ctx *ctx,
1297                     struct s5p_jpeg_fmt *sjpeg_formats, int n,
1298                     struct v4l2_fmtdesc *f, u32 type)
1299 {
1300         int i, num = 0;
1301         unsigned int fmt_ver_flag = ctx->jpeg->variant->fmt_ver_flag;
1302
1303         for (i = 0; i < n; ++i) {
1304                 if (sjpeg_formats[i].flags & type &&
1305                     sjpeg_formats[i].flags & fmt_ver_flag) {
1306                         /* index-th format of type type found ? */
1307                         if (num == f->index)
1308                                 break;
1309                         /* Correct type but haven't reached our index yet,
1310                          * just increment per-type index
1311                          */
1312                         ++num;
1313                 }
1314         }
1315
1316         /* Format not found */
1317         if (i >= n)
1318                 return -EINVAL;
1319
1320         strlcpy(f->description, sjpeg_formats[i].name, sizeof(f->description));
1321         f->pixelformat = sjpeg_formats[i].fourcc;
1322
1323         return 0;
1324 }
1325
1326 static int s5p_jpeg_enum_fmt_vid_cap(struct file *file, void *priv,
1327                                    struct v4l2_fmtdesc *f)
1328 {
1329         struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1330
1331         if (ctx->mode == S5P_JPEG_ENCODE)
1332                 return enum_fmt(ctx, sjpeg_formats, SJPEG_NUM_FORMATS, f,
1333                                 SJPEG_FMT_FLAG_ENC_CAPTURE);
1334
1335         return enum_fmt(ctx, sjpeg_formats, SJPEG_NUM_FORMATS, f,
1336                         SJPEG_FMT_FLAG_DEC_CAPTURE);
1337 }
1338
1339 static int s5p_jpeg_enum_fmt_vid_out(struct file *file, void *priv,
1340                                    struct v4l2_fmtdesc *f)
1341 {
1342         struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1343
1344         if (ctx->mode == S5P_JPEG_ENCODE)
1345                 return enum_fmt(ctx, sjpeg_formats, SJPEG_NUM_FORMATS, f,
1346                                 SJPEG_FMT_FLAG_ENC_OUTPUT);
1347
1348         return enum_fmt(ctx, sjpeg_formats, SJPEG_NUM_FORMATS, f,
1349                         SJPEG_FMT_FLAG_DEC_OUTPUT);
1350 }
1351
1352 static struct s5p_jpeg_q_data *get_q_data(struct s5p_jpeg_ctx *ctx,
1353                                           enum v4l2_buf_type type)
1354 {
1355         if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
1356                 return &ctx->out_q;
1357         if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1358                 return &ctx->cap_q;
1359
1360         return NULL;
1361 }
1362
1363 static int s5p_jpeg_g_fmt(struct file *file, void *priv, struct v4l2_format *f)
1364 {
1365         struct vb2_queue *vq;
1366         struct s5p_jpeg_q_data *q_data = NULL;
1367         struct v4l2_pix_format *pix = &f->fmt.pix;
1368         struct s5p_jpeg_ctx *ct = fh_to_ctx(priv);
1369
1370         vq = v4l2_m2m_get_vq(ct->fh.m2m_ctx, f->type);
1371         if (!vq)
1372                 return -EINVAL;
1373
1374         if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1375             ct->mode == S5P_JPEG_DECODE && !ct->hdr_parsed)
1376                 return -EINVAL;
1377         q_data = get_q_data(ct, f->type);
1378         BUG_ON(q_data == NULL);
1379
1380         pix->width = q_data->w;
1381         pix->height = q_data->h;
1382         pix->field = V4L2_FIELD_NONE;
1383         pix->pixelformat = q_data->fmt->fourcc;
1384         pix->bytesperline = 0;
1385         if (q_data->fmt->fourcc != V4L2_PIX_FMT_JPEG) {
1386                 u32 bpl = q_data->w;
1387
1388                 if (q_data->fmt->colplanes == 1)
1389                         bpl = (bpl * q_data->fmt->depth) >> 3;
1390                 pix->bytesperline = bpl;
1391         }
1392         pix->sizeimage = q_data->size;
1393
1394         return 0;
1395 }
1396
1397 static struct s5p_jpeg_fmt *s5p_jpeg_find_format(struct s5p_jpeg_ctx *ctx,
1398                                 u32 pixelformat, unsigned int fmt_type)
1399 {
1400         unsigned int k, fmt_flag;
1401
1402         if (ctx->mode == S5P_JPEG_ENCODE)
1403                 fmt_flag = (fmt_type == FMT_TYPE_OUTPUT) ?
1404                                 SJPEG_FMT_FLAG_ENC_OUTPUT :
1405                                 SJPEG_FMT_FLAG_ENC_CAPTURE;
1406         else
1407                 fmt_flag = (fmt_type == FMT_TYPE_OUTPUT) ?
1408                                 SJPEG_FMT_FLAG_DEC_OUTPUT :
1409                                 SJPEG_FMT_FLAG_DEC_CAPTURE;
1410
1411         for (k = 0; k < ARRAY_SIZE(sjpeg_formats); k++) {
1412                 struct s5p_jpeg_fmt *fmt = &sjpeg_formats[k];
1413
1414                 if (fmt->fourcc == pixelformat &&
1415                     fmt->flags & fmt_flag &&
1416                     fmt->flags & ctx->jpeg->variant->fmt_ver_flag) {
1417                         return fmt;
1418                 }
1419         }
1420
1421         return NULL;
1422 }
1423
1424 static void jpeg_bound_align_image(struct s5p_jpeg_ctx *ctx,
1425                                    u32 *w, unsigned int wmin, unsigned int wmax,
1426                                    unsigned int walign,
1427                                    u32 *h, unsigned int hmin, unsigned int hmax,
1428                                    unsigned int halign)
1429 {
1430         int width, height, w_step, h_step;
1431
1432         width = *w;
1433         height = *h;
1434
1435         w_step = 1 << walign;
1436         h_step = 1 << halign;
1437
1438         if (ctx->jpeg->variant->hw3250_compat) {
1439                 /*
1440                  * Rightmost and bottommost pixels are cropped by the
1441                  * Exynos3250/compatible JPEG IP for RGB formats, for the
1442                  * specific width and height values respectively. This
1443                  * assignment will result in v4l_bound_align_image returning
1444                  * dimensions reduced by 1 for the aforementioned cases.
1445                  */
1446                 if (w_step == 4 && ((width & 3) == 1)) {
1447                         wmax = width;
1448                         hmax = height;
1449                 }
1450         }
1451
1452         v4l_bound_align_image(w, wmin, wmax, walign, h, hmin, hmax, halign, 0);
1453
1454         if (*w < width && (*w + w_step) < wmax)
1455                 *w += w_step;
1456         if (*h < height && (*h + h_step) < hmax)
1457                 *h += h_step;
1458 }
1459
1460 static int vidioc_try_fmt(struct v4l2_format *f, struct s5p_jpeg_fmt *fmt,
1461                           struct s5p_jpeg_ctx *ctx, int q_type)
1462 {
1463         struct v4l2_pix_format *pix = &f->fmt.pix;
1464
1465         if (pix->field == V4L2_FIELD_ANY)
1466                 pix->field = V4L2_FIELD_NONE;
1467         else if (pix->field != V4L2_FIELD_NONE)
1468                 return -EINVAL;
1469
1470         /* V4L2 specification suggests the driver corrects the format struct
1471          * if any of the dimensions is unsupported
1472          */
1473         if (q_type == FMT_TYPE_OUTPUT)
1474                 jpeg_bound_align_image(ctx, &pix->width, S5P_JPEG_MIN_WIDTH,
1475                                        S5P_JPEG_MAX_WIDTH, 0,
1476                                        &pix->height, S5P_JPEG_MIN_HEIGHT,
1477                                        S5P_JPEG_MAX_HEIGHT, 0);
1478         else
1479                 jpeg_bound_align_image(ctx, &pix->width, S5P_JPEG_MIN_WIDTH,
1480                                        S5P_JPEG_MAX_WIDTH, fmt->h_align,
1481                                        &pix->height, S5P_JPEG_MIN_HEIGHT,
1482                                        S5P_JPEG_MAX_HEIGHT, fmt->v_align);
1483
1484         if (fmt->fourcc == V4L2_PIX_FMT_JPEG) {
1485                 if (pix->sizeimage <= 0)
1486                         pix->sizeimage = PAGE_SIZE;
1487                 pix->bytesperline = 0;
1488         } else {
1489                 u32 bpl = pix->bytesperline;
1490
1491                 if (fmt->colplanes > 1 && bpl < pix->width)
1492                         bpl = pix->width; /* planar */
1493
1494                 if (fmt->colplanes == 1 && /* packed */
1495                     (bpl << 3) / fmt->depth < pix->width)
1496                         bpl = (pix->width * fmt->depth) >> 3;
1497
1498                 pix->bytesperline = bpl;
1499                 pix->sizeimage = (pix->width * pix->height * fmt->depth) >> 3;
1500         }
1501
1502         return 0;
1503 }
1504
1505 static int s5p_jpeg_try_fmt_vid_cap(struct file *file, void *priv,
1506                                   struct v4l2_format *f)
1507 {
1508         struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1509         struct v4l2_pix_format *pix = &f->fmt.pix;
1510         struct s5p_jpeg_fmt *fmt;
1511         int ret;
1512
1513         fmt = s5p_jpeg_find_format(ctx, f->fmt.pix.pixelformat,
1514                                                 FMT_TYPE_CAPTURE);
1515         if (!fmt) {
1516                 v4l2_err(&ctx->jpeg->v4l2_dev,
1517                          "Fourcc format (0x%08x) invalid.\n",
1518                          f->fmt.pix.pixelformat);
1519                 return -EINVAL;
1520         }
1521
1522         if (!ctx->jpeg->variant->hw_ex4_compat || ctx->mode != S5P_JPEG_DECODE)
1523                 goto exit;
1524
1525         /*
1526          * The exynos4x12 device requires resulting YUV image
1527          * subsampling not to be lower than the input jpeg subsampling.
1528          * If this requirement is not met then downgrade the requested
1529          * capture format to the one with subsampling equal to the input jpeg.
1530          */
1531         if ((fmt->flags & SJPEG_FMT_NON_RGB) &&
1532             (fmt->subsampling < ctx->subsampling)) {
1533                 ret = s5p_jpeg_adjust_fourcc_to_subsampling(ctx->subsampling,
1534                                                             fmt->fourcc,
1535                                                             &pix->pixelformat,
1536                                                             ctx);
1537                 if (ret < 0)
1538                         pix->pixelformat = V4L2_PIX_FMT_GREY;
1539
1540                 fmt = s5p_jpeg_find_format(ctx, pix->pixelformat,
1541                                                         FMT_TYPE_CAPTURE);
1542         }
1543
1544         /*
1545          * Decompression of a JPEG file with 4:2:0 subsampling and odd
1546          * width to the YUV 4:2:0 compliant formats produces a raw image
1547          * with broken luma component. Adjust capture format to RGB565
1548          * in such a case.
1549          */
1550         if (ctx->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_420 &&
1551             (ctx->out_q.w & 1) &&
1552             (pix->pixelformat == V4L2_PIX_FMT_NV12 ||
1553              pix->pixelformat == V4L2_PIX_FMT_NV21 ||
1554              pix->pixelformat == V4L2_PIX_FMT_YUV420)) {
1555                 pix->pixelformat = V4L2_PIX_FMT_RGB565;
1556                 fmt = s5p_jpeg_find_format(ctx, pix->pixelformat,
1557                                                         FMT_TYPE_CAPTURE);
1558         }
1559
1560 exit:
1561         return vidioc_try_fmt(f, fmt, ctx, FMT_TYPE_CAPTURE);
1562 }
1563
1564 static int s5p_jpeg_try_fmt_vid_out(struct file *file, void *priv,
1565                                   struct v4l2_format *f)
1566 {
1567         struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1568         struct s5p_jpeg_fmt *fmt;
1569
1570         fmt = s5p_jpeg_find_format(ctx, f->fmt.pix.pixelformat,
1571                                                 FMT_TYPE_OUTPUT);
1572         if (!fmt) {
1573                 v4l2_err(&ctx->jpeg->v4l2_dev,
1574                          "Fourcc format (0x%08x) invalid.\n",
1575                          f->fmt.pix.pixelformat);
1576                 return -EINVAL;
1577         }
1578
1579         return vidioc_try_fmt(f, fmt, ctx, FMT_TYPE_OUTPUT);
1580 }
1581
1582 static int exynos4_jpeg_get_output_buffer_size(struct s5p_jpeg_ctx *ctx,
1583                                                 struct v4l2_format *f,
1584                                                 int fmt_depth)
1585 {
1586         struct v4l2_pix_format *pix = &f->fmt.pix;
1587         u32 pix_fmt = f->fmt.pix.pixelformat;
1588         int w = pix->width, h = pix->height, wh_align;
1589         int padding = 0;
1590
1591         if (pix_fmt == V4L2_PIX_FMT_RGB32 ||
1592             pix_fmt == V4L2_PIX_FMT_RGB565 ||
1593             pix_fmt == V4L2_PIX_FMT_NV24 ||
1594             pix_fmt == V4L2_PIX_FMT_NV42 ||
1595             pix_fmt == V4L2_PIX_FMT_NV12 ||
1596             pix_fmt == V4L2_PIX_FMT_NV21 ||
1597             pix_fmt == V4L2_PIX_FMT_YUV420)
1598                 wh_align = 4;
1599         else
1600                 wh_align = 1;
1601
1602         jpeg_bound_align_image(ctx, &w, S5P_JPEG_MIN_WIDTH,
1603                                S5P_JPEG_MAX_WIDTH, wh_align,
1604                                &h, S5P_JPEG_MIN_HEIGHT,
1605                                S5P_JPEG_MAX_HEIGHT, wh_align);
1606
1607         if (ctx->jpeg->variant->version == SJPEG_EXYNOS4)
1608                 padding = PAGE_SIZE;
1609
1610         return (w * h * fmt_depth >> 3) + padding;
1611 }
1612
1613 static int exynos3250_jpeg_try_downscale(struct s5p_jpeg_ctx *ctx,
1614                                    struct v4l2_rect *r);
1615
1616 static int s5p_jpeg_s_fmt(struct s5p_jpeg_ctx *ct, struct v4l2_format *f)
1617 {
1618         struct vb2_queue *vq;
1619         struct s5p_jpeg_q_data *q_data = NULL;
1620         struct v4l2_pix_format *pix = &f->fmt.pix;
1621         struct v4l2_ctrl *ctrl_subs;
1622         struct v4l2_rect scale_rect;
1623         unsigned int f_type;
1624
1625         vq = v4l2_m2m_get_vq(ct->fh.m2m_ctx, f->type);
1626         if (!vq)
1627                 return -EINVAL;
1628
1629         q_data = get_q_data(ct, f->type);
1630         BUG_ON(q_data == NULL);
1631
1632         if (vb2_is_busy(vq)) {
1633                 v4l2_err(&ct->jpeg->v4l2_dev, "%s queue busy\n", __func__);
1634                 return -EBUSY;
1635         }
1636
1637         f_type = V4L2_TYPE_IS_OUTPUT(f->type) ?
1638                         FMT_TYPE_OUTPUT : FMT_TYPE_CAPTURE;
1639
1640         q_data->fmt = s5p_jpeg_find_format(ct, pix->pixelformat, f_type);
1641         if (ct->mode == S5P_JPEG_ENCODE ||
1642                 (ct->mode == S5P_JPEG_DECODE &&
1643                 q_data->fmt->fourcc != V4L2_PIX_FMT_JPEG)) {
1644                 q_data->w = pix->width;
1645                 q_data->h = pix->height;
1646         }
1647         if (q_data->fmt->fourcc != V4L2_PIX_FMT_JPEG) {
1648                 /*
1649                  * During encoding Exynos4x12 SoCs access wider memory area
1650                  * than it results from Image_x and Image_y values written to
1651                  * the JPEG_IMAGE_SIZE register. In order to avoid sysmmu
1652                  * page fault calculate proper buffer size in such a case.
1653                  */
1654                 if (ct->jpeg->variant->hw_ex4_compat &&
1655                     f_type == FMT_TYPE_OUTPUT && ct->mode == S5P_JPEG_ENCODE)
1656                         q_data->size = exynos4_jpeg_get_output_buffer_size(ct,
1657                                                         f,
1658                                                         q_data->fmt->depth);
1659                 else
1660                         q_data->size = q_data->w * q_data->h *
1661                                                 q_data->fmt->depth >> 3;
1662         } else {
1663                 q_data->size = pix->sizeimage;
1664         }
1665
1666         if (f_type == FMT_TYPE_OUTPUT) {
1667                 ctrl_subs = v4l2_ctrl_find(&ct->ctrl_handler,
1668                                         V4L2_CID_JPEG_CHROMA_SUBSAMPLING);
1669                 if (ctrl_subs)
1670                         v4l2_ctrl_s_ctrl(ctrl_subs, q_data->fmt->subsampling);
1671                 ct->crop_altered = false;
1672         }
1673
1674         /*
1675          * For decoding init crop_rect with capture buffer dimmensions which
1676          * contain aligned dimensions of the input JPEG image and do it only
1677          * if crop rectangle hasn't been altered by the user space e.g. with
1678          * S_SELECTION ioctl. For encoding assign output buffer dimensions.
1679          */
1680         if (!ct->crop_altered &&
1681             ((ct->mode == S5P_JPEG_DECODE && f_type == FMT_TYPE_CAPTURE) ||
1682              (ct->mode == S5P_JPEG_ENCODE && f_type == FMT_TYPE_OUTPUT))) {
1683                 ct->crop_rect.width = pix->width;
1684                 ct->crop_rect.height = pix->height;
1685         }
1686
1687         /*
1688          * Prevent downscaling to YUV420 format by more than 2
1689          * for Exynos3250/compatible SoC as it produces broken raw image
1690          * in such cases.
1691          */
1692         if (ct->mode == S5P_JPEG_DECODE &&
1693             f_type == FMT_TYPE_CAPTURE &&
1694             ct->jpeg->variant->hw3250_compat &&
1695             pix->pixelformat == V4L2_PIX_FMT_YUV420 &&
1696             ct->scale_factor > 2) {
1697                 scale_rect.width = ct->out_q.w / 2;
1698                 scale_rect.height = ct->out_q.h / 2;
1699                 exynos3250_jpeg_try_downscale(ct, &scale_rect);
1700         }
1701
1702         return 0;
1703 }
1704
1705 static int s5p_jpeg_s_fmt_vid_cap(struct file *file, void *priv,
1706                                 struct v4l2_format *f)
1707 {
1708         int ret;
1709
1710         ret = s5p_jpeg_try_fmt_vid_cap(file, priv, f);
1711         if (ret)
1712                 return ret;
1713
1714         return s5p_jpeg_s_fmt(fh_to_ctx(priv), f);
1715 }
1716
1717 static int s5p_jpeg_s_fmt_vid_out(struct file *file, void *priv,
1718                                 struct v4l2_format *f)
1719 {
1720         int ret;
1721
1722         ret = s5p_jpeg_try_fmt_vid_out(file, priv, f);
1723         if (ret)
1724                 return ret;
1725
1726         return s5p_jpeg_s_fmt(fh_to_ctx(priv), f);
1727 }
1728
1729 static int s5p_jpeg_subscribe_event(struct v4l2_fh *fh,
1730                                     const struct v4l2_event_subscription *sub)
1731 {
1732         if (sub->type == V4L2_EVENT_SOURCE_CHANGE)
1733                 return v4l2_src_change_event_subscribe(fh, sub);
1734
1735         return -EINVAL;
1736 }
1737
1738 static int exynos3250_jpeg_try_downscale(struct s5p_jpeg_ctx *ctx,
1739                                    struct v4l2_rect *r)
1740 {
1741         int w_ratio, h_ratio, scale_factor, cur_ratio, i;
1742
1743         w_ratio = ctx->out_q.w / r->width;
1744         h_ratio = ctx->out_q.h / r->height;
1745
1746         scale_factor = w_ratio > h_ratio ? w_ratio : h_ratio;
1747         scale_factor = clamp_val(scale_factor, 1, 8);
1748
1749         /* Align scale ratio to the nearest power of 2 */
1750         for (i = 0; i <= 3; ++i) {
1751                 cur_ratio = 1 << i;
1752                 if (scale_factor <= cur_ratio) {
1753                         ctx->scale_factor = cur_ratio;
1754                         break;
1755                 }
1756         }
1757
1758         r->width = round_down(ctx->out_q.w / ctx->scale_factor, 2);
1759         r->height = round_down(ctx->out_q.h / ctx->scale_factor, 2);
1760
1761         ctx->crop_rect.width = r->width;
1762         ctx->crop_rect.height = r->height;
1763         ctx->crop_rect.left = 0;
1764         ctx->crop_rect.top = 0;
1765
1766         ctx->crop_altered = true;
1767
1768         return 0;
1769 }
1770
1771 /* Return 1 if rectangle a is enclosed in rectangle b, or 0 otherwise. */
1772 static int enclosed_rectangle(struct v4l2_rect *a, struct v4l2_rect *b)
1773 {
1774         if (a->left < b->left || a->top < b->top)
1775                 return 0;
1776         if (a->left + a->width > b->left + b->width)
1777                 return 0;
1778         if (a->top + a->height > b->top + b->height)
1779                 return 0;
1780
1781         return 1;
1782 }
1783
1784 static int exynos3250_jpeg_try_crop(struct s5p_jpeg_ctx *ctx,
1785                                    struct v4l2_rect *r)
1786 {
1787         struct v4l2_rect base_rect;
1788         int w_step, h_step;
1789
1790         switch (ctx->cap_q.fmt->fourcc) {
1791         case V4L2_PIX_FMT_NV12:
1792         case V4L2_PIX_FMT_NV21:
1793                 w_step = 1;
1794                 h_step = 2;
1795                 break;
1796         case V4L2_PIX_FMT_YUV420:
1797                 w_step = 2;
1798                 h_step = 2;
1799                 break;
1800         default:
1801                 w_step = 1;
1802                 h_step = 1;
1803                 break;
1804         }
1805
1806         base_rect.top = 0;
1807         base_rect.left = 0;
1808         base_rect.width = ctx->out_q.w;
1809         base_rect.height = ctx->out_q.h;
1810
1811         r->width = round_down(r->width, w_step);
1812         r->height = round_down(r->height, h_step);
1813         r->left = round_down(r->left, 2);
1814         r->top = round_down(r->top, 2);
1815
1816         if (!enclosed_rectangle(r, &base_rect))
1817                 return -EINVAL;
1818
1819         ctx->crop_rect.left = r->left;
1820         ctx->crop_rect.top = r->top;
1821         ctx->crop_rect.width = r->width;
1822         ctx->crop_rect.height = r->height;
1823
1824         ctx->crop_altered = true;
1825
1826         return 0;
1827 }
1828
1829 /*
1830  * V4L2 controls
1831  */
1832
1833 static int s5p_jpeg_g_selection(struct file *file, void *priv,
1834                          struct v4l2_selection *s)
1835 {
1836         struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1837
1838         if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
1839             s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1840                 return -EINVAL;
1841
1842         /* For JPEG blob active == default == bounds */
1843         switch (s->target) {
1844         case V4L2_SEL_TGT_CROP:
1845         case V4L2_SEL_TGT_CROP_BOUNDS:
1846         case V4L2_SEL_TGT_CROP_DEFAULT:
1847         case V4L2_SEL_TGT_COMPOSE_DEFAULT:
1848                 s->r.width = ctx->out_q.w;
1849                 s->r.height = ctx->out_q.h;
1850                 s->r.left = 0;
1851                 s->r.top = 0;
1852                 break;
1853         case V4L2_SEL_TGT_COMPOSE:
1854         case V4L2_SEL_TGT_COMPOSE_BOUNDS:
1855         case V4L2_SEL_TGT_COMPOSE_PADDED:
1856                 s->r.width = ctx->crop_rect.width;
1857                 s->r.height =  ctx->crop_rect.height;
1858                 s->r.left = ctx->crop_rect.left;
1859                 s->r.top = ctx->crop_rect.top;
1860                 break;
1861         default:
1862                 return -EINVAL;
1863         }
1864         return 0;
1865 }
1866
1867 /*
1868  * V4L2 controls
1869  */
1870 static int s5p_jpeg_s_selection(struct file *file, void *fh,
1871                                   struct v4l2_selection *s)
1872 {
1873         struct s5p_jpeg_ctx *ctx = fh_to_ctx(file->private_data);
1874         struct v4l2_rect *rect = &s->r;
1875         int ret = -EINVAL;
1876
1877         if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1878                 return -EINVAL;
1879
1880         if (s->target == V4L2_SEL_TGT_COMPOSE) {
1881                 if (ctx->mode != S5P_JPEG_DECODE)
1882                         return -EINVAL;
1883                 if (ctx->jpeg->variant->hw3250_compat)
1884                         ret = exynos3250_jpeg_try_downscale(ctx, rect);
1885         } else if (s->target == V4L2_SEL_TGT_CROP) {
1886                 if (ctx->mode != S5P_JPEG_ENCODE)
1887                         return -EINVAL;
1888                 if (ctx->jpeg->variant->hw3250_compat)
1889                         ret = exynos3250_jpeg_try_crop(ctx, rect);
1890         }
1891
1892         return ret;
1893 }
1894
1895 static int s5p_jpeg_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1896 {
1897         struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl);
1898         struct s5p_jpeg *jpeg = ctx->jpeg;
1899         unsigned long flags;
1900
1901         switch (ctrl->id) {
1902         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1903                 spin_lock_irqsave(&jpeg->slock, flags);
1904                 ctrl->val = s5p_jpeg_to_user_subsampling(ctx);
1905                 spin_unlock_irqrestore(&jpeg->slock, flags);
1906                 break;
1907         }
1908
1909         return 0;
1910 }
1911
1912 static int s5p_jpeg_adjust_subs_ctrl(struct s5p_jpeg_ctx *ctx, int *ctrl_val)
1913 {
1914         switch (ctx->jpeg->variant->version) {
1915         case SJPEG_S5P:
1916                 return 0;
1917         case SJPEG_EXYNOS3250:
1918         case SJPEG_EXYNOS5420:
1919                 /*
1920                  * The exynos3250/compatible device can produce JPEG image only
1921                  * of 4:4:4 subsampling when given RGB32 source image.
1922                  */
1923                 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB32)
1924                         *ctrl_val = 0;
1925                 break;
1926         case SJPEG_EXYNOS4:
1927                 /*
1928                  * The exynos4x12 device requires input raw image fourcc
1929                  * to be V4L2_PIX_FMT_GREY if gray jpeg format
1930                  * is to be set.
1931                  */
1932                 if (ctx->out_q.fmt->fourcc != V4L2_PIX_FMT_GREY &&
1933                     *ctrl_val == V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY)
1934                         return -EINVAL;
1935                 break;
1936         }
1937
1938         /*
1939          * The exynos4x12 and exynos3250/compatible devices require resulting
1940          * jpeg subsampling not to be lower than the input raw image
1941          * subsampling.
1942          */
1943         if (ctx->out_q.fmt->subsampling > *ctrl_val)
1944                 *ctrl_val = ctx->out_q.fmt->subsampling;
1945
1946         return 0;
1947 }
1948
1949 static int s5p_jpeg_try_ctrl(struct v4l2_ctrl *ctrl)
1950 {
1951         struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl);
1952         unsigned long flags;
1953         int ret = 0;
1954
1955         spin_lock_irqsave(&ctx->jpeg->slock, flags);
1956
1957         if (ctrl->id == V4L2_CID_JPEG_CHROMA_SUBSAMPLING)
1958                 ret = s5p_jpeg_adjust_subs_ctrl(ctx, &ctrl->val);
1959
1960         spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
1961         return ret;
1962 }
1963
1964 static int s5p_jpeg_s_ctrl(struct v4l2_ctrl *ctrl)
1965 {
1966         struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl);
1967         unsigned long flags;
1968
1969         spin_lock_irqsave(&ctx->jpeg->slock, flags);
1970
1971         switch (ctrl->id) {
1972         case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1973                 ctx->compr_quality = ctrl->val;
1974                 break;
1975         case V4L2_CID_JPEG_RESTART_INTERVAL:
1976                 ctx->restart_interval = ctrl->val;
1977                 break;
1978         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1979                 ctx->subsampling = ctrl->val;
1980                 break;
1981         }
1982
1983         spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
1984         return 0;
1985 }
1986
1987 static const struct v4l2_ctrl_ops s5p_jpeg_ctrl_ops = {
1988         .g_volatile_ctrl        = s5p_jpeg_g_volatile_ctrl,
1989         .try_ctrl               = s5p_jpeg_try_ctrl,
1990         .s_ctrl                 = s5p_jpeg_s_ctrl,
1991 };
1992
1993 static int s5p_jpeg_controls_create(struct s5p_jpeg_ctx *ctx)
1994 {
1995         unsigned int mask = ~0x27; /* 444, 422, 420, GRAY */
1996         struct v4l2_ctrl *ctrl;
1997         int ret;
1998
1999         v4l2_ctrl_handler_init(&ctx->ctrl_handler, 3);
2000
2001         if (ctx->mode == S5P_JPEG_ENCODE) {
2002                 v4l2_ctrl_new_std(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops,
2003                                   V4L2_CID_JPEG_COMPRESSION_QUALITY,
2004                                   0, 3, 1, S5P_JPEG_COMPR_QUAL_WORST);
2005
2006                 v4l2_ctrl_new_std(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops,
2007                                   V4L2_CID_JPEG_RESTART_INTERVAL,
2008                                   0, 0xffff, 1, 0);
2009                 if (ctx->jpeg->variant->version == SJPEG_S5P)
2010                         mask = ~0x06; /* 422, 420 */
2011         }
2012
2013         ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops,
2014                                       V4L2_CID_JPEG_CHROMA_SUBSAMPLING,
2015                                       V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY, mask,
2016                                       V4L2_JPEG_CHROMA_SUBSAMPLING_422);
2017
2018         if (ctx->ctrl_handler.error) {
2019                 ret = ctx->ctrl_handler.error;
2020                 goto error_free;
2021         }
2022
2023         if (ctx->mode == S5P_JPEG_DECODE)
2024                 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE |
2025                         V4L2_CTRL_FLAG_READ_ONLY;
2026
2027         ret = v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
2028         if (ret < 0)
2029                 goto error_free;
2030
2031         return ret;
2032
2033 error_free:
2034         v4l2_ctrl_handler_free(&ctx->ctrl_handler);
2035         return ret;
2036 }
2037
2038 static const struct v4l2_ioctl_ops s5p_jpeg_ioctl_ops = {
2039         .vidioc_querycap                = s5p_jpeg_querycap,
2040
2041         .vidioc_enum_fmt_vid_cap        = s5p_jpeg_enum_fmt_vid_cap,
2042         .vidioc_enum_fmt_vid_out        = s5p_jpeg_enum_fmt_vid_out,
2043
2044         .vidioc_g_fmt_vid_cap           = s5p_jpeg_g_fmt,
2045         .vidioc_g_fmt_vid_out           = s5p_jpeg_g_fmt,
2046
2047         .vidioc_try_fmt_vid_cap         = s5p_jpeg_try_fmt_vid_cap,
2048         .vidioc_try_fmt_vid_out         = s5p_jpeg_try_fmt_vid_out,
2049
2050         .vidioc_s_fmt_vid_cap           = s5p_jpeg_s_fmt_vid_cap,
2051         .vidioc_s_fmt_vid_out           = s5p_jpeg_s_fmt_vid_out,
2052
2053         .vidioc_reqbufs                 = v4l2_m2m_ioctl_reqbufs,
2054         .vidioc_querybuf                = v4l2_m2m_ioctl_querybuf,
2055         .vidioc_qbuf                    = v4l2_m2m_ioctl_qbuf,
2056         .vidioc_dqbuf                   = v4l2_m2m_ioctl_dqbuf,
2057
2058         .vidioc_streamon                = v4l2_m2m_ioctl_streamon,
2059         .vidioc_streamoff               = v4l2_m2m_ioctl_streamoff,
2060
2061         .vidioc_g_selection             = s5p_jpeg_g_selection,
2062         .vidioc_s_selection             = s5p_jpeg_s_selection,
2063
2064         .vidioc_subscribe_event         = s5p_jpeg_subscribe_event,
2065         .vidioc_unsubscribe_event       = v4l2_event_unsubscribe,
2066 };
2067
2068 /*
2069  * ============================================================================
2070  * mem2mem callbacks
2071  * ============================================================================
2072  */
2073
2074 static void s5p_jpeg_device_run(void *priv)
2075 {
2076         struct s5p_jpeg_ctx *ctx = priv;
2077         struct s5p_jpeg *jpeg = ctx->jpeg;
2078         struct vb2_v4l2_buffer *src_buf, *dst_buf;
2079         unsigned long src_addr, dst_addr, flags;
2080
2081         spin_lock_irqsave(&ctx->jpeg->slock, flags);
2082
2083         src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2084         dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2085         src_addr = vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf, 0);
2086         dst_addr = vb2_dma_contig_plane_dma_addr(&dst_buf->vb2_buf, 0);
2087
2088         s5p_jpeg_reset(jpeg->regs);
2089         s5p_jpeg_poweron(jpeg->regs);
2090         s5p_jpeg_proc_mode(jpeg->regs, ctx->mode);
2091         if (ctx->mode == S5P_JPEG_ENCODE) {
2092                 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565)
2093                         s5p_jpeg_input_raw_mode(jpeg->regs,
2094                                                         S5P_JPEG_RAW_IN_565);
2095                 else
2096                         s5p_jpeg_input_raw_mode(jpeg->regs,
2097                                                         S5P_JPEG_RAW_IN_422);
2098                 s5p_jpeg_subsampling_mode(jpeg->regs, ctx->subsampling);
2099                 s5p_jpeg_dri(jpeg->regs, ctx->restart_interval);
2100                 s5p_jpeg_x(jpeg->regs, ctx->out_q.w);
2101                 s5p_jpeg_y(jpeg->regs, ctx->out_q.h);
2102                 s5p_jpeg_imgadr(jpeg->regs, src_addr);
2103                 s5p_jpeg_jpgadr(jpeg->regs, dst_addr);
2104
2105                 /* ultimately comes from sizeimage from userspace */
2106                 s5p_jpeg_enc_stream_int(jpeg->regs, ctx->cap_q.size);
2107
2108                 /* JPEG RGB to YCbCr conversion matrix */
2109                 s5p_jpeg_coef(jpeg->regs, 1, 1, S5P_JPEG_COEF11);
2110                 s5p_jpeg_coef(jpeg->regs, 1, 2, S5P_JPEG_COEF12);
2111                 s5p_jpeg_coef(jpeg->regs, 1, 3, S5P_JPEG_COEF13);
2112                 s5p_jpeg_coef(jpeg->regs, 2, 1, S5P_JPEG_COEF21);
2113                 s5p_jpeg_coef(jpeg->regs, 2, 2, S5P_JPEG_COEF22);
2114                 s5p_jpeg_coef(jpeg->regs, 2, 3, S5P_JPEG_COEF23);
2115                 s5p_jpeg_coef(jpeg->regs, 3, 1, S5P_JPEG_COEF31);
2116                 s5p_jpeg_coef(jpeg->regs, 3, 2, S5P_JPEG_COEF32);
2117                 s5p_jpeg_coef(jpeg->regs, 3, 3, S5P_JPEG_COEF33);
2118
2119                 /*
2120                  * JPEG IP allows storing 4 quantization tables
2121                  * We fill table 0 for luma and table 1 for chroma
2122                  */
2123                 s5p_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality);
2124                 s5p_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality);
2125                 /* use table 0 for Y */
2126                 s5p_jpeg_qtbl(jpeg->regs, 1, 0);
2127                 /* use table 1 for Cb and Cr*/
2128                 s5p_jpeg_qtbl(jpeg->regs, 2, 1);
2129                 s5p_jpeg_qtbl(jpeg->regs, 3, 1);
2130
2131                 /* Y, Cb, Cr use Huffman table 0 */
2132                 s5p_jpeg_htbl_ac(jpeg->regs, 1);
2133                 s5p_jpeg_htbl_dc(jpeg->regs, 1);
2134                 s5p_jpeg_htbl_ac(jpeg->regs, 2);
2135                 s5p_jpeg_htbl_dc(jpeg->regs, 2);
2136                 s5p_jpeg_htbl_ac(jpeg->regs, 3);
2137                 s5p_jpeg_htbl_dc(jpeg->regs, 3);
2138         } else { /* S5P_JPEG_DECODE */
2139                 s5p_jpeg_rst_int_enable(jpeg->regs, true);
2140                 s5p_jpeg_data_num_int_enable(jpeg->regs, true);
2141                 s5p_jpeg_final_mcu_num_int_enable(jpeg->regs, true);
2142                 if (ctx->cap_q.fmt->fourcc == V4L2_PIX_FMT_YUYV)
2143                         s5p_jpeg_outform_raw(jpeg->regs, S5P_JPEG_RAW_OUT_422);
2144                 else
2145                         s5p_jpeg_outform_raw(jpeg->regs, S5P_JPEG_RAW_OUT_420);
2146                 s5p_jpeg_jpgadr(jpeg->regs, src_addr);
2147                 s5p_jpeg_imgadr(jpeg->regs, dst_addr);
2148         }
2149
2150         s5p_jpeg_start(jpeg->regs);
2151
2152         spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
2153 }
2154
2155 static void exynos4_jpeg_set_img_addr(struct s5p_jpeg_ctx *ctx)
2156 {
2157         struct s5p_jpeg *jpeg = ctx->jpeg;
2158         struct s5p_jpeg_fmt *fmt;
2159         struct vb2_v4l2_buffer *vb;
2160         struct s5p_jpeg_addr jpeg_addr = {};
2161         u32 pix_size, padding_bytes = 0;
2162
2163         jpeg_addr.cb = 0;
2164         jpeg_addr.cr = 0;
2165
2166         pix_size = ctx->cap_q.w * ctx->cap_q.h;
2167
2168         if (ctx->mode == S5P_JPEG_ENCODE) {
2169                 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2170                 fmt = ctx->out_q.fmt;
2171                 if (ctx->out_q.w % 2 && fmt->h_align > 0)
2172                         padding_bytes = ctx->out_q.h;
2173         } else {
2174                 fmt = ctx->cap_q.fmt;
2175                 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2176         }
2177
2178         jpeg_addr.y = vb2_dma_contig_plane_dma_addr(&vb->vb2_buf, 0);
2179
2180         if (fmt->colplanes == 2) {
2181                 jpeg_addr.cb = jpeg_addr.y + pix_size - padding_bytes;
2182         } else if (fmt->colplanes == 3) {
2183                 jpeg_addr.cb = jpeg_addr.y + pix_size;
2184                 if (fmt->fourcc == V4L2_PIX_FMT_YUV420)
2185                         jpeg_addr.cr = jpeg_addr.cb + pix_size / 4;
2186                 else
2187                         jpeg_addr.cr = jpeg_addr.cb + pix_size / 2;
2188         }
2189
2190         exynos4_jpeg_set_frame_buf_address(jpeg->regs, &jpeg_addr);
2191 }
2192
2193 static void exynos4_jpeg_set_jpeg_addr(struct s5p_jpeg_ctx *ctx)
2194 {
2195         struct s5p_jpeg *jpeg = ctx->jpeg;
2196         struct vb2_v4l2_buffer *vb;
2197         unsigned int jpeg_addr = 0;
2198
2199         if (ctx->mode == S5P_JPEG_ENCODE)
2200                 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2201         else
2202                 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2203
2204         jpeg_addr = vb2_dma_contig_plane_dma_addr(&vb->vb2_buf, 0);
2205         if (jpeg->variant->version == SJPEG_EXYNOS5433 &&
2206             ctx->mode == S5P_JPEG_DECODE)
2207                 jpeg_addr += ctx->out_q.sos;
2208         exynos4_jpeg_set_stream_buf_address(jpeg->regs, jpeg_addr);
2209 }
2210
2211 static inline void exynos4_jpeg_set_img_fmt(void __iomem *base,
2212                                             unsigned int img_fmt)
2213 {
2214         __exynos4_jpeg_set_img_fmt(base, img_fmt, SJPEG_EXYNOS4);
2215 }
2216
2217 static inline void exynos5433_jpeg_set_img_fmt(void __iomem *base,
2218                                                unsigned int img_fmt)
2219 {
2220         __exynos4_jpeg_set_img_fmt(base, img_fmt, SJPEG_EXYNOS5433);
2221 }
2222
2223 static inline void exynos4_jpeg_set_enc_out_fmt(void __iomem *base,
2224                                                 unsigned int out_fmt)
2225 {
2226         __exynos4_jpeg_set_enc_out_fmt(base, out_fmt, SJPEG_EXYNOS4);
2227 }
2228
2229 static inline void exynos5433_jpeg_set_enc_out_fmt(void __iomem *base,
2230                                                    unsigned int out_fmt)
2231 {
2232         __exynos4_jpeg_set_enc_out_fmt(base, out_fmt, SJPEG_EXYNOS5433);
2233 }
2234
2235 static void exynos4_jpeg_device_run(void *priv)
2236 {
2237         struct s5p_jpeg_ctx *ctx = priv;
2238         struct s5p_jpeg *jpeg = ctx->jpeg;
2239         unsigned int bitstream_size;
2240         unsigned long flags;
2241
2242         spin_lock_irqsave(&jpeg->slock, flags);
2243
2244         if (ctx->mode == S5P_JPEG_ENCODE) {
2245                 exynos4_jpeg_sw_reset(jpeg->regs);
2246                 exynos4_jpeg_set_interrupt(jpeg->regs, jpeg->variant->version);
2247                 exynos4_jpeg_set_huf_table_enable(jpeg->regs, 1);
2248
2249                 exynos4_jpeg_set_huff_tbl(jpeg->regs);
2250
2251                 /*
2252                  * JPEG IP allows storing 4 quantization tables
2253                  * We fill table 0 for luma and table 1 for chroma
2254                  */
2255                 exynos4_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality);
2256                 exynos4_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality);
2257
2258                 exynos4_jpeg_set_encode_tbl_select(jpeg->regs,
2259                                                         ctx->compr_quality);
2260                 exynos4_jpeg_set_stream_size(jpeg->regs, ctx->cap_q.w,
2261                                                         ctx->cap_q.h);
2262
2263                 if (ctx->jpeg->variant->version == SJPEG_EXYNOS4) {
2264                         exynos4_jpeg_set_enc_out_fmt(jpeg->regs,
2265                                                      ctx->subsampling);
2266                         exynos4_jpeg_set_img_fmt(jpeg->regs,
2267                                                  ctx->out_q.fmt->fourcc);
2268                 } else {
2269                         exynos5433_jpeg_set_enc_out_fmt(jpeg->regs,
2270                                                         ctx->subsampling);
2271                         exynos5433_jpeg_set_img_fmt(jpeg->regs,
2272                                                     ctx->out_q.fmt->fourcc);
2273                 }
2274                 exynos4_jpeg_set_img_addr(ctx);
2275                 exynos4_jpeg_set_jpeg_addr(ctx);
2276                 exynos4_jpeg_set_encode_hoff_cnt(jpeg->regs,
2277                                                         ctx->out_q.fmt->fourcc);
2278         } else {
2279                 exynos4_jpeg_sw_reset(jpeg->regs);
2280                 exynos4_jpeg_set_interrupt(jpeg->regs,
2281                                            jpeg->variant->version);
2282                 exynos4_jpeg_set_img_addr(ctx);
2283                 exynos4_jpeg_set_jpeg_addr(ctx);
2284
2285                 if (jpeg->variant->version == SJPEG_EXYNOS5433) {
2286                         exynos4_jpeg_parse_huff_tbl(ctx);
2287                         exynos4_jpeg_parse_decode_h_tbl(ctx);
2288
2289                         exynos4_jpeg_parse_q_tbl(ctx);
2290                         exynos4_jpeg_parse_decode_q_tbl(ctx);
2291
2292                         exynos4_jpeg_set_huf_table_enable(jpeg->regs, 1);
2293
2294                         exynos4_jpeg_set_stream_size(jpeg->regs, ctx->cap_q.w,
2295                                         ctx->cap_q.h);
2296                         exynos5433_jpeg_set_enc_out_fmt(jpeg->regs,
2297                                                         ctx->subsampling);
2298                         exynos5433_jpeg_set_img_fmt(jpeg->regs,
2299                                                     ctx->cap_q.fmt->fourcc);
2300                         bitstream_size = DIV_ROUND_UP(ctx->out_q.size, 16);
2301                 } else {
2302                         exynos4_jpeg_set_img_fmt(jpeg->regs,
2303                                                  ctx->cap_q.fmt->fourcc);
2304                         bitstream_size = DIV_ROUND_UP(ctx->out_q.size, 32);
2305                 }
2306
2307                 exynos4_jpeg_set_dec_bitstream_size(jpeg->regs, bitstream_size);
2308         }
2309
2310         exynos4_jpeg_set_sys_int_enable(jpeg->regs, 1);
2311         exynos4_jpeg_set_enc_dec_mode(jpeg->regs, ctx->mode);
2312
2313         spin_unlock_irqrestore(&jpeg->slock, flags);
2314 }
2315
2316 static void exynos3250_jpeg_set_img_addr(struct s5p_jpeg_ctx *ctx)
2317 {
2318         struct s5p_jpeg *jpeg = ctx->jpeg;
2319         struct s5p_jpeg_fmt *fmt;
2320         struct vb2_v4l2_buffer *vb;
2321         struct s5p_jpeg_addr jpeg_addr = {};
2322         u32 pix_size;
2323
2324         pix_size = ctx->cap_q.w * ctx->cap_q.h;
2325
2326         if (ctx->mode == S5P_JPEG_ENCODE) {
2327                 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2328                 fmt = ctx->out_q.fmt;
2329         } else {
2330                 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2331                 fmt = ctx->cap_q.fmt;
2332         }
2333
2334         jpeg_addr.y = vb2_dma_contig_plane_dma_addr(&vb->vb2_buf, 0);
2335
2336         if (fmt->colplanes == 2) {
2337                 jpeg_addr.cb = jpeg_addr.y + pix_size;
2338         } else if (fmt->colplanes == 3) {
2339                 jpeg_addr.cb = jpeg_addr.y + pix_size;
2340                 if (fmt->fourcc == V4L2_PIX_FMT_YUV420)
2341                         jpeg_addr.cr = jpeg_addr.cb + pix_size / 4;
2342                 else
2343                         jpeg_addr.cr = jpeg_addr.cb + pix_size / 2;
2344         }
2345
2346         exynos3250_jpeg_imgadr(jpeg->regs, &jpeg_addr);
2347 }
2348
2349 static void exynos3250_jpeg_set_jpeg_addr(struct s5p_jpeg_ctx *ctx)
2350 {
2351         struct s5p_jpeg *jpeg = ctx->jpeg;
2352         struct vb2_v4l2_buffer *vb;
2353         unsigned int jpeg_addr = 0;
2354
2355         if (ctx->mode == S5P_JPEG_ENCODE)
2356                 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2357         else
2358                 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2359
2360         jpeg_addr = vb2_dma_contig_plane_dma_addr(&vb->vb2_buf, 0);
2361         exynos3250_jpeg_jpgadr(jpeg->regs, jpeg_addr);
2362 }
2363
2364 static void exynos3250_jpeg_device_run(void *priv)
2365 {
2366         struct s5p_jpeg_ctx *ctx = priv;
2367         struct s5p_jpeg *jpeg = ctx->jpeg;
2368         unsigned long flags;
2369
2370         spin_lock_irqsave(&ctx->jpeg->slock, flags);
2371
2372         exynos3250_jpeg_reset(jpeg->regs);
2373         exynos3250_jpeg_set_dma_num(jpeg->regs);
2374         exynos3250_jpeg_poweron(jpeg->regs);
2375         exynos3250_jpeg_clk_set(jpeg->regs);
2376         exynos3250_jpeg_proc_mode(jpeg->regs, ctx->mode);
2377
2378         if (ctx->mode == S5P_JPEG_ENCODE) {
2379                 exynos3250_jpeg_input_raw_fmt(jpeg->regs,
2380                                               ctx->out_q.fmt->fourcc);
2381                 exynos3250_jpeg_dri(jpeg->regs, ctx->restart_interval);
2382
2383                 /*
2384                  * JPEG IP allows storing 4 quantization tables
2385                  * We fill table 0 for luma and table 1 for chroma
2386                  */
2387                 s5p_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality);
2388                 s5p_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality);
2389                 /* use table 0 for Y */
2390                 exynos3250_jpeg_qtbl(jpeg->regs, 1, 0);
2391                 /* use table 1 for Cb and Cr*/
2392                 exynos3250_jpeg_qtbl(jpeg->regs, 2, 1);
2393                 exynos3250_jpeg_qtbl(jpeg->regs, 3, 1);
2394
2395                 /*
2396                  * Some SoCs require setting Huffman tables before each run
2397                  */
2398                 if (jpeg->variant->htbl_reinit) {
2399                         s5p_jpeg_set_hdctbl(jpeg->regs);
2400                         s5p_jpeg_set_hdctblg(jpeg->regs);
2401                         s5p_jpeg_set_hactbl(jpeg->regs);
2402                         s5p_jpeg_set_hactblg(jpeg->regs);
2403                 }
2404
2405                 /* Y, Cb, Cr use Huffman table 0 */
2406                 exynos3250_jpeg_htbl_ac(jpeg->regs, 1);
2407                 exynos3250_jpeg_htbl_dc(jpeg->regs, 1);
2408                 exynos3250_jpeg_htbl_ac(jpeg->regs, 2);
2409                 exynos3250_jpeg_htbl_dc(jpeg->regs, 2);
2410                 exynos3250_jpeg_htbl_ac(jpeg->regs, 3);
2411                 exynos3250_jpeg_htbl_dc(jpeg->regs, 3);
2412
2413                 exynos3250_jpeg_set_x(jpeg->regs, ctx->crop_rect.width);
2414                 exynos3250_jpeg_set_y(jpeg->regs, ctx->crop_rect.height);
2415                 exynos3250_jpeg_stride(jpeg->regs, ctx->out_q.fmt->fourcc,
2416                                                                 ctx->out_q.w);
2417                 exynos3250_jpeg_offset(jpeg->regs, ctx->crop_rect.left,
2418                                                         ctx->crop_rect.top);
2419                 exynos3250_jpeg_set_img_addr(ctx);
2420                 exynos3250_jpeg_set_jpeg_addr(ctx);
2421                 exynos3250_jpeg_subsampling_mode(jpeg->regs, ctx->subsampling);
2422
2423                 /* ultimately comes from sizeimage from userspace */
2424                 exynos3250_jpeg_enc_stream_bound(jpeg->regs, ctx->cap_q.size);
2425
2426                 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565 ||
2427                     ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565X ||
2428                     ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB32)
2429                         exynos3250_jpeg_set_y16(jpeg->regs, true);
2430         } else {
2431                 exynos3250_jpeg_set_img_addr(ctx);
2432                 exynos3250_jpeg_set_jpeg_addr(ctx);
2433                 exynos3250_jpeg_stride(jpeg->regs, ctx->cap_q.fmt->fourcc,
2434                                                                 ctx->cap_q.w);
2435                 exynos3250_jpeg_offset(jpeg->regs, 0, 0);
2436                 exynos3250_jpeg_dec_scaling_ratio(jpeg->regs,
2437                                                         ctx->scale_factor);
2438                 exynos3250_jpeg_dec_stream_size(jpeg->regs, ctx->out_q.size);
2439                 exynos3250_jpeg_output_raw_fmt(jpeg->regs,
2440                                                 ctx->cap_q.fmt->fourcc);
2441         }
2442
2443         exynos3250_jpeg_interrupts_enable(jpeg->regs);
2444
2445         /* JPEG RGB to YCbCr conversion matrix */
2446         exynos3250_jpeg_coef(jpeg->regs, ctx->mode);
2447
2448         exynos3250_jpeg_set_timer(jpeg->regs, EXYNOS3250_IRQ_TIMEOUT);
2449         jpeg->irq_status = 0;
2450         exynos3250_jpeg_start(jpeg->regs);
2451
2452         spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
2453 }
2454
2455 static int s5p_jpeg_job_ready(void *priv)
2456 {
2457         struct s5p_jpeg_ctx *ctx = priv;
2458
2459         if (ctx->mode == S5P_JPEG_DECODE) {
2460                 /*
2461                  * We have only one input buffer and one output buffer. If there
2462                  * is a resolution change event, no need to continue decoding.
2463                  */
2464                 if (ctx->state == JPEGCTX_RESOLUTION_CHANGE)
2465                         return 0;
2466
2467                 return ctx->hdr_parsed;
2468         }
2469
2470         return 1;
2471 }
2472
2473 static void s5p_jpeg_job_abort(void *priv)
2474 {
2475 }
2476
2477 static struct v4l2_m2m_ops s5p_jpeg_m2m_ops = {
2478         .device_run     = s5p_jpeg_device_run,
2479         .job_ready      = s5p_jpeg_job_ready,
2480         .job_abort      = s5p_jpeg_job_abort,
2481 };
2482
2483 static struct v4l2_m2m_ops exynos3250_jpeg_m2m_ops = {
2484         .device_run     = exynos3250_jpeg_device_run,
2485         .job_ready      = s5p_jpeg_job_ready,
2486         .job_abort      = s5p_jpeg_job_abort,
2487 };
2488
2489 static struct v4l2_m2m_ops exynos4_jpeg_m2m_ops = {
2490         .device_run     = exynos4_jpeg_device_run,
2491         .job_ready      = s5p_jpeg_job_ready,
2492         .job_abort      = s5p_jpeg_job_abort,
2493 };
2494
2495 /*
2496  * ============================================================================
2497  * Queue operations
2498  * ============================================================================
2499  */
2500
2501 static int s5p_jpeg_queue_setup(struct vb2_queue *vq,
2502                            unsigned int *nbuffers, unsigned int *nplanes,
2503                            unsigned int sizes[], struct device *alloc_devs[])
2504 {
2505         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vq);
2506         struct s5p_jpeg_q_data *q_data = NULL;
2507         unsigned int size, count = *nbuffers;
2508
2509         q_data = get_q_data(ctx, vq->type);
2510         BUG_ON(q_data == NULL);
2511
2512         size = q_data->size;
2513
2514         /*
2515          * header is parsed during decoding and parsed information stored
2516          * in the context so we do not allow another buffer to overwrite it
2517          */
2518         if (ctx->mode == S5P_JPEG_DECODE)
2519                 count = 1;
2520
2521         *nbuffers = count;
2522         *nplanes = 1;
2523         sizes[0] = size;
2524
2525         return 0;
2526 }
2527
2528 static int s5p_jpeg_buf_prepare(struct vb2_buffer *vb)
2529 {
2530         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
2531         struct s5p_jpeg_q_data *q_data = NULL;
2532
2533         q_data = get_q_data(ctx, vb->vb2_queue->type);
2534         BUG_ON(q_data == NULL);
2535
2536         if (vb2_plane_size(vb, 0) < q_data->size) {
2537                 pr_err("%s data will not fit into plane (%lu < %lu)\n",
2538                                 __func__, vb2_plane_size(vb, 0),
2539                                 (long)q_data->size);
2540                 return -EINVAL;
2541         }
2542
2543         vb2_set_plane_payload(vb, 0, q_data->size);
2544
2545         return 0;
2546 }
2547
2548 static void s5p_jpeg_set_capture_queue_data(struct s5p_jpeg_ctx *ctx)
2549 {
2550         struct s5p_jpeg_q_data *q_data = &ctx->cap_q;
2551
2552         q_data->w = ctx->out_q.w;
2553         q_data->h = ctx->out_q.h;
2554
2555         /*
2556          * This call to jpeg_bound_align_image() takes care of width and
2557          * height values alignment when user space calls the QBUF of
2558          * OUTPUT buffer after the S_FMT of CAPTURE buffer.
2559          * Please note that on Exynos4x12 SoCs, resigning from executing
2560          * S_FMT on capture buffer for each JPEG image can result in a
2561          * hardware hangup if subsampling is lower than the one of input
2562          * JPEG.
2563          */
2564         jpeg_bound_align_image(ctx, &q_data->w, S5P_JPEG_MIN_WIDTH,
2565                                S5P_JPEG_MAX_WIDTH, q_data->fmt->h_align,
2566                                &q_data->h, S5P_JPEG_MIN_HEIGHT,
2567                                S5P_JPEG_MAX_HEIGHT, q_data->fmt->v_align);
2568
2569         q_data->size = q_data->w * q_data->h * q_data->fmt->depth >> 3;
2570 }
2571
2572 static void s5p_jpeg_buf_queue(struct vb2_buffer *vb)
2573 {
2574         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
2575         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
2576
2577         if (ctx->mode == S5P_JPEG_DECODE &&
2578             vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
2579                 static const struct v4l2_event ev_src_ch = {
2580                         .type = V4L2_EVENT_SOURCE_CHANGE,
2581                         .u.src_change.changes = V4L2_EVENT_SRC_CH_RESOLUTION,
2582                 };
2583                 struct vb2_queue *dst_vq;
2584                 u32 ori_w;
2585                 u32 ori_h;
2586
2587                 dst_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx,
2588                                          V4L2_BUF_TYPE_VIDEO_CAPTURE);
2589                 ori_w = ctx->out_q.w;
2590                 ori_h = ctx->out_q.h;
2591
2592                 ctx->hdr_parsed = s5p_jpeg_parse_hdr(&ctx->out_q,
2593                      (unsigned long)vb2_plane_vaddr(vb, 0),
2594                      min((unsigned long)ctx->out_q.size,
2595                          vb2_get_plane_payload(vb, 0)), ctx);
2596                 if (!ctx->hdr_parsed) {
2597                         vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
2598                         return;
2599                 }
2600
2601                 /*
2602                  * If there is a resolution change event, only update capture
2603                  * queue when it is not streaming. Otherwise, update it in
2604                  * STREAMOFF. See s5p_jpeg_stop_streaming for detail.
2605                  */
2606                 if (ctx->out_q.w != ori_w || ctx->out_q.h != ori_h) {
2607                         v4l2_event_queue_fh(&ctx->fh, &ev_src_ch);
2608                         if (vb2_is_streaming(dst_vq))
2609                                 ctx->state = JPEGCTX_RESOLUTION_CHANGE;
2610                         else
2611                                 s5p_jpeg_set_capture_queue_data(ctx);
2612                 }
2613         }
2614
2615         v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
2616 }
2617
2618 static int s5p_jpeg_start_streaming(struct vb2_queue *q, unsigned int count)
2619 {
2620         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q);
2621         int ret;
2622
2623         ret = pm_runtime_get_sync(ctx->jpeg->dev);
2624
2625         return ret > 0 ? 0 : ret;
2626 }
2627
2628 static void s5p_jpeg_stop_streaming(struct vb2_queue *q)
2629 {
2630         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q);
2631
2632         /*
2633          * STREAMOFF is an acknowledgment for resolution change event.
2634          * Before STREAMOFF, we still have to return the old resolution and
2635          * subsampling. Update capture queue when the stream is off.
2636          */
2637         if (ctx->state == JPEGCTX_RESOLUTION_CHANGE &&
2638             q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2639                 s5p_jpeg_set_capture_queue_data(ctx);
2640                 ctx->state = JPEGCTX_RUNNING;
2641         }
2642
2643         pm_runtime_put(ctx->jpeg->dev);
2644 }
2645
2646 static const struct vb2_ops s5p_jpeg_qops = {
2647         .queue_setup            = s5p_jpeg_queue_setup,
2648         .buf_prepare            = s5p_jpeg_buf_prepare,
2649         .buf_queue              = s5p_jpeg_buf_queue,
2650         .wait_prepare           = vb2_ops_wait_prepare,
2651         .wait_finish            = vb2_ops_wait_finish,
2652         .start_streaming        = s5p_jpeg_start_streaming,
2653         .stop_streaming         = s5p_jpeg_stop_streaming,
2654 };
2655
2656 static int queue_init(void *priv, struct vb2_queue *src_vq,
2657                       struct vb2_queue *dst_vq)
2658 {
2659         struct s5p_jpeg_ctx *ctx = priv;
2660         int ret;
2661
2662         src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
2663         src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
2664         src_vq->drv_priv = ctx;
2665         src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
2666         src_vq->ops = &s5p_jpeg_qops;
2667         src_vq->mem_ops = &vb2_dma_contig_memops;
2668         src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
2669         src_vq->lock = &ctx->jpeg->lock;
2670         src_vq->dev = ctx->jpeg->dev;
2671
2672         ret = vb2_queue_init(src_vq);
2673         if (ret)
2674                 return ret;
2675
2676         dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2677         dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;
2678         dst_vq->drv_priv = ctx;
2679         dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
2680         dst_vq->ops = &s5p_jpeg_qops;
2681         dst_vq->mem_ops = &vb2_dma_contig_memops;
2682         dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
2683         dst_vq->lock = &ctx->jpeg->lock;
2684         dst_vq->dev = ctx->jpeg->dev;
2685
2686         return vb2_queue_init(dst_vq);
2687 }
2688
2689 /*
2690  * ============================================================================
2691  * ISR
2692  * ============================================================================
2693  */
2694
2695 static irqreturn_t s5p_jpeg_irq(int irq, void *dev_id)
2696 {
2697         struct s5p_jpeg *jpeg = dev_id;
2698         struct s5p_jpeg_ctx *curr_ctx;
2699         struct vb2_v4l2_buffer *src_buf, *dst_buf;
2700         unsigned long payload_size = 0;
2701         enum vb2_buffer_state state = VB2_BUF_STATE_DONE;
2702         bool enc_jpeg_too_large = false;
2703         bool timer_elapsed = false;
2704         bool op_completed = false;
2705
2706         spin_lock(&jpeg->slock);
2707
2708         curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2709
2710         src_buf = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2711         dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2712
2713         if (curr_ctx->mode == S5P_JPEG_ENCODE)
2714                 enc_jpeg_too_large = s5p_jpeg_enc_stream_stat(jpeg->regs);
2715         timer_elapsed = s5p_jpeg_timer_stat(jpeg->regs);
2716         op_completed = s5p_jpeg_result_stat_ok(jpeg->regs);
2717         if (curr_ctx->mode == S5P_JPEG_DECODE)
2718                 op_completed = op_completed &&
2719                                         s5p_jpeg_stream_stat_ok(jpeg->regs);
2720
2721         if (enc_jpeg_too_large) {
2722                 state = VB2_BUF_STATE_ERROR;
2723                 s5p_jpeg_clear_enc_stream_stat(jpeg->regs);
2724         } else if (timer_elapsed) {
2725                 state = VB2_BUF_STATE_ERROR;
2726                 s5p_jpeg_clear_timer_stat(jpeg->regs);
2727         } else if (!op_completed) {
2728                 state = VB2_BUF_STATE_ERROR;
2729         } else {
2730                 payload_size = s5p_jpeg_compressed_size(jpeg->regs);
2731         }
2732
2733         dst_buf->timecode = src_buf->timecode;
2734         dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp;
2735         dst_buf->flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
2736         dst_buf->flags |=
2737                 src_buf->flags & V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
2738
2739         v4l2_m2m_buf_done(src_buf, state);
2740         if (curr_ctx->mode == S5P_JPEG_ENCODE)
2741                 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload_size);
2742         v4l2_m2m_buf_done(dst_buf, state);
2743
2744         curr_ctx->subsampling = s5p_jpeg_get_subsampling_mode(jpeg->regs);
2745         spin_unlock(&jpeg->slock);
2746
2747         s5p_jpeg_clear_int(jpeg->regs);
2748
2749         v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2750         return IRQ_HANDLED;
2751 }
2752
2753 static irqreturn_t exynos4_jpeg_irq(int irq, void *priv)
2754 {
2755         unsigned int int_status;
2756         struct vb2_v4l2_buffer *src_vb, *dst_vb;
2757         struct s5p_jpeg *jpeg = priv;
2758         struct s5p_jpeg_ctx *curr_ctx;
2759         unsigned long payload_size = 0;
2760
2761         spin_lock(&jpeg->slock);
2762
2763         exynos4_jpeg_set_sys_int_enable(jpeg->regs, 0);
2764
2765         curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2766
2767         src_vb = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2768         dst_vb = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2769
2770         int_status = exynos4_jpeg_get_int_status(jpeg->regs);
2771
2772         if (int_status) {
2773                 switch (int_status & 0x1f) {
2774                 case 0x1:
2775                         jpeg->irq_ret = ERR_PROT;
2776                         break;
2777                 case 0x2:
2778                         jpeg->irq_ret = OK_ENC_OR_DEC;
2779                         break;
2780                 case 0x4:
2781                         jpeg->irq_ret = ERR_DEC_INVALID_FORMAT;
2782                         break;
2783                 case 0x8:
2784                         jpeg->irq_ret = ERR_MULTI_SCAN;
2785                         break;
2786                 case 0x10:
2787                         jpeg->irq_ret = ERR_FRAME;
2788                         break;
2789                 default:
2790                         jpeg->irq_ret = ERR_UNKNOWN;
2791                         break;
2792                 }
2793         } else {
2794                 jpeg->irq_ret = ERR_UNKNOWN;
2795         }
2796
2797         if (jpeg->irq_ret == OK_ENC_OR_DEC) {
2798                 if (curr_ctx->mode == S5P_JPEG_ENCODE) {
2799                         payload_size = exynos4_jpeg_get_stream_size(jpeg->regs);
2800                         vb2_set_plane_payload(&dst_vb->vb2_buf,
2801                                         0, payload_size);
2802                 }
2803                 v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_DONE);
2804                 v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_DONE);
2805         } else {
2806                 v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_ERROR);
2807                 v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_ERROR);
2808         }
2809
2810         if (jpeg->variant->version == SJPEG_EXYNOS4)
2811                 curr_ctx->subsampling = exynos4_jpeg_get_frame_fmt(jpeg->regs);
2812
2813         exynos4_jpeg_set_enc_dec_mode(jpeg->regs, S5P_JPEG_DISABLE);
2814
2815         spin_unlock(&jpeg->slock);
2816
2817         v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2818         return IRQ_HANDLED;
2819 }
2820
2821 static irqreturn_t exynos3250_jpeg_irq(int irq, void *dev_id)
2822 {
2823         struct s5p_jpeg *jpeg = dev_id;
2824         struct s5p_jpeg_ctx *curr_ctx;
2825         struct vb2_v4l2_buffer *src_buf, *dst_buf;
2826         unsigned long payload_size = 0;
2827         enum vb2_buffer_state state = VB2_BUF_STATE_DONE;
2828         bool interrupt_timeout = false;
2829         bool stream_error = false;
2830         u32 irq_status;
2831
2832         spin_lock(&jpeg->slock);
2833
2834         irq_status = exynos3250_jpeg_get_timer_status(jpeg->regs);
2835         if (irq_status & EXYNOS3250_TIMER_INT_STAT) {
2836                 exynos3250_jpeg_clear_timer_status(jpeg->regs);
2837                 interrupt_timeout = true;
2838                 dev_err(jpeg->dev, "Interrupt timeout occurred.\n");
2839         }
2840
2841         irq_status = exynos3250_jpeg_get_int_status(jpeg->regs);
2842         exynos3250_jpeg_clear_int_status(jpeg->regs, irq_status);
2843
2844         jpeg->irq_status |= irq_status;
2845
2846         if (jpeg->variant->version == SJPEG_EXYNOS5420 &&
2847             irq_status & EXYNOS3250_STREAM_STAT) {
2848                 stream_error = true;
2849                 dev_err(jpeg->dev, "Syntax error or unrecoverable error occurred.\n");
2850         }
2851
2852         curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2853
2854         if (!curr_ctx)
2855                 goto exit_unlock;
2856
2857         if ((irq_status & EXYNOS3250_HEADER_STAT) &&
2858             (curr_ctx->mode == S5P_JPEG_DECODE)) {
2859                 exynos3250_jpeg_rstart(jpeg->regs);
2860                 goto exit_unlock;
2861         }
2862
2863         if (jpeg->irq_status & (EXYNOS3250_JPEG_DONE |
2864                                 EXYNOS3250_WDMA_DONE |
2865                                 EXYNOS3250_RDMA_DONE |
2866                                 EXYNOS3250_RESULT_STAT))
2867                 payload_size = exynos3250_jpeg_compressed_size(jpeg->regs);
2868         else if (interrupt_timeout || stream_error)
2869                 state = VB2_BUF_STATE_ERROR;
2870         else
2871                 goto exit_unlock;
2872
2873         src_buf = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2874         dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2875
2876         dst_buf->timecode = src_buf->timecode;
2877         dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp;
2878
2879         v4l2_m2m_buf_done(src_buf, state);
2880         if (curr_ctx->mode == S5P_JPEG_ENCODE)
2881                 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload_size);
2882         v4l2_m2m_buf_done(dst_buf, state);
2883
2884         curr_ctx->subsampling =
2885                         exynos3250_jpeg_get_subsampling_mode(jpeg->regs);
2886
2887         spin_unlock(&jpeg->slock);
2888
2889         v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2890         return IRQ_HANDLED;
2891
2892 exit_unlock:
2893         spin_unlock(&jpeg->slock);
2894         return IRQ_HANDLED;
2895 }
2896
2897 static void *jpeg_get_drv_data(struct device *dev);
2898
2899 /*
2900  * ============================================================================
2901  * Driver basic infrastructure
2902  * ============================================================================
2903  */
2904
2905 static int s5p_jpeg_probe(struct platform_device *pdev)
2906 {
2907         struct s5p_jpeg *jpeg;
2908         struct resource *res;
2909         int i, ret;
2910
2911         /* JPEG IP abstraction struct */
2912         jpeg = devm_kzalloc(&pdev->dev, sizeof(struct s5p_jpeg), GFP_KERNEL);
2913         if (!jpeg)
2914                 return -ENOMEM;
2915
2916         jpeg->variant = jpeg_get_drv_data(&pdev->dev);
2917
2918         mutex_init(&jpeg->lock);
2919         spin_lock_init(&jpeg->slock);
2920         jpeg->dev = &pdev->dev;
2921
2922         /* memory-mapped registers */
2923         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2924
2925         jpeg->regs = devm_ioremap_resource(&pdev->dev, res);
2926         if (IS_ERR(jpeg->regs))
2927                 return PTR_ERR(jpeg->regs);
2928
2929         /* interrupt service routine registration */
2930         jpeg->irq = ret = platform_get_irq(pdev, 0);
2931         if (ret < 0) {
2932                 dev_err(&pdev->dev, "cannot find IRQ\n");
2933                 return ret;
2934         }
2935
2936         ret = devm_request_irq(&pdev->dev, jpeg->irq, jpeg->variant->jpeg_irq,
2937                                 0, dev_name(&pdev->dev), jpeg);
2938         if (ret) {
2939                 dev_err(&pdev->dev, "cannot claim IRQ %d\n", jpeg->irq);
2940                 return ret;
2941         }
2942
2943         /* clocks */
2944         for (i = 0; i < jpeg->variant->num_clocks; i++) {
2945                 jpeg->clocks[i] = devm_clk_get(&pdev->dev,
2946                                               jpeg->variant->clk_names[i]);
2947                 if (IS_ERR(jpeg->clocks[i])) {
2948                         dev_err(&pdev->dev, "failed to get clock: %s\n",
2949                                 jpeg->variant->clk_names[i]);
2950                         return PTR_ERR(jpeg->clocks[i]);
2951                 }
2952         }
2953
2954         /* v4l2 device */
2955         ret = v4l2_device_register(&pdev->dev, &jpeg->v4l2_dev);
2956         if (ret) {
2957                 dev_err(&pdev->dev, "Failed to register v4l2 device\n");
2958                 return ret;
2959         }
2960
2961         /* mem2mem device */
2962         jpeg->m2m_dev = v4l2_m2m_init(jpeg->variant->m2m_ops);
2963         if (IS_ERR(jpeg->m2m_dev)) {
2964                 v4l2_err(&jpeg->v4l2_dev, "Failed to init mem2mem device\n");
2965                 ret = PTR_ERR(jpeg->m2m_dev);
2966                 goto device_register_rollback;
2967         }
2968
2969         vb2_dma_contig_set_max_seg_size(&pdev->dev, DMA_BIT_MASK(32));
2970
2971         /* JPEG encoder /dev/videoX node */
2972         jpeg->vfd_encoder = video_device_alloc();
2973         if (!jpeg->vfd_encoder) {
2974                 v4l2_err(&jpeg->v4l2_dev, "Failed to allocate video device\n");
2975                 ret = -ENOMEM;
2976                 goto m2m_init_rollback;
2977         }
2978         snprintf(jpeg->vfd_encoder->name, sizeof(jpeg->vfd_encoder->name),
2979                                 "%s-enc", S5P_JPEG_M2M_NAME);
2980         jpeg->vfd_encoder->fops         = &s5p_jpeg_fops;
2981         jpeg->vfd_encoder->ioctl_ops    = &s5p_jpeg_ioctl_ops;
2982         jpeg->vfd_encoder->minor        = -1;
2983         jpeg->vfd_encoder->release      = video_device_release;
2984         jpeg->vfd_encoder->lock         = &jpeg->lock;
2985         jpeg->vfd_encoder->v4l2_dev     = &jpeg->v4l2_dev;
2986         jpeg->vfd_encoder->vfl_dir      = VFL_DIR_M2M;
2987
2988         ret = video_register_device(jpeg->vfd_encoder, VFL_TYPE_GRABBER, -1);
2989         if (ret) {
2990                 v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n");
2991                 video_device_release(jpeg->vfd_encoder);
2992                 goto m2m_init_rollback;
2993         }
2994
2995         video_set_drvdata(jpeg->vfd_encoder, jpeg);
2996         v4l2_info(&jpeg->v4l2_dev,
2997                   "encoder device registered as /dev/video%d\n",
2998                   jpeg->vfd_encoder->num);
2999
3000         /* JPEG decoder /dev/videoX node */
3001         jpeg->vfd_decoder = video_device_alloc();
3002         if (!jpeg->vfd_decoder) {
3003                 v4l2_err(&jpeg->v4l2_dev, "Failed to allocate video device\n");
3004                 ret = -ENOMEM;
3005                 goto enc_vdev_register_rollback;
3006         }
3007         snprintf(jpeg->vfd_decoder->name, sizeof(jpeg->vfd_decoder->name),
3008                                 "%s-dec", S5P_JPEG_M2M_NAME);
3009         jpeg->vfd_decoder->fops         = &s5p_jpeg_fops;
3010         jpeg->vfd_decoder->ioctl_ops    = &s5p_jpeg_ioctl_ops;
3011         jpeg->vfd_decoder->minor        = -1;
3012         jpeg->vfd_decoder->release      = video_device_release;
3013         jpeg->vfd_decoder->lock         = &jpeg->lock;
3014         jpeg->vfd_decoder->v4l2_dev     = &jpeg->v4l2_dev;
3015         jpeg->vfd_decoder->vfl_dir      = VFL_DIR_M2M;
3016
3017         ret = video_register_device(jpeg->vfd_decoder, VFL_TYPE_GRABBER, -1);
3018         if (ret) {
3019                 v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n");
3020                 video_device_release(jpeg->vfd_decoder);
3021                 goto enc_vdev_register_rollback;
3022         }
3023
3024         video_set_drvdata(jpeg->vfd_decoder, jpeg);
3025         v4l2_info(&jpeg->v4l2_dev,
3026                   "decoder device registered as /dev/video%d\n",
3027                   jpeg->vfd_decoder->num);
3028
3029         /* final statements & power management */
3030         platform_set_drvdata(pdev, jpeg);
3031
3032         pm_runtime_enable(&pdev->dev);
3033
3034         v4l2_info(&jpeg->v4l2_dev, "Samsung S5P JPEG codec\n");
3035
3036         return 0;
3037
3038 enc_vdev_register_rollback:
3039         video_unregister_device(jpeg->vfd_encoder);
3040
3041 m2m_init_rollback:
3042         v4l2_m2m_release(jpeg->m2m_dev);
3043
3044 device_register_rollback:
3045         v4l2_device_unregister(&jpeg->v4l2_dev);
3046
3047         return ret;
3048 }
3049
3050 static int s5p_jpeg_remove(struct platform_device *pdev)
3051 {
3052         struct s5p_jpeg *jpeg = platform_get_drvdata(pdev);
3053         int i;
3054
3055         pm_runtime_disable(jpeg->dev);
3056
3057         video_unregister_device(jpeg->vfd_decoder);
3058         video_unregister_device(jpeg->vfd_encoder);
3059         vb2_dma_contig_clear_max_seg_size(&pdev->dev);
3060         v4l2_m2m_release(jpeg->m2m_dev);
3061         v4l2_device_unregister(&jpeg->v4l2_dev);
3062
3063         if (!pm_runtime_status_suspended(&pdev->dev)) {
3064                 for (i = jpeg->variant->num_clocks - 1; i >= 0; i--)
3065                         clk_disable_unprepare(jpeg->clocks[i]);
3066         }
3067
3068         return 0;
3069 }
3070
3071 #ifdef CONFIG_PM
3072 static int s5p_jpeg_runtime_suspend(struct device *dev)
3073 {
3074         struct s5p_jpeg *jpeg = dev_get_drvdata(dev);
3075         int i;
3076
3077         for (i = jpeg->variant->num_clocks - 1; i >= 0; i--)
3078                 clk_disable_unprepare(jpeg->clocks[i]);
3079
3080         return 0;
3081 }
3082
3083 static int s5p_jpeg_runtime_resume(struct device *dev)
3084 {
3085         struct s5p_jpeg *jpeg = dev_get_drvdata(dev);
3086         unsigned long flags;
3087         int i, ret;
3088
3089         for (i = 0; i < jpeg->variant->num_clocks; i++) {
3090                 ret = clk_prepare_enable(jpeg->clocks[i]);
3091                 if (ret) {
3092                         while (--i > 0)
3093                                 clk_disable_unprepare(jpeg->clocks[i]);
3094                         return ret;
3095                 }
3096         }
3097
3098         spin_lock_irqsave(&jpeg->slock, flags);
3099
3100         /*
3101          * JPEG IP allows storing two Huffman tables for each component.
3102          * We fill table 0 for each component and do this here only
3103          * for S5PC210 and Exynos3250 SoCs. Exynos4x12 and Exynos542x SoC
3104          * require programming their Huffman tables each time the encoding
3105          * process is initialized, and thus it is accomplished in the
3106          * device_run callback of m2m_ops.
3107          */
3108         if (!jpeg->variant->htbl_reinit) {
3109                 s5p_jpeg_set_hdctbl(jpeg->regs);
3110                 s5p_jpeg_set_hdctblg(jpeg->regs);
3111                 s5p_jpeg_set_hactbl(jpeg->regs);
3112                 s5p_jpeg_set_hactblg(jpeg->regs);
3113         }
3114
3115         spin_unlock_irqrestore(&jpeg->slock, flags);
3116
3117         return 0;
3118 }
3119 #endif /* CONFIG_PM */
3120
3121 static const struct dev_pm_ops s5p_jpeg_pm_ops = {
3122         SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
3123                                 pm_runtime_force_resume)
3124         SET_RUNTIME_PM_OPS(s5p_jpeg_runtime_suspend, s5p_jpeg_runtime_resume,
3125                            NULL)
3126 };
3127
3128 static struct s5p_jpeg_variant s5p_jpeg_drvdata = {
3129         .version        = SJPEG_S5P,
3130         .jpeg_irq       = s5p_jpeg_irq,
3131         .m2m_ops        = &s5p_jpeg_m2m_ops,
3132         .fmt_ver_flag   = SJPEG_FMT_FLAG_S5P,
3133         .clk_names      = {"jpeg"},
3134         .num_clocks     = 1,
3135 };
3136
3137 static struct s5p_jpeg_variant exynos3250_jpeg_drvdata = {
3138         .version        = SJPEG_EXYNOS3250,
3139         .jpeg_irq       = exynos3250_jpeg_irq,
3140         .m2m_ops        = &exynos3250_jpeg_m2m_ops,
3141         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS3250,
3142         .hw3250_compat  = 1,
3143         .clk_names      = {"jpeg", "sclk"},
3144         .num_clocks     = 2,
3145 };
3146
3147 static struct s5p_jpeg_variant exynos4_jpeg_drvdata = {
3148         .version        = SJPEG_EXYNOS4,
3149         .jpeg_irq       = exynos4_jpeg_irq,
3150         .m2m_ops        = &exynos4_jpeg_m2m_ops,
3151         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS4,
3152         .htbl_reinit    = 1,
3153         .clk_names      = {"jpeg"},
3154         .num_clocks     = 1,
3155         .hw_ex4_compat  = 1,
3156 };
3157
3158 static struct s5p_jpeg_variant exynos5420_jpeg_drvdata = {
3159         .version        = SJPEG_EXYNOS5420,
3160         .jpeg_irq       = exynos3250_jpeg_irq,          /* intentionally 3250 */
3161         .m2m_ops        = &exynos3250_jpeg_m2m_ops,     /* intentionally 3250 */
3162         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS3250,    /* intentionally 3250 */
3163         .hw3250_compat  = 1,
3164         .htbl_reinit    = 1,
3165         .clk_names      = {"jpeg"},
3166         .num_clocks     = 1,
3167 };
3168
3169 static struct s5p_jpeg_variant exynos5433_jpeg_drvdata = {
3170         .version        = SJPEG_EXYNOS5433,
3171         .jpeg_irq       = exynos4_jpeg_irq,
3172         .m2m_ops        = &exynos4_jpeg_m2m_ops,
3173         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS4,
3174         .htbl_reinit    = 1,
3175         .clk_names      = {"pclk", "aclk", "aclk_xiu", "sclk"},
3176         .num_clocks     = 4,
3177         .hw_ex4_compat  = 1,
3178 };
3179
3180 static const struct of_device_id samsung_jpeg_match[] = {
3181         {
3182                 .compatible = "samsung,s5pv210-jpeg",
3183                 .data = &s5p_jpeg_drvdata,
3184         }, {
3185                 .compatible = "samsung,exynos3250-jpeg",
3186                 .data = &exynos3250_jpeg_drvdata,
3187         }, {
3188                 .compatible = "samsung,exynos4210-jpeg",
3189                 .data = &exynos4_jpeg_drvdata,
3190         }, {
3191                 .compatible = "samsung,exynos4212-jpeg",
3192                 .data = &exynos4_jpeg_drvdata,
3193         }, {
3194                 .compatible = "samsung,exynos5420-jpeg",
3195                 .data = &exynos5420_jpeg_drvdata,
3196         }, {
3197                 .compatible = "samsung,exynos5433-jpeg",
3198                 .data = &exynos5433_jpeg_drvdata,
3199         },
3200         {},
3201 };
3202
3203 MODULE_DEVICE_TABLE(of, samsung_jpeg_match);
3204
3205 static void *jpeg_get_drv_data(struct device *dev)
3206 {
3207         struct s5p_jpeg_variant *driver_data = NULL;
3208         const struct of_device_id *match;
3209
3210         if (!IS_ENABLED(CONFIG_OF) || !dev->of_node)
3211                 return &s5p_jpeg_drvdata;
3212
3213         match = of_match_node(samsung_jpeg_match, dev->of_node);
3214
3215         if (match)
3216                 driver_data = (struct s5p_jpeg_variant *)match->data;
3217
3218         return driver_data;
3219 }
3220
3221 static struct platform_driver s5p_jpeg_driver = {
3222         .probe = s5p_jpeg_probe,
3223         .remove = s5p_jpeg_remove,
3224         .driver = {
3225                 .of_match_table = of_match_ptr(samsung_jpeg_match),
3226                 .name           = S5P_JPEG_M2M_NAME,
3227                 .pm             = &s5p_jpeg_pm_ops,
3228         },
3229 };
3230
3231 module_platform_driver(s5p_jpeg_driver);
3232
3233 MODULE_AUTHOR("Andrzej Pietrasiewicz <andrzej.p@samsung.com>");
3234 MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>");
3235 MODULE_DESCRIPTION("Samsung JPEG codec driver");
3236 MODULE_LICENSE("GPL");