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-v4l2.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         case SJPEG_EXYNOS5420:
 625                 if (ctx->subsampling > 3)
 626                         return V4L2_JPEG_CHROMA_SUBSAMPLING_411;
 627                 return exynos3250_decoded_subsampling[ctx->subsampling];
 628         case SJPEG_EXYNOS4:
 629         case SJPEG_EXYNOS5433:
 630                 if (ctx->subsampling > 2)
 631                         return V4L2_JPEG_CHROMA_SUBSAMPLING_420;
 632                 return exynos4x12_decoded_subsampling[ctx->subsampling];
 633         default:
 634                 return V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY;
 635         }
 636 }
 637
 638 static inline void s5p_jpeg_set_qtbl(void __iomem *regs,
 639                                      const unsigned char *qtbl,
 640                                      unsigned long tab, int len)
 641 {
 642         int i;
 643
 644         for (i = 0; i < len; i++)
 645                 writel((unsigned int)qtbl[i], regs + tab + (i * 0x04));
 646 }
 647
 648 static inline void s5p_jpeg_set_qtbl_lum(void __iomem *regs, int quality)
 649 {
 650         /* this driver fills quantisation table 0 with data for luma */
 651         s5p_jpeg_set_qtbl(regs, qtbl_luminance[quality],
 652                           S5P_JPG_QTBL_CONTENT(0),
 653                           ARRAY_SIZE(qtbl_luminance[quality]));
 654 }
 655
 656 static inline void s5p_jpeg_set_qtbl_chr(void __iomem *regs, int quality)
 657 {
 658         /* this driver fills quantisation table 1 with data for chroma */
 659         s5p_jpeg_set_qtbl(regs, qtbl_chrominance[quality],
 660                           S5P_JPG_QTBL_CONTENT(1),
 661                           ARRAY_SIZE(qtbl_chrominance[quality]));
 662 }
 663
 664 static inline void s5p_jpeg_set_htbl(void __iomem *regs,
 665                                      const unsigned char *htbl,
 666                                      unsigned long tab, int len)
 667 {
 668         int i;
 669
 670         for (i = 0; i < len; i++)
 671                 writel((unsigned int)htbl[i], regs + tab + (i * 0x04));
 672 }
 673
 674 static inline void s5p_jpeg_set_hdctbl(void __iomem *regs)
 675 {
 676         /* this driver fills table 0 for this component */
 677         s5p_jpeg_set_htbl(regs, hdctbl0, S5P_JPG_HDCTBL(0),
 678                                                 ARRAY_SIZE(hdctbl0));
 679 }
 680
 681 static inline void s5p_jpeg_set_hdctblg(void __iomem *regs)
 682 {
 683         /* this driver fills table 0 for this component */
 684         s5p_jpeg_set_htbl(regs, hdctblg0, S5P_JPG_HDCTBLG(0),
 685                                                 ARRAY_SIZE(hdctblg0));
 686 }
 687
 688 static inline void s5p_jpeg_set_hactbl(void __iomem *regs)
 689 {
 690         /* this driver fills table 0 for this component */
 691         s5p_jpeg_set_htbl(regs, hactbl0, S5P_JPG_HACTBL(0),
 692                                                 ARRAY_SIZE(hactbl0));
 693 }
 694
 695 static inline void s5p_jpeg_set_hactblg(void __iomem *regs)
 696 {
 697         /* this driver fills table 0 for this component */
 698         s5p_jpeg_set_htbl(regs, hactblg0, S5P_JPG_HACTBLG(0),
 699                                                 ARRAY_SIZE(hactblg0));
 700 }
 701
 702 static inline void exynos4_jpeg_set_tbl(void __iomem *regs,
 703                                         const unsigned char *tbl,
 704                                         unsigned long tab, int len)
 705 {
 706         int i;
 707         unsigned int dword;
 708
 709         for (i = 0; i < len; i += 4) {
 710                 dword = tbl[i] |
 711                         (tbl[i + 1] << 8) |
 712                         (tbl[i + 2] << 16) |
 713                         (tbl[i + 3] << 24);
 714                 writel(dword, regs + tab + i);
 715         }
 716 }
 717
 718 static inline void exynos4_jpeg_set_qtbl_lum(void __iomem *regs, int quality)
 719 {
 720         /* this driver fills quantisation table 0 with data for luma */
 721         exynos4_jpeg_set_tbl(regs, qtbl_luminance[quality],
 722                              EXYNOS4_QTBL_CONTENT(0),
 723                              ARRAY_SIZE(qtbl_luminance[quality]));
 724 }
 725
 726 static inline void exynos4_jpeg_set_qtbl_chr(void __iomem *regs, int quality)
 727 {
 728         /* this driver fills quantisation table 1 with data for chroma */
 729         exynos4_jpeg_set_tbl(regs, qtbl_chrominance[quality],
 730                              EXYNOS4_QTBL_CONTENT(1),
 731                              ARRAY_SIZE(qtbl_chrominance[quality]));
 732 }
 733
 734 static void exynos4_jpeg_set_huff_tbl(void __iomem *base)
 735 {
 736         exynos4_jpeg_set_tbl(base, hdctbl0, EXYNOS4_HUFF_TBL_HDCLL,
 737                                                         ARRAY_SIZE(hdctbl0));
 738         exynos4_jpeg_set_tbl(base, hdctbl0, EXYNOS4_HUFF_TBL_HDCCL,
 739                                                         ARRAY_SIZE(hdctbl0));
 740         exynos4_jpeg_set_tbl(base, hdctblg0, EXYNOS4_HUFF_TBL_HDCLV,
 741                                                         ARRAY_SIZE(hdctblg0));
 742         exynos4_jpeg_set_tbl(base, hdctblg0, EXYNOS4_HUFF_TBL_HDCCV,
 743                                                         ARRAY_SIZE(hdctblg0));
 744         exynos4_jpeg_set_tbl(base, hactbl0, EXYNOS4_HUFF_TBL_HACLL,
 745                                                         ARRAY_SIZE(hactbl0));
 746         exynos4_jpeg_set_tbl(base, hactbl0, EXYNOS4_HUFF_TBL_HACCL,
 747                                                         ARRAY_SIZE(hactbl0));
 748         exynos4_jpeg_set_tbl(base, hactblg0, EXYNOS4_HUFF_TBL_HACLV,
 749                                                         ARRAY_SIZE(hactblg0));
 750         exynos4_jpeg_set_tbl(base, hactblg0, EXYNOS4_HUFF_TBL_HACCV,
 751                                                         ARRAY_SIZE(hactblg0));
 752 }
 753
 754 static inline int __exynos4_huff_tbl(int class, int id, bool lenval)
 755 {
 756         /*
 757          * class: 0 - DC, 1 - AC
 758          * id: 0 - Y, 1 - Cb/Cr
 759          */
 760         if (class) {
 761                 if (id)
 762                         return lenval ? EXYNOS4_HUFF_TBL_HACCL :
 763                                 EXYNOS4_HUFF_TBL_HACCV;
 764                 return lenval ? EXYNOS4_HUFF_TBL_HACLL : EXYNOS4_HUFF_TBL_HACLV;
 765
 766         }
 767         /* class == 0 */
 768         if (id)
 769                 return lenval ? EXYNOS4_HUFF_TBL_HDCCL : EXYNOS4_HUFF_TBL_HDCCV;
 770
 771         return lenval ? EXYNOS4_HUFF_TBL_HDCLL : EXYNOS4_HUFF_TBL_HDCLV;
 772 }
 773
 774 static inline int exynos4_huff_tbl_len(int class, int id)
 775 {
 776         return __exynos4_huff_tbl(class, id, true);
 777 }
 778
 779 static inline int exynos4_huff_tbl_val(int class, int id)
 780 {
 781         return __exynos4_huff_tbl(class, id, false);
 782 }
 783
 784 static int get_byte(struct s5p_jpeg_buffer *buf);
 785 static int get_word_be(struct s5p_jpeg_buffer *buf, unsigned int *word);
 786 static void skip(struct s5p_jpeg_buffer *buf, long len);
 787
 788 static void exynos4_jpeg_parse_decode_h_tbl(struct s5p_jpeg_ctx *ctx)
 789 {
 790         struct s5p_jpeg *jpeg = ctx->jpeg;
 791         struct vb2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
 792         struct s5p_jpeg_buffer jpeg_buffer;
 793         unsigned int word;
 794         int c, x, components;
 795
 796         jpeg_buffer.size = 2; /* Ls */
 797         jpeg_buffer.data =
 798                 (unsigned long)vb2_plane_vaddr(vb, 0) + ctx->out_q.sos + 2;
 799         jpeg_buffer.curr = 0;
 800
 801         word = 0;
 802
 803         if (get_word_be(&jpeg_buffer, &word))
 804                 return;
 805         jpeg_buffer.size = (long)word - 2;
 806         jpeg_buffer.data += 2;
 807         jpeg_buffer.curr = 0;
 808
 809         components = get_byte(&jpeg_buffer);
 810         if (components == -1)
 811                 return;
 812         while (components--) {
 813                 c = get_byte(&jpeg_buffer);
 814                 if (c == -1)
 815                         return;
 816                 x = get_byte(&jpeg_buffer);
 817                 if (x == -1)
 818                         return;
 819                 exynos4_jpeg_select_dec_h_tbl(jpeg->regs, c,
 820                                         (((x >> 4) & 0x1) << 1) | (x & 0x1));
 821         }
 822
 823 }
 824
 825 static void exynos4_jpeg_parse_huff_tbl(struct s5p_jpeg_ctx *ctx)
 826 {
 827         struct s5p_jpeg *jpeg = ctx->jpeg;
 828         struct vb2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
 829         struct s5p_jpeg_buffer jpeg_buffer;
 830         unsigned int word;
 831         int c, i, n, j;
 832
 833         for (j = 0; j < ctx->out_q.dht.n; ++j) {
 834                 jpeg_buffer.size = ctx->out_q.dht.len[j];
 835                 jpeg_buffer.data = (unsigned long)vb2_plane_vaddr(vb, 0) +
 836                                    ctx->out_q.dht.marker[j];
 837                 jpeg_buffer.curr = 0;
 838
 839                 word = 0;
 840                 while (jpeg_buffer.curr < jpeg_buffer.size) {
 841                         char id, class;
 842
 843                         c = get_byte(&jpeg_buffer);
 844                         if (c == -1)
 845                                 return;
 846                         id = c & 0xf;
 847                         class = (c >> 4) & 0xf;
 848                         n = 0;
 849                         for (i = 0; i < 16; ++i) {
 850                                 c = get_byte(&jpeg_buffer);
 851                                 if (c == -1)
 852                                         return;
 853                                 word |= c << ((i % 4) * 8);
 854                                 if ((i + 1) % 4 == 0) {
 855                                         writel(word, jpeg->regs +
 856                                         exynos4_huff_tbl_len(class, id) +
 857                                         (i / 4) * 4);
 858                                         word = 0;
 859                                 }
 860                                 n += c;
 861                         }
 862                         word = 0;
 863                         for (i = 0; i < n; ++i) {
 864                                 c = get_byte(&jpeg_buffer);
 865                                 if (c == -1)
 866                                         return;
 867                                 word |= c << ((i % 4) * 8);
 868                                 if ((i + 1) % 4 == 0) {
 869                                         writel(word, jpeg->regs +
 870                                         exynos4_huff_tbl_val(class, id) +
 871                                         (i / 4) * 4);
 872                                         word = 0;
 873                                 }
 874                         }
 875                         if (i % 4) {
 876                                 writel(word, jpeg->regs +
 877                                 exynos4_huff_tbl_val(class, id) + (i / 4) * 4);
 878                         }
 879                         word = 0;
 880                 }
 881         }
 882 }
 883
 884 static void exynos4_jpeg_parse_decode_q_tbl(struct s5p_jpeg_ctx *ctx)
 885 {
 886         struct s5p_jpeg *jpeg = ctx->jpeg;
 887         struct vb2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
 888         struct s5p_jpeg_buffer jpeg_buffer;
 889         int c, x, components;
 890
 891         jpeg_buffer.size = ctx->out_q.sof_len;
 892         jpeg_buffer.data =
 893                 (unsigned long)vb2_plane_vaddr(vb, 0) + ctx->out_q.sof;
 894         jpeg_buffer.curr = 0;
 895
 896         skip(&jpeg_buffer, 5); /* P, Y, X */
 897         components = get_byte(&jpeg_buffer);
 898         if (components == -1)
 899                 return;
 900
 901         exynos4_jpeg_set_dec_components(jpeg->regs, components);
 902
 903         while (components--) {
 904                 c = get_byte(&jpeg_buffer);
 905                 if (c == -1)
 906                         return;
 907                 skip(&jpeg_buffer, 1);
 908                 x = get_byte(&jpeg_buffer);
 909                 if (x == -1)
 910                         return;
 911                 exynos4_jpeg_select_dec_q_tbl(jpeg->regs, c, x);
 912         }
 913 }
 914
 915 static void exynos4_jpeg_parse_q_tbl(struct s5p_jpeg_ctx *ctx)
 916 {
 917         struct s5p_jpeg *jpeg = ctx->jpeg;
 918         struct vb2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
 919         struct s5p_jpeg_buffer jpeg_buffer;
 920         unsigned int word;
 921         int c, i, j;
 922
 923         for (j = 0; j < ctx->out_q.dqt.n; ++j) {
 924                 jpeg_buffer.size = ctx->out_q.dqt.len[j];
 925                 jpeg_buffer.data = (unsigned long)vb2_plane_vaddr(vb, 0) +
 926                                    ctx->out_q.dqt.marker[j];
 927                 jpeg_buffer.curr = 0;
 928
 929                 word = 0;
 930                 while (jpeg_buffer.size - jpeg_buffer.curr >= 65) {
 931                         char id;
 932
 933                         c = get_byte(&jpeg_buffer);
 934                         if (c == -1)
 935                                 return;
 936                         id = c & 0xf;
 937                         /* nonzero means extended mode - not supported */
 938                         if ((c >> 4) & 0xf)
 939                                 return;
 940                         for (i = 0; i < 64; ++i) {
 941                                 c = get_byte(&jpeg_buffer);
 942                                 if (c == -1)
 943                                         return;
 944                                 word |= c << ((i % 4) * 8);
 945                                 if ((i + 1) % 4 == 0) {
 946                                         writel(word, jpeg->regs +
 947                                         EXYNOS4_QTBL_CONTENT(id) + (i / 4) * 4);
 948                                         word = 0;
 949                                 }
 950                         }
 951                         word = 0;
 952                 }
 953         }
 954 }
 955
 956 /*
 957  * ============================================================================
 958  * Device file operations
 959  * ============================================================================
 960  */
 961
 962 static int queue_init(void *priv, struct vb2_queue *src_vq,
 963                       struct vb2_queue *dst_vq);
 964 static struct s5p_jpeg_fmt *s5p_jpeg_find_format(struct s5p_jpeg_ctx *ctx,
 965                                 __u32 pixelformat, unsigned int fmt_type);
 966 static int s5p_jpeg_controls_create(struct s5p_jpeg_ctx *ctx);
 967
 968 static int s5p_jpeg_open(struct file *file)
 969 {
 970         struct s5p_jpeg *jpeg = video_drvdata(file);
 971         struct video_device *vfd = video_devdata(file);
 972         struct s5p_jpeg_ctx *ctx;
 973         struct s5p_jpeg_fmt *out_fmt, *cap_fmt;
 974         int ret = 0;
 975
 976         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 977         if (!ctx)
 978                 return -ENOMEM;
 979
 980         if (mutex_lock_interruptible(&jpeg->lock)) {
 981                 ret = -ERESTARTSYS;
 982                 goto free;
 983         }
 984
 985         v4l2_fh_init(&ctx->fh, vfd);
 986         /* Use separate control handler per file handle */
 987         ctx->fh.ctrl_handler = &ctx->ctrl_handler;
 988         file->private_data = &ctx->fh;
 989         v4l2_fh_add(&ctx->fh);
 990
 991         ctx->jpeg = jpeg;
 992         if (vfd == jpeg->vfd_encoder) {
 993                 ctx->mode = S5P_JPEG_ENCODE;
 994                 out_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_RGB565,
 995                                                         FMT_TYPE_OUTPUT);
 996                 cap_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_JPEG,
 997                                                         FMT_TYPE_CAPTURE);
 998         } else {
 999                 ctx->mode = S5P_JPEG_DECODE;
1000                 out_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_JPEG,
1001                                                         FMT_TYPE_OUTPUT);
1002                 cap_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_YUYV,
1003                                                         FMT_TYPE_CAPTURE);
1004                 ctx->scale_factor = EXYNOS3250_DEC_SCALE_FACTOR_8_8;
1005         }
1006
1007         ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(jpeg->m2m_dev, ctx, queue_init);
1008         if (IS_ERR(ctx->fh.m2m_ctx)) {
1009                 ret = PTR_ERR(ctx->fh.m2m_ctx);
1010                 goto error;
1011         }
1012
1013         ctx->out_q.fmt = out_fmt;
1014         ctx->cap_q.fmt = cap_fmt;
1015
1016         ret = s5p_jpeg_controls_create(ctx);
1017         if (ret < 0)
1018                 goto error;
1019
1020         mutex_unlock(&jpeg->lock);
1021         return 0;
1022
1023 error:
1024         v4l2_fh_del(&ctx->fh);
1025         v4l2_fh_exit(&ctx->fh);
1026         mutex_unlock(&jpeg->lock);
1027 free:
1028         kfree(ctx);
1029         return ret;
1030 }
1031
1032 static int s5p_jpeg_release(struct file *file)
1033 {
1034         struct s5p_jpeg *jpeg = video_drvdata(file);
1035         struct s5p_jpeg_ctx *ctx = fh_to_ctx(file->private_data);
1036
1037         mutex_lock(&jpeg->lock);
1038         v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
1039         v4l2_ctrl_handler_free(&ctx->ctrl_handler);
1040         v4l2_fh_del(&ctx->fh);
1041         v4l2_fh_exit(&ctx->fh);
1042         kfree(ctx);
1043         mutex_unlock(&jpeg->lock);
1044
1045         return 0;
1046 }
1047
1048 static const struct v4l2_file_operations s5p_jpeg_fops = {
1049         .owner          = THIS_MODULE,
1050         .open           = s5p_jpeg_open,
1051         .release        = s5p_jpeg_release,
1052         .poll           = v4l2_m2m_fop_poll,
1053         .unlocked_ioctl = video_ioctl2,
1054         .mmap           = v4l2_m2m_fop_mmap,
1055 };
1056
1057 /*
1058  * ============================================================================
1059  * video ioctl operations
1060  * ============================================================================
1061  */
1062
1063 static int get_byte(struct s5p_jpeg_buffer *buf)
1064 {
1065         if (buf->curr >= buf->size)
1066                 return -1;
1067
1068         return ((unsigned char *)buf->data)[buf->curr++];
1069 }
1070
1071 static int get_word_be(struct s5p_jpeg_buffer *buf, unsigned int *word)
1072 {
1073         unsigned int temp;
1074         int byte;
1075
1076         byte = get_byte(buf);
1077         if (byte == -1)
1078                 return -1;
1079         temp = byte << 8;
1080         byte = get_byte(buf);
1081         if (byte == -1)
1082                 return -1;
1083         *word = (unsigned int)byte | temp;
1084         return 0;
1085 }
1086
1087 static void skip(struct s5p_jpeg_buffer *buf, long len)
1088 {
1089         if (len <= 0)
1090                 return;
1091
1092         while (len--)
1093                 get_byte(buf);
1094 }
1095
1096 static bool s5p_jpeg_parse_hdr(struct s5p_jpeg_q_data *result,
1097                                unsigned long buffer, unsigned long size,
1098                                struct s5p_jpeg_ctx *ctx)
1099 {
1100         int c, components = 0, notfound, n_dht = 0, n_dqt = 0;
1101         unsigned int height, width, word, subsampling = 0, sos = 0, sof = 0,
1102                      sof_len = 0;
1103         unsigned int dht[S5P_JPEG_MAX_MARKER], dht_len[S5P_JPEG_MAX_MARKER],
1104                      dqt[S5P_JPEG_MAX_MARKER], dqt_len[S5P_JPEG_MAX_MARKER];
1105         long length;
1106         struct s5p_jpeg_buffer jpeg_buffer;
1107
1108         jpeg_buffer.size = size;
1109         jpeg_buffer.data = buffer;
1110         jpeg_buffer.curr = 0;
1111
1112         notfound = 1;
1113         while (notfound || !sos) {
1114                 c = get_byte(&jpeg_buffer);
1115                 if (c == -1)
1116                         return false;
1117                 if (c != 0xff)
1118                         continue;
1119                 do
1120                         c = get_byte(&jpeg_buffer);
1121                 while (c == 0xff);
1122                 if (c == -1)
1123                         return false;
1124                 if (c == 0)
1125                         continue;
1126                 length = 0;
1127                 switch (c) {
1128                 /* SOF0: baseline JPEG */
1129                 case SOF0:
1130                         if (get_word_be(&jpeg_buffer, &word))
1131                                 break;
1132                         length = (long)word - 2;
1133                         if (!length)
1134                                 return false;
1135                         sof = jpeg_buffer.curr; /* after 0xffc0 */
1136                         sof_len = length;
1137                         if (get_byte(&jpeg_buffer) == -1)
1138                                 break;
1139                         if (get_word_be(&jpeg_buffer, &height))
1140                                 break;
1141                         if (get_word_be(&jpeg_buffer, &width))
1142                                 break;
1143                         components = get_byte(&jpeg_buffer);
1144                         if (components == -1)
1145                                 break;
1146
1147                         if (components == 1) {
1148                                 subsampling = 0x33;
1149                         } else {
1150                                 skip(&jpeg_buffer, 1);
1151                                 subsampling = get_byte(&jpeg_buffer);
1152                                 skip(&jpeg_buffer, 1);
1153                         }
1154                         if (components > 3)
1155                                 return false;
1156                         skip(&jpeg_buffer, components * 2);
1157                         notfound = 0;
1158                         break;
1159
1160                 case DQT:
1161                         if (get_word_be(&jpeg_buffer, &word))
1162                                 break;
1163                         length = (long)word - 2;
1164                         if (!length)
1165                                 return false;
1166                         if (n_dqt >= S5P_JPEG_MAX_MARKER)
1167                                 return false;
1168                         dqt[n_dqt] = jpeg_buffer.curr; /* after 0xffdb */
1169                         dqt_len[n_dqt++] = length;
1170                         skip(&jpeg_buffer, length);
1171                         break;
1172
1173                 case DHT:
1174                         if (get_word_be(&jpeg_buffer, &word))
1175                                 break;
1176                         length = (long)word - 2;
1177                         if (!length)
1178                                 return false;
1179                         if (n_dht >= S5P_JPEG_MAX_MARKER)
1180                                 return false;
1181                         dht[n_dht] = jpeg_buffer.curr; /* after 0xffc4 */
1182                         dht_len[n_dht++] = length;
1183                         skip(&jpeg_buffer, length);
1184                         break;
1185
1186                 case SOS:
1187                         sos = jpeg_buffer.curr - 2; /* 0xffda */
1188                         break;
1189
1190                 /* skip payload-less markers */
1191                 case RST ... RST + 7:
1192                 case SOI:
1193                 case EOI:
1194                 case TEM:
1195                         break;
1196
1197                 /* skip uninteresting payload markers */
1198                 default:
1199                         if (get_word_be(&jpeg_buffer, &word))
1200                                 break;
1201                         length = (long)word - 2;
1202                         skip(&jpeg_buffer, length);
1203                         break;
1204                 }
1205         }
1206         result->w = width;
1207         result->h = height;
1208         result->sos = sos;
1209         result->dht.n = n_dht;
1210         while (n_dht--) {
1211                 result->dht.marker[n_dht] = dht[n_dht];
1212                 result->dht.len[n_dht] = dht_len[n_dht];
1213         }
1214         result->dqt.n = n_dqt;
1215         while (n_dqt--) {
1216                 result->dqt.marker[n_dqt] = dqt[n_dqt];
1217                 result->dqt.len[n_dqt] = dqt_len[n_dqt];
1218         }
1219         result->sof = sof;
1220         result->sof_len = sof_len;
1221         result->size = result->components = components;
1222
1223         switch (subsampling) {
1224         case 0x11:
1225                 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444;
1226                 break;
1227         case 0x21:
1228                 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422;
1229                 break;
1230         case 0x22:
1231                 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420;
1232                 break;
1233         case 0x33:
1234                 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY;
1235                 break;
1236         default:
1237                 return false;
1238         }
1239
1240         return !notfound && sos;
1241 }
1242
1243 static int s5p_jpeg_querycap(struct file *file, void *priv,
1244                            struct v4l2_capability *cap)
1245 {
1246         struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1247
1248         if (ctx->mode == S5P_JPEG_ENCODE) {
1249                 strlcpy(cap->driver, S5P_JPEG_M2M_NAME " encoder",
1250                         sizeof(cap->driver));
1251                 strlcpy(cap->card, S5P_JPEG_M2M_NAME " encoder",
1252                         sizeof(cap->card));
1253         } else {
1254                 strlcpy(cap->driver, S5P_JPEG_M2M_NAME " decoder",
1255                         sizeof(cap->driver));
1256                 strlcpy(cap->card, S5P_JPEG_M2M_NAME " decoder",
1257                         sizeof(cap->card));
1258         }
1259         cap->bus_info[0] = 0;
1260         cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M;
1261         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1262         return 0;
1263 }
1264
1265 static int enum_fmt(struct s5p_jpeg_fmt *sjpeg_formats, int n,
1266                     struct v4l2_fmtdesc *f, u32 type)
1267 {
1268         int i, num = 0;
1269
1270         for (i = 0; i < n; ++i) {
1271                 if (sjpeg_formats[i].flags & type) {
1272                         /* index-th format of type type found ? */
1273                         if (num == f->index)
1274                                 break;
1275                         /* Correct type but haven't reached our index yet,
1276                          * just increment per-type index */
1277                         ++num;
1278                 }
1279         }
1280
1281         /* Format not found */
1282         if (i >= n)
1283                 return -EINVAL;
1284
1285         strlcpy(f->description, sjpeg_formats[i].name, sizeof(f->description));
1286         f->pixelformat = sjpeg_formats[i].fourcc;
1287
1288         return 0;
1289 }
1290
1291 static int s5p_jpeg_enum_fmt_vid_cap(struct file *file, void *priv,
1292                                    struct v4l2_fmtdesc *f)
1293 {
1294         struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1295
1296         if (ctx->mode == S5P_JPEG_ENCODE)
1297                 return enum_fmt(sjpeg_formats, SJPEG_NUM_FORMATS, f,
1298                                 SJPEG_FMT_FLAG_ENC_CAPTURE);
1299
1300         return enum_fmt(sjpeg_formats, SJPEG_NUM_FORMATS, f,
1301                                         SJPEG_FMT_FLAG_DEC_CAPTURE);
1302 }
1303
1304 static int s5p_jpeg_enum_fmt_vid_out(struct file *file, void *priv,
1305                                    struct v4l2_fmtdesc *f)
1306 {
1307         struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1308
1309         if (ctx->mode == S5P_JPEG_ENCODE)
1310                 return enum_fmt(sjpeg_formats, SJPEG_NUM_FORMATS, f,
1311                                 SJPEG_FMT_FLAG_ENC_OUTPUT);
1312
1313         return enum_fmt(sjpeg_formats, SJPEG_NUM_FORMATS, f,
1314                                         SJPEG_FMT_FLAG_DEC_OUTPUT);
1315 }
1316
1317 static struct s5p_jpeg_q_data *get_q_data(struct s5p_jpeg_ctx *ctx,
1318                                           enum v4l2_buf_type type)
1319 {
1320         if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
1321                 return &ctx->out_q;
1322         if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1323                 return &ctx->cap_q;
1324
1325         return NULL;
1326 }
1327
1328 static int s5p_jpeg_g_fmt(struct file *file, void *priv, struct v4l2_format *f)
1329 {
1330         struct vb2_queue *vq;
1331         struct s5p_jpeg_q_data *q_data = NULL;
1332         struct v4l2_pix_format *pix = &f->fmt.pix;
1333         struct s5p_jpeg_ctx *ct = fh_to_ctx(priv);
1334
1335         vq = v4l2_m2m_get_vq(ct->fh.m2m_ctx, f->type);
1336         if (!vq)
1337                 return -EINVAL;
1338
1339         if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1340             ct->mode == S5P_JPEG_DECODE && !ct->hdr_parsed)
1341                 return -EINVAL;
1342         q_data = get_q_data(ct, f->type);
1343         BUG_ON(q_data == NULL);
1344
1345         pix->width = q_data->w;
1346         pix->height = q_data->h;
1347         pix->field = V4L2_FIELD_NONE;
1348         pix->pixelformat = q_data->fmt->fourcc;
1349         pix->bytesperline = 0;
1350         if (q_data->fmt->fourcc != V4L2_PIX_FMT_JPEG) {
1351                 u32 bpl = q_data->w;
1352                 if (q_data->fmt->colplanes == 1)
1353                         bpl = (bpl * q_data->fmt->depth) >> 3;
1354                 pix->bytesperline = bpl;
1355         }
1356         pix->sizeimage = q_data->size;
1357
1358         return 0;
1359 }
1360
1361 static struct s5p_jpeg_fmt *s5p_jpeg_find_format(struct s5p_jpeg_ctx *ctx,
1362                                 u32 pixelformat, unsigned int fmt_type)
1363 {
1364         unsigned int k, fmt_flag;
1365
1366         if (ctx->mode == S5P_JPEG_ENCODE)
1367                 fmt_flag = (fmt_type == FMT_TYPE_OUTPUT) ?
1368                                 SJPEG_FMT_FLAG_ENC_OUTPUT :
1369                                 SJPEG_FMT_FLAG_ENC_CAPTURE;
1370         else
1371                 fmt_flag = (fmt_type == FMT_TYPE_OUTPUT) ?
1372                                 SJPEG_FMT_FLAG_DEC_OUTPUT :
1373                                 SJPEG_FMT_FLAG_DEC_CAPTURE;
1374
1375         for (k = 0; k < ARRAY_SIZE(sjpeg_formats); k++) {
1376                 struct s5p_jpeg_fmt *fmt = &sjpeg_formats[k];
1377                 if (fmt->fourcc == pixelformat &&
1378                     fmt->flags & fmt_flag &&
1379                     fmt->flags & ctx->jpeg->variant->fmt_ver_flag) {
1380                         return fmt;
1381                 }
1382         }
1383
1384         return NULL;
1385 }
1386
1387 static void jpeg_bound_align_image(struct s5p_jpeg_ctx *ctx,
1388                                    u32 *w, unsigned int wmin, unsigned int wmax,
1389                                    unsigned int walign,
1390                                    u32 *h, unsigned int hmin, unsigned int hmax,
1391                                    unsigned int halign)
1392 {
1393         int width, height, w_step, h_step;
1394
1395         width = *w;
1396         height = *h;
1397
1398         w_step = 1 << walign;
1399         h_step = 1 << halign;
1400
1401         if (ctx->jpeg->variant->hw3250_compat) {
1402                 /*
1403                  * Rightmost and bottommost pixels are cropped by the
1404                  * Exynos3250/compatible JPEG IP for RGB formats, for the
1405                  * specific width and height values respectively. This
1406                  * assignment will result in v4l_bound_align_image returning
1407                  * dimensions reduced by 1 for the aforementioned cases.
1408                  */
1409                 if (w_step == 4 && ((width & 3) == 1)) {
1410                         wmax = width;
1411                         hmax = height;
1412                 }
1413         }
1414
1415         v4l_bound_align_image(w, wmin, wmax, walign, h, hmin, hmax, halign, 0);
1416
1417         if (*w < width && (*w + w_step) < wmax)
1418                 *w += w_step;
1419         if (*h < height && (*h + h_step) < hmax)
1420                 *h += h_step;
1421 }
1422
1423 static int vidioc_try_fmt(struct v4l2_format *f, struct s5p_jpeg_fmt *fmt,
1424                           struct s5p_jpeg_ctx *ctx, int q_type)
1425 {
1426         struct v4l2_pix_format *pix = &f->fmt.pix;
1427
1428         if (pix->field == V4L2_FIELD_ANY)
1429                 pix->field = V4L2_FIELD_NONE;
1430         else if (pix->field != V4L2_FIELD_NONE)
1431                 return -EINVAL;
1432
1433         /* V4L2 specification suggests the driver corrects the format struct
1434          * if any of the dimensions is unsupported */
1435         if (q_type == FMT_TYPE_OUTPUT)
1436                 jpeg_bound_align_image(ctx, &pix->width, S5P_JPEG_MIN_WIDTH,
1437                                        S5P_JPEG_MAX_WIDTH, 0,
1438                                        &pix->height, S5P_JPEG_MIN_HEIGHT,
1439                                        S5P_JPEG_MAX_HEIGHT, 0);
1440         else
1441                 jpeg_bound_align_image(ctx, &pix->width, S5P_JPEG_MIN_WIDTH,
1442                                        S5P_JPEG_MAX_WIDTH, fmt->h_align,
1443                                        &pix->height, S5P_JPEG_MIN_HEIGHT,
1444                                        S5P_JPEG_MAX_HEIGHT, fmt->v_align);
1445
1446         if (fmt->fourcc == V4L2_PIX_FMT_JPEG) {
1447                 if (pix->sizeimage <= 0)
1448                         pix->sizeimage = PAGE_SIZE;
1449                 pix->bytesperline = 0;
1450         } else {
1451                 u32 bpl = pix->bytesperline;
1452
1453                 if (fmt->colplanes > 1 && bpl < pix->width)
1454                         bpl = pix->width; /* planar */
1455
1456                 if (fmt->colplanes == 1 && /* packed */
1457                     (bpl << 3) / fmt->depth < pix->width)
1458                         bpl = (pix->width * fmt->depth) >> 3;
1459
1460                 pix->bytesperline = bpl;
1461                 pix->sizeimage = (pix->width * pix->height * fmt->depth) >> 3;
1462         }
1463
1464         return 0;
1465 }
1466
1467 static int s5p_jpeg_try_fmt_vid_cap(struct file *file, void *priv,
1468                                   struct v4l2_format *f)
1469 {
1470         struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1471         struct v4l2_pix_format *pix = &f->fmt.pix;
1472         struct s5p_jpeg_fmt *fmt;
1473         int ret;
1474
1475         fmt = s5p_jpeg_find_format(ctx, f->fmt.pix.pixelformat,
1476                                                 FMT_TYPE_CAPTURE);
1477         if (!fmt) {
1478                 v4l2_err(&ctx->jpeg->v4l2_dev,
1479                          "Fourcc format (0x%08x) invalid.\n",
1480                          f->fmt.pix.pixelformat);
1481                 return -EINVAL;
1482         }
1483
1484         if (!ctx->jpeg->variant->hw_ex4_compat || ctx->mode != S5P_JPEG_DECODE)
1485                 goto exit;
1486
1487         /*
1488          * The exynos4x12 device requires resulting YUV image
1489          * subsampling not to be lower than the input jpeg subsampling.
1490          * If this requirement is not met then downgrade the requested
1491          * capture format to the one with subsampling equal to the input jpeg.
1492          */
1493         if ((fmt->flags & SJPEG_FMT_NON_RGB) &&
1494             (fmt->subsampling < ctx->subsampling)) {
1495                 ret = s5p_jpeg_adjust_fourcc_to_subsampling(ctx->subsampling,
1496                                                             fmt->fourcc,
1497                                                             &pix->pixelformat,
1498                                                             ctx);
1499                 if (ret < 0)
1500                         pix->pixelformat = V4L2_PIX_FMT_GREY;
1501
1502                 fmt = s5p_jpeg_find_format(ctx, pix->pixelformat,
1503                                                         FMT_TYPE_CAPTURE);
1504         }
1505
1506         /*
1507          * Decompression of a JPEG file with 4:2:0 subsampling and odd
1508          * width to the YUV 4:2:0 compliant formats produces a raw image
1509          * with broken luma component. Adjust capture format to RGB565
1510          * in such a case.
1511          */
1512         if (ctx->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_420 &&
1513             (ctx->out_q.w & 1) &&
1514             (pix->pixelformat == V4L2_PIX_FMT_NV12 ||
1515              pix->pixelformat == V4L2_PIX_FMT_NV21 ||
1516              pix->pixelformat == V4L2_PIX_FMT_YUV420)) {
1517                 pix->pixelformat = V4L2_PIX_FMT_RGB565;
1518                 fmt = s5p_jpeg_find_format(ctx, pix->pixelformat,
1519                                                         FMT_TYPE_CAPTURE);
1520         }
1521
1522 exit:
1523         return vidioc_try_fmt(f, fmt, ctx, FMT_TYPE_CAPTURE);
1524 }
1525
1526 static int s5p_jpeg_try_fmt_vid_out(struct file *file, void *priv,
1527                                   struct v4l2_format *f)
1528 {
1529         struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1530         struct s5p_jpeg_fmt *fmt;
1531
1532         fmt = s5p_jpeg_find_format(ctx, f->fmt.pix.pixelformat,
1533                                                 FMT_TYPE_OUTPUT);
1534         if (!fmt) {
1535                 v4l2_err(&ctx->jpeg->v4l2_dev,
1536                          "Fourcc format (0x%08x) invalid.\n",
1537                          f->fmt.pix.pixelformat);
1538                 return -EINVAL;
1539         }
1540
1541         return vidioc_try_fmt(f, fmt, ctx, FMT_TYPE_OUTPUT);
1542 }
1543
1544 static int exynos4_jpeg_get_output_buffer_size(struct s5p_jpeg_ctx *ctx,
1545                                                 struct v4l2_format *f,
1546                                                 int fmt_depth)
1547 {
1548         struct v4l2_pix_format *pix = &f->fmt.pix;
1549         u32 pix_fmt = f->fmt.pix.pixelformat;
1550         int w = pix->width, h = pix->height, wh_align;
1551
1552         if (pix_fmt == V4L2_PIX_FMT_RGB32 ||
1553             pix_fmt == V4L2_PIX_FMT_NV24 ||
1554             pix_fmt == V4L2_PIX_FMT_NV42 ||
1555             pix_fmt == V4L2_PIX_FMT_NV12 ||
1556             pix_fmt == V4L2_PIX_FMT_NV21 ||
1557             pix_fmt == V4L2_PIX_FMT_YUV420)
1558                 wh_align = 4;
1559         else
1560                 wh_align = 1;
1561
1562         jpeg_bound_align_image(ctx, &w, S5P_JPEG_MIN_WIDTH,
1563                                S5P_JPEG_MAX_WIDTH, wh_align,
1564                                &h, S5P_JPEG_MIN_HEIGHT,
1565                                S5P_JPEG_MAX_HEIGHT, wh_align);
1566
1567         return w * h * fmt_depth >> 3;
1568 }
1569
1570 static int exynos3250_jpeg_try_downscale(struct s5p_jpeg_ctx *ctx,
1571                                    struct v4l2_rect *r);
1572
1573 static int s5p_jpeg_s_fmt(struct s5p_jpeg_ctx *ct, struct v4l2_format *f)
1574 {
1575         struct vb2_queue *vq;
1576         struct s5p_jpeg_q_data *q_data = NULL;
1577         struct v4l2_pix_format *pix = &f->fmt.pix;
1578         struct v4l2_ctrl *ctrl_subs;
1579         struct v4l2_rect scale_rect;
1580         unsigned int f_type;
1581
1582         vq = v4l2_m2m_get_vq(ct->fh.m2m_ctx, f->type);
1583         if (!vq)
1584                 return -EINVAL;
1585
1586         q_data = get_q_data(ct, f->type);
1587         BUG_ON(q_data == NULL);
1588
1589         if (vb2_is_busy(vq)) {
1590                 v4l2_err(&ct->jpeg->v4l2_dev, "%s queue busy\n", __func__);
1591                 return -EBUSY;
1592         }
1593
1594         f_type = V4L2_TYPE_IS_OUTPUT(f->type) ?
1595                         FMT_TYPE_OUTPUT : FMT_TYPE_CAPTURE;
1596
1597         q_data->fmt = s5p_jpeg_find_format(ct, pix->pixelformat, f_type);
1598         q_data->w = pix->width;
1599         q_data->h = pix->height;
1600         if (q_data->fmt->fourcc != V4L2_PIX_FMT_JPEG) {
1601                 /*
1602                  * During encoding Exynos4x12 SoCs access wider memory area
1603                  * than it results from Image_x and Image_y values written to
1604                  * the JPEG_IMAGE_SIZE register. In order to avoid sysmmu
1605                  * page fault calculate proper buffer size in such a case.
1606                  */
1607                 if (ct->jpeg->variant->hw_ex4_compat &&
1608                     f_type == FMT_TYPE_OUTPUT && ct->mode == S5P_JPEG_ENCODE)
1609                         q_data->size = exynos4_jpeg_get_output_buffer_size(ct,
1610                                                         f,
1611                                                         q_data->fmt->depth);
1612                 else
1613                         q_data->size = q_data->w * q_data->h *
1614                                                 q_data->fmt->depth >> 3;
1615         } else {
1616                 q_data->size = pix->sizeimage;
1617         }
1618
1619         if (f_type == FMT_TYPE_OUTPUT) {
1620                 ctrl_subs = v4l2_ctrl_find(&ct->ctrl_handler,
1621                                         V4L2_CID_JPEG_CHROMA_SUBSAMPLING);
1622                 if (ctrl_subs)
1623                         v4l2_ctrl_s_ctrl(ctrl_subs, q_data->fmt->subsampling);
1624                 ct->crop_altered = false;
1625         }
1626
1627         /*
1628          * For decoding init crop_rect with capture buffer dimmensions which
1629          * contain aligned dimensions of the input JPEG image and do it only
1630          * if crop rectangle hasn't been altered by the user space e.g. with
1631          * S_SELECTION ioctl. For encoding assign output buffer dimensions.
1632          */
1633         if (!ct->crop_altered &&
1634             ((ct->mode == S5P_JPEG_DECODE && f_type == FMT_TYPE_CAPTURE) ||
1635              (ct->mode == S5P_JPEG_ENCODE && f_type == FMT_TYPE_OUTPUT))) {
1636                 ct->crop_rect.width = pix->width;
1637                 ct->crop_rect.height = pix->height;
1638         }
1639
1640         /*
1641          * Prevent downscaling to YUV420 format by more than 2
1642          * for Exynos3250/compatible SoC as it produces broken raw image
1643          * in such cases.
1644          */
1645         if (ct->mode == S5P_JPEG_DECODE &&
1646             f_type == FMT_TYPE_CAPTURE &&
1647             ct->jpeg->variant->hw3250_compat &&
1648             pix->pixelformat == V4L2_PIX_FMT_YUV420 &&
1649             ct->scale_factor > 2) {
1650                 scale_rect.width = ct->out_q.w / 2;
1651                 scale_rect.height = ct->out_q.h / 2;
1652                 exynos3250_jpeg_try_downscale(ct, &scale_rect);
1653         }
1654
1655         return 0;
1656 }
1657
1658 static int s5p_jpeg_s_fmt_vid_cap(struct file *file, void *priv,
1659                                 struct v4l2_format *f)
1660 {
1661         int ret;
1662
1663         ret = s5p_jpeg_try_fmt_vid_cap(file, priv, f);
1664         if (ret)
1665                 return ret;
1666
1667         return s5p_jpeg_s_fmt(fh_to_ctx(priv), f);
1668 }
1669
1670 static int s5p_jpeg_s_fmt_vid_out(struct file *file, void *priv,
1671                                 struct v4l2_format *f)
1672 {
1673         int ret;
1674
1675         ret = s5p_jpeg_try_fmt_vid_out(file, priv, f);
1676         if (ret)
1677                 return ret;
1678
1679         return s5p_jpeg_s_fmt(fh_to_ctx(priv), f);
1680 }
1681
1682 static int exynos3250_jpeg_try_downscale(struct s5p_jpeg_ctx *ctx,
1683                                    struct v4l2_rect *r)
1684 {
1685         int w_ratio, h_ratio, scale_factor, cur_ratio, i;
1686
1687         w_ratio = ctx->out_q.w / r->width;
1688         h_ratio = ctx->out_q.h / r->height;
1689
1690         scale_factor = w_ratio > h_ratio ? w_ratio : h_ratio;
1691         scale_factor = clamp_val(scale_factor, 1, 8);
1692
1693         /* Align scale ratio to the nearest power of 2 */
1694         for (i = 0; i <= 3; ++i) {
1695                 cur_ratio = 1 << i;
1696                 if (scale_factor <= cur_ratio) {
1697                         ctx->scale_factor = cur_ratio;
1698                         break;
1699                 }
1700         }
1701
1702         r->width = round_down(ctx->out_q.w / ctx->scale_factor, 2);
1703         r->height = round_down(ctx->out_q.h / ctx->scale_factor, 2);
1704
1705         ctx->crop_rect.width = r->width;
1706         ctx->crop_rect.height = r->height;
1707         ctx->crop_rect.left = 0;
1708         ctx->crop_rect.top = 0;
1709
1710         ctx->crop_altered = true;
1711
1712         return 0;
1713 }
1714
1715 /* Return 1 if rectangle a is enclosed in rectangle b, or 0 otherwise. */
1716 static int enclosed_rectangle(struct v4l2_rect *a, struct v4l2_rect *b)
1717 {
1718         if (a->left < b->left || a->top < b->top)
1719                 return 0;
1720         if (a->left + a->width > b->left + b->width)
1721                 return 0;
1722         if (a->top + a->height > b->top + b->height)
1723                 return 0;
1724
1725         return 1;
1726 }
1727
1728 static int exynos3250_jpeg_try_crop(struct s5p_jpeg_ctx *ctx,
1729                                    struct v4l2_rect *r)
1730 {
1731         struct v4l2_rect base_rect;
1732         int w_step, h_step;
1733
1734         switch (ctx->cap_q.fmt->fourcc) {
1735         case V4L2_PIX_FMT_NV12:
1736         case V4L2_PIX_FMT_NV21:
1737                 w_step = 1;
1738                 h_step = 2;
1739                 break;
1740         case V4L2_PIX_FMT_YUV420:
1741                 w_step = 2;
1742                 h_step = 2;
1743                 break;
1744         default:
1745                 w_step = 1;
1746                 h_step = 1;
1747                 break;
1748         }
1749
1750         base_rect.top = 0;
1751         base_rect.left = 0;
1752         base_rect.width = ctx->out_q.w;
1753         base_rect.height = ctx->out_q.h;
1754
1755         r->width = round_down(r->width, w_step);
1756         r->height = round_down(r->height, h_step);
1757         r->left = round_down(r->left, 2);
1758         r->top = round_down(r->top, 2);
1759
1760         if (!enclosed_rectangle(r, &base_rect))
1761                 return -EINVAL;
1762
1763         ctx->crop_rect.left = r->left;
1764         ctx->crop_rect.top = r->top;
1765         ctx->crop_rect.width = r->width;
1766         ctx->crop_rect.height = r->height;
1767
1768         ctx->crop_altered = true;
1769
1770         return 0;
1771 }
1772
1773 /*
1774  * V4L2 controls
1775  */
1776
1777 static int s5p_jpeg_g_selection(struct file *file, void *priv,
1778                          struct v4l2_selection *s)
1779 {
1780         struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1781
1782         if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
1783             s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1784                 return -EINVAL;
1785
1786         /* For JPEG blob active == default == bounds */
1787         switch (s->target) {
1788         case V4L2_SEL_TGT_CROP:
1789         case V4L2_SEL_TGT_CROP_BOUNDS:
1790         case V4L2_SEL_TGT_CROP_DEFAULT:
1791         case V4L2_SEL_TGT_COMPOSE_DEFAULT:
1792                 s->r.width = ctx->out_q.w;
1793                 s->r.height = ctx->out_q.h;
1794                 s->r.left = 0;
1795                 s->r.top = 0;
1796                 break;
1797         case V4L2_SEL_TGT_COMPOSE:
1798         case V4L2_SEL_TGT_COMPOSE_BOUNDS:
1799         case V4L2_SEL_TGT_COMPOSE_PADDED:
1800                 s->r.width = ctx->crop_rect.width;
1801                 s->r.height =  ctx->crop_rect.height;
1802                 s->r.left = ctx->crop_rect.left;
1803                 s->r.top = ctx->crop_rect.top;
1804                 break;
1805         default:
1806                 return -EINVAL;
1807         }
1808         return 0;
1809 }
1810
1811 /*
1812  * V4L2 controls
1813  */
1814 static int s5p_jpeg_s_selection(struct file *file, void *fh,
1815                                   struct v4l2_selection *s)
1816 {
1817         struct s5p_jpeg_ctx *ctx = fh_to_ctx(file->private_data);
1818         struct v4l2_rect *rect = &s->r;
1819         int ret = -EINVAL;
1820
1821         if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1822                 return -EINVAL;
1823
1824         if (s->target == V4L2_SEL_TGT_COMPOSE) {
1825                 if (ctx->mode != S5P_JPEG_DECODE)
1826                         return -EINVAL;
1827                 if (ctx->jpeg->variant->hw3250_compat)
1828                         ret = exynos3250_jpeg_try_downscale(ctx, rect);
1829         } else if (s->target == V4L2_SEL_TGT_CROP) {
1830                 if (ctx->mode != S5P_JPEG_ENCODE)
1831                         return -EINVAL;
1832                 if (ctx->jpeg->variant->hw3250_compat)
1833                         ret = exynos3250_jpeg_try_crop(ctx, rect);
1834         }
1835
1836         return ret;
1837 }
1838
1839 static int s5p_jpeg_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1840 {
1841         struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl);
1842         struct s5p_jpeg *jpeg = ctx->jpeg;
1843         unsigned long flags;
1844
1845         switch (ctrl->id) {
1846         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1847                 spin_lock_irqsave(&jpeg->slock, flags);
1848                 ctrl->val = s5p_jpeg_to_user_subsampling(ctx);
1849                 spin_unlock_irqrestore(&jpeg->slock, flags);
1850                 break;
1851         }
1852
1853         return 0;
1854 }
1855
1856 static int s5p_jpeg_adjust_subs_ctrl(struct s5p_jpeg_ctx *ctx, int *ctrl_val)
1857 {
1858         switch (ctx->jpeg->variant->version) {
1859         case SJPEG_S5P:
1860                 return 0;
1861         case SJPEG_EXYNOS3250:
1862         case SJPEG_EXYNOS5420:
1863                 /*
1864                  * The exynos3250/compatible device can produce JPEG image only
1865                  * of 4:4:4 subsampling when given RGB32 source image.
1866                  */
1867                 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB32)
1868                         *ctrl_val = 0;
1869                 break;
1870         case SJPEG_EXYNOS4:
1871                 /*
1872                  * The exynos4x12 device requires input raw image fourcc
1873                  * to be V4L2_PIX_FMT_GREY if gray jpeg format
1874                  * is to be set.
1875                  */
1876                 if (ctx->out_q.fmt->fourcc != V4L2_PIX_FMT_GREY &&
1877                     *ctrl_val == V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY)
1878                         return -EINVAL;
1879                 break;
1880         }
1881
1882         /*
1883          * The exynos4x12 and exynos3250/compatible devices require resulting
1884          * jpeg subsampling not to be lower than the input raw image
1885          * subsampling.
1886          */
1887         if (ctx->out_q.fmt->subsampling > *ctrl_val)
1888                 *ctrl_val = ctx->out_q.fmt->subsampling;
1889
1890         return 0;
1891 }
1892
1893 static int s5p_jpeg_try_ctrl(struct v4l2_ctrl *ctrl)
1894 {
1895         struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl);
1896         unsigned long flags;
1897         int ret = 0;
1898
1899         spin_lock_irqsave(&ctx->jpeg->slock, flags);
1900
1901         if (ctrl->id == V4L2_CID_JPEG_CHROMA_SUBSAMPLING)
1902                 ret = s5p_jpeg_adjust_subs_ctrl(ctx, &ctrl->val);
1903
1904         spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
1905         return ret;
1906 }
1907
1908 static int s5p_jpeg_s_ctrl(struct v4l2_ctrl *ctrl)
1909 {
1910         struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl);
1911         unsigned long flags;
1912
1913         spin_lock_irqsave(&ctx->jpeg->slock, flags);
1914
1915         switch (ctrl->id) {
1916         case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1917                 ctx->compr_quality = ctrl->val;
1918                 break;
1919         case V4L2_CID_JPEG_RESTART_INTERVAL:
1920                 ctx->restart_interval = ctrl->val;
1921                 break;
1922         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1923                 ctx->subsampling = ctrl->val;
1924                 break;
1925         }
1926
1927         spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
1928         return 0;
1929 }
1930
1931 static const struct v4l2_ctrl_ops s5p_jpeg_ctrl_ops = {
1932         .g_volatile_ctrl        = s5p_jpeg_g_volatile_ctrl,
1933         .try_ctrl               = s5p_jpeg_try_ctrl,
1934         .s_ctrl                 = s5p_jpeg_s_ctrl,
1935 };
1936
1937 static int s5p_jpeg_controls_create(struct s5p_jpeg_ctx *ctx)
1938 {
1939         unsigned int mask = ~0x27; /* 444, 422, 420, GRAY */
1940         struct v4l2_ctrl *ctrl;
1941         int ret;
1942
1943         v4l2_ctrl_handler_init(&ctx->ctrl_handler, 3);
1944
1945         if (ctx->mode == S5P_JPEG_ENCODE) {
1946                 v4l2_ctrl_new_std(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops,
1947                                   V4L2_CID_JPEG_COMPRESSION_QUALITY,
1948                                   0, 3, 1, S5P_JPEG_COMPR_QUAL_WORST);
1949
1950                 v4l2_ctrl_new_std(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops,
1951                                   V4L2_CID_JPEG_RESTART_INTERVAL,
1952                                   0, 3, 0xffff, 0);
1953                 if (ctx->jpeg->variant->version == SJPEG_S5P)
1954                         mask = ~0x06; /* 422, 420 */
1955         }
1956
1957         ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops,
1958                                       V4L2_CID_JPEG_CHROMA_SUBSAMPLING,
1959                                       V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY, mask,
1960                                       V4L2_JPEG_CHROMA_SUBSAMPLING_422);
1961
1962         if (ctx->ctrl_handler.error) {
1963                 ret = ctx->ctrl_handler.error;
1964                 goto error_free;
1965         }
1966
1967         if (ctx->mode == S5P_JPEG_DECODE)
1968                 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE |
1969                         V4L2_CTRL_FLAG_READ_ONLY;
1970
1971         ret = v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
1972         if (ret < 0)
1973                 goto error_free;
1974
1975         return ret;
1976
1977 error_free:
1978         v4l2_ctrl_handler_free(&ctx->ctrl_handler);
1979         return ret;
1980 }
1981
1982 static const struct v4l2_ioctl_ops s5p_jpeg_ioctl_ops = {
1983         .vidioc_querycap                = s5p_jpeg_querycap,
1984
1985         .vidioc_enum_fmt_vid_cap        = s5p_jpeg_enum_fmt_vid_cap,
1986         .vidioc_enum_fmt_vid_out        = s5p_jpeg_enum_fmt_vid_out,
1987
1988         .vidioc_g_fmt_vid_cap           = s5p_jpeg_g_fmt,
1989         .vidioc_g_fmt_vid_out           = s5p_jpeg_g_fmt,
1990
1991         .vidioc_try_fmt_vid_cap         = s5p_jpeg_try_fmt_vid_cap,
1992         .vidioc_try_fmt_vid_out         = s5p_jpeg_try_fmt_vid_out,
1993
1994         .vidioc_s_fmt_vid_cap           = s5p_jpeg_s_fmt_vid_cap,
1995         .vidioc_s_fmt_vid_out           = s5p_jpeg_s_fmt_vid_out,
1996
1997         .vidioc_reqbufs                 = v4l2_m2m_ioctl_reqbufs,
1998         .vidioc_querybuf                = v4l2_m2m_ioctl_querybuf,
1999         .vidioc_qbuf                    = v4l2_m2m_ioctl_qbuf,
2000         .vidioc_dqbuf                   = v4l2_m2m_ioctl_dqbuf,
2001
2002         .vidioc_streamon                = v4l2_m2m_ioctl_streamon,
2003         .vidioc_streamoff               = v4l2_m2m_ioctl_streamoff,
2004
2005         .vidioc_g_selection             = s5p_jpeg_g_selection,
2006         .vidioc_s_selection             = s5p_jpeg_s_selection,
2007 };
2008
2009 /*
2010  * ============================================================================
2011  * mem2mem callbacks
2012  * ============================================================================
2013  */
2014
2015 static void s5p_jpeg_device_run(void *priv)
2016 {
2017         struct s5p_jpeg_ctx *ctx = priv;
2018         struct s5p_jpeg *jpeg = ctx->jpeg;
2019         struct vb2_buffer *src_buf, *dst_buf;
2020         unsigned long src_addr, dst_addr, flags;
2021
2022         spin_lock_irqsave(&ctx->jpeg->slock, flags);
2023
2024         src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2025         dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2026         src_addr = vb2_dma_contig_plane_dma_addr(src_buf, 0);
2027         dst_addr = vb2_dma_contig_plane_dma_addr(dst_buf, 0);
2028
2029         s5p_jpeg_reset(jpeg->regs);
2030         s5p_jpeg_poweron(jpeg->regs);
2031         s5p_jpeg_proc_mode(jpeg->regs, ctx->mode);
2032         if (ctx->mode == S5P_JPEG_ENCODE) {
2033                 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565)
2034                         s5p_jpeg_input_raw_mode(jpeg->regs,
2035                                                         S5P_JPEG_RAW_IN_565);
2036                 else
2037                         s5p_jpeg_input_raw_mode(jpeg->regs,
2038                                                         S5P_JPEG_RAW_IN_422);
2039                 s5p_jpeg_subsampling_mode(jpeg->regs, ctx->subsampling);
2040                 s5p_jpeg_dri(jpeg->regs, ctx->restart_interval);
2041                 s5p_jpeg_x(jpeg->regs, ctx->out_q.w);
2042                 s5p_jpeg_y(jpeg->regs, ctx->out_q.h);
2043                 s5p_jpeg_imgadr(jpeg->regs, src_addr);
2044                 s5p_jpeg_jpgadr(jpeg->regs, dst_addr);
2045
2046                 /* ultimately comes from sizeimage from userspace */
2047                 s5p_jpeg_enc_stream_int(jpeg->regs, ctx->cap_q.size);
2048
2049                 /* JPEG RGB to YCbCr conversion matrix */
2050                 s5p_jpeg_coef(jpeg->regs, 1, 1, S5P_JPEG_COEF11);
2051                 s5p_jpeg_coef(jpeg->regs, 1, 2, S5P_JPEG_COEF12);
2052                 s5p_jpeg_coef(jpeg->regs, 1, 3, S5P_JPEG_COEF13);
2053                 s5p_jpeg_coef(jpeg->regs, 2, 1, S5P_JPEG_COEF21);
2054                 s5p_jpeg_coef(jpeg->regs, 2, 2, S5P_JPEG_COEF22);
2055                 s5p_jpeg_coef(jpeg->regs, 2, 3, S5P_JPEG_COEF23);
2056                 s5p_jpeg_coef(jpeg->regs, 3, 1, S5P_JPEG_COEF31);
2057                 s5p_jpeg_coef(jpeg->regs, 3, 2, S5P_JPEG_COEF32);
2058                 s5p_jpeg_coef(jpeg->regs, 3, 3, S5P_JPEG_COEF33);
2059
2060                 /*
2061                  * JPEG IP allows storing 4 quantization tables
2062                  * We fill table 0 for luma and table 1 for chroma
2063                  */
2064                 s5p_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality);
2065                 s5p_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality);
2066                 /* use table 0 for Y */
2067                 s5p_jpeg_qtbl(jpeg->regs, 1, 0);
2068                 /* use table 1 for Cb and Cr*/
2069                 s5p_jpeg_qtbl(jpeg->regs, 2, 1);
2070                 s5p_jpeg_qtbl(jpeg->regs, 3, 1);
2071
2072                 /* Y, Cb, Cr use Huffman table 0 */
2073                 s5p_jpeg_htbl_ac(jpeg->regs, 1);
2074                 s5p_jpeg_htbl_dc(jpeg->regs, 1);
2075                 s5p_jpeg_htbl_ac(jpeg->regs, 2);
2076                 s5p_jpeg_htbl_dc(jpeg->regs, 2);
2077                 s5p_jpeg_htbl_ac(jpeg->regs, 3);
2078                 s5p_jpeg_htbl_dc(jpeg->regs, 3);
2079         } else { /* S5P_JPEG_DECODE */
2080                 s5p_jpeg_rst_int_enable(jpeg->regs, true);
2081                 s5p_jpeg_data_num_int_enable(jpeg->regs, true);
2082                 s5p_jpeg_final_mcu_num_int_enable(jpeg->regs, true);
2083                 if (ctx->cap_q.fmt->fourcc == V4L2_PIX_FMT_YUYV)
2084                         s5p_jpeg_outform_raw(jpeg->regs, S5P_JPEG_RAW_OUT_422);
2085                 else
2086                         s5p_jpeg_outform_raw(jpeg->regs, S5P_JPEG_RAW_OUT_420);
2087                 s5p_jpeg_jpgadr(jpeg->regs, src_addr);
2088                 s5p_jpeg_imgadr(jpeg->regs, dst_addr);
2089         }
2090
2091         s5p_jpeg_start(jpeg->regs);
2092
2093         spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
2094 }
2095
2096 static void exynos4_jpeg_set_img_addr(struct s5p_jpeg_ctx *ctx)
2097 {
2098         struct s5p_jpeg *jpeg = ctx->jpeg;
2099         struct s5p_jpeg_fmt *fmt;
2100         struct vb2_buffer *vb;
2101         struct s5p_jpeg_addr jpeg_addr = {};
2102         u32 pix_size, padding_bytes = 0;
2103
2104         jpeg_addr.cb = 0;
2105         jpeg_addr.cr = 0;
2106
2107         pix_size = ctx->cap_q.w * ctx->cap_q.h;
2108
2109         if (ctx->mode == S5P_JPEG_ENCODE) {
2110                 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2111                 fmt = ctx->out_q.fmt;
2112                 if (ctx->out_q.w % 2 && fmt->h_align > 0)
2113                         padding_bytes = ctx->out_q.h;
2114         } else {
2115                 fmt = ctx->cap_q.fmt;
2116                 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2117         }
2118
2119         jpeg_addr.y = vb2_dma_contig_plane_dma_addr(vb, 0);
2120
2121         if (fmt->colplanes == 2) {
2122                 jpeg_addr.cb = jpeg_addr.y + pix_size - padding_bytes;
2123         } else if (fmt->colplanes == 3) {
2124                 jpeg_addr.cb = jpeg_addr.y + pix_size;
2125                 if (fmt->fourcc == V4L2_PIX_FMT_YUV420)
2126                         jpeg_addr.cr = jpeg_addr.cb + pix_size / 4;
2127                 else
2128                         jpeg_addr.cr = jpeg_addr.cb + pix_size / 2;
2129         }
2130
2131         exynos4_jpeg_set_frame_buf_address(jpeg->regs, &jpeg_addr);
2132 }
2133
2134 static void exynos4_jpeg_set_jpeg_addr(struct s5p_jpeg_ctx *ctx)
2135 {
2136         struct s5p_jpeg *jpeg = ctx->jpeg;
2137         struct vb2_buffer *vb;
2138         unsigned int jpeg_addr = 0;
2139
2140         if (ctx->mode == S5P_JPEG_ENCODE)
2141                 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2142         else
2143                 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2144
2145         jpeg_addr = vb2_dma_contig_plane_dma_addr(vb, 0);
2146         if (jpeg->variant->version == SJPEG_EXYNOS5433 &&
2147             ctx->mode == S5P_JPEG_DECODE)
2148                 jpeg_addr += ctx->out_q.sos;
2149         exynos4_jpeg_set_stream_buf_address(jpeg->regs, jpeg_addr);
2150 }
2151
2152 static inline void exynos4_jpeg_set_img_fmt(void __iomem *base,
2153                                             unsigned int img_fmt)
2154 {
2155         __exynos4_jpeg_set_img_fmt(base, img_fmt, SJPEG_EXYNOS4);
2156 }
2157
2158 static inline void exynos5433_jpeg_set_img_fmt(void __iomem *base,
2159                                                unsigned int img_fmt)
2160 {
2161         __exynos4_jpeg_set_img_fmt(base, img_fmt, SJPEG_EXYNOS5433);
2162 }
2163
2164 static inline void exynos4_jpeg_set_enc_out_fmt(void __iomem *base,
2165                                                 unsigned int out_fmt)
2166 {
2167         __exynos4_jpeg_set_enc_out_fmt(base, out_fmt, SJPEG_EXYNOS4);
2168 }
2169
2170 static inline void exynos5433_jpeg_set_enc_out_fmt(void __iomem *base,
2171                                                    unsigned int out_fmt)
2172 {
2173         __exynos4_jpeg_set_enc_out_fmt(base, out_fmt, SJPEG_EXYNOS5433);
2174 }
2175
2176 static void exynos4_jpeg_device_run(void *priv)
2177 {
2178         struct s5p_jpeg_ctx *ctx = priv;
2179         struct s5p_jpeg *jpeg = ctx->jpeg;
2180         unsigned int bitstream_size;
2181         unsigned long flags;
2182
2183         spin_lock_irqsave(&jpeg->slock, flags);
2184
2185         if (ctx->mode == S5P_JPEG_ENCODE) {
2186                 exynos4_jpeg_sw_reset(jpeg->regs);
2187                 exynos4_jpeg_set_interrupt(jpeg->regs, jpeg->variant->version);
2188                 exynos4_jpeg_set_huf_table_enable(jpeg->regs, 1);
2189
2190                 exynos4_jpeg_set_huff_tbl(jpeg->regs);
2191
2192                 /*
2193                  * JPEG IP allows storing 4 quantization tables
2194                  * We fill table 0 for luma and table 1 for chroma
2195                  */
2196                 exynos4_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality);
2197                 exynos4_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality);
2198
2199                 exynos4_jpeg_set_encode_tbl_select(jpeg->regs,
2200                                                         ctx->compr_quality);
2201                 exynos4_jpeg_set_stream_size(jpeg->regs, ctx->cap_q.w,
2202                                                         ctx->cap_q.h);
2203
2204                 if (ctx->jpeg->variant->version == SJPEG_EXYNOS4) {
2205                         exynos4_jpeg_set_enc_out_fmt(jpeg->regs,
2206                                                      ctx->subsampling);
2207                         exynos4_jpeg_set_img_fmt(jpeg->regs,
2208                                                  ctx->out_q.fmt->fourcc);
2209                 } else {
2210                         exynos5433_jpeg_set_enc_out_fmt(jpeg->regs,
2211                                                         ctx->subsampling);
2212                         exynos5433_jpeg_set_img_fmt(jpeg->regs,
2213                                                     ctx->out_q.fmt->fourcc);
2214                 }
2215                 exynos4_jpeg_set_img_addr(ctx);
2216                 exynos4_jpeg_set_jpeg_addr(ctx);
2217                 exynos4_jpeg_set_encode_hoff_cnt(jpeg->regs,
2218                                                         ctx->out_q.fmt->fourcc);
2219         } else {
2220                 exynos4_jpeg_sw_reset(jpeg->regs);
2221                 exynos4_jpeg_set_interrupt(jpeg->regs,
2222                                            jpeg->variant->version);
2223                 exynos4_jpeg_set_img_addr(ctx);
2224                 exynos4_jpeg_set_jpeg_addr(ctx);
2225
2226                 if (jpeg->variant->version == SJPEG_EXYNOS5433) {
2227                         exynos4_jpeg_parse_huff_tbl(ctx);
2228                         exynos4_jpeg_parse_decode_h_tbl(ctx);
2229
2230                         exynos4_jpeg_parse_q_tbl(ctx);
2231                         exynos4_jpeg_parse_decode_q_tbl(ctx);
2232
2233                         exynos4_jpeg_set_huf_table_enable(jpeg->regs, 1);
2234
2235                         exynos4_jpeg_set_stream_size(jpeg->regs, ctx->cap_q.w,
2236                                         ctx->cap_q.h);
2237                         exynos5433_jpeg_set_enc_out_fmt(jpeg->regs,
2238                                                         ctx->subsampling);
2239                         exynos5433_jpeg_set_img_fmt(jpeg->regs,
2240                                                     ctx->cap_q.fmt->fourcc);
2241                         bitstream_size = DIV_ROUND_UP(ctx->out_q.size, 16);
2242                 } else {
2243                         exynos4_jpeg_set_img_fmt(jpeg->regs,
2244                                                  ctx->cap_q.fmt->fourcc);
2245                         bitstream_size = DIV_ROUND_UP(ctx->out_q.size, 32);
2246                 }
2247
2248                 exynos4_jpeg_set_dec_bitstream_size(jpeg->regs, bitstream_size);
2249         }
2250
2251         exynos4_jpeg_set_enc_dec_mode(jpeg->regs, ctx->mode);
2252
2253         spin_unlock_irqrestore(&jpeg->slock, flags);
2254 }
2255
2256 static void exynos3250_jpeg_set_img_addr(struct s5p_jpeg_ctx *ctx)
2257 {
2258         struct s5p_jpeg *jpeg = ctx->jpeg;
2259         struct s5p_jpeg_fmt *fmt;
2260         struct vb2_buffer *vb;
2261         struct s5p_jpeg_addr jpeg_addr = {};
2262         u32 pix_size;
2263
2264         pix_size = ctx->cap_q.w * ctx->cap_q.h;
2265
2266         if (ctx->mode == S5P_JPEG_ENCODE) {
2267                 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2268                 fmt = ctx->out_q.fmt;
2269         } else {
2270                 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2271                 fmt = ctx->cap_q.fmt;
2272         }
2273
2274         jpeg_addr.y = vb2_dma_contig_plane_dma_addr(vb, 0);
2275
2276         if (fmt->colplanes == 2) {
2277                 jpeg_addr.cb = jpeg_addr.y + pix_size;
2278         } else if (fmt->colplanes == 3) {
2279                 jpeg_addr.cb = jpeg_addr.y + pix_size;
2280                 if (fmt->fourcc == V4L2_PIX_FMT_YUV420)
2281                         jpeg_addr.cr = jpeg_addr.cb + pix_size / 4;
2282                 else
2283                         jpeg_addr.cr = jpeg_addr.cb + pix_size / 2;
2284         }
2285
2286         exynos3250_jpeg_imgadr(jpeg->regs, &jpeg_addr);
2287 }
2288
2289 static void exynos3250_jpeg_set_jpeg_addr(struct s5p_jpeg_ctx *ctx)
2290 {
2291         struct s5p_jpeg *jpeg = ctx->jpeg;
2292         struct vb2_buffer *vb;
2293         unsigned int jpeg_addr = 0;
2294
2295         if (ctx->mode == S5P_JPEG_ENCODE)
2296                 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2297         else
2298                 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2299
2300         jpeg_addr = vb2_dma_contig_plane_dma_addr(vb, 0);
2301         exynos3250_jpeg_jpgadr(jpeg->regs, jpeg_addr);
2302 }
2303
2304 static void exynos3250_jpeg_device_run(void *priv)
2305 {
2306         struct s5p_jpeg_ctx *ctx = priv;
2307         struct s5p_jpeg *jpeg = ctx->jpeg;
2308         unsigned long flags;
2309
2310         spin_lock_irqsave(&ctx->jpeg->slock, flags);
2311
2312         exynos3250_jpeg_reset(jpeg->regs);
2313         exynos3250_jpeg_set_dma_num(jpeg->regs);
2314         exynos3250_jpeg_poweron(jpeg->regs);
2315         exynos3250_jpeg_clk_set(jpeg->regs);
2316         exynos3250_jpeg_proc_mode(jpeg->regs, ctx->mode);
2317
2318         if (ctx->mode == S5P_JPEG_ENCODE) {
2319                 exynos3250_jpeg_input_raw_fmt(jpeg->regs,
2320                                               ctx->out_q.fmt->fourcc);
2321                 exynos3250_jpeg_dri(jpeg->regs, ctx->restart_interval);
2322
2323                 /*
2324                  * JPEG IP allows storing 4 quantization tables
2325                  * We fill table 0 for luma and table 1 for chroma
2326                  */
2327                 s5p_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality);
2328                 s5p_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality);
2329                 /* use table 0 for Y */
2330                 exynos3250_jpeg_qtbl(jpeg->regs, 1, 0);
2331                 /* use table 1 for Cb and Cr*/
2332                 exynos3250_jpeg_qtbl(jpeg->regs, 2, 1);
2333                 exynos3250_jpeg_qtbl(jpeg->regs, 3, 1);
2334
2335                 /*
2336                  * Some SoCs require setting Huffman tables before each run
2337                  */
2338                 if (jpeg->variant->htbl_reinit) {
2339                         s5p_jpeg_set_hdctbl(jpeg->regs);
2340                         s5p_jpeg_set_hdctblg(jpeg->regs);
2341                         s5p_jpeg_set_hactbl(jpeg->regs);
2342                         s5p_jpeg_set_hactblg(jpeg->regs);
2343                 }
2344
2345                 /* Y, Cb, Cr use Huffman table 0 */
2346                 exynos3250_jpeg_htbl_ac(jpeg->regs, 1);
2347                 exynos3250_jpeg_htbl_dc(jpeg->regs, 1);
2348                 exynos3250_jpeg_htbl_ac(jpeg->regs, 2);
2349                 exynos3250_jpeg_htbl_dc(jpeg->regs, 2);
2350                 exynos3250_jpeg_htbl_ac(jpeg->regs, 3);
2351                 exynos3250_jpeg_htbl_dc(jpeg->regs, 3);
2352
2353                 exynos3250_jpeg_set_x(jpeg->regs, ctx->crop_rect.width);
2354                 exynos3250_jpeg_set_y(jpeg->regs, ctx->crop_rect.height);
2355                 exynos3250_jpeg_stride(jpeg->regs, ctx->out_q.fmt->fourcc,
2356                                                                 ctx->out_q.w);
2357                 exynos3250_jpeg_offset(jpeg->regs, ctx->crop_rect.left,
2358                                                         ctx->crop_rect.top);
2359                 exynos3250_jpeg_set_img_addr(ctx);
2360                 exynos3250_jpeg_set_jpeg_addr(ctx);
2361                 exynos3250_jpeg_subsampling_mode(jpeg->regs, ctx->subsampling);
2362
2363                 /* ultimately comes from sizeimage from userspace */
2364                 exynos3250_jpeg_enc_stream_bound(jpeg->regs, ctx->cap_q.size);
2365
2366                 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565 ||
2367                     ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565X ||
2368                     ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB32)
2369                         exynos3250_jpeg_set_y16(jpeg->regs, true);
2370         } else {
2371                 exynos3250_jpeg_set_img_addr(ctx);
2372                 exynos3250_jpeg_set_jpeg_addr(ctx);
2373                 exynos3250_jpeg_stride(jpeg->regs, ctx->cap_q.fmt->fourcc,
2374                                                                 ctx->cap_q.w);
2375                 exynos3250_jpeg_offset(jpeg->regs, 0, 0);
2376                 exynos3250_jpeg_dec_scaling_ratio(jpeg->regs,
2377                                                         ctx->scale_factor);
2378                 exynos3250_jpeg_dec_stream_size(jpeg->regs, ctx->out_q.size);
2379                 exynos3250_jpeg_output_raw_fmt(jpeg->regs,
2380                                                 ctx->cap_q.fmt->fourcc);
2381         }
2382
2383         exynos3250_jpeg_interrupts_enable(jpeg->regs);
2384
2385         /* JPEG RGB to YCbCr conversion matrix */
2386         exynos3250_jpeg_coef(jpeg->regs, ctx->mode);
2387
2388         exynos3250_jpeg_set_timer(jpeg->regs, EXYNOS3250_IRQ_TIMEOUT);
2389         jpeg->irq_status = 0;
2390         exynos3250_jpeg_start(jpeg->regs);
2391
2392         spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
2393 }
2394
2395 static int s5p_jpeg_job_ready(void *priv)
2396 {
2397         struct s5p_jpeg_ctx *ctx = priv;
2398
2399         if (ctx->mode == S5P_JPEG_DECODE)
2400                 return ctx->hdr_parsed;
2401         return 1;
2402 }
2403
2404 static void s5p_jpeg_job_abort(void *priv)
2405 {
2406 }
2407
2408 static struct v4l2_m2m_ops s5p_jpeg_m2m_ops = {
2409         .device_run     = s5p_jpeg_device_run,
2410         .job_ready      = s5p_jpeg_job_ready,
2411         .job_abort      = s5p_jpeg_job_abort,
2412 };
2413
2414 static struct v4l2_m2m_ops exynos3250_jpeg_m2m_ops = {
2415         .device_run     = exynos3250_jpeg_device_run,
2416         .job_ready      = s5p_jpeg_job_ready,
2417         .job_abort      = s5p_jpeg_job_abort,
2418 };
2419
2420 static struct v4l2_m2m_ops exynos4_jpeg_m2m_ops = {
2421         .device_run     = exynos4_jpeg_device_run,
2422         .job_ready      = s5p_jpeg_job_ready,
2423         .job_abort      = s5p_jpeg_job_abort,
2424 };
2425
2426 /*
2427  * ============================================================================
2428  * Queue operations
2429  * ============================================================================
2430  */
2431
2432 static int s5p_jpeg_queue_setup(struct vb2_queue *vq,
2433                            const void *parg,
2434                            unsigned int *nbuffers, unsigned int *nplanes,
2435                            unsigned int sizes[], void *alloc_ctxs[])
2436 {
2437         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vq);
2438         struct s5p_jpeg_q_data *q_data = NULL;
2439         unsigned int size, count = *nbuffers;
2440
2441         q_data = get_q_data(ctx, vq->type);
2442         BUG_ON(q_data == NULL);
2443
2444         size = q_data->size;
2445
2446         /*
2447          * header is parsed during decoding and parsed information stored
2448          * in the context so we do not allow another buffer to overwrite it
2449          */
2450         if (ctx->mode == S5P_JPEG_DECODE)
2451                 count = 1;
2452
2453         *nbuffers = count;
2454         *nplanes = 1;
2455         sizes[0] = size;
2456         alloc_ctxs[0] = ctx->jpeg->alloc_ctx;
2457
2458         return 0;
2459 }
2460
2461 static int s5p_jpeg_buf_prepare(struct vb2_buffer *vb)
2462 {
2463         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
2464         struct s5p_jpeg_q_data *q_data = NULL;
2465
2466         q_data = get_q_data(ctx, vb->vb2_queue->type);
2467         BUG_ON(q_data == NULL);
2468
2469         if (vb2_plane_size(vb, 0) < q_data->size) {
2470                 pr_err("%s data will not fit into plane (%lu < %lu)\n",
2471                                 __func__, vb2_plane_size(vb, 0),
2472                                 (long)q_data->size);
2473                 return -EINVAL;
2474         }
2475
2476         vb2_set_plane_payload(vb, 0, q_data->size);
2477
2478         return 0;
2479 }
2480
2481 static void s5p_jpeg_buf_queue(struct vb2_buffer *vb)
2482 {
2483         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
2484         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
2485
2486         if (ctx->mode == S5P_JPEG_DECODE &&
2487             vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
2488                 struct s5p_jpeg_q_data tmp, *q_data;
2489                 ctx->hdr_parsed = s5p_jpeg_parse_hdr(&tmp,
2490                      (unsigned long)vb2_plane_vaddr(vb, 0),
2491                      min((unsigned long)ctx->out_q.size,
2492                          vb2_get_plane_payload(vb, 0)), ctx);
2493                 if (!ctx->hdr_parsed) {
2494                         vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
2495                         return;
2496                 }
2497
2498                 q_data = &ctx->out_q;
2499                 q_data->w = tmp.w;
2500                 q_data->h = tmp.h;
2501                 q_data->sos = tmp.sos;
2502                 memcpy(q_data->dht.marker, tmp.dht.marker,
2503                        sizeof(tmp.dht.marker));
2504                 memcpy(q_data->dht.len, tmp.dht.len, sizeof(tmp.dht.len));
2505                 q_data->dht.n = tmp.dht.n;
2506                 memcpy(q_data->dqt.marker, tmp.dqt.marker,
2507                        sizeof(tmp.dqt.marker));
2508                 memcpy(q_data->dqt.len, tmp.dqt.len, sizeof(tmp.dqt.len));
2509                 q_data->dqt.n = tmp.dqt.n;
2510                 q_data->sof = tmp.sof;
2511                 q_data->sof_len = tmp.sof_len;
2512
2513                 q_data = &ctx->cap_q;
2514                 q_data->w = tmp.w;
2515                 q_data->h = tmp.h;
2516         }
2517
2518         v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
2519 }
2520
2521 static int s5p_jpeg_start_streaming(struct vb2_queue *q, unsigned int count)
2522 {
2523         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q);
2524         int ret;
2525
2526         ret = pm_runtime_get_sync(ctx->jpeg->dev);
2527
2528         return ret > 0 ? 0 : ret;
2529 }
2530
2531 static void s5p_jpeg_stop_streaming(struct vb2_queue *q)
2532 {
2533         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q);
2534
2535         pm_runtime_put(ctx->jpeg->dev);
2536 }
2537
2538 static struct vb2_ops s5p_jpeg_qops = {
2539         .queue_setup            = s5p_jpeg_queue_setup,
2540         .buf_prepare            = s5p_jpeg_buf_prepare,
2541         .buf_queue              = s5p_jpeg_buf_queue,
2542         .wait_prepare           = vb2_ops_wait_prepare,
2543         .wait_finish            = vb2_ops_wait_finish,
2544         .start_streaming        = s5p_jpeg_start_streaming,
2545         .stop_streaming         = s5p_jpeg_stop_streaming,
2546 };
2547
2548 static int queue_init(void *priv, struct vb2_queue *src_vq,
2549                       struct vb2_queue *dst_vq)
2550 {
2551         struct s5p_jpeg_ctx *ctx = priv;
2552         int ret;
2553
2554         src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
2555         src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
2556         src_vq->drv_priv = ctx;
2557         src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
2558         src_vq->ops = &s5p_jpeg_qops;
2559         src_vq->mem_ops = &vb2_dma_contig_memops;
2560         src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
2561         src_vq->lock = &ctx->jpeg->lock;
2562
2563         ret = vb2_queue_init(src_vq);
2564         if (ret)
2565                 return ret;
2566
2567         dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2568         dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;
2569         dst_vq->drv_priv = ctx;
2570         dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
2571         dst_vq->ops = &s5p_jpeg_qops;
2572         dst_vq->mem_ops = &vb2_dma_contig_memops;
2573         dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
2574         dst_vq->lock = &ctx->jpeg->lock;
2575
2576         return vb2_queue_init(dst_vq);
2577 }
2578
2579 /*
2580  * ============================================================================
2581  * ISR
2582  * ============================================================================
2583  */
2584
2585 static irqreturn_t s5p_jpeg_irq(int irq, void *dev_id)
2586 {
2587         struct s5p_jpeg *jpeg = dev_id;
2588         struct s5p_jpeg_ctx *curr_ctx;
2589         struct vb2_v4l2_buffer *src_buf, *dst_buf;
2590         unsigned long payload_size = 0;
2591         enum vb2_buffer_state state = VB2_BUF_STATE_DONE;
2592         bool enc_jpeg_too_large = false;
2593         bool timer_elapsed = false;
2594         bool op_completed = false;
2595
2596         spin_lock(&jpeg->slock);
2597
2598         curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2599
2600         src_buf = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2601         dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2602
2603         if (curr_ctx->mode == S5P_JPEG_ENCODE)
2604                 enc_jpeg_too_large = s5p_jpeg_enc_stream_stat(jpeg->regs);
2605         timer_elapsed = s5p_jpeg_timer_stat(jpeg->regs);
2606         op_completed = s5p_jpeg_result_stat_ok(jpeg->regs);
2607         if (curr_ctx->mode == S5P_JPEG_DECODE)
2608                 op_completed = op_completed &&
2609                                         s5p_jpeg_stream_stat_ok(jpeg->regs);
2610
2611         if (enc_jpeg_too_large) {
2612                 state = VB2_BUF_STATE_ERROR;
2613                 s5p_jpeg_clear_enc_stream_stat(jpeg->regs);
2614         } else if (timer_elapsed) {
2615                 state = VB2_BUF_STATE_ERROR;
2616                 s5p_jpeg_clear_timer_stat(jpeg->regs);
2617         } else if (!op_completed) {
2618                 state = VB2_BUF_STATE_ERROR;
2619         } else {
2620                 payload_size = s5p_jpeg_compressed_size(jpeg->regs);
2621         }
2622
2623         dst_buf->timecode = src_buf->timecode;
2624         dst_buf->timestamp = src_buf->timestamp;
2625         dst_buf->flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
2626         dst_buf->flags |=
2627                 src_buf->flags & V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
2628
2629         v4l2_m2m_buf_done(src_buf, state);
2630         if (curr_ctx->mode == S5P_JPEG_ENCODE)
2631                 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload_size);
2632         v4l2_m2m_buf_done(dst_buf, state);
2633         v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2634
2635         curr_ctx->subsampling = s5p_jpeg_get_subsampling_mode(jpeg->regs);
2636         spin_unlock(&jpeg->slock);
2637
2638         s5p_jpeg_clear_int(jpeg->regs);
2639
2640         return IRQ_HANDLED;
2641 }
2642
2643 static irqreturn_t exynos4_jpeg_irq(int irq, void *priv)
2644 {
2645         unsigned int int_status;
2646         struct vb2_v4l2_buffer *src_vb, *dst_vb;
2647         struct s5p_jpeg *jpeg = priv;
2648         struct s5p_jpeg_ctx *curr_ctx;
2649         unsigned long payload_size = 0;
2650
2651         spin_lock(&jpeg->slock);
2652
2653         curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2654
2655         src_vb = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2656         dst_vb = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2657
2658         int_status = exynos4_jpeg_get_int_status(jpeg->regs);
2659
2660         if (int_status) {
2661                 switch (int_status & 0x1f) {
2662                 case 0x1:
2663                         jpeg->irq_ret = ERR_PROT;
2664                         break;
2665                 case 0x2:
2666                         jpeg->irq_ret = OK_ENC_OR_DEC;
2667                         break;
2668                 case 0x4:
2669                         jpeg->irq_ret = ERR_DEC_INVALID_FORMAT;
2670                         break;
2671                 case 0x8:
2672                         jpeg->irq_ret = ERR_MULTI_SCAN;
2673                         break;
2674                 case 0x10:
2675                         jpeg->irq_ret = ERR_FRAME;
2676                         break;
2677                 default:
2678                         jpeg->irq_ret = ERR_UNKNOWN;
2679                         break;
2680                 }
2681         } else {
2682                 jpeg->irq_ret = ERR_UNKNOWN;
2683         }
2684
2685         if (jpeg->irq_ret == OK_ENC_OR_DEC) {
2686                 if (curr_ctx->mode == S5P_JPEG_ENCODE) {
2687                         payload_size = exynos4_jpeg_get_stream_size(jpeg->regs);
2688                         vb2_set_plane_payload(&dst_vb->vb2_buf,
2689                                         0, payload_size);
2690                 }
2691                 v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_DONE);
2692                 v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_DONE);
2693         } else {
2694                 v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_ERROR);
2695                 v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_ERROR);
2696         }
2697
2698         v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2699         if (jpeg->variant->version == SJPEG_EXYNOS4)
2700                 curr_ctx->subsampling = exynos4_jpeg_get_frame_fmt(jpeg->regs);
2701
2702         spin_unlock(&jpeg->slock);
2703         return IRQ_HANDLED;
2704 }
2705
2706 static irqreturn_t exynos3250_jpeg_irq(int irq, void *dev_id)
2707 {
2708         struct s5p_jpeg *jpeg = dev_id;
2709         struct s5p_jpeg_ctx *curr_ctx;
2710         struct vb2_v4l2_buffer *src_buf, *dst_buf;
2711         unsigned long payload_size = 0;
2712         enum vb2_buffer_state state = VB2_BUF_STATE_DONE;
2713         bool interrupt_timeout = false;
2714         u32 irq_status;
2715
2716         spin_lock(&jpeg->slock);
2717
2718         irq_status = exynos3250_jpeg_get_timer_status(jpeg->regs);
2719         if (irq_status & EXYNOS3250_TIMER_INT_STAT) {
2720                 exynos3250_jpeg_clear_timer_status(jpeg->regs);
2721                 interrupt_timeout = true;
2722                 dev_err(jpeg->dev, "Interrupt timeout occurred.\n");
2723         }
2724
2725         irq_status = exynos3250_jpeg_get_int_status(jpeg->regs);
2726         exynos3250_jpeg_clear_int_status(jpeg->regs, irq_status);
2727
2728         jpeg->irq_status |= irq_status;
2729
2730         curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2731
2732         if (!curr_ctx)
2733                 goto exit_unlock;
2734
2735         if ((irq_status & EXYNOS3250_HEADER_STAT) &&
2736             (curr_ctx->mode == S5P_JPEG_DECODE)) {
2737                 exynos3250_jpeg_rstart(jpeg->regs);
2738                 goto exit_unlock;
2739         }
2740
2741         if (jpeg->irq_status & (EXYNOS3250_JPEG_DONE |
2742                                 EXYNOS3250_WDMA_DONE |
2743                                 EXYNOS3250_RDMA_DONE |
2744                                 EXYNOS3250_RESULT_STAT))
2745                 payload_size = exynos3250_jpeg_compressed_size(jpeg->regs);
2746         else if (interrupt_timeout)
2747                 state = VB2_BUF_STATE_ERROR;
2748         else
2749                 goto exit_unlock;
2750
2751         src_buf = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2752         dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2753
2754         dst_buf->timecode = src_buf->timecode;
2755         dst_buf->timestamp = src_buf->timestamp;
2756
2757         v4l2_m2m_buf_done(src_buf, state);
2758         if (curr_ctx->mode == S5P_JPEG_ENCODE)
2759                 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload_size);
2760         v4l2_m2m_buf_done(dst_buf, state);
2761         v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2762
2763         curr_ctx->subsampling =
2764                         exynos3250_jpeg_get_subsampling_mode(jpeg->regs);
2765 exit_unlock:
2766         spin_unlock(&jpeg->slock);
2767         return IRQ_HANDLED;
2768 }
2769
2770 static void *jpeg_get_drv_data(struct device *dev);
2771
2772 /*
2773  * ============================================================================
2774  * Driver basic infrastructure
2775  * ============================================================================
2776  */
2777
2778 static int s5p_jpeg_probe(struct platform_device *pdev)
2779 {
2780         struct s5p_jpeg *jpeg;
2781         struct resource *res;
2782         int i, ret;
2783
2784         /* JPEG IP abstraction struct */
2785         jpeg = devm_kzalloc(&pdev->dev, sizeof(struct s5p_jpeg), GFP_KERNEL);
2786         if (!jpeg)
2787                 return -ENOMEM;
2788
2789         jpeg->variant = jpeg_get_drv_data(&pdev->dev);
2790
2791         mutex_init(&jpeg->lock);
2792         spin_lock_init(&jpeg->slock);
2793         jpeg->dev = &pdev->dev;
2794
2795         /* memory-mapped registers */
2796         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2797
2798         jpeg->regs = devm_ioremap_resource(&pdev->dev, res);
2799         if (IS_ERR(jpeg->regs))
2800                 return PTR_ERR(jpeg->regs);
2801
2802         /* interrupt service routine registration */
2803         jpeg->irq = ret = platform_get_irq(pdev, 0);
2804         if (ret < 0) {
2805                 dev_err(&pdev->dev, "cannot find IRQ\n");
2806                 return ret;
2807         }
2808
2809         ret = devm_request_irq(&pdev->dev, jpeg->irq, jpeg->variant->jpeg_irq,
2810                                 0, dev_name(&pdev->dev), jpeg);
2811         if (ret) {
2812                 dev_err(&pdev->dev, "cannot claim IRQ %d\n", jpeg->irq);
2813                 return ret;
2814         }
2815
2816         /* clocks */
2817         for (i = 0; i < jpeg->variant->num_clocks; i++) {
2818                 jpeg->clocks[i] = devm_clk_get(&pdev->dev,
2819                                               jpeg->variant->clk_names[i]);
2820                 if (IS_ERR(jpeg->clocks[i])) {
2821                         dev_err(&pdev->dev, "failed to get clock: %s\n",
2822                                 jpeg->variant->clk_names[i]);
2823                         return PTR_ERR(jpeg->clocks[i]);
2824                 }
2825         }
2826
2827         /* v4l2 device */
2828         ret = v4l2_device_register(&pdev->dev, &jpeg->v4l2_dev);
2829         if (ret) {
2830                 dev_err(&pdev->dev, "Failed to register v4l2 device\n");
2831                 return ret;
2832         }
2833
2834         /* mem2mem device */
2835         jpeg->m2m_dev = v4l2_m2m_init(jpeg->variant->m2m_ops);
2836         if (IS_ERR(jpeg->m2m_dev)) {
2837                 v4l2_err(&jpeg->v4l2_dev, "Failed to init mem2mem device\n");
2838                 ret = PTR_ERR(jpeg->m2m_dev);
2839                 goto device_register_rollback;
2840         }
2841
2842         jpeg->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
2843         if (IS_ERR(jpeg->alloc_ctx)) {
2844                 v4l2_err(&jpeg->v4l2_dev, "Failed to init memory allocator\n");
2845                 ret = PTR_ERR(jpeg->alloc_ctx);
2846                 goto m2m_init_rollback;
2847         }
2848
2849         /* JPEG encoder /dev/videoX node */
2850         jpeg->vfd_encoder = video_device_alloc();
2851         if (!jpeg->vfd_encoder) {
2852                 v4l2_err(&jpeg->v4l2_dev, "Failed to allocate video device\n");
2853                 ret = -ENOMEM;
2854                 goto vb2_allocator_rollback;
2855         }
2856         snprintf(jpeg->vfd_encoder->name, sizeof(jpeg->vfd_encoder->name),
2857                                 "%s-enc", S5P_JPEG_M2M_NAME);
2858         jpeg->vfd_encoder->fops         = &s5p_jpeg_fops;
2859         jpeg->vfd_encoder->ioctl_ops    = &s5p_jpeg_ioctl_ops;
2860         jpeg->vfd_encoder->minor        = -1;
2861         jpeg->vfd_encoder->release      = video_device_release;
2862         jpeg->vfd_encoder->lock         = &jpeg->lock;
2863         jpeg->vfd_encoder->v4l2_dev     = &jpeg->v4l2_dev;
2864         jpeg->vfd_encoder->vfl_dir      = VFL_DIR_M2M;
2865
2866         ret = video_register_device(jpeg->vfd_encoder, VFL_TYPE_GRABBER, -1);
2867         if (ret) {
2868                 v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n");
2869                 video_device_release(jpeg->vfd_encoder);
2870                 goto vb2_allocator_rollback;
2871         }
2872
2873         video_set_drvdata(jpeg->vfd_encoder, jpeg);
2874         v4l2_info(&jpeg->v4l2_dev,
2875                   "encoder device registered as /dev/video%d\n",
2876                   jpeg->vfd_encoder->num);
2877
2878         /* JPEG decoder /dev/videoX node */
2879         jpeg->vfd_decoder = video_device_alloc();
2880         if (!jpeg->vfd_decoder) {
2881                 v4l2_err(&jpeg->v4l2_dev, "Failed to allocate video device\n");
2882                 ret = -ENOMEM;
2883                 goto enc_vdev_register_rollback;
2884         }
2885         snprintf(jpeg->vfd_decoder->name, sizeof(jpeg->vfd_decoder->name),
2886                                 "%s-dec", S5P_JPEG_M2M_NAME);
2887         jpeg->vfd_decoder->fops         = &s5p_jpeg_fops;
2888         jpeg->vfd_decoder->ioctl_ops    = &s5p_jpeg_ioctl_ops;
2889         jpeg->vfd_decoder->minor        = -1;
2890         jpeg->vfd_decoder->release      = video_device_release;
2891         jpeg->vfd_decoder->lock         = &jpeg->lock;
2892         jpeg->vfd_decoder->v4l2_dev     = &jpeg->v4l2_dev;
2893         jpeg->vfd_decoder->vfl_dir      = VFL_DIR_M2M;
2894
2895         ret = video_register_device(jpeg->vfd_decoder, VFL_TYPE_GRABBER, -1);
2896         if (ret) {
2897                 v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n");
2898                 video_device_release(jpeg->vfd_decoder);
2899                 goto enc_vdev_register_rollback;
2900         }
2901
2902         video_set_drvdata(jpeg->vfd_decoder, jpeg);
2903         v4l2_info(&jpeg->v4l2_dev,
2904                   "decoder device registered as /dev/video%d\n",
2905                   jpeg->vfd_decoder->num);
2906
2907         /* final statements & power management */
2908         platform_set_drvdata(pdev, jpeg);
2909
2910         pm_runtime_enable(&pdev->dev);
2911
2912         v4l2_info(&jpeg->v4l2_dev, "Samsung S5P JPEG codec\n");
2913
2914         return 0;
2915
2916 enc_vdev_register_rollback:
2917         video_unregister_device(jpeg->vfd_encoder);
2918
2919 vb2_allocator_rollback:
2920         vb2_dma_contig_cleanup_ctx(jpeg->alloc_ctx);
2921
2922 m2m_init_rollback:
2923         v4l2_m2m_release(jpeg->m2m_dev);
2924
2925 device_register_rollback:
2926         v4l2_device_unregister(&jpeg->v4l2_dev);
2927
2928         return ret;
2929 }
2930
2931 static int s5p_jpeg_remove(struct platform_device *pdev)
2932 {
2933         struct s5p_jpeg *jpeg = platform_get_drvdata(pdev);
2934         int i;
2935
2936         pm_runtime_disable(jpeg->dev);
2937
2938         video_unregister_device(jpeg->vfd_decoder);
2939         video_unregister_device(jpeg->vfd_encoder);
2940         vb2_dma_contig_cleanup_ctx(jpeg->alloc_ctx);
2941         v4l2_m2m_release(jpeg->m2m_dev);
2942         v4l2_device_unregister(&jpeg->v4l2_dev);
2943
2944         if (!pm_runtime_status_suspended(&pdev->dev)) {
2945                 for (i = jpeg->variant->num_clocks - 1; i >= 0; i--)
2946                         clk_disable_unprepare(jpeg->clocks[i]);
2947         }
2948
2949         return 0;
2950 }
2951
2952 #ifdef CONFIG_PM
2953 static int s5p_jpeg_runtime_suspend(struct device *dev)
2954 {
2955         struct s5p_jpeg *jpeg = dev_get_drvdata(dev);
2956         int i;
2957
2958         for (i = jpeg->variant->num_clocks - 1; i >= 0; i--)
2959                 clk_disable_unprepare(jpeg->clocks[i]);
2960
2961         return 0;
2962 }
2963
2964 static int s5p_jpeg_runtime_resume(struct device *dev)
2965 {
2966         struct s5p_jpeg *jpeg = dev_get_drvdata(dev);
2967         unsigned long flags;
2968         int i, ret;
2969
2970         for (i = 0; i < jpeg->variant->num_clocks; i++) {
2971                 ret = clk_prepare_enable(jpeg->clocks[i]);
2972                 if (ret) {
2973                         while (--i > 0)
2974                                 clk_disable_unprepare(jpeg->clocks[i]);
2975                         return ret;
2976                 }
2977         }
2978
2979         spin_lock_irqsave(&jpeg->slock, flags);
2980
2981         /*
2982          * JPEG IP allows storing two Huffman tables for each component.
2983          * We fill table 0 for each component and do this here only
2984          * for S5PC210 and Exynos3250 SoCs. Exynos4x12 and Exynos542x SoC
2985          * require programming their Huffman tables each time the encoding
2986          * process is initialized, and thus it is accomplished in the
2987          * device_run callback of m2m_ops.
2988          */
2989         if (!jpeg->variant->htbl_reinit) {
2990                 s5p_jpeg_set_hdctbl(jpeg->regs);
2991                 s5p_jpeg_set_hdctblg(jpeg->regs);
2992                 s5p_jpeg_set_hactbl(jpeg->regs);
2993                 s5p_jpeg_set_hactblg(jpeg->regs);
2994         }
2995
2996         spin_unlock_irqrestore(&jpeg->slock, flags);
2997
2998         return 0;
2999 }
3000 #endif /* CONFIG_PM */
3001
3002 #ifdef CONFIG_PM_SLEEP
3003 static int s5p_jpeg_suspend(struct device *dev)
3004 {
3005         if (pm_runtime_suspended(dev))
3006                 return 0;
3007
3008         return s5p_jpeg_runtime_suspend(dev);
3009 }
3010
3011 static int s5p_jpeg_resume(struct device *dev)
3012 {
3013         if (pm_runtime_suspended(dev))
3014                 return 0;
3015
3016         return s5p_jpeg_runtime_resume(dev);
3017 }
3018 #endif
3019
3020 static const struct dev_pm_ops s5p_jpeg_pm_ops = {
3021         SET_SYSTEM_SLEEP_PM_OPS(s5p_jpeg_suspend, s5p_jpeg_resume)
3022         SET_RUNTIME_PM_OPS(s5p_jpeg_runtime_suspend, s5p_jpeg_runtime_resume, NULL)
3023 };
3024
3025 static struct s5p_jpeg_variant s5p_jpeg_drvdata = {
3026         .version        = SJPEG_S5P,
3027         .jpeg_irq       = s5p_jpeg_irq,
3028         .m2m_ops        = &s5p_jpeg_m2m_ops,
3029         .fmt_ver_flag   = SJPEG_FMT_FLAG_S5P,
3030         .clk_names      = {"jpeg"},
3031         .num_clocks     = 1,
3032 };
3033
3034 static struct s5p_jpeg_variant exynos3250_jpeg_drvdata = {
3035         .version        = SJPEG_EXYNOS3250,
3036         .jpeg_irq       = exynos3250_jpeg_irq,
3037         .m2m_ops        = &exynos3250_jpeg_m2m_ops,
3038         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS3250,
3039         .hw3250_compat  = 1,
3040         .clk_names      = {"jpeg", "sclk"},
3041         .num_clocks     = 2,
3042 };
3043
3044 static struct s5p_jpeg_variant exynos4_jpeg_drvdata = {
3045         .version        = SJPEG_EXYNOS4,
3046         .jpeg_irq       = exynos4_jpeg_irq,
3047         .m2m_ops        = &exynos4_jpeg_m2m_ops,
3048         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS4,
3049         .htbl_reinit    = 1,
3050         .clk_names      = {"jpeg"},
3051         .num_clocks     = 1,
3052         .hw_ex4_compat  = 1,
3053 };
3054
3055 static struct s5p_jpeg_variant exynos5420_jpeg_drvdata = {
3056         .version        = SJPEG_EXYNOS5420,
3057         .jpeg_irq       = exynos3250_jpeg_irq,          /* intentionally 3250 */
3058         .m2m_ops        = &exynos3250_jpeg_m2m_ops,     /* intentionally 3250 */
3059         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS3250,    /* intentionally 3250 */
3060         .hw3250_compat  = 1,
3061         .htbl_reinit    = 1,
3062         .clk_names      = {"jpeg"},
3063         .num_clocks     = 1,
3064 };
3065
3066 static struct s5p_jpeg_variant exynos5433_jpeg_drvdata = {
3067         .version        = SJPEG_EXYNOS5433,
3068         .jpeg_irq       = exynos4_jpeg_irq,
3069         .m2m_ops        = &exynos4_jpeg_m2m_ops,
3070         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS4,
3071         .htbl_reinit    = 1,
3072         .clk_names      = {"pclk", "aclk", "aclk_xiu", "sclk"},
3073         .num_clocks     = 4,
3074         .hw_ex4_compat  = 1,
3075 };
3076
3077 static const struct of_device_id samsung_jpeg_match[] = {
3078         {
3079                 .compatible = "samsung,s5pv210-jpeg",
3080                 .data = &s5p_jpeg_drvdata,
3081         }, {
3082                 .compatible = "samsung,exynos3250-jpeg",
3083                 .data = &exynos3250_jpeg_drvdata,
3084         }, {
3085                 .compatible = "samsung,exynos4210-jpeg",
3086                 .data = &exynos4_jpeg_drvdata,
3087         }, {
3088                 .compatible = "samsung,exynos4212-jpeg",
3089                 .data = &exynos4_jpeg_drvdata,
3090         }, {
3091                 .compatible = "samsung,exynos5420-jpeg",
3092                 .data = &exynos5420_jpeg_drvdata,
3093         }, {
3094                 .compatible = "samsung,exynos5433-jpeg",
3095                 .data = &exynos5433_jpeg_drvdata,
3096         },
3097         {},
3098 };
3099
3100 MODULE_DEVICE_TABLE(of, samsung_jpeg_match);
3101
3102 static void *jpeg_get_drv_data(struct device *dev)
3103 {
3104         struct s5p_jpeg_variant *driver_data = NULL;
3105         const struct of_device_id *match;
3106
3107         if (!IS_ENABLED(CONFIG_OF) || !dev->of_node)
3108                 return &s5p_jpeg_drvdata;
3109
3110         match = of_match_node(samsung_jpeg_match, dev->of_node);
3111
3112         if (match)
3113                 driver_data = (struct s5p_jpeg_variant *)match->data;
3114
3115         return driver_data;
3116 }
3117
3118 static struct platform_driver s5p_jpeg_driver = {
3119         .probe = s5p_jpeg_probe,
3120         .remove = s5p_jpeg_remove,
3121         .driver = {
3122                 .of_match_table = of_match_ptr(samsung_jpeg_match),
3123                 .name           = S5P_JPEG_M2M_NAME,
3124                 .pm             = &s5p_jpeg_pm_ops,
3125         },
3126 };
3127
3128 module_platform_driver(s5p_jpeg_driver);
3129
3130 MODULE_AUTHOR("Andrzej Pietrasiewicz <andrzej.p@samsung.com>");
3131 MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>");
3132 MODULE_DESCRIPTION("Samsung JPEG codec driver");
3133 MODULE_LICENSE("GPL");