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 struct v4l2_m2m_ops s5p_jpeg_m2m_ops = {
2474         .device_run     = s5p_jpeg_device_run,
2475         .job_ready      = s5p_jpeg_job_ready,
2476 };
2477
2478 static struct v4l2_m2m_ops exynos3250_jpeg_m2m_ops = {
2479         .device_run     = exynos3250_jpeg_device_run,
2480         .job_ready      = s5p_jpeg_job_ready,
2481 };
2482
2483 static struct v4l2_m2m_ops exynos4_jpeg_m2m_ops = {
2484         .device_run     = exynos4_jpeg_device_run,
2485         .job_ready      = s5p_jpeg_job_ready,
2486 };
2487
2488 /*
2489  * ============================================================================
2490  * Queue operations
2491  * ============================================================================
2492  */
2493
2494 static int s5p_jpeg_queue_setup(struct vb2_queue *vq,
2495                            unsigned int *nbuffers, unsigned int *nplanes,
2496                            unsigned int sizes[], struct device *alloc_devs[])
2497 {
2498         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vq);
2499         struct s5p_jpeg_q_data *q_data = NULL;
2500         unsigned int size, count = *nbuffers;
2501
2502         q_data = get_q_data(ctx, vq->type);
2503         BUG_ON(q_data == NULL);
2504
2505         size = q_data->size;
2506
2507         /*
2508          * header is parsed during decoding and parsed information stored
2509          * in the context so we do not allow another buffer to overwrite it
2510          */
2511         if (ctx->mode == S5P_JPEG_DECODE)
2512                 count = 1;
2513
2514         *nbuffers = count;
2515         *nplanes = 1;
2516         sizes[0] = size;
2517
2518         return 0;
2519 }
2520
2521 static int s5p_jpeg_buf_prepare(struct vb2_buffer *vb)
2522 {
2523         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
2524         struct s5p_jpeg_q_data *q_data = NULL;
2525
2526         q_data = get_q_data(ctx, vb->vb2_queue->type);
2527         BUG_ON(q_data == NULL);
2528
2529         if (vb2_plane_size(vb, 0) < q_data->size) {
2530                 pr_err("%s data will not fit into plane (%lu < %lu)\n",
2531                                 __func__, vb2_plane_size(vb, 0),
2532                                 (long)q_data->size);
2533                 return -EINVAL;
2534         }
2535
2536         vb2_set_plane_payload(vb, 0, q_data->size);
2537
2538         return 0;
2539 }
2540
2541 static void s5p_jpeg_set_capture_queue_data(struct s5p_jpeg_ctx *ctx)
2542 {
2543         struct s5p_jpeg_q_data *q_data = &ctx->cap_q;
2544
2545         q_data->w = ctx->out_q.w;
2546         q_data->h = ctx->out_q.h;
2547
2548         /*
2549          * This call to jpeg_bound_align_image() takes care of width and
2550          * height values alignment when user space calls the QBUF of
2551          * OUTPUT buffer after the S_FMT of CAPTURE buffer.
2552          * Please note that on Exynos4x12 SoCs, resigning from executing
2553          * S_FMT on capture buffer for each JPEG image can result in a
2554          * hardware hangup if subsampling is lower than the one of input
2555          * JPEG.
2556          */
2557         jpeg_bound_align_image(ctx, &q_data->w, S5P_JPEG_MIN_WIDTH,
2558                                S5P_JPEG_MAX_WIDTH, q_data->fmt->h_align,
2559                                &q_data->h, S5P_JPEG_MIN_HEIGHT,
2560                                S5P_JPEG_MAX_HEIGHT, q_data->fmt->v_align);
2561
2562         q_data->size = q_data->w * q_data->h * q_data->fmt->depth >> 3;
2563 }
2564
2565 static void s5p_jpeg_buf_queue(struct vb2_buffer *vb)
2566 {
2567         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
2568         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
2569
2570         if (ctx->mode == S5P_JPEG_DECODE &&
2571             vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
2572                 static const struct v4l2_event ev_src_ch = {
2573                         .type = V4L2_EVENT_SOURCE_CHANGE,
2574                         .u.src_change.changes = V4L2_EVENT_SRC_CH_RESOLUTION,
2575                 };
2576                 struct vb2_queue *dst_vq;
2577                 u32 ori_w;
2578                 u32 ori_h;
2579
2580                 dst_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx,
2581                                          V4L2_BUF_TYPE_VIDEO_CAPTURE);
2582                 ori_w = ctx->out_q.w;
2583                 ori_h = ctx->out_q.h;
2584
2585                 ctx->hdr_parsed = s5p_jpeg_parse_hdr(&ctx->out_q,
2586                      (unsigned long)vb2_plane_vaddr(vb, 0),
2587                      min((unsigned long)ctx->out_q.size,
2588                          vb2_get_plane_payload(vb, 0)), ctx);
2589                 if (!ctx->hdr_parsed) {
2590                         vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
2591                         return;
2592                 }
2593
2594                 /*
2595                  * If there is a resolution change event, only update capture
2596                  * queue when it is not streaming. Otherwise, update it in
2597                  * STREAMOFF. See s5p_jpeg_stop_streaming for detail.
2598                  */
2599                 if (ctx->out_q.w != ori_w || ctx->out_q.h != ori_h) {
2600                         v4l2_event_queue_fh(&ctx->fh, &ev_src_ch);
2601                         if (vb2_is_streaming(dst_vq))
2602                                 ctx->state = JPEGCTX_RESOLUTION_CHANGE;
2603                         else
2604                                 s5p_jpeg_set_capture_queue_data(ctx);
2605                 }
2606         }
2607
2608         v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
2609 }
2610
2611 static int s5p_jpeg_start_streaming(struct vb2_queue *q, unsigned int count)
2612 {
2613         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q);
2614         int ret;
2615
2616         ret = pm_runtime_get_sync(ctx->jpeg->dev);
2617
2618         return ret > 0 ? 0 : ret;
2619 }
2620
2621 static void s5p_jpeg_stop_streaming(struct vb2_queue *q)
2622 {
2623         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q);
2624
2625         /*
2626          * STREAMOFF is an acknowledgment for resolution change event.
2627          * Before STREAMOFF, we still have to return the old resolution and
2628          * subsampling. Update capture queue when the stream is off.
2629          */
2630         if (ctx->state == JPEGCTX_RESOLUTION_CHANGE &&
2631             q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2632                 s5p_jpeg_set_capture_queue_data(ctx);
2633                 ctx->state = JPEGCTX_RUNNING;
2634         }
2635
2636         pm_runtime_put(ctx->jpeg->dev);
2637 }
2638
2639 static const struct vb2_ops s5p_jpeg_qops = {
2640         .queue_setup            = s5p_jpeg_queue_setup,
2641         .buf_prepare            = s5p_jpeg_buf_prepare,
2642         .buf_queue              = s5p_jpeg_buf_queue,
2643         .wait_prepare           = vb2_ops_wait_prepare,
2644         .wait_finish            = vb2_ops_wait_finish,
2645         .start_streaming        = s5p_jpeg_start_streaming,
2646         .stop_streaming         = s5p_jpeg_stop_streaming,
2647 };
2648
2649 static int queue_init(void *priv, struct vb2_queue *src_vq,
2650                       struct vb2_queue *dst_vq)
2651 {
2652         struct s5p_jpeg_ctx *ctx = priv;
2653         int ret;
2654
2655         src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
2656         src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
2657         src_vq->drv_priv = ctx;
2658         src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
2659         src_vq->ops = &s5p_jpeg_qops;
2660         src_vq->mem_ops = &vb2_dma_contig_memops;
2661         src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
2662         src_vq->lock = &ctx->jpeg->lock;
2663         src_vq->dev = ctx->jpeg->dev;
2664
2665         ret = vb2_queue_init(src_vq);
2666         if (ret)
2667                 return ret;
2668
2669         dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2670         dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;
2671         dst_vq->drv_priv = ctx;
2672         dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
2673         dst_vq->ops = &s5p_jpeg_qops;
2674         dst_vq->mem_ops = &vb2_dma_contig_memops;
2675         dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
2676         dst_vq->lock = &ctx->jpeg->lock;
2677         dst_vq->dev = ctx->jpeg->dev;
2678
2679         return vb2_queue_init(dst_vq);
2680 }
2681
2682 /*
2683  * ============================================================================
2684  * ISR
2685  * ============================================================================
2686  */
2687
2688 static irqreturn_t s5p_jpeg_irq(int irq, void *dev_id)
2689 {
2690         struct s5p_jpeg *jpeg = dev_id;
2691         struct s5p_jpeg_ctx *curr_ctx;
2692         struct vb2_v4l2_buffer *src_buf, *dst_buf;
2693         unsigned long payload_size = 0;
2694         enum vb2_buffer_state state = VB2_BUF_STATE_DONE;
2695         bool enc_jpeg_too_large = false;
2696         bool timer_elapsed = false;
2697         bool op_completed = false;
2698
2699         spin_lock(&jpeg->slock);
2700
2701         curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2702
2703         src_buf = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2704         dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2705
2706         if (curr_ctx->mode == S5P_JPEG_ENCODE)
2707                 enc_jpeg_too_large = s5p_jpeg_enc_stream_stat(jpeg->regs);
2708         timer_elapsed = s5p_jpeg_timer_stat(jpeg->regs);
2709         op_completed = s5p_jpeg_result_stat_ok(jpeg->regs);
2710         if (curr_ctx->mode == S5P_JPEG_DECODE)
2711                 op_completed = op_completed &&
2712                                         s5p_jpeg_stream_stat_ok(jpeg->regs);
2713
2714         if (enc_jpeg_too_large) {
2715                 state = VB2_BUF_STATE_ERROR;
2716                 s5p_jpeg_clear_enc_stream_stat(jpeg->regs);
2717         } else if (timer_elapsed) {
2718                 state = VB2_BUF_STATE_ERROR;
2719                 s5p_jpeg_clear_timer_stat(jpeg->regs);
2720         } else if (!op_completed) {
2721                 state = VB2_BUF_STATE_ERROR;
2722         } else {
2723                 payload_size = s5p_jpeg_compressed_size(jpeg->regs);
2724         }
2725
2726         dst_buf->timecode = src_buf->timecode;
2727         dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp;
2728         dst_buf->flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
2729         dst_buf->flags |=
2730                 src_buf->flags & V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
2731
2732         v4l2_m2m_buf_done(src_buf, state);
2733         if (curr_ctx->mode == S5P_JPEG_ENCODE)
2734                 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload_size);
2735         v4l2_m2m_buf_done(dst_buf, state);
2736
2737         curr_ctx->subsampling = s5p_jpeg_get_subsampling_mode(jpeg->regs);
2738         spin_unlock(&jpeg->slock);
2739
2740         s5p_jpeg_clear_int(jpeg->regs);
2741
2742         v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2743         return IRQ_HANDLED;
2744 }
2745
2746 static irqreturn_t exynos4_jpeg_irq(int irq, void *priv)
2747 {
2748         unsigned int int_status;
2749         struct vb2_v4l2_buffer *src_vb, *dst_vb;
2750         struct s5p_jpeg *jpeg = priv;
2751         struct s5p_jpeg_ctx *curr_ctx;
2752         unsigned long payload_size = 0;
2753
2754         spin_lock(&jpeg->slock);
2755
2756         exynos4_jpeg_set_sys_int_enable(jpeg->regs, 0);
2757
2758         curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2759
2760         src_vb = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2761         dst_vb = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2762
2763         int_status = exynos4_jpeg_get_int_status(jpeg->regs);
2764
2765         if (int_status) {
2766                 switch (int_status & 0x1f) {
2767                 case 0x1:
2768                         jpeg->irq_ret = ERR_PROT;
2769                         break;
2770                 case 0x2:
2771                         jpeg->irq_ret = OK_ENC_OR_DEC;
2772                         break;
2773                 case 0x4:
2774                         jpeg->irq_ret = ERR_DEC_INVALID_FORMAT;
2775                         break;
2776                 case 0x8:
2777                         jpeg->irq_ret = ERR_MULTI_SCAN;
2778                         break;
2779                 case 0x10:
2780                         jpeg->irq_ret = ERR_FRAME;
2781                         break;
2782                 default:
2783                         jpeg->irq_ret = ERR_UNKNOWN;
2784                         break;
2785                 }
2786         } else {
2787                 jpeg->irq_ret = ERR_UNKNOWN;
2788         }
2789
2790         if (jpeg->irq_ret == OK_ENC_OR_DEC) {
2791                 if (curr_ctx->mode == S5P_JPEG_ENCODE) {
2792                         payload_size = exynos4_jpeg_get_stream_size(jpeg->regs);
2793                         vb2_set_plane_payload(&dst_vb->vb2_buf,
2794                                         0, payload_size);
2795                 }
2796                 v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_DONE);
2797                 v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_DONE);
2798         } else {
2799                 v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_ERROR);
2800                 v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_ERROR);
2801         }
2802
2803         if (jpeg->variant->version == SJPEG_EXYNOS4)
2804                 curr_ctx->subsampling = exynos4_jpeg_get_frame_fmt(jpeg->regs);
2805
2806         exynos4_jpeg_set_enc_dec_mode(jpeg->regs, S5P_JPEG_DISABLE);
2807
2808         spin_unlock(&jpeg->slock);
2809
2810         v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2811         return IRQ_HANDLED;
2812 }
2813
2814 static irqreturn_t exynos3250_jpeg_irq(int irq, void *dev_id)
2815 {
2816         struct s5p_jpeg *jpeg = dev_id;
2817         struct s5p_jpeg_ctx *curr_ctx;
2818         struct vb2_v4l2_buffer *src_buf, *dst_buf;
2819         unsigned long payload_size = 0;
2820         enum vb2_buffer_state state = VB2_BUF_STATE_DONE;
2821         bool interrupt_timeout = false;
2822         bool stream_error = false;
2823         u32 irq_status;
2824
2825         spin_lock(&jpeg->slock);
2826
2827         irq_status = exynos3250_jpeg_get_timer_status(jpeg->regs);
2828         if (irq_status & EXYNOS3250_TIMER_INT_STAT) {
2829                 exynos3250_jpeg_clear_timer_status(jpeg->regs);
2830                 interrupt_timeout = true;
2831                 dev_err(jpeg->dev, "Interrupt timeout occurred.\n");
2832         }
2833
2834         irq_status = exynos3250_jpeg_get_int_status(jpeg->regs);
2835         exynos3250_jpeg_clear_int_status(jpeg->regs, irq_status);
2836
2837         jpeg->irq_status |= irq_status;
2838
2839         if (jpeg->variant->version == SJPEG_EXYNOS5420 &&
2840             irq_status & EXYNOS3250_STREAM_STAT) {
2841                 stream_error = true;
2842                 dev_err(jpeg->dev, "Syntax error or unrecoverable error occurred.\n");
2843         }
2844
2845         curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2846
2847         if (!curr_ctx)
2848                 goto exit_unlock;
2849
2850         if ((irq_status & EXYNOS3250_HEADER_STAT) &&
2851             (curr_ctx->mode == S5P_JPEG_DECODE)) {
2852                 exynos3250_jpeg_rstart(jpeg->regs);
2853                 goto exit_unlock;
2854         }
2855
2856         if (jpeg->irq_status & (EXYNOS3250_JPEG_DONE |
2857                                 EXYNOS3250_WDMA_DONE |
2858                                 EXYNOS3250_RDMA_DONE |
2859                                 EXYNOS3250_RESULT_STAT))
2860                 payload_size = exynos3250_jpeg_compressed_size(jpeg->regs);
2861         else if (interrupt_timeout || stream_error)
2862                 state = VB2_BUF_STATE_ERROR;
2863         else
2864                 goto exit_unlock;
2865
2866         src_buf = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2867         dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2868
2869         dst_buf->timecode = src_buf->timecode;
2870         dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp;
2871
2872         v4l2_m2m_buf_done(src_buf, state);
2873         if (curr_ctx->mode == S5P_JPEG_ENCODE)
2874                 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload_size);
2875         v4l2_m2m_buf_done(dst_buf, state);
2876
2877         curr_ctx->subsampling =
2878                         exynos3250_jpeg_get_subsampling_mode(jpeg->regs);
2879
2880         spin_unlock(&jpeg->slock);
2881
2882         v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2883         return IRQ_HANDLED;
2884
2885 exit_unlock:
2886         spin_unlock(&jpeg->slock);
2887         return IRQ_HANDLED;
2888 }
2889
2890 static void *jpeg_get_drv_data(struct device *dev);
2891
2892 /*
2893  * ============================================================================
2894  * Driver basic infrastructure
2895  * ============================================================================
2896  */
2897
2898 static int s5p_jpeg_probe(struct platform_device *pdev)
2899 {
2900         struct s5p_jpeg *jpeg;
2901         struct resource *res;
2902         int i, ret;
2903
2904         /* JPEG IP abstraction struct */
2905         jpeg = devm_kzalloc(&pdev->dev, sizeof(struct s5p_jpeg), GFP_KERNEL);
2906         if (!jpeg)
2907                 return -ENOMEM;
2908
2909         jpeg->variant = jpeg_get_drv_data(&pdev->dev);
2910
2911         mutex_init(&jpeg->lock);
2912         spin_lock_init(&jpeg->slock);
2913         jpeg->dev = &pdev->dev;
2914
2915         /* memory-mapped registers */
2916         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2917
2918         jpeg->regs = devm_ioremap_resource(&pdev->dev, res);
2919         if (IS_ERR(jpeg->regs))
2920                 return PTR_ERR(jpeg->regs);
2921
2922         /* interrupt service routine registration */
2923         jpeg->irq = ret = platform_get_irq(pdev, 0);
2924         if (ret < 0) {
2925                 dev_err(&pdev->dev, "cannot find IRQ\n");
2926                 return ret;
2927         }
2928
2929         ret = devm_request_irq(&pdev->dev, jpeg->irq, jpeg->variant->jpeg_irq,
2930                                 0, dev_name(&pdev->dev), jpeg);
2931         if (ret) {
2932                 dev_err(&pdev->dev, "cannot claim IRQ %d\n", jpeg->irq);
2933                 return ret;
2934         }
2935
2936         /* clocks */
2937         for (i = 0; i < jpeg->variant->num_clocks; i++) {
2938                 jpeg->clocks[i] = devm_clk_get(&pdev->dev,
2939                                               jpeg->variant->clk_names[i]);
2940                 if (IS_ERR(jpeg->clocks[i])) {
2941                         dev_err(&pdev->dev, "failed to get clock: %s\n",
2942                                 jpeg->variant->clk_names[i]);
2943                         return PTR_ERR(jpeg->clocks[i]);
2944                 }
2945         }
2946
2947         /* v4l2 device */
2948         ret = v4l2_device_register(&pdev->dev, &jpeg->v4l2_dev);
2949         if (ret) {
2950                 dev_err(&pdev->dev, "Failed to register v4l2 device\n");
2951                 return ret;
2952         }
2953
2954         /* mem2mem device */
2955         jpeg->m2m_dev = v4l2_m2m_init(jpeg->variant->m2m_ops);
2956         if (IS_ERR(jpeg->m2m_dev)) {
2957                 v4l2_err(&jpeg->v4l2_dev, "Failed to init mem2mem device\n");
2958                 ret = PTR_ERR(jpeg->m2m_dev);
2959                 goto device_register_rollback;
2960         }
2961
2962         vb2_dma_contig_set_max_seg_size(&pdev->dev, DMA_BIT_MASK(32));
2963
2964         /* JPEG encoder /dev/videoX node */
2965         jpeg->vfd_encoder = video_device_alloc();
2966         if (!jpeg->vfd_encoder) {
2967                 v4l2_err(&jpeg->v4l2_dev, "Failed to allocate video device\n");
2968                 ret = -ENOMEM;
2969                 goto m2m_init_rollback;
2970         }
2971         snprintf(jpeg->vfd_encoder->name, sizeof(jpeg->vfd_encoder->name),
2972                                 "%s-enc", S5P_JPEG_M2M_NAME);
2973         jpeg->vfd_encoder->fops         = &s5p_jpeg_fops;
2974         jpeg->vfd_encoder->ioctl_ops    = &s5p_jpeg_ioctl_ops;
2975         jpeg->vfd_encoder->minor        = -1;
2976         jpeg->vfd_encoder->release      = video_device_release;
2977         jpeg->vfd_encoder->lock         = &jpeg->lock;
2978         jpeg->vfd_encoder->v4l2_dev     = &jpeg->v4l2_dev;
2979         jpeg->vfd_encoder->vfl_dir      = VFL_DIR_M2M;
2980
2981         ret = video_register_device(jpeg->vfd_encoder, VFL_TYPE_GRABBER, -1);
2982         if (ret) {
2983                 v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n");
2984                 video_device_release(jpeg->vfd_encoder);
2985                 goto m2m_init_rollback;
2986         }
2987
2988         video_set_drvdata(jpeg->vfd_encoder, jpeg);
2989         v4l2_info(&jpeg->v4l2_dev,
2990                   "encoder device registered as /dev/video%d\n",
2991                   jpeg->vfd_encoder->num);
2992
2993         /* JPEG decoder /dev/videoX node */
2994         jpeg->vfd_decoder = video_device_alloc();
2995         if (!jpeg->vfd_decoder) {
2996                 v4l2_err(&jpeg->v4l2_dev, "Failed to allocate video device\n");
2997                 ret = -ENOMEM;
2998                 goto enc_vdev_register_rollback;
2999         }
3000         snprintf(jpeg->vfd_decoder->name, sizeof(jpeg->vfd_decoder->name),
3001                                 "%s-dec", S5P_JPEG_M2M_NAME);
3002         jpeg->vfd_decoder->fops         = &s5p_jpeg_fops;
3003         jpeg->vfd_decoder->ioctl_ops    = &s5p_jpeg_ioctl_ops;
3004         jpeg->vfd_decoder->minor        = -1;
3005         jpeg->vfd_decoder->release      = video_device_release;
3006         jpeg->vfd_decoder->lock         = &jpeg->lock;
3007         jpeg->vfd_decoder->v4l2_dev     = &jpeg->v4l2_dev;
3008         jpeg->vfd_decoder->vfl_dir      = VFL_DIR_M2M;
3009
3010         ret = video_register_device(jpeg->vfd_decoder, VFL_TYPE_GRABBER, -1);
3011         if (ret) {
3012                 v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n");
3013                 video_device_release(jpeg->vfd_decoder);
3014                 goto enc_vdev_register_rollback;
3015         }
3016
3017         video_set_drvdata(jpeg->vfd_decoder, jpeg);
3018         v4l2_info(&jpeg->v4l2_dev,
3019                   "decoder device registered as /dev/video%d\n",
3020                   jpeg->vfd_decoder->num);
3021
3022         /* final statements & power management */
3023         platform_set_drvdata(pdev, jpeg);
3024
3025         pm_runtime_enable(&pdev->dev);
3026
3027         v4l2_info(&jpeg->v4l2_dev, "Samsung S5P JPEG codec\n");
3028
3029         return 0;
3030
3031 enc_vdev_register_rollback:
3032         video_unregister_device(jpeg->vfd_encoder);
3033
3034 m2m_init_rollback:
3035         v4l2_m2m_release(jpeg->m2m_dev);
3036
3037 device_register_rollback:
3038         v4l2_device_unregister(&jpeg->v4l2_dev);
3039
3040         return ret;
3041 }
3042
3043 static int s5p_jpeg_remove(struct platform_device *pdev)
3044 {
3045         struct s5p_jpeg *jpeg = platform_get_drvdata(pdev);
3046         int i;
3047
3048         pm_runtime_disable(jpeg->dev);
3049
3050         video_unregister_device(jpeg->vfd_decoder);
3051         video_unregister_device(jpeg->vfd_encoder);
3052         vb2_dma_contig_clear_max_seg_size(&pdev->dev);
3053         v4l2_m2m_release(jpeg->m2m_dev);
3054         v4l2_device_unregister(&jpeg->v4l2_dev);
3055
3056         if (!pm_runtime_status_suspended(&pdev->dev)) {
3057                 for (i = jpeg->variant->num_clocks - 1; i >= 0; i--)
3058                         clk_disable_unprepare(jpeg->clocks[i]);
3059         }
3060
3061         return 0;
3062 }
3063
3064 #ifdef CONFIG_PM
3065 static int s5p_jpeg_runtime_suspend(struct device *dev)
3066 {
3067         struct s5p_jpeg *jpeg = dev_get_drvdata(dev);
3068         int i;
3069
3070         for (i = jpeg->variant->num_clocks - 1; i >= 0; i--)
3071                 clk_disable_unprepare(jpeg->clocks[i]);
3072
3073         return 0;
3074 }
3075
3076 static int s5p_jpeg_runtime_resume(struct device *dev)
3077 {
3078         struct s5p_jpeg *jpeg = dev_get_drvdata(dev);
3079         unsigned long flags;
3080         int i, ret;
3081
3082         for (i = 0; i < jpeg->variant->num_clocks; i++) {
3083                 ret = clk_prepare_enable(jpeg->clocks[i]);
3084                 if (ret) {
3085                         while (--i >= 0)
3086                                 clk_disable_unprepare(jpeg->clocks[i]);
3087                         return ret;
3088                 }
3089         }
3090
3091         spin_lock_irqsave(&jpeg->slock, flags);
3092
3093         /*
3094          * JPEG IP allows storing two Huffman tables for each component.
3095          * We fill table 0 for each component and do this here only
3096          * for S5PC210 and Exynos3250 SoCs. Exynos4x12 and Exynos542x SoC
3097          * require programming their Huffman tables each time the encoding
3098          * process is initialized, and thus it is accomplished in the
3099          * device_run callback of m2m_ops.
3100          */
3101         if (!jpeg->variant->htbl_reinit) {
3102                 s5p_jpeg_set_hdctbl(jpeg->regs);
3103                 s5p_jpeg_set_hdctblg(jpeg->regs);
3104                 s5p_jpeg_set_hactbl(jpeg->regs);
3105                 s5p_jpeg_set_hactblg(jpeg->regs);
3106         }
3107
3108         spin_unlock_irqrestore(&jpeg->slock, flags);
3109
3110         return 0;
3111 }
3112 #endif /* CONFIG_PM */
3113
3114 static const struct dev_pm_ops s5p_jpeg_pm_ops = {
3115         SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
3116                                 pm_runtime_force_resume)
3117         SET_RUNTIME_PM_OPS(s5p_jpeg_runtime_suspend, s5p_jpeg_runtime_resume,
3118                            NULL)
3119 };
3120
3121 static struct s5p_jpeg_variant s5p_jpeg_drvdata = {
3122         .version        = SJPEG_S5P,
3123         .jpeg_irq       = s5p_jpeg_irq,
3124         .m2m_ops        = &s5p_jpeg_m2m_ops,
3125         .fmt_ver_flag   = SJPEG_FMT_FLAG_S5P,
3126         .clk_names      = {"jpeg"},
3127         .num_clocks     = 1,
3128 };
3129
3130 static struct s5p_jpeg_variant exynos3250_jpeg_drvdata = {
3131         .version        = SJPEG_EXYNOS3250,
3132         .jpeg_irq       = exynos3250_jpeg_irq,
3133         .m2m_ops        = &exynos3250_jpeg_m2m_ops,
3134         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS3250,
3135         .hw3250_compat  = 1,
3136         .clk_names      = {"jpeg", "sclk"},
3137         .num_clocks     = 2,
3138 };
3139
3140 static struct s5p_jpeg_variant exynos4_jpeg_drvdata = {
3141         .version        = SJPEG_EXYNOS4,
3142         .jpeg_irq       = exynos4_jpeg_irq,
3143         .m2m_ops        = &exynos4_jpeg_m2m_ops,
3144         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS4,
3145         .htbl_reinit    = 1,
3146         .clk_names      = {"jpeg"},
3147         .num_clocks     = 1,
3148         .hw_ex4_compat  = 1,
3149 };
3150
3151 static struct s5p_jpeg_variant exynos5420_jpeg_drvdata = {
3152         .version        = SJPEG_EXYNOS5420,
3153         .jpeg_irq       = exynos3250_jpeg_irq,          /* intentionally 3250 */
3154         .m2m_ops        = &exynos3250_jpeg_m2m_ops,     /* intentionally 3250 */
3155         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS3250,    /* intentionally 3250 */
3156         .hw3250_compat  = 1,
3157         .htbl_reinit    = 1,
3158         .clk_names      = {"jpeg"},
3159         .num_clocks     = 1,
3160 };
3161
3162 static struct s5p_jpeg_variant exynos5433_jpeg_drvdata = {
3163         .version        = SJPEG_EXYNOS5433,
3164         .jpeg_irq       = exynos4_jpeg_irq,
3165         .m2m_ops        = &exynos4_jpeg_m2m_ops,
3166         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS4,
3167         .htbl_reinit    = 1,
3168         .clk_names      = {"pclk", "aclk", "aclk_xiu", "sclk"},
3169         .num_clocks     = 4,
3170         .hw_ex4_compat  = 1,
3171 };
3172
3173 static const struct of_device_id samsung_jpeg_match[] = {
3174         {
3175                 .compatible = "samsung,s5pv210-jpeg",
3176                 .data = &s5p_jpeg_drvdata,
3177         }, {
3178                 .compatible = "samsung,exynos3250-jpeg",
3179                 .data = &exynos3250_jpeg_drvdata,
3180         }, {
3181                 .compatible = "samsung,exynos4210-jpeg",
3182                 .data = &exynos4_jpeg_drvdata,
3183         }, {
3184                 .compatible = "samsung,exynos4212-jpeg",
3185                 .data = &exynos4_jpeg_drvdata,
3186         }, {
3187                 .compatible = "samsung,exynos5420-jpeg",
3188                 .data = &exynos5420_jpeg_drvdata,
3189         }, {
3190                 .compatible = "samsung,exynos5433-jpeg",
3191                 .data = &exynos5433_jpeg_drvdata,
3192         },
3193         {},
3194 };
3195
3196 MODULE_DEVICE_TABLE(of, samsung_jpeg_match);
3197
3198 static void *jpeg_get_drv_data(struct device *dev)
3199 {
3200         struct s5p_jpeg_variant *driver_data = NULL;
3201         const struct of_device_id *match;
3202
3203         if (!IS_ENABLED(CONFIG_OF) || !dev->of_node)
3204                 return &s5p_jpeg_drvdata;
3205
3206         match = of_match_node(samsung_jpeg_match, dev->of_node);
3207
3208         if (match)
3209                 driver_data = (struct s5p_jpeg_variant *)match->data;
3210
3211         return driver_data;
3212 }
3213
3214 static struct platform_driver s5p_jpeg_driver = {
3215         .probe = s5p_jpeg_probe,
3216         .remove = s5p_jpeg_remove,
3217         .driver = {
3218                 .of_match_table = of_match_ptr(samsung_jpeg_match),
3219                 .name           = S5P_JPEG_M2M_NAME,
3220                 .pm             = &s5p_jpeg_pm_ops,
3221         },
3222 };
3223
3224 module_platform_driver(s5p_jpeg_driver);
3225
3226 MODULE_AUTHOR("Andrzej Pietrasiewicz <andrzej.p@samsung.com>");
3227 MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>");
3228 MODULE_DESCRIPTION("Samsung JPEG codec driver");
3229 MODULE_LICENSE("GPL");