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         int padding = 0;
1552
1553         if (pix_fmt == V4L2_PIX_FMT_RGB32 ||
1554             pix_fmt == V4L2_PIX_FMT_RGB565 ||
1555             pix_fmt == V4L2_PIX_FMT_NV24 ||
1556             pix_fmt == V4L2_PIX_FMT_NV42 ||
1557             pix_fmt == V4L2_PIX_FMT_NV12 ||
1558             pix_fmt == V4L2_PIX_FMT_NV21 ||
1559             pix_fmt == V4L2_PIX_FMT_YUV420)
1560                 wh_align = 4;
1561         else
1562                 wh_align = 1;
1563
1564         jpeg_bound_align_image(ctx, &w, S5P_JPEG_MIN_WIDTH,
1565                                S5P_JPEG_MAX_WIDTH, wh_align,
1566                                &h, S5P_JPEG_MIN_HEIGHT,
1567                                S5P_JPEG_MAX_HEIGHT, wh_align);
1568
1569         if (ctx->jpeg->variant->version == SJPEG_EXYNOS4)
1570                 padding = PAGE_SIZE;
1571
1572         return (w * h * fmt_depth >> 3) + padding;
1573 }
1574
1575 static int exynos3250_jpeg_try_downscale(struct s5p_jpeg_ctx *ctx,
1576                                    struct v4l2_rect *r);
1577
1578 static int s5p_jpeg_s_fmt(struct s5p_jpeg_ctx *ct, struct v4l2_format *f)
1579 {
1580         struct vb2_queue *vq;
1581         struct s5p_jpeg_q_data *q_data = NULL;
1582         struct v4l2_pix_format *pix = &f->fmt.pix;
1583         struct v4l2_ctrl *ctrl_subs;
1584         struct v4l2_rect scale_rect;
1585         unsigned int f_type;
1586
1587         vq = v4l2_m2m_get_vq(ct->fh.m2m_ctx, f->type);
1588         if (!vq)
1589                 return -EINVAL;
1590
1591         q_data = get_q_data(ct, f->type);
1592         BUG_ON(q_data == NULL);
1593
1594         if (vb2_is_busy(vq)) {
1595                 v4l2_err(&ct->jpeg->v4l2_dev, "%s queue busy\n", __func__);
1596                 return -EBUSY;
1597         }
1598
1599         f_type = V4L2_TYPE_IS_OUTPUT(f->type) ?
1600                         FMT_TYPE_OUTPUT : FMT_TYPE_CAPTURE;
1601
1602         q_data->fmt = s5p_jpeg_find_format(ct, pix->pixelformat, f_type);
1603         q_data->w = pix->width;
1604         q_data->h = pix->height;
1605         if (q_data->fmt->fourcc != V4L2_PIX_FMT_JPEG) {
1606                 /*
1607                  * During encoding Exynos4x12 SoCs access wider memory area
1608                  * than it results from Image_x and Image_y values written to
1609                  * the JPEG_IMAGE_SIZE register. In order to avoid sysmmu
1610                  * page fault calculate proper buffer size in such a case.
1611                  */
1612                 if (ct->jpeg->variant->hw_ex4_compat &&
1613                     f_type == FMT_TYPE_OUTPUT && ct->mode == S5P_JPEG_ENCODE)
1614                         q_data->size = exynos4_jpeg_get_output_buffer_size(ct,
1615                                                         f,
1616                                                         q_data->fmt->depth);
1617                 else
1618                         q_data->size = q_data->w * q_data->h *
1619                                                 q_data->fmt->depth >> 3;
1620         } else {
1621                 q_data->size = pix->sizeimage;
1622         }
1623
1624         if (f_type == FMT_TYPE_OUTPUT) {
1625                 ctrl_subs = v4l2_ctrl_find(&ct->ctrl_handler,
1626                                         V4L2_CID_JPEG_CHROMA_SUBSAMPLING);
1627                 if (ctrl_subs)
1628                         v4l2_ctrl_s_ctrl(ctrl_subs, q_data->fmt->subsampling);
1629                 ct->crop_altered = false;
1630         }
1631
1632         /*
1633          * For decoding init crop_rect with capture buffer dimmensions which
1634          * contain aligned dimensions of the input JPEG image and do it only
1635          * if crop rectangle hasn't been altered by the user space e.g. with
1636          * S_SELECTION ioctl. For encoding assign output buffer dimensions.
1637          */
1638         if (!ct->crop_altered &&
1639             ((ct->mode == S5P_JPEG_DECODE && f_type == FMT_TYPE_CAPTURE) ||
1640              (ct->mode == S5P_JPEG_ENCODE && f_type == FMT_TYPE_OUTPUT))) {
1641                 ct->crop_rect.width = pix->width;
1642                 ct->crop_rect.height = pix->height;
1643         }
1644
1645         /*
1646          * Prevent downscaling to YUV420 format by more than 2
1647          * for Exynos3250/compatible SoC as it produces broken raw image
1648          * in such cases.
1649          */
1650         if (ct->mode == S5P_JPEG_DECODE &&
1651             f_type == FMT_TYPE_CAPTURE &&
1652             ct->jpeg->variant->hw3250_compat &&
1653             pix->pixelformat == V4L2_PIX_FMT_YUV420 &&
1654             ct->scale_factor > 2) {
1655                 scale_rect.width = ct->out_q.w / 2;
1656                 scale_rect.height = ct->out_q.h / 2;
1657                 exynos3250_jpeg_try_downscale(ct, &scale_rect);
1658         }
1659
1660         return 0;
1661 }
1662
1663 static int s5p_jpeg_s_fmt_vid_cap(struct file *file, void *priv,
1664                                 struct v4l2_format *f)
1665 {
1666         int ret;
1667
1668         ret = s5p_jpeg_try_fmt_vid_cap(file, priv, f);
1669         if (ret)
1670                 return ret;
1671
1672         return s5p_jpeg_s_fmt(fh_to_ctx(priv), f);
1673 }
1674
1675 static int s5p_jpeg_s_fmt_vid_out(struct file *file, void *priv,
1676                                 struct v4l2_format *f)
1677 {
1678         int ret;
1679
1680         ret = s5p_jpeg_try_fmt_vid_out(file, priv, f);
1681         if (ret)
1682                 return ret;
1683
1684         return s5p_jpeg_s_fmt(fh_to_ctx(priv), f);
1685 }
1686
1687 static int exynos3250_jpeg_try_downscale(struct s5p_jpeg_ctx *ctx,
1688                                    struct v4l2_rect *r)
1689 {
1690         int w_ratio, h_ratio, scale_factor, cur_ratio, i;
1691
1692         w_ratio = ctx->out_q.w / r->width;
1693         h_ratio = ctx->out_q.h / r->height;
1694
1695         scale_factor = w_ratio > h_ratio ? w_ratio : h_ratio;
1696         scale_factor = clamp_val(scale_factor, 1, 8);
1697
1698         /* Align scale ratio to the nearest power of 2 */
1699         for (i = 0; i <= 3; ++i) {
1700                 cur_ratio = 1 << i;
1701                 if (scale_factor <= cur_ratio) {
1702                         ctx->scale_factor = cur_ratio;
1703                         break;
1704                 }
1705         }
1706
1707         r->width = round_down(ctx->out_q.w / ctx->scale_factor, 2);
1708         r->height = round_down(ctx->out_q.h / ctx->scale_factor, 2);
1709
1710         ctx->crop_rect.width = r->width;
1711         ctx->crop_rect.height = r->height;
1712         ctx->crop_rect.left = 0;
1713         ctx->crop_rect.top = 0;
1714
1715         ctx->crop_altered = true;
1716
1717         return 0;
1718 }
1719
1720 /* Return 1 if rectangle a is enclosed in rectangle b, or 0 otherwise. */
1721 static int enclosed_rectangle(struct v4l2_rect *a, struct v4l2_rect *b)
1722 {
1723         if (a->left < b->left || a->top < b->top)
1724                 return 0;
1725         if (a->left + a->width > b->left + b->width)
1726                 return 0;
1727         if (a->top + a->height > b->top + b->height)
1728                 return 0;
1729
1730         return 1;
1731 }
1732
1733 static int exynos3250_jpeg_try_crop(struct s5p_jpeg_ctx *ctx,
1734                                    struct v4l2_rect *r)
1735 {
1736         struct v4l2_rect base_rect;
1737         int w_step, h_step;
1738
1739         switch (ctx->cap_q.fmt->fourcc) {
1740         case V4L2_PIX_FMT_NV12:
1741         case V4L2_PIX_FMT_NV21:
1742                 w_step = 1;
1743                 h_step = 2;
1744                 break;
1745         case V4L2_PIX_FMT_YUV420:
1746                 w_step = 2;
1747                 h_step = 2;
1748                 break;
1749         default:
1750                 w_step = 1;
1751                 h_step = 1;
1752                 break;
1753         }
1754
1755         base_rect.top = 0;
1756         base_rect.left = 0;
1757         base_rect.width = ctx->out_q.w;
1758         base_rect.height = ctx->out_q.h;
1759
1760         r->width = round_down(r->width, w_step);
1761         r->height = round_down(r->height, h_step);
1762         r->left = round_down(r->left, 2);
1763         r->top = round_down(r->top, 2);
1764
1765         if (!enclosed_rectangle(r, &base_rect))
1766                 return -EINVAL;
1767
1768         ctx->crop_rect.left = r->left;
1769         ctx->crop_rect.top = r->top;
1770         ctx->crop_rect.width = r->width;
1771         ctx->crop_rect.height = r->height;
1772
1773         ctx->crop_altered = true;
1774
1775         return 0;
1776 }
1777
1778 /*
1779  * V4L2 controls
1780  */
1781
1782 static int s5p_jpeg_g_selection(struct file *file, void *priv,
1783                          struct v4l2_selection *s)
1784 {
1785         struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1786
1787         if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
1788             s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1789                 return -EINVAL;
1790
1791         /* For JPEG blob active == default == bounds */
1792         switch (s->target) {
1793         case V4L2_SEL_TGT_CROP:
1794         case V4L2_SEL_TGT_CROP_BOUNDS:
1795         case V4L2_SEL_TGT_CROP_DEFAULT:
1796         case V4L2_SEL_TGT_COMPOSE_DEFAULT:
1797                 s->r.width = ctx->out_q.w;
1798                 s->r.height = ctx->out_q.h;
1799                 s->r.left = 0;
1800                 s->r.top = 0;
1801                 break;
1802         case V4L2_SEL_TGT_COMPOSE:
1803         case V4L2_SEL_TGT_COMPOSE_BOUNDS:
1804         case V4L2_SEL_TGT_COMPOSE_PADDED:
1805                 s->r.width = ctx->crop_rect.width;
1806                 s->r.height =  ctx->crop_rect.height;
1807                 s->r.left = ctx->crop_rect.left;
1808                 s->r.top = ctx->crop_rect.top;
1809                 break;
1810         default:
1811                 return -EINVAL;
1812         }
1813         return 0;
1814 }
1815
1816 /*
1817  * V4L2 controls
1818  */
1819 static int s5p_jpeg_s_selection(struct file *file, void *fh,
1820                                   struct v4l2_selection *s)
1821 {
1822         struct s5p_jpeg_ctx *ctx = fh_to_ctx(file->private_data);
1823         struct v4l2_rect *rect = &s->r;
1824         int ret = -EINVAL;
1825
1826         if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1827                 return -EINVAL;
1828
1829         if (s->target == V4L2_SEL_TGT_COMPOSE) {
1830                 if (ctx->mode != S5P_JPEG_DECODE)
1831                         return -EINVAL;
1832                 if (ctx->jpeg->variant->hw3250_compat)
1833                         ret = exynos3250_jpeg_try_downscale(ctx, rect);
1834         } else if (s->target == V4L2_SEL_TGT_CROP) {
1835                 if (ctx->mode != S5P_JPEG_ENCODE)
1836                         return -EINVAL;
1837                 if (ctx->jpeg->variant->hw3250_compat)
1838                         ret = exynos3250_jpeg_try_crop(ctx, rect);
1839         }
1840
1841         return ret;
1842 }
1843
1844 static int s5p_jpeg_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1845 {
1846         struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl);
1847         struct s5p_jpeg *jpeg = ctx->jpeg;
1848         unsigned long flags;
1849
1850         switch (ctrl->id) {
1851         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1852                 spin_lock_irqsave(&jpeg->slock, flags);
1853                 ctrl->val = s5p_jpeg_to_user_subsampling(ctx);
1854                 spin_unlock_irqrestore(&jpeg->slock, flags);
1855                 break;
1856         }
1857
1858         return 0;
1859 }
1860
1861 static int s5p_jpeg_adjust_subs_ctrl(struct s5p_jpeg_ctx *ctx, int *ctrl_val)
1862 {
1863         switch (ctx->jpeg->variant->version) {
1864         case SJPEG_S5P:
1865                 return 0;
1866         case SJPEG_EXYNOS3250:
1867         case SJPEG_EXYNOS5420:
1868                 /*
1869                  * The exynos3250/compatible device can produce JPEG image only
1870                  * of 4:4:4 subsampling when given RGB32 source image.
1871                  */
1872                 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB32)
1873                         *ctrl_val = 0;
1874                 break;
1875         case SJPEG_EXYNOS4:
1876                 /*
1877                  * The exynos4x12 device requires input raw image fourcc
1878                  * to be V4L2_PIX_FMT_GREY if gray jpeg format
1879                  * is to be set.
1880                  */
1881                 if (ctx->out_q.fmt->fourcc != V4L2_PIX_FMT_GREY &&
1882                     *ctrl_val == V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY)
1883                         return -EINVAL;
1884                 break;
1885         }
1886
1887         /*
1888          * The exynos4x12 and exynos3250/compatible devices require resulting
1889          * jpeg subsampling not to be lower than the input raw image
1890          * subsampling.
1891          */
1892         if (ctx->out_q.fmt->subsampling > *ctrl_val)
1893                 *ctrl_val = ctx->out_q.fmt->subsampling;
1894
1895         return 0;
1896 }
1897
1898 static int s5p_jpeg_try_ctrl(struct v4l2_ctrl *ctrl)
1899 {
1900         struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl);
1901         unsigned long flags;
1902         int ret = 0;
1903
1904         spin_lock_irqsave(&ctx->jpeg->slock, flags);
1905
1906         if (ctrl->id == V4L2_CID_JPEG_CHROMA_SUBSAMPLING)
1907                 ret = s5p_jpeg_adjust_subs_ctrl(ctx, &ctrl->val);
1908
1909         spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
1910         return ret;
1911 }
1912
1913 static int s5p_jpeg_s_ctrl(struct v4l2_ctrl *ctrl)
1914 {
1915         struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl);
1916         unsigned long flags;
1917
1918         spin_lock_irqsave(&ctx->jpeg->slock, flags);
1919
1920         switch (ctrl->id) {
1921         case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1922                 ctx->compr_quality = ctrl->val;
1923                 break;
1924         case V4L2_CID_JPEG_RESTART_INTERVAL:
1925                 ctx->restart_interval = ctrl->val;
1926                 break;
1927         case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1928                 ctx->subsampling = ctrl->val;
1929                 break;
1930         }
1931
1932         spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
1933         return 0;
1934 }
1935
1936 static const struct v4l2_ctrl_ops s5p_jpeg_ctrl_ops = {
1937         .g_volatile_ctrl        = s5p_jpeg_g_volatile_ctrl,
1938         .try_ctrl               = s5p_jpeg_try_ctrl,
1939         .s_ctrl                 = s5p_jpeg_s_ctrl,
1940 };
1941
1942 static int s5p_jpeg_controls_create(struct s5p_jpeg_ctx *ctx)
1943 {
1944         unsigned int mask = ~0x27; /* 444, 422, 420, GRAY */
1945         struct v4l2_ctrl *ctrl;
1946         int ret;
1947
1948         v4l2_ctrl_handler_init(&ctx->ctrl_handler, 3);
1949
1950         if (ctx->mode == S5P_JPEG_ENCODE) {
1951                 v4l2_ctrl_new_std(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops,
1952                                   V4L2_CID_JPEG_COMPRESSION_QUALITY,
1953                                   0, 3, 1, S5P_JPEG_COMPR_QUAL_WORST);
1954
1955                 v4l2_ctrl_new_std(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops,
1956                                   V4L2_CID_JPEG_RESTART_INTERVAL,
1957                                   0, 3, 0xffff, 0);
1958                 if (ctx->jpeg->variant->version == SJPEG_S5P)
1959                         mask = ~0x06; /* 422, 420 */
1960         }
1961
1962         ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops,
1963                                       V4L2_CID_JPEG_CHROMA_SUBSAMPLING,
1964                                       V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY, mask,
1965                                       V4L2_JPEG_CHROMA_SUBSAMPLING_422);
1966
1967         if (ctx->ctrl_handler.error) {
1968                 ret = ctx->ctrl_handler.error;
1969                 goto error_free;
1970         }
1971
1972         if (ctx->mode == S5P_JPEG_DECODE)
1973                 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE |
1974                         V4L2_CTRL_FLAG_READ_ONLY;
1975
1976         ret = v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
1977         if (ret < 0)
1978                 goto error_free;
1979
1980         return ret;
1981
1982 error_free:
1983         v4l2_ctrl_handler_free(&ctx->ctrl_handler);
1984         return ret;
1985 }
1986
1987 static const struct v4l2_ioctl_ops s5p_jpeg_ioctl_ops = {
1988         .vidioc_querycap                = s5p_jpeg_querycap,
1989
1990         .vidioc_enum_fmt_vid_cap        = s5p_jpeg_enum_fmt_vid_cap,
1991         .vidioc_enum_fmt_vid_out        = s5p_jpeg_enum_fmt_vid_out,
1992
1993         .vidioc_g_fmt_vid_cap           = s5p_jpeg_g_fmt,
1994         .vidioc_g_fmt_vid_out           = s5p_jpeg_g_fmt,
1995
1996         .vidioc_try_fmt_vid_cap         = s5p_jpeg_try_fmt_vid_cap,
1997         .vidioc_try_fmt_vid_out         = s5p_jpeg_try_fmt_vid_out,
1998
1999         .vidioc_s_fmt_vid_cap           = s5p_jpeg_s_fmt_vid_cap,
2000         .vidioc_s_fmt_vid_out           = s5p_jpeg_s_fmt_vid_out,
2001
2002         .vidioc_reqbufs                 = v4l2_m2m_ioctl_reqbufs,
2003         .vidioc_querybuf                = v4l2_m2m_ioctl_querybuf,
2004         .vidioc_qbuf                    = v4l2_m2m_ioctl_qbuf,
2005         .vidioc_dqbuf                   = v4l2_m2m_ioctl_dqbuf,
2006
2007         .vidioc_streamon                = v4l2_m2m_ioctl_streamon,
2008         .vidioc_streamoff               = v4l2_m2m_ioctl_streamoff,
2009
2010         .vidioc_g_selection             = s5p_jpeg_g_selection,
2011         .vidioc_s_selection             = s5p_jpeg_s_selection,
2012 };
2013
2014 /*
2015  * ============================================================================
2016  * mem2mem callbacks
2017  * ============================================================================
2018  */
2019
2020 static void s5p_jpeg_device_run(void *priv)
2021 {
2022         struct s5p_jpeg_ctx *ctx = priv;
2023         struct s5p_jpeg *jpeg = ctx->jpeg;
2024         struct vb2_buffer *src_buf, *dst_buf;
2025         unsigned long src_addr, dst_addr, flags;
2026
2027         spin_lock_irqsave(&ctx->jpeg->slock, flags);
2028
2029         src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2030         dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2031         src_addr = vb2_dma_contig_plane_dma_addr(src_buf, 0);
2032         dst_addr = vb2_dma_contig_plane_dma_addr(dst_buf, 0);
2033
2034         s5p_jpeg_reset(jpeg->regs);
2035         s5p_jpeg_poweron(jpeg->regs);
2036         s5p_jpeg_proc_mode(jpeg->regs, ctx->mode);
2037         if (ctx->mode == S5P_JPEG_ENCODE) {
2038                 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565)
2039                         s5p_jpeg_input_raw_mode(jpeg->regs,
2040                                                         S5P_JPEG_RAW_IN_565);
2041                 else
2042                         s5p_jpeg_input_raw_mode(jpeg->regs,
2043                                                         S5P_JPEG_RAW_IN_422);
2044                 s5p_jpeg_subsampling_mode(jpeg->regs, ctx->subsampling);
2045                 s5p_jpeg_dri(jpeg->regs, ctx->restart_interval);
2046                 s5p_jpeg_x(jpeg->regs, ctx->out_q.w);
2047                 s5p_jpeg_y(jpeg->regs, ctx->out_q.h);
2048                 s5p_jpeg_imgadr(jpeg->regs, src_addr);
2049                 s5p_jpeg_jpgadr(jpeg->regs, dst_addr);
2050
2051                 /* ultimately comes from sizeimage from userspace */
2052                 s5p_jpeg_enc_stream_int(jpeg->regs, ctx->cap_q.size);
2053
2054                 /* JPEG RGB to YCbCr conversion matrix */
2055                 s5p_jpeg_coef(jpeg->regs, 1, 1, S5P_JPEG_COEF11);
2056                 s5p_jpeg_coef(jpeg->regs, 1, 2, S5P_JPEG_COEF12);
2057                 s5p_jpeg_coef(jpeg->regs, 1, 3, S5P_JPEG_COEF13);
2058                 s5p_jpeg_coef(jpeg->regs, 2, 1, S5P_JPEG_COEF21);
2059                 s5p_jpeg_coef(jpeg->regs, 2, 2, S5P_JPEG_COEF22);
2060                 s5p_jpeg_coef(jpeg->regs, 2, 3, S5P_JPEG_COEF23);
2061                 s5p_jpeg_coef(jpeg->regs, 3, 1, S5P_JPEG_COEF31);
2062                 s5p_jpeg_coef(jpeg->regs, 3, 2, S5P_JPEG_COEF32);
2063                 s5p_jpeg_coef(jpeg->regs, 3, 3, S5P_JPEG_COEF33);
2064
2065                 /*
2066                  * JPEG IP allows storing 4 quantization tables
2067                  * We fill table 0 for luma and table 1 for chroma
2068                  */
2069                 s5p_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality);
2070                 s5p_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality);
2071                 /* use table 0 for Y */
2072                 s5p_jpeg_qtbl(jpeg->regs, 1, 0);
2073                 /* use table 1 for Cb and Cr*/
2074                 s5p_jpeg_qtbl(jpeg->regs, 2, 1);
2075                 s5p_jpeg_qtbl(jpeg->regs, 3, 1);
2076
2077                 /* Y, Cb, Cr use Huffman table 0 */
2078                 s5p_jpeg_htbl_ac(jpeg->regs, 1);
2079                 s5p_jpeg_htbl_dc(jpeg->regs, 1);
2080                 s5p_jpeg_htbl_ac(jpeg->regs, 2);
2081                 s5p_jpeg_htbl_dc(jpeg->regs, 2);
2082                 s5p_jpeg_htbl_ac(jpeg->regs, 3);
2083                 s5p_jpeg_htbl_dc(jpeg->regs, 3);
2084         } else { /* S5P_JPEG_DECODE */
2085                 s5p_jpeg_rst_int_enable(jpeg->regs, true);
2086                 s5p_jpeg_data_num_int_enable(jpeg->regs, true);
2087                 s5p_jpeg_final_mcu_num_int_enable(jpeg->regs, true);
2088                 if (ctx->cap_q.fmt->fourcc == V4L2_PIX_FMT_YUYV)
2089                         s5p_jpeg_outform_raw(jpeg->regs, S5P_JPEG_RAW_OUT_422);
2090                 else
2091                         s5p_jpeg_outform_raw(jpeg->regs, S5P_JPEG_RAW_OUT_420);
2092                 s5p_jpeg_jpgadr(jpeg->regs, src_addr);
2093                 s5p_jpeg_imgadr(jpeg->regs, dst_addr);
2094         }
2095
2096         s5p_jpeg_start(jpeg->regs);
2097
2098         spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
2099 }
2100
2101 static void exynos4_jpeg_set_img_addr(struct s5p_jpeg_ctx *ctx)
2102 {
2103         struct s5p_jpeg *jpeg = ctx->jpeg;
2104         struct s5p_jpeg_fmt *fmt;
2105         struct vb2_buffer *vb;
2106         struct s5p_jpeg_addr jpeg_addr = {};
2107         u32 pix_size, padding_bytes = 0;
2108
2109         jpeg_addr.cb = 0;
2110         jpeg_addr.cr = 0;
2111
2112         pix_size = ctx->cap_q.w * ctx->cap_q.h;
2113
2114         if (ctx->mode == S5P_JPEG_ENCODE) {
2115                 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2116                 fmt = ctx->out_q.fmt;
2117                 if (ctx->out_q.w % 2 && fmt->h_align > 0)
2118                         padding_bytes = ctx->out_q.h;
2119         } else {
2120                 fmt = ctx->cap_q.fmt;
2121                 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2122         }
2123
2124         jpeg_addr.y = vb2_dma_contig_plane_dma_addr(vb, 0);
2125
2126         if (fmt->colplanes == 2) {
2127                 jpeg_addr.cb = jpeg_addr.y + pix_size - padding_bytes;
2128         } else if (fmt->colplanes == 3) {
2129                 jpeg_addr.cb = jpeg_addr.y + pix_size;
2130                 if (fmt->fourcc == V4L2_PIX_FMT_YUV420)
2131                         jpeg_addr.cr = jpeg_addr.cb + pix_size / 4;
2132                 else
2133                         jpeg_addr.cr = jpeg_addr.cb + pix_size / 2;
2134         }
2135
2136         exynos4_jpeg_set_frame_buf_address(jpeg->regs, &jpeg_addr);
2137 }
2138
2139 static void exynos4_jpeg_set_jpeg_addr(struct s5p_jpeg_ctx *ctx)
2140 {
2141         struct s5p_jpeg *jpeg = ctx->jpeg;
2142         struct vb2_buffer *vb;
2143         unsigned int jpeg_addr = 0;
2144
2145         if (ctx->mode == S5P_JPEG_ENCODE)
2146                 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2147         else
2148                 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2149
2150         jpeg_addr = vb2_dma_contig_plane_dma_addr(vb, 0);
2151         if (jpeg->variant->version == SJPEG_EXYNOS5433 &&
2152             ctx->mode == S5P_JPEG_DECODE)
2153                 jpeg_addr += ctx->out_q.sos;
2154         exynos4_jpeg_set_stream_buf_address(jpeg->regs, jpeg_addr);
2155 }
2156
2157 static inline void exynos4_jpeg_set_img_fmt(void __iomem *base,
2158                                             unsigned int img_fmt)
2159 {
2160         __exynos4_jpeg_set_img_fmt(base, img_fmt, SJPEG_EXYNOS4);
2161 }
2162
2163 static inline void exynos5433_jpeg_set_img_fmt(void __iomem *base,
2164                                                unsigned int img_fmt)
2165 {
2166         __exynos4_jpeg_set_img_fmt(base, img_fmt, SJPEG_EXYNOS5433);
2167 }
2168
2169 static inline void exynos4_jpeg_set_enc_out_fmt(void __iomem *base,
2170                                                 unsigned int out_fmt)
2171 {
2172         __exynos4_jpeg_set_enc_out_fmt(base, out_fmt, SJPEG_EXYNOS4);
2173 }
2174
2175 static inline void exynos5433_jpeg_set_enc_out_fmt(void __iomem *base,
2176                                                    unsigned int out_fmt)
2177 {
2178         __exynos4_jpeg_set_enc_out_fmt(base, out_fmt, SJPEG_EXYNOS5433);
2179 }
2180
2181 static void exynos4_jpeg_device_run(void *priv)
2182 {
2183         struct s5p_jpeg_ctx *ctx = priv;
2184         struct s5p_jpeg *jpeg = ctx->jpeg;
2185         unsigned int bitstream_size;
2186         unsigned long flags;
2187
2188         spin_lock_irqsave(&jpeg->slock, flags);
2189
2190         if (ctx->mode == S5P_JPEG_ENCODE) {
2191                 exynos4_jpeg_sw_reset(jpeg->regs);
2192                 exynos4_jpeg_set_interrupt(jpeg->regs, jpeg->variant->version);
2193                 exynos4_jpeg_set_huf_table_enable(jpeg->regs, 1);
2194
2195                 exynos4_jpeg_set_huff_tbl(jpeg->regs);
2196
2197                 /*
2198                  * JPEG IP allows storing 4 quantization tables
2199                  * We fill table 0 for luma and table 1 for chroma
2200                  */
2201                 exynos4_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality);
2202                 exynos4_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality);
2203
2204                 exynos4_jpeg_set_encode_tbl_select(jpeg->regs,
2205                                                         ctx->compr_quality);
2206                 exynos4_jpeg_set_stream_size(jpeg->regs, ctx->cap_q.w,
2207                                                         ctx->cap_q.h);
2208
2209                 if (ctx->jpeg->variant->version == SJPEG_EXYNOS4) {
2210                         exynos4_jpeg_set_enc_out_fmt(jpeg->regs,
2211                                                      ctx->subsampling);
2212                         exynos4_jpeg_set_img_fmt(jpeg->regs,
2213                                                  ctx->out_q.fmt->fourcc);
2214                 } else {
2215                         exynos5433_jpeg_set_enc_out_fmt(jpeg->regs,
2216                                                         ctx->subsampling);
2217                         exynos5433_jpeg_set_img_fmt(jpeg->regs,
2218                                                     ctx->out_q.fmt->fourcc);
2219                 }
2220                 exynos4_jpeg_set_img_addr(ctx);
2221                 exynos4_jpeg_set_jpeg_addr(ctx);
2222                 exynos4_jpeg_set_encode_hoff_cnt(jpeg->regs,
2223                                                         ctx->out_q.fmt->fourcc);
2224         } else {
2225                 exynos4_jpeg_sw_reset(jpeg->regs);
2226                 exynos4_jpeg_set_interrupt(jpeg->regs,
2227                                            jpeg->variant->version);
2228                 exynos4_jpeg_set_img_addr(ctx);
2229                 exynos4_jpeg_set_jpeg_addr(ctx);
2230
2231                 if (jpeg->variant->version == SJPEG_EXYNOS5433) {
2232                         exynos4_jpeg_parse_huff_tbl(ctx);
2233                         exynos4_jpeg_parse_decode_h_tbl(ctx);
2234
2235                         exynos4_jpeg_parse_q_tbl(ctx);
2236                         exynos4_jpeg_parse_decode_q_tbl(ctx);
2237
2238                         exynos4_jpeg_set_huf_table_enable(jpeg->regs, 1);
2239
2240                         exynos4_jpeg_set_stream_size(jpeg->regs, ctx->cap_q.w,
2241                                         ctx->cap_q.h);
2242                         exynos5433_jpeg_set_enc_out_fmt(jpeg->regs,
2243                                                         ctx->subsampling);
2244                         exynos5433_jpeg_set_img_fmt(jpeg->regs,
2245                                                     ctx->cap_q.fmt->fourcc);
2246                         bitstream_size = DIV_ROUND_UP(ctx->out_q.size, 16);
2247                 } else {
2248                         exynos4_jpeg_set_img_fmt(jpeg->regs,
2249                                                  ctx->cap_q.fmt->fourcc);
2250                         bitstream_size = DIV_ROUND_UP(ctx->out_q.size, 32);
2251                 }
2252
2253                 exynos4_jpeg_set_dec_bitstream_size(jpeg->regs, bitstream_size);
2254         }
2255
2256         exynos4_jpeg_set_enc_dec_mode(jpeg->regs, ctx->mode);
2257
2258         spin_unlock_irqrestore(&jpeg->slock, flags);
2259 }
2260
2261 static void exynos3250_jpeg_set_img_addr(struct s5p_jpeg_ctx *ctx)
2262 {
2263         struct s5p_jpeg *jpeg = ctx->jpeg;
2264         struct s5p_jpeg_fmt *fmt;
2265         struct vb2_buffer *vb;
2266         struct s5p_jpeg_addr jpeg_addr = {};
2267         u32 pix_size;
2268
2269         pix_size = ctx->cap_q.w * ctx->cap_q.h;
2270
2271         if (ctx->mode == S5P_JPEG_ENCODE) {
2272                 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2273                 fmt = ctx->out_q.fmt;
2274         } else {
2275                 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2276                 fmt = ctx->cap_q.fmt;
2277         }
2278
2279         jpeg_addr.y = vb2_dma_contig_plane_dma_addr(vb, 0);
2280
2281         if (fmt->colplanes == 2) {
2282                 jpeg_addr.cb = jpeg_addr.y + pix_size;
2283         } else if (fmt->colplanes == 3) {
2284                 jpeg_addr.cb = jpeg_addr.y + pix_size;
2285                 if (fmt->fourcc == V4L2_PIX_FMT_YUV420)
2286                         jpeg_addr.cr = jpeg_addr.cb + pix_size / 4;
2287                 else
2288                         jpeg_addr.cr = jpeg_addr.cb + pix_size / 2;
2289         }
2290
2291         exynos3250_jpeg_imgadr(jpeg->regs, &jpeg_addr);
2292 }
2293
2294 static void exynos3250_jpeg_set_jpeg_addr(struct s5p_jpeg_ctx *ctx)
2295 {
2296         struct s5p_jpeg *jpeg = ctx->jpeg;
2297         struct vb2_buffer *vb;
2298         unsigned int jpeg_addr = 0;
2299
2300         if (ctx->mode == S5P_JPEG_ENCODE)
2301                 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2302         else
2303                 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2304
2305         jpeg_addr = vb2_dma_contig_plane_dma_addr(vb, 0);
2306         exynos3250_jpeg_jpgadr(jpeg->regs, jpeg_addr);
2307 }
2308
2309 static void exynos3250_jpeg_device_run(void *priv)
2310 {
2311         struct s5p_jpeg_ctx *ctx = priv;
2312         struct s5p_jpeg *jpeg = ctx->jpeg;
2313         unsigned long flags;
2314
2315         spin_lock_irqsave(&ctx->jpeg->slock, flags);
2316
2317         exynos3250_jpeg_reset(jpeg->regs);
2318         exynos3250_jpeg_set_dma_num(jpeg->regs);
2319         exynos3250_jpeg_poweron(jpeg->regs);
2320         exynos3250_jpeg_clk_set(jpeg->regs);
2321         exynos3250_jpeg_proc_mode(jpeg->regs, ctx->mode);
2322
2323         if (ctx->mode == S5P_JPEG_ENCODE) {
2324                 exynos3250_jpeg_input_raw_fmt(jpeg->regs,
2325                                               ctx->out_q.fmt->fourcc);
2326                 exynos3250_jpeg_dri(jpeg->regs, ctx->restart_interval);
2327
2328                 /*
2329                  * JPEG IP allows storing 4 quantization tables
2330                  * We fill table 0 for luma and table 1 for chroma
2331                  */
2332                 s5p_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality);
2333                 s5p_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality);
2334                 /* use table 0 for Y */
2335                 exynos3250_jpeg_qtbl(jpeg->regs, 1, 0);
2336                 /* use table 1 for Cb and Cr*/
2337                 exynos3250_jpeg_qtbl(jpeg->regs, 2, 1);
2338                 exynos3250_jpeg_qtbl(jpeg->regs, 3, 1);
2339
2340                 /*
2341                  * Some SoCs require setting Huffman tables before each run
2342                  */
2343                 if (jpeg->variant->htbl_reinit) {
2344                         s5p_jpeg_set_hdctbl(jpeg->regs);
2345                         s5p_jpeg_set_hdctblg(jpeg->regs);
2346                         s5p_jpeg_set_hactbl(jpeg->regs);
2347                         s5p_jpeg_set_hactblg(jpeg->regs);
2348                 }
2349
2350                 /* Y, Cb, Cr use Huffman table 0 */
2351                 exynos3250_jpeg_htbl_ac(jpeg->regs, 1);
2352                 exynos3250_jpeg_htbl_dc(jpeg->regs, 1);
2353                 exynos3250_jpeg_htbl_ac(jpeg->regs, 2);
2354                 exynos3250_jpeg_htbl_dc(jpeg->regs, 2);
2355                 exynos3250_jpeg_htbl_ac(jpeg->regs, 3);
2356                 exynos3250_jpeg_htbl_dc(jpeg->regs, 3);
2357
2358                 exynos3250_jpeg_set_x(jpeg->regs, ctx->crop_rect.width);
2359                 exynos3250_jpeg_set_y(jpeg->regs, ctx->crop_rect.height);
2360                 exynos3250_jpeg_stride(jpeg->regs, ctx->out_q.fmt->fourcc,
2361                                                                 ctx->out_q.w);
2362                 exynos3250_jpeg_offset(jpeg->regs, ctx->crop_rect.left,
2363                                                         ctx->crop_rect.top);
2364                 exynos3250_jpeg_set_img_addr(ctx);
2365                 exynos3250_jpeg_set_jpeg_addr(ctx);
2366                 exynos3250_jpeg_subsampling_mode(jpeg->regs, ctx->subsampling);
2367
2368                 /* ultimately comes from sizeimage from userspace */
2369                 exynos3250_jpeg_enc_stream_bound(jpeg->regs, ctx->cap_q.size);
2370
2371                 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565 ||
2372                     ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565X ||
2373                     ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB32)
2374                         exynos3250_jpeg_set_y16(jpeg->regs, true);
2375         } else {
2376                 exynos3250_jpeg_set_img_addr(ctx);
2377                 exynos3250_jpeg_set_jpeg_addr(ctx);
2378                 exynos3250_jpeg_stride(jpeg->regs, ctx->cap_q.fmt->fourcc,
2379                                                                 ctx->cap_q.w);
2380                 exynos3250_jpeg_offset(jpeg->regs, 0, 0);
2381                 exynos3250_jpeg_dec_scaling_ratio(jpeg->regs,
2382                                                         ctx->scale_factor);
2383                 exynos3250_jpeg_dec_stream_size(jpeg->regs, ctx->out_q.size);
2384                 exynos3250_jpeg_output_raw_fmt(jpeg->regs,
2385                                                 ctx->cap_q.fmt->fourcc);
2386         }
2387
2388         exynos3250_jpeg_interrupts_enable(jpeg->regs);
2389
2390         /* JPEG RGB to YCbCr conversion matrix */
2391         exynos3250_jpeg_coef(jpeg->regs, ctx->mode);
2392
2393         exynos3250_jpeg_set_timer(jpeg->regs, EXYNOS3250_IRQ_TIMEOUT);
2394         jpeg->irq_status = 0;
2395         exynos3250_jpeg_start(jpeg->regs);
2396
2397         spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
2398 }
2399
2400 static int s5p_jpeg_job_ready(void *priv)
2401 {
2402         struct s5p_jpeg_ctx *ctx = priv;
2403
2404         if (ctx->mode == S5P_JPEG_DECODE)
2405                 return ctx->hdr_parsed;
2406         return 1;
2407 }
2408
2409 static void s5p_jpeg_job_abort(void *priv)
2410 {
2411 }
2412
2413 static struct v4l2_m2m_ops s5p_jpeg_m2m_ops = {
2414         .device_run     = s5p_jpeg_device_run,
2415         .job_ready      = s5p_jpeg_job_ready,
2416         .job_abort      = s5p_jpeg_job_abort,
2417 };
2418
2419 static struct v4l2_m2m_ops exynos3250_jpeg_m2m_ops = {
2420         .device_run     = exynos3250_jpeg_device_run,
2421         .job_ready      = s5p_jpeg_job_ready,
2422         .job_abort      = s5p_jpeg_job_abort,
2423 };
2424
2425 static struct v4l2_m2m_ops exynos4_jpeg_m2m_ops = {
2426         .device_run     = exynos4_jpeg_device_run,
2427         .job_ready      = s5p_jpeg_job_ready,
2428         .job_abort      = s5p_jpeg_job_abort,
2429 };
2430
2431 /*
2432  * ============================================================================
2433  * Queue operations
2434  * ============================================================================
2435  */
2436
2437 static int s5p_jpeg_queue_setup(struct vb2_queue *vq,
2438                            unsigned int *nbuffers, unsigned int *nplanes,
2439                            unsigned int sizes[], struct device *alloc_devs[])
2440 {
2441         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vq);
2442         struct s5p_jpeg_q_data *q_data = NULL;
2443         unsigned int size, count = *nbuffers;
2444
2445         q_data = get_q_data(ctx, vq->type);
2446         BUG_ON(q_data == NULL);
2447
2448         size = q_data->size;
2449
2450         /*
2451          * header is parsed during decoding and parsed information stored
2452          * in the context so we do not allow another buffer to overwrite it
2453          */
2454         if (ctx->mode == S5P_JPEG_DECODE)
2455                 count = 1;
2456
2457         *nbuffers = count;
2458         *nplanes = 1;
2459         sizes[0] = size;
2460
2461         return 0;
2462 }
2463
2464 static int s5p_jpeg_buf_prepare(struct vb2_buffer *vb)
2465 {
2466         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
2467         struct s5p_jpeg_q_data *q_data = NULL;
2468
2469         q_data = get_q_data(ctx, vb->vb2_queue->type);
2470         BUG_ON(q_data == NULL);
2471
2472         if (vb2_plane_size(vb, 0) < q_data->size) {
2473                 pr_err("%s data will not fit into plane (%lu < %lu)\n",
2474                                 __func__, vb2_plane_size(vb, 0),
2475                                 (long)q_data->size);
2476                 return -EINVAL;
2477         }
2478
2479         vb2_set_plane_payload(vb, 0, q_data->size);
2480
2481         return 0;
2482 }
2483
2484 static void s5p_jpeg_buf_queue(struct vb2_buffer *vb)
2485 {
2486         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
2487         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
2488
2489         if (ctx->mode == S5P_JPEG_DECODE &&
2490             vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
2491                 struct s5p_jpeg_q_data tmp, *q_data;
2492                 ctx->hdr_parsed = s5p_jpeg_parse_hdr(&tmp,
2493                      (unsigned long)vb2_plane_vaddr(vb, 0),
2494                      min((unsigned long)ctx->out_q.size,
2495                          vb2_get_plane_payload(vb, 0)), ctx);
2496                 if (!ctx->hdr_parsed) {
2497                         vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
2498                         return;
2499                 }
2500
2501                 q_data = &ctx->out_q;
2502                 q_data->w = tmp.w;
2503                 q_data->h = tmp.h;
2504                 q_data->sos = tmp.sos;
2505                 memcpy(q_data->dht.marker, tmp.dht.marker,
2506                        sizeof(tmp.dht.marker));
2507                 memcpy(q_data->dht.len, tmp.dht.len, sizeof(tmp.dht.len));
2508                 q_data->dht.n = tmp.dht.n;
2509                 memcpy(q_data->dqt.marker, tmp.dqt.marker,
2510                        sizeof(tmp.dqt.marker));
2511                 memcpy(q_data->dqt.len, tmp.dqt.len, sizeof(tmp.dqt.len));
2512                 q_data->dqt.n = tmp.dqt.n;
2513                 q_data->sof = tmp.sof;
2514                 q_data->sof_len = tmp.sof_len;
2515
2516                 q_data = &ctx->cap_q;
2517                 q_data->w = tmp.w;
2518                 q_data->h = tmp.h;
2519         }
2520
2521         v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
2522 }
2523
2524 static int s5p_jpeg_start_streaming(struct vb2_queue *q, unsigned int count)
2525 {
2526         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q);
2527         int ret;
2528
2529         ret = pm_runtime_get_sync(ctx->jpeg->dev);
2530
2531         return ret > 0 ? 0 : ret;
2532 }
2533
2534 static void s5p_jpeg_stop_streaming(struct vb2_queue *q)
2535 {
2536         struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q);
2537
2538         pm_runtime_put(ctx->jpeg->dev);
2539 }
2540
2541 static struct vb2_ops s5p_jpeg_qops = {
2542         .queue_setup            = s5p_jpeg_queue_setup,
2543         .buf_prepare            = s5p_jpeg_buf_prepare,
2544         .buf_queue              = s5p_jpeg_buf_queue,
2545         .wait_prepare           = vb2_ops_wait_prepare,
2546         .wait_finish            = vb2_ops_wait_finish,
2547         .start_streaming        = s5p_jpeg_start_streaming,
2548         .stop_streaming         = s5p_jpeg_stop_streaming,
2549 };
2550
2551 static int queue_init(void *priv, struct vb2_queue *src_vq,
2552                       struct vb2_queue *dst_vq)
2553 {
2554         struct s5p_jpeg_ctx *ctx = priv;
2555         int ret;
2556
2557         src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
2558         src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
2559         src_vq->drv_priv = ctx;
2560         src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
2561         src_vq->ops = &s5p_jpeg_qops;
2562         src_vq->mem_ops = &vb2_dma_contig_memops;
2563         src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
2564         src_vq->lock = &ctx->jpeg->lock;
2565         src_vq->dev = ctx->jpeg->dev;
2566
2567         ret = vb2_queue_init(src_vq);
2568         if (ret)
2569                 return ret;
2570
2571         dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2572         dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;
2573         dst_vq->drv_priv = ctx;
2574         dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
2575         dst_vq->ops = &s5p_jpeg_qops;
2576         dst_vq->mem_ops = &vb2_dma_contig_memops;
2577         dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
2578         dst_vq->lock = &ctx->jpeg->lock;
2579         dst_vq->dev = ctx->jpeg->dev;
2580
2581         return vb2_queue_init(dst_vq);
2582 }
2583
2584 /*
2585  * ============================================================================
2586  * ISR
2587  * ============================================================================
2588  */
2589
2590 static irqreturn_t s5p_jpeg_irq(int irq, void *dev_id)
2591 {
2592         struct s5p_jpeg *jpeg = dev_id;
2593         struct s5p_jpeg_ctx *curr_ctx;
2594         struct vb2_v4l2_buffer *src_buf, *dst_buf;
2595         unsigned long payload_size = 0;
2596         enum vb2_buffer_state state = VB2_BUF_STATE_DONE;
2597         bool enc_jpeg_too_large = false;
2598         bool timer_elapsed = false;
2599         bool op_completed = false;
2600
2601         spin_lock(&jpeg->slock);
2602
2603         curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2604
2605         src_buf = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2606         dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2607
2608         if (curr_ctx->mode == S5P_JPEG_ENCODE)
2609                 enc_jpeg_too_large = s5p_jpeg_enc_stream_stat(jpeg->regs);
2610         timer_elapsed = s5p_jpeg_timer_stat(jpeg->regs);
2611         op_completed = s5p_jpeg_result_stat_ok(jpeg->regs);
2612         if (curr_ctx->mode == S5P_JPEG_DECODE)
2613                 op_completed = op_completed &&
2614                                         s5p_jpeg_stream_stat_ok(jpeg->regs);
2615
2616         if (enc_jpeg_too_large) {
2617                 state = VB2_BUF_STATE_ERROR;
2618                 s5p_jpeg_clear_enc_stream_stat(jpeg->regs);
2619         } else if (timer_elapsed) {
2620                 state = VB2_BUF_STATE_ERROR;
2621                 s5p_jpeg_clear_timer_stat(jpeg->regs);
2622         } else if (!op_completed) {
2623                 state = VB2_BUF_STATE_ERROR;
2624         } else {
2625                 payload_size = s5p_jpeg_compressed_size(jpeg->regs);
2626         }
2627
2628         dst_buf->timecode = src_buf->timecode;
2629         dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp;
2630         dst_buf->flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
2631         dst_buf->flags |=
2632                 src_buf->flags & V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
2633
2634         v4l2_m2m_buf_done(src_buf, state);
2635         if (curr_ctx->mode == S5P_JPEG_ENCODE)
2636                 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload_size);
2637         v4l2_m2m_buf_done(dst_buf, state);
2638         v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2639
2640         curr_ctx->subsampling = s5p_jpeg_get_subsampling_mode(jpeg->regs);
2641         spin_unlock(&jpeg->slock);
2642
2643         s5p_jpeg_clear_int(jpeg->regs);
2644
2645         return IRQ_HANDLED;
2646 }
2647
2648 static irqreturn_t exynos4_jpeg_irq(int irq, void *priv)
2649 {
2650         unsigned int int_status;
2651         struct vb2_v4l2_buffer *src_vb, *dst_vb;
2652         struct s5p_jpeg *jpeg = priv;
2653         struct s5p_jpeg_ctx *curr_ctx;
2654         unsigned long payload_size = 0;
2655
2656         spin_lock(&jpeg->slock);
2657
2658         curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2659
2660         src_vb = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2661         dst_vb = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2662
2663         int_status = exynos4_jpeg_get_int_status(jpeg->regs);
2664
2665         if (int_status) {
2666                 switch (int_status & 0x1f) {
2667                 case 0x1:
2668                         jpeg->irq_ret = ERR_PROT;
2669                         break;
2670                 case 0x2:
2671                         jpeg->irq_ret = OK_ENC_OR_DEC;
2672                         break;
2673                 case 0x4:
2674                         jpeg->irq_ret = ERR_DEC_INVALID_FORMAT;
2675                         break;
2676                 case 0x8:
2677                         jpeg->irq_ret = ERR_MULTI_SCAN;
2678                         break;
2679                 case 0x10:
2680                         jpeg->irq_ret = ERR_FRAME;
2681                         break;
2682                 default:
2683                         jpeg->irq_ret = ERR_UNKNOWN;
2684                         break;
2685                 }
2686         } else {
2687                 jpeg->irq_ret = ERR_UNKNOWN;
2688         }
2689
2690         if (jpeg->irq_ret == OK_ENC_OR_DEC) {
2691                 if (curr_ctx->mode == S5P_JPEG_ENCODE) {
2692                         payload_size = exynos4_jpeg_get_stream_size(jpeg->regs);
2693                         vb2_set_plane_payload(&dst_vb->vb2_buf,
2694                                         0, payload_size);
2695                 }
2696                 v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_DONE);
2697                 v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_DONE);
2698         } else {
2699                 v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_ERROR);
2700                 v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_ERROR);
2701         }
2702
2703         v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2704         if (jpeg->variant->version == SJPEG_EXYNOS4)
2705                 curr_ctx->subsampling = exynos4_jpeg_get_frame_fmt(jpeg->regs);
2706
2707         spin_unlock(&jpeg->slock);
2708         return IRQ_HANDLED;
2709 }
2710
2711 static irqreturn_t exynos3250_jpeg_irq(int irq, void *dev_id)
2712 {
2713         struct s5p_jpeg *jpeg = dev_id;
2714         struct s5p_jpeg_ctx *curr_ctx;
2715         struct vb2_v4l2_buffer *src_buf, *dst_buf;
2716         unsigned long payload_size = 0;
2717         enum vb2_buffer_state state = VB2_BUF_STATE_DONE;
2718         bool interrupt_timeout = false;
2719         u32 irq_status;
2720
2721         spin_lock(&jpeg->slock);
2722
2723         irq_status = exynos3250_jpeg_get_timer_status(jpeg->regs);
2724         if (irq_status & EXYNOS3250_TIMER_INT_STAT) {
2725                 exynos3250_jpeg_clear_timer_status(jpeg->regs);
2726                 interrupt_timeout = true;
2727                 dev_err(jpeg->dev, "Interrupt timeout occurred.\n");
2728         }
2729
2730         irq_status = exynos3250_jpeg_get_int_status(jpeg->regs);
2731         exynos3250_jpeg_clear_int_status(jpeg->regs, irq_status);
2732
2733         jpeg->irq_status |= irq_status;
2734
2735         curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2736
2737         if (!curr_ctx)
2738                 goto exit_unlock;
2739
2740         if ((irq_status & EXYNOS3250_HEADER_STAT) &&
2741             (curr_ctx->mode == S5P_JPEG_DECODE)) {
2742                 exynos3250_jpeg_rstart(jpeg->regs);
2743                 goto exit_unlock;
2744         }
2745
2746         if (jpeg->irq_status & (EXYNOS3250_JPEG_DONE |
2747                                 EXYNOS3250_WDMA_DONE |
2748                                 EXYNOS3250_RDMA_DONE |
2749                                 EXYNOS3250_RESULT_STAT))
2750                 payload_size = exynos3250_jpeg_compressed_size(jpeg->regs);
2751         else if (interrupt_timeout)
2752                 state = VB2_BUF_STATE_ERROR;
2753         else
2754                 goto exit_unlock;
2755
2756         src_buf = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2757         dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2758
2759         dst_buf->timecode = src_buf->timecode;
2760         dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp;
2761
2762         v4l2_m2m_buf_done(src_buf, state);
2763         if (curr_ctx->mode == S5P_JPEG_ENCODE)
2764                 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload_size);
2765         v4l2_m2m_buf_done(dst_buf, state);
2766         v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2767
2768         curr_ctx->subsampling =
2769                         exynos3250_jpeg_get_subsampling_mode(jpeg->regs);
2770 exit_unlock:
2771         spin_unlock(&jpeg->slock);
2772         return IRQ_HANDLED;
2773 }
2774
2775 static void *jpeg_get_drv_data(struct device *dev);
2776
2777 /*
2778  * ============================================================================
2779  * Driver basic infrastructure
2780  * ============================================================================
2781  */
2782
2783 static int s5p_jpeg_probe(struct platform_device *pdev)
2784 {
2785         struct s5p_jpeg *jpeg;
2786         struct resource *res;
2787         int i, ret;
2788
2789         /* JPEG IP abstraction struct */
2790         jpeg = devm_kzalloc(&pdev->dev, sizeof(struct s5p_jpeg), GFP_KERNEL);
2791         if (!jpeg)
2792                 return -ENOMEM;
2793
2794         jpeg->variant = jpeg_get_drv_data(&pdev->dev);
2795
2796         mutex_init(&jpeg->lock);
2797         spin_lock_init(&jpeg->slock);
2798         jpeg->dev = &pdev->dev;
2799
2800         /* memory-mapped registers */
2801         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2802
2803         jpeg->regs = devm_ioremap_resource(&pdev->dev, res);
2804         if (IS_ERR(jpeg->regs))
2805                 return PTR_ERR(jpeg->regs);
2806
2807         /* interrupt service routine registration */
2808         jpeg->irq = ret = platform_get_irq(pdev, 0);
2809         if (ret < 0) {
2810                 dev_err(&pdev->dev, "cannot find IRQ\n");
2811                 return ret;
2812         }
2813
2814         ret = devm_request_irq(&pdev->dev, jpeg->irq, jpeg->variant->jpeg_irq,
2815                                 0, dev_name(&pdev->dev), jpeg);
2816         if (ret) {
2817                 dev_err(&pdev->dev, "cannot claim IRQ %d\n", jpeg->irq);
2818                 return ret;
2819         }
2820
2821         /* clocks */
2822         for (i = 0; i < jpeg->variant->num_clocks; i++) {
2823                 jpeg->clocks[i] = devm_clk_get(&pdev->dev,
2824                                               jpeg->variant->clk_names[i]);
2825                 if (IS_ERR(jpeg->clocks[i])) {
2826                         dev_err(&pdev->dev, "failed to get clock: %s\n",
2827                                 jpeg->variant->clk_names[i]);
2828                         return PTR_ERR(jpeg->clocks[i]);
2829                 }
2830         }
2831
2832         /* v4l2 device */
2833         ret = v4l2_device_register(&pdev->dev, &jpeg->v4l2_dev);
2834         if (ret) {
2835                 dev_err(&pdev->dev, "Failed to register v4l2 device\n");
2836                 return ret;
2837         }
2838
2839         /* mem2mem device */
2840         jpeg->m2m_dev = v4l2_m2m_init(jpeg->variant->m2m_ops);
2841         if (IS_ERR(jpeg->m2m_dev)) {
2842                 v4l2_err(&jpeg->v4l2_dev, "Failed to init mem2mem device\n");
2843                 ret = PTR_ERR(jpeg->m2m_dev);
2844                 goto device_register_rollback;
2845         }
2846
2847         vb2_dma_contig_set_max_seg_size(&pdev->dev, DMA_BIT_MASK(32));
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 m2m_init_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 m2m_init_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 m2m_init_rollback:
2920         v4l2_m2m_release(jpeg->m2m_dev);
2921
2922 device_register_rollback:
2923         v4l2_device_unregister(&jpeg->v4l2_dev);
2924
2925         return ret;
2926 }
2927
2928 static int s5p_jpeg_remove(struct platform_device *pdev)
2929 {
2930         struct s5p_jpeg *jpeg = platform_get_drvdata(pdev);
2931         int i;
2932
2933         pm_runtime_disable(jpeg->dev);
2934
2935         video_unregister_device(jpeg->vfd_decoder);
2936         video_unregister_device(jpeg->vfd_encoder);
2937         vb2_dma_contig_clear_max_seg_size(&pdev->dev);
2938         v4l2_m2m_release(jpeg->m2m_dev);
2939         v4l2_device_unregister(&jpeg->v4l2_dev);
2940
2941         if (!pm_runtime_status_suspended(&pdev->dev)) {
2942                 for (i = jpeg->variant->num_clocks - 1; i >= 0; i--)
2943                         clk_disable_unprepare(jpeg->clocks[i]);
2944         }
2945
2946         return 0;
2947 }
2948
2949 #ifdef CONFIG_PM
2950 static int s5p_jpeg_runtime_suspend(struct device *dev)
2951 {
2952         struct s5p_jpeg *jpeg = dev_get_drvdata(dev);
2953         int i;
2954
2955         for (i = jpeg->variant->num_clocks - 1; i >= 0; i--)
2956                 clk_disable_unprepare(jpeg->clocks[i]);
2957
2958         return 0;
2959 }
2960
2961 static int s5p_jpeg_runtime_resume(struct device *dev)
2962 {
2963         struct s5p_jpeg *jpeg = dev_get_drvdata(dev);
2964         unsigned long flags;
2965         int i, ret;
2966
2967         for (i = 0; i < jpeg->variant->num_clocks; i++) {
2968                 ret = clk_prepare_enable(jpeg->clocks[i]);
2969                 if (ret) {
2970                         while (--i > 0)
2971                                 clk_disable_unprepare(jpeg->clocks[i]);
2972                         return ret;
2973                 }
2974         }
2975
2976         spin_lock_irqsave(&jpeg->slock, flags);
2977
2978         /*
2979          * JPEG IP allows storing two Huffman tables for each component.
2980          * We fill table 0 for each component and do this here only
2981          * for S5PC210 and Exynos3250 SoCs. Exynos4x12 and Exynos542x SoC
2982          * require programming their Huffman tables each time the encoding
2983          * process is initialized, and thus it is accomplished in the
2984          * device_run callback of m2m_ops.
2985          */
2986         if (!jpeg->variant->htbl_reinit) {
2987                 s5p_jpeg_set_hdctbl(jpeg->regs);
2988                 s5p_jpeg_set_hdctblg(jpeg->regs);
2989                 s5p_jpeg_set_hactbl(jpeg->regs);
2990                 s5p_jpeg_set_hactblg(jpeg->regs);
2991         }
2992
2993         spin_unlock_irqrestore(&jpeg->slock, flags);
2994
2995         return 0;
2996 }
2997 #endif /* CONFIG_PM */
2998
2999 #ifdef CONFIG_PM_SLEEP
3000 static int s5p_jpeg_suspend(struct device *dev)
3001 {
3002         if (pm_runtime_suspended(dev))
3003                 return 0;
3004
3005         return s5p_jpeg_runtime_suspend(dev);
3006 }
3007
3008 static int s5p_jpeg_resume(struct device *dev)
3009 {
3010         if (pm_runtime_suspended(dev))
3011                 return 0;
3012
3013         return s5p_jpeg_runtime_resume(dev);
3014 }
3015 #endif
3016
3017 static const struct dev_pm_ops s5p_jpeg_pm_ops = {
3018         SET_SYSTEM_SLEEP_PM_OPS(s5p_jpeg_suspend, s5p_jpeg_resume)
3019         SET_RUNTIME_PM_OPS(s5p_jpeg_runtime_suspend, s5p_jpeg_runtime_resume, NULL)
3020 };
3021
3022 static struct s5p_jpeg_variant s5p_jpeg_drvdata = {
3023         .version        = SJPEG_S5P,
3024         .jpeg_irq       = s5p_jpeg_irq,
3025         .m2m_ops        = &s5p_jpeg_m2m_ops,
3026         .fmt_ver_flag   = SJPEG_FMT_FLAG_S5P,
3027         .clk_names      = {"jpeg"},
3028         .num_clocks     = 1,
3029 };
3030
3031 static struct s5p_jpeg_variant exynos3250_jpeg_drvdata = {
3032         .version        = SJPEG_EXYNOS3250,
3033         .jpeg_irq       = exynos3250_jpeg_irq,
3034         .m2m_ops        = &exynos3250_jpeg_m2m_ops,
3035         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS3250,
3036         .hw3250_compat  = 1,
3037         .clk_names      = {"jpeg", "sclk"},
3038         .num_clocks     = 2,
3039 };
3040
3041 static struct s5p_jpeg_variant exynos4_jpeg_drvdata = {
3042         .version        = SJPEG_EXYNOS4,
3043         .jpeg_irq       = exynos4_jpeg_irq,
3044         .m2m_ops        = &exynos4_jpeg_m2m_ops,
3045         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS4,
3046         .htbl_reinit    = 1,
3047         .clk_names      = {"jpeg"},
3048         .num_clocks     = 1,
3049         .hw_ex4_compat  = 1,
3050 };
3051
3052 static struct s5p_jpeg_variant exynos5420_jpeg_drvdata = {
3053         .version        = SJPEG_EXYNOS5420,
3054         .jpeg_irq       = exynos3250_jpeg_irq,          /* intentionally 3250 */
3055         .m2m_ops        = &exynos3250_jpeg_m2m_ops,     /* intentionally 3250 */
3056         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS3250,    /* intentionally 3250 */
3057         .hw3250_compat  = 1,
3058         .htbl_reinit    = 1,
3059         .clk_names      = {"jpeg"},
3060         .num_clocks     = 1,
3061 };
3062
3063 static struct s5p_jpeg_variant exynos5433_jpeg_drvdata = {
3064         .version        = SJPEG_EXYNOS5433,
3065         .jpeg_irq       = exynos4_jpeg_irq,
3066         .m2m_ops        = &exynos4_jpeg_m2m_ops,
3067         .fmt_ver_flag   = SJPEG_FMT_FLAG_EXYNOS4,
3068         .htbl_reinit    = 1,
3069         .clk_names      = {"pclk", "aclk", "aclk_xiu", "sclk"},
3070         .num_clocks     = 4,
3071         .hw_ex4_compat  = 1,
3072 };
3073
3074 static const struct of_device_id samsung_jpeg_match[] = {
3075         {
3076                 .compatible = "samsung,s5pv210-jpeg",
3077                 .data = &s5p_jpeg_drvdata,
3078         }, {
3079                 .compatible = "samsung,exynos3250-jpeg",
3080                 .data = &exynos3250_jpeg_drvdata,
3081         }, {
3082                 .compatible = "samsung,exynos4210-jpeg",
3083                 .data = &exynos4_jpeg_drvdata,
3084         }, {
3085                 .compatible = "samsung,exynos4212-jpeg",
3086                 .data = &exynos4_jpeg_drvdata,
3087         }, {
3088                 .compatible = "samsung,exynos5420-jpeg",
3089                 .data = &exynos5420_jpeg_drvdata,
3090         }, {
3091                 .compatible = "samsung,exynos5433-jpeg",
3092                 .data = &exynos5433_jpeg_drvdata,
3093         },
3094         {},
3095 };
3096
3097 MODULE_DEVICE_TABLE(of, samsung_jpeg_match);
3098
3099 static void *jpeg_get_drv_data(struct device *dev)
3100 {
3101         struct s5p_jpeg_variant *driver_data = NULL;
3102         const struct of_device_id *match;
3103
3104         if (!IS_ENABLED(CONFIG_OF) || !dev->of_node)
3105                 return &s5p_jpeg_drvdata;
3106
3107         match = of_match_node(samsung_jpeg_match, dev->of_node);
3108
3109         if (match)
3110                 driver_data = (struct s5p_jpeg_variant *)match->data;
3111
3112         return driver_data;
3113 }
3114
3115 static struct platform_driver s5p_jpeg_driver = {
3116         .probe = s5p_jpeg_probe,
3117         .remove = s5p_jpeg_remove,
3118         .driver = {
3119                 .of_match_table = of_match_ptr(samsung_jpeg_match),
3120                 .name           = S5P_JPEG_M2M_NAME,
3121                 .pm             = &s5p_jpeg_pm_ops,
3122         },
3123 };
3124
3125 module_platform_driver(s5p_jpeg_driver);
3126
3127 MODULE_AUTHOR("Andrzej Pietrasiewicz <andrzej.p@samsung.com>");
3128 MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>");
3129 MODULE_DESCRIPTION("Samsung JPEG codec driver");
3130 MODULE_LICENSE("GPL");