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