1 /* linux/drivers/media/platform/s5p-jpeg/jpeg-core.c
3 * Copyright (c) 2011-2014 Samsung Electronics Co., Ltd.
4 * http://www.samsung.com
6 * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
7 * Author: Jacek Anaszewski <j.anaszewski@samsung.com>
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.
14 #include <linux/clk.h>
15 #include <linux/err.h>
16 #include <linux/gfp.h>
17 #include <linux/interrupt.h>
19 #include <linux/kernel.h>
20 #include <linux/module.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>
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"
38 static struct s5p_jpeg_fmt sjpeg_formats[] = {
41 .fourcc = V4L2_PIX_FMT_JPEG,
42 .flags = SJPEG_FMT_FLAG_ENC_CAPTURE |
43 SJPEG_FMT_FLAG_DEC_OUTPUT |
45 SJPEG_FMT_FLAG_EXYNOS3250 |
46 SJPEG_FMT_FLAG_EXYNOS4,
49 .name = "YUV 4:2:2 packed, YCbYCr",
50 .fourcc = V4L2_PIX_FMT_YUYV,
55 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
56 SJPEG_FMT_FLAG_DEC_CAPTURE |
59 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
62 .name = "YUV 4:2:2 packed, YCbYCr",
63 .fourcc = V4L2_PIX_FMT_YUYV,
68 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
69 SJPEG_FMT_FLAG_DEC_CAPTURE |
70 SJPEG_FMT_FLAG_EXYNOS4 |
72 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
75 .name = "YUV 4:2:2 packed, YCbYCr",
76 .fourcc = V4L2_PIX_FMT_YUYV,
81 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
82 SJPEG_FMT_FLAG_DEC_CAPTURE |
83 SJPEG_FMT_FLAG_EXYNOS3250 |
85 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
88 .name = "YUV 4:2:2 packed, YCrYCb",
89 .fourcc = V4L2_PIX_FMT_YVYU,
94 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
95 SJPEG_FMT_FLAG_DEC_CAPTURE |
96 SJPEG_FMT_FLAG_EXYNOS4 |
98 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
101 .name = "YUV 4:2:2 packed, YCrYCb",
102 .fourcc = V4L2_PIX_FMT_YVYU,
107 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
108 SJPEG_FMT_FLAG_DEC_CAPTURE |
109 SJPEG_FMT_FLAG_EXYNOS3250 |
111 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
114 .name = "YUV 4:2:2 packed, YCrYCb",
115 .fourcc = V4L2_PIX_FMT_UYVY,
120 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
121 SJPEG_FMT_FLAG_DEC_CAPTURE |
122 SJPEG_FMT_FLAG_EXYNOS3250 |
124 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
127 .name = "YUV 4:2:2 packed, YCrYCb",
128 .fourcc = V4L2_PIX_FMT_VYUY,
133 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
134 SJPEG_FMT_FLAG_DEC_CAPTURE |
135 SJPEG_FMT_FLAG_EXYNOS3250 |
137 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
141 .fourcc = V4L2_PIX_FMT_RGB565,
146 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
147 SJPEG_FMT_FLAG_DEC_CAPTURE |
148 SJPEG_FMT_FLAG_EXYNOS4 |
150 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
154 .fourcc = V4L2_PIX_FMT_RGB565,
159 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
160 SJPEG_FMT_FLAG_DEC_CAPTURE |
161 SJPEG_FMT_FLAG_EXYNOS3250 |
163 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
167 .fourcc = V4L2_PIX_FMT_RGB565X,
172 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
173 SJPEG_FMT_FLAG_DEC_CAPTURE |
174 SJPEG_FMT_FLAG_EXYNOS3250 |
176 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
180 .fourcc = V4L2_PIX_FMT_RGB565,
185 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
188 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
191 .name = "ARGB8888, 32 bpp",
192 .fourcc = V4L2_PIX_FMT_RGB32,
197 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
198 SJPEG_FMT_FLAG_DEC_CAPTURE |
199 SJPEG_FMT_FLAG_EXYNOS4 |
201 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
204 .name = "ARGB8888, 32 bpp",
205 .fourcc = V4L2_PIX_FMT_RGB32,
210 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
211 SJPEG_FMT_FLAG_DEC_CAPTURE |
212 SJPEG_FMT_FLAG_EXYNOS3250 |
214 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
217 .name = "YUV 4:4:4 planar, Y/CbCr",
218 .fourcc = V4L2_PIX_FMT_NV24,
223 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
224 SJPEG_FMT_FLAG_DEC_CAPTURE |
225 SJPEG_FMT_FLAG_EXYNOS4 |
227 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
230 .name = "YUV 4:4:4 planar, Y/CrCb",
231 .fourcc = V4L2_PIX_FMT_NV42,
236 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
237 SJPEG_FMT_FLAG_DEC_CAPTURE |
238 SJPEG_FMT_FLAG_EXYNOS4 |
240 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444,
243 .name = "YUV 4:2:2 planar, Y/CrCb",
244 .fourcc = V4L2_PIX_FMT_NV61,
249 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
250 SJPEG_FMT_FLAG_DEC_CAPTURE |
251 SJPEG_FMT_FLAG_EXYNOS4 |
253 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
256 .name = "YUV 4:2:2 planar, Y/CbCr",
257 .fourcc = V4L2_PIX_FMT_NV16,
262 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
263 SJPEG_FMT_FLAG_DEC_CAPTURE |
264 SJPEG_FMT_FLAG_EXYNOS4 |
266 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422,
269 .name = "YUV 4:2:0 planar, Y/CbCr",
270 .fourcc = V4L2_PIX_FMT_NV12,
275 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
276 SJPEG_FMT_FLAG_DEC_CAPTURE |
277 SJPEG_FMT_FLAG_EXYNOS4 |
279 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420,
282 .name = "YUV 4:2:0 planar, Y/CbCr",
283 .fourcc = V4L2_PIX_FMT_NV12,
288 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
289 SJPEG_FMT_FLAG_DEC_CAPTURE |
290 SJPEG_FMT_FLAG_EXYNOS3250 |
292 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420,
295 .name = "YUV 4:2:0 planar, Y/CbCr",
296 .fourcc = V4L2_PIX_FMT_NV12,
301 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
302 SJPEG_FMT_FLAG_DEC_CAPTURE |
305 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420,
308 .name = "YUV 4:2:0 planar, Y/CrCb",
309 .fourcc = V4L2_PIX_FMT_NV21,
314 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
315 SJPEG_FMT_FLAG_DEC_CAPTURE |
316 SJPEG_FMT_FLAG_EXYNOS3250 |
318 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420,
321 .name = "YUV 4:2:0 planar, Y/CrCb",
322 .fourcc = V4L2_PIX_FMT_NV21,
327 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
328 SJPEG_FMT_FLAG_DEC_CAPTURE |
329 SJPEG_FMT_FLAG_EXYNOS3250 |
330 SJPEG_FMT_FLAG_EXYNOS4 |
332 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420,
335 .name = "YUV 4:2:0 contiguous 3-planar, Y/Cb/Cr",
336 .fourcc = V4L2_PIX_FMT_YUV420,
341 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
342 SJPEG_FMT_FLAG_DEC_CAPTURE |
343 SJPEG_FMT_FLAG_EXYNOS4 |
345 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420,
348 .name = "YUV 4:2:0 contiguous 3-planar, Y/Cb/Cr",
349 .fourcc = V4L2_PIX_FMT_YUV420,
354 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
355 SJPEG_FMT_FLAG_DEC_CAPTURE |
356 SJPEG_FMT_FLAG_EXYNOS3250 |
358 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420,
362 .fourcc = V4L2_PIX_FMT_GREY,
365 .flags = SJPEG_FMT_FLAG_ENC_OUTPUT |
366 SJPEG_FMT_FLAG_DEC_CAPTURE |
367 SJPEG_FMT_FLAG_EXYNOS4 |
369 .subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY,
372 #define SJPEG_NUM_FORMATS ARRAY_SIZE(sjpeg_formats)
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
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
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
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
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
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
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
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
460 static const unsigned char hdctbl0[16] = {
461 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0
464 static const unsigned char hdctblg0[12] = {
465 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb
467 static const unsigned char hactbl0[16] = {
468 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d
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,
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.
501 static const u32 subs422_fourcc_dwngrd_schema[] = {
506 static const u32 subs420_fourcc_dwngrd_schema[] = {
520 * Lookup table for translation of a fourcc to the position
521 * of its downgraded counterpart in the *fourcc_dwngrd_schema
524 static const u32 fourcc_to_dwngrd_schema_id[] = {
537 static int s5p_jpeg_get_dwngrd_sch_id_by_fourcc(u32 fourcc)
540 for (i = 0; i < ARRAY_SIZE(fourcc_to_dwngrd_schema_id); ++i) {
541 if (fourcc_to_dwngrd_schema_id[i] == fourcc)
548 static int s5p_jpeg_adjust_fourcc_to_subsampling(
549 enum v4l2_jpeg_chroma_subsampling subs,
552 struct s5p_jpeg_ctx *ctx)
556 if (ctx->subsampling != V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY) {
558 s5p_jpeg_get_dwngrd_sch_id_by_fourcc(in_fourcc);
559 if (dwngrd_sch_id < 0)
563 switch (ctx->subsampling) {
564 case V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY:
565 *out_fourcc = V4L2_PIX_FMT_GREY;
567 case V4L2_JPEG_CHROMA_SUBSAMPLING_420:
569 ARRAY_SIZE(subs420_fourcc_dwngrd_schema) - 1)
571 *out_fourcc = subs420_fourcc_dwngrd_schema[dwngrd_sch_id];
573 case V4L2_JPEG_CHROMA_SUBSAMPLING_422:
575 ARRAY_SIZE(subs422_fourcc_dwngrd_schema) - 1)
577 *out_fourcc = subs422_fourcc_dwngrd_schema[dwngrd_sch_id];
580 *out_fourcc = V4L2_PIX_FMT_GREY;
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,
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,
601 V4L2_JPEG_CHROMA_SUBSAMPLING_411,
604 static inline struct s5p_jpeg_ctx *ctrl_to_ctx(struct v4l2_ctrl *c)
606 return container_of(c->handler, struct s5p_jpeg_ctx, ctrl_handler);
609 static inline struct s5p_jpeg_ctx *fh_to_ctx(struct v4l2_fh *fh)
611 return container_of(fh, struct s5p_jpeg_ctx, fh);
614 static int s5p_jpeg_to_user_subsampling(struct s5p_jpeg_ctx *ctx)
616 WARN_ON(ctx->subsampling > 3);
618 switch (ctx->jpeg->variant->version) {
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];
629 case SJPEG_EXYNOS5433:
630 if (ctx->subsampling > 2)
631 return V4L2_JPEG_CHROMA_SUBSAMPLING_420;
632 return exynos4x12_decoded_subsampling[ctx->subsampling];
634 return V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY;
638 static inline void s5p_jpeg_set_qtbl(void __iomem *regs,
639 const unsigned char *qtbl,
640 unsigned long tab, int len)
644 for (i = 0; i < len; i++)
645 writel((unsigned int)qtbl[i], regs + tab + (i * 0x04));
648 static inline void s5p_jpeg_set_qtbl_lum(void __iomem *regs, int quality)
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]));
656 static inline void s5p_jpeg_set_qtbl_chr(void __iomem *regs, int quality)
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]));
664 static inline void s5p_jpeg_set_htbl(void __iomem *regs,
665 const unsigned char *htbl,
666 unsigned long tab, int len)
670 for (i = 0; i < len; i++)
671 writel((unsigned int)htbl[i], regs + tab + (i * 0x04));
674 static inline void s5p_jpeg_set_hdctbl(void __iomem *regs)
676 /* this driver fills table 0 for this component */
677 s5p_jpeg_set_htbl(regs, hdctbl0, S5P_JPG_HDCTBL(0),
678 ARRAY_SIZE(hdctbl0));
681 static inline void s5p_jpeg_set_hdctblg(void __iomem *regs)
683 /* this driver fills table 0 for this component */
684 s5p_jpeg_set_htbl(regs, hdctblg0, S5P_JPG_HDCTBLG(0),
685 ARRAY_SIZE(hdctblg0));
688 static inline void s5p_jpeg_set_hactbl(void __iomem *regs)
690 /* this driver fills table 0 for this component */
691 s5p_jpeg_set_htbl(regs, hactbl0, S5P_JPG_HACTBL(0),
692 ARRAY_SIZE(hactbl0));
695 static inline void s5p_jpeg_set_hactblg(void __iomem *regs)
697 /* this driver fills table 0 for this component */
698 s5p_jpeg_set_htbl(regs, hactblg0, S5P_JPG_HACTBLG(0),
699 ARRAY_SIZE(hactblg0));
702 static inline void exynos4_jpeg_set_tbl(void __iomem *regs,
703 const unsigned char *tbl,
704 unsigned long tab, int len)
709 for (i = 0; i < len; i += 4) {
714 writel(dword, regs + tab + i);
718 static inline void exynos4_jpeg_set_qtbl_lum(void __iomem *regs, int quality)
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]));
726 static inline void exynos4_jpeg_set_qtbl_chr(void __iomem *regs, int quality)
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]));
734 static void exynos4_jpeg_set_huff_tbl(void __iomem *base)
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));
754 static inline int __exynos4_huff_tbl(int class, int id, bool lenval)
757 * class: 0 - DC, 1 - AC
758 * id: 0 - Y, 1 - Cb/Cr
762 return lenval ? EXYNOS4_HUFF_TBL_HACCL :
763 EXYNOS4_HUFF_TBL_HACCV;
764 return lenval ? EXYNOS4_HUFF_TBL_HACLL : EXYNOS4_HUFF_TBL_HACLV;
769 return lenval ? EXYNOS4_HUFF_TBL_HDCCL : EXYNOS4_HUFF_TBL_HDCCV;
771 return lenval ? EXYNOS4_HUFF_TBL_HDCLL : EXYNOS4_HUFF_TBL_HDCLV;
774 static inline int exynos4_huff_tbl_len(int class, int id)
776 return __exynos4_huff_tbl(class, id, true);
779 static inline int exynos4_huff_tbl_val(int class, int id)
781 return __exynos4_huff_tbl(class, id, false);
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);
788 static void exynos4_jpeg_parse_decode_h_tbl(struct s5p_jpeg_ctx *ctx)
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;
794 int c, x, components;
796 jpeg_buffer.size = 2; /* Ls */
798 (unsigned long)vb2_plane_vaddr(vb, 0) + ctx->out_q.sos + 2;
799 jpeg_buffer.curr = 0;
803 if (get_word_be(&jpeg_buffer, &word))
805 jpeg_buffer.size = (long)word - 2;
806 jpeg_buffer.data += 2;
807 jpeg_buffer.curr = 0;
809 components = get_byte(&jpeg_buffer);
810 if (components == -1)
812 while (components--) {
813 c = get_byte(&jpeg_buffer);
816 x = get_byte(&jpeg_buffer);
819 exynos4_jpeg_select_dec_h_tbl(jpeg->regs, c,
820 (((x >> 4) & 0x1) << 1) | (x & 0x1));
825 static void exynos4_jpeg_parse_huff_tbl(struct s5p_jpeg_ctx *ctx)
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;
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;
840 while (jpeg_buffer.curr < jpeg_buffer.size) {
843 c = get_byte(&jpeg_buffer);
847 class = (c >> 4) & 0xf;
849 for (i = 0; i < 16; ++i) {
850 c = get_byte(&jpeg_buffer);
853 word |= c << ((i % 4) * 8);
854 if ((i + 1) % 4 == 0) {
855 writel(word, jpeg->regs +
856 exynos4_huff_tbl_len(class, id) +
863 for (i = 0; i < n; ++i) {
864 c = get_byte(&jpeg_buffer);
867 word |= c << ((i % 4) * 8);
868 if ((i + 1) % 4 == 0) {
869 writel(word, jpeg->regs +
870 exynos4_huff_tbl_val(class, id) +
876 writel(word, jpeg->regs +
877 exynos4_huff_tbl_val(class, id) + (i / 4) * 4);
884 static void exynos4_jpeg_parse_decode_q_tbl(struct s5p_jpeg_ctx *ctx)
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;
891 jpeg_buffer.size = ctx->out_q.sof_len;
893 (unsigned long)vb2_plane_vaddr(vb, 0) + ctx->out_q.sof;
894 jpeg_buffer.curr = 0;
896 skip(&jpeg_buffer, 5); /* P, Y, X */
897 components = get_byte(&jpeg_buffer);
898 if (components == -1)
901 exynos4_jpeg_set_dec_components(jpeg->regs, components);
903 while (components--) {
904 c = get_byte(&jpeg_buffer);
907 skip(&jpeg_buffer, 1);
908 x = get_byte(&jpeg_buffer);
911 exynos4_jpeg_select_dec_q_tbl(jpeg->regs, c, x);
915 static void exynos4_jpeg_parse_q_tbl(struct s5p_jpeg_ctx *ctx)
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;
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;
930 while (jpeg_buffer.size - jpeg_buffer.curr >= 65) {
933 c = get_byte(&jpeg_buffer);
937 /* nonzero means extended mode - not supported */
940 for (i = 0; i < 64; ++i) {
941 c = get_byte(&jpeg_buffer);
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);
957 * ============================================================================
958 * Device file operations
959 * ============================================================================
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);
968 static int s5p_jpeg_open(struct file *file)
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;
976 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
980 if (mutex_lock_interruptible(&jpeg->lock)) {
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);
992 if (vfd == jpeg->vfd_encoder) {
993 ctx->mode = S5P_JPEG_ENCODE;
994 out_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_RGB565,
996 cap_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_JPEG,
999 ctx->mode = S5P_JPEG_DECODE;
1000 out_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_JPEG,
1002 cap_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_YUYV,
1004 ctx->scale_factor = EXYNOS3250_DEC_SCALE_FACTOR_8_8;
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);
1013 ctx->out_q.fmt = out_fmt;
1014 ctx->cap_q.fmt = cap_fmt;
1016 ret = s5p_jpeg_controls_create(ctx);
1020 mutex_unlock(&jpeg->lock);
1024 v4l2_fh_del(&ctx->fh);
1025 v4l2_fh_exit(&ctx->fh);
1026 mutex_unlock(&jpeg->lock);
1032 static int s5p_jpeg_release(struct file *file)
1034 struct s5p_jpeg *jpeg = video_drvdata(file);
1035 struct s5p_jpeg_ctx *ctx = fh_to_ctx(file->private_data);
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);
1043 mutex_unlock(&jpeg->lock);
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,
1058 * ============================================================================
1059 * video ioctl operations
1060 * ============================================================================
1063 static int get_byte(struct s5p_jpeg_buffer *buf)
1065 if (buf->curr >= buf->size)
1068 return ((unsigned char *)buf->data)[buf->curr++];
1071 static int get_word_be(struct s5p_jpeg_buffer *buf, unsigned int *word)
1076 byte = get_byte(buf);
1080 byte = get_byte(buf);
1083 *word = (unsigned int)byte | temp;
1087 static void skip(struct s5p_jpeg_buffer *buf, long len)
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)
1100 int c, components = 0, notfound, n_dht = 0, n_dqt = 0;
1101 unsigned int height, width, word, subsampling = 0, sos = 0, sof = 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];
1106 struct s5p_jpeg_buffer jpeg_buffer;
1108 jpeg_buffer.size = size;
1109 jpeg_buffer.data = buffer;
1110 jpeg_buffer.curr = 0;
1113 while (notfound || !sos) {
1114 c = get_byte(&jpeg_buffer);
1120 c = get_byte(&jpeg_buffer);
1128 /* SOF0: baseline JPEG */
1130 if (get_word_be(&jpeg_buffer, &word))
1132 length = (long)word - 2;
1135 sof = jpeg_buffer.curr; /* after 0xffc0 */
1137 if (get_byte(&jpeg_buffer) == -1)
1139 if (get_word_be(&jpeg_buffer, &height))
1141 if (get_word_be(&jpeg_buffer, &width))
1143 components = get_byte(&jpeg_buffer);
1144 if (components == -1)
1147 if (components == 1) {
1150 skip(&jpeg_buffer, 1);
1151 subsampling = get_byte(&jpeg_buffer);
1152 skip(&jpeg_buffer, 1);
1156 skip(&jpeg_buffer, components * 2);
1161 if (get_word_be(&jpeg_buffer, &word))
1163 length = (long)word - 2;
1166 if (n_dqt >= S5P_JPEG_MAX_MARKER)
1168 dqt[n_dqt] = jpeg_buffer.curr; /* after 0xffdb */
1169 dqt_len[n_dqt++] = length;
1170 skip(&jpeg_buffer, length);
1174 if (get_word_be(&jpeg_buffer, &word))
1176 length = (long)word - 2;
1179 if (n_dht >= S5P_JPEG_MAX_MARKER)
1181 dht[n_dht] = jpeg_buffer.curr; /* after 0xffc4 */
1182 dht_len[n_dht++] = length;
1183 skip(&jpeg_buffer, length);
1187 sos = jpeg_buffer.curr - 2; /* 0xffda */
1190 /* skip payload-less markers */
1191 case RST ... RST + 7:
1197 /* skip uninteresting payload markers */
1199 if (get_word_be(&jpeg_buffer, &word))
1201 length = (long)word - 2;
1202 skip(&jpeg_buffer, length);
1209 result->dht.n = n_dht;
1211 result->dht.marker[n_dht] = dht[n_dht];
1212 result->dht.len[n_dht] = dht_len[n_dht];
1214 result->dqt.n = n_dqt;
1216 result->dqt.marker[n_dqt] = dqt[n_dqt];
1217 result->dqt.len[n_dqt] = dqt_len[n_dqt];
1220 result->sof_len = sof_len;
1221 result->size = result->components = components;
1223 switch (subsampling) {
1225 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444;
1228 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422;
1231 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420;
1234 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY;
1240 return !notfound && sos;
1243 static int s5p_jpeg_querycap(struct file *file, void *priv,
1244 struct v4l2_capability *cap)
1246 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
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",
1254 strlcpy(cap->driver, S5P_JPEG_M2M_NAME " decoder",
1255 sizeof(cap->driver));
1256 strlcpy(cap->card, S5P_JPEG_M2M_NAME " decoder",
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;
1265 static int enum_fmt(struct s5p_jpeg_fmt *sjpeg_formats, int n,
1266 struct v4l2_fmtdesc *f, u32 type)
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)
1275 /* Correct type but haven't reached our index yet,
1276 * just increment per-type index */
1281 /* Format not found */
1285 strlcpy(f->description, sjpeg_formats[i].name, sizeof(f->description));
1286 f->pixelformat = sjpeg_formats[i].fourcc;
1291 static int s5p_jpeg_enum_fmt_vid_cap(struct file *file, void *priv,
1292 struct v4l2_fmtdesc *f)
1294 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1296 if (ctx->mode == S5P_JPEG_ENCODE)
1297 return enum_fmt(sjpeg_formats, SJPEG_NUM_FORMATS, f,
1298 SJPEG_FMT_FLAG_ENC_CAPTURE);
1300 return enum_fmt(sjpeg_formats, SJPEG_NUM_FORMATS, f,
1301 SJPEG_FMT_FLAG_DEC_CAPTURE);
1304 static int s5p_jpeg_enum_fmt_vid_out(struct file *file, void *priv,
1305 struct v4l2_fmtdesc *f)
1307 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1309 if (ctx->mode == S5P_JPEG_ENCODE)
1310 return enum_fmt(sjpeg_formats, SJPEG_NUM_FORMATS, f,
1311 SJPEG_FMT_FLAG_ENC_OUTPUT);
1313 return enum_fmt(sjpeg_formats, SJPEG_NUM_FORMATS, f,
1314 SJPEG_FMT_FLAG_DEC_OUTPUT);
1317 static struct s5p_jpeg_q_data *get_q_data(struct s5p_jpeg_ctx *ctx,
1318 enum v4l2_buf_type type)
1320 if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
1322 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1328 static int s5p_jpeg_g_fmt(struct file *file, void *priv, struct v4l2_format *f)
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);
1335 vq = v4l2_m2m_get_vq(ct->fh.m2m_ctx, f->type);
1339 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1340 ct->mode == S5P_JPEG_DECODE && !ct->hdr_parsed)
1342 q_data = get_q_data(ct, f->type);
1343 BUG_ON(q_data == NULL);
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;
1356 pix->sizeimage = q_data->size;
1361 static struct s5p_jpeg_fmt *s5p_jpeg_find_format(struct s5p_jpeg_ctx *ctx,
1362 u32 pixelformat, unsigned int fmt_type)
1364 unsigned int k, fmt_flag;
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;
1371 fmt_flag = (fmt_type == FMT_TYPE_OUTPUT) ?
1372 SJPEG_FMT_FLAG_DEC_OUTPUT :
1373 SJPEG_FMT_FLAG_DEC_CAPTURE;
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) {
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)
1393 int width, height, w_step, h_step;
1398 w_step = 1 << walign;
1399 h_step = 1 << halign;
1401 if (ctx->jpeg->variant->hw3250_compat) {
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.
1409 if (w_step == 4 && ((width & 3) == 1)) {
1415 v4l_bound_align_image(w, wmin, wmax, walign, h, hmin, hmax, halign, 0);
1417 if (*w < width && (*w + w_step) < wmax)
1419 if (*h < height && (*h + h_step) < hmax)
1423 static int vidioc_try_fmt(struct v4l2_format *f, struct s5p_jpeg_fmt *fmt,
1424 struct s5p_jpeg_ctx *ctx, int q_type)
1426 struct v4l2_pix_format *pix = &f->fmt.pix;
1428 if (pix->field == V4L2_FIELD_ANY)
1429 pix->field = V4L2_FIELD_NONE;
1430 else if (pix->field != V4L2_FIELD_NONE)
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);
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);
1446 if (fmt->fourcc == V4L2_PIX_FMT_JPEG) {
1447 if (pix->sizeimage <= 0)
1448 pix->sizeimage = PAGE_SIZE;
1449 pix->bytesperline = 0;
1451 u32 bpl = pix->bytesperline;
1453 if (fmt->colplanes > 1 && bpl < pix->width)
1454 bpl = pix->width; /* planar */
1456 if (fmt->colplanes == 1 && /* packed */
1457 (bpl << 3) / fmt->depth < pix->width)
1458 bpl = (pix->width * fmt->depth) >> 3;
1460 pix->bytesperline = bpl;
1461 pix->sizeimage = (pix->width * pix->height * fmt->depth) >> 3;
1467 static int s5p_jpeg_try_fmt_vid_cap(struct file *file, void *priv,
1468 struct v4l2_format *f)
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;
1475 fmt = s5p_jpeg_find_format(ctx, f->fmt.pix.pixelformat,
1478 v4l2_err(&ctx->jpeg->v4l2_dev,
1479 "Fourcc format (0x%08x) invalid.\n",
1480 f->fmt.pix.pixelformat);
1484 if (!ctx->jpeg->variant->hw_ex4_compat || ctx->mode != S5P_JPEG_DECODE)
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.
1493 if ((fmt->flags & SJPEG_FMT_NON_RGB) &&
1494 (fmt->subsampling < ctx->subsampling)) {
1495 ret = s5p_jpeg_adjust_fourcc_to_subsampling(ctx->subsampling,
1500 pix->pixelformat = V4L2_PIX_FMT_GREY;
1502 fmt = s5p_jpeg_find_format(ctx, pix->pixelformat,
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
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,
1523 return vidioc_try_fmt(f, fmt, ctx, FMT_TYPE_CAPTURE);
1526 static int s5p_jpeg_try_fmt_vid_out(struct file *file, void *priv,
1527 struct v4l2_format *f)
1529 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1530 struct s5p_jpeg_fmt *fmt;
1532 fmt = s5p_jpeg_find_format(ctx, f->fmt.pix.pixelformat,
1535 v4l2_err(&ctx->jpeg->v4l2_dev,
1536 "Fourcc format (0x%08x) invalid.\n",
1537 f->fmt.pix.pixelformat);
1541 return vidioc_try_fmt(f, fmt, ctx, FMT_TYPE_OUTPUT);
1544 static int exynos4_jpeg_get_output_buffer_size(struct s5p_jpeg_ctx *ctx,
1545 struct v4l2_format *f,
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;
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)
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);
1569 if (ctx->jpeg->variant->version == SJPEG_EXYNOS4)
1570 padding = PAGE_SIZE;
1572 return (w * h * fmt_depth >> 3) + padding;
1575 static int exynos3250_jpeg_try_downscale(struct s5p_jpeg_ctx *ctx,
1576 struct v4l2_rect *r);
1578 static int s5p_jpeg_s_fmt(struct s5p_jpeg_ctx *ct, struct v4l2_format *f)
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;
1587 vq = v4l2_m2m_get_vq(ct->fh.m2m_ctx, f->type);
1591 q_data = get_q_data(ct, f->type);
1592 BUG_ON(q_data == NULL);
1594 if (vb2_is_busy(vq)) {
1595 v4l2_err(&ct->jpeg->v4l2_dev, "%s queue busy\n", __func__);
1599 f_type = V4L2_TYPE_IS_OUTPUT(f->type) ?
1600 FMT_TYPE_OUTPUT : FMT_TYPE_CAPTURE;
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) {
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.
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,
1616 q_data->fmt->depth);
1618 q_data->size = q_data->w * q_data->h *
1619 q_data->fmt->depth >> 3;
1621 q_data->size = pix->sizeimage;
1624 if (f_type == FMT_TYPE_OUTPUT) {
1625 ctrl_subs = v4l2_ctrl_find(&ct->ctrl_handler,
1626 V4L2_CID_JPEG_CHROMA_SUBSAMPLING);
1628 v4l2_ctrl_s_ctrl(ctrl_subs, q_data->fmt->subsampling);
1629 ct->crop_altered = false;
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.
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;
1646 * Prevent downscaling to YUV420 format by more than 2
1647 * for Exynos3250/compatible SoC as it produces broken raw image
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);
1663 static int s5p_jpeg_s_fmt_vid_cap(struct file *file, void *priv,
1664 struct v4l2_format *f)
1668 ret = s5p_jpeg_try_fmt_vid_cap(file, priv, f);
1672 return s5p_jpeg_s_fmt(fh_to_ctx(priv), f);
1675 static int s5p_jpeg_s_fmt_vid_out(struct file *file, void *priv,
1676 struct v4l2_format *f)
1680 ret = s5p_jpeg_try_fmt_vid_out(file, priv, f);
1684 return s5p_jpeg_s_fmt(fh_to_ctx(priv), f);
1687 static int exynos3250_jpeg_try_downscale(struct s5p_jpeg_ctx *ctx,
1688 struct v4l2_rect *r)
1690 int w_ratio, h_ratio, scale_factor, cur_ratio, i;
1692 w_ratio = ctx->out_q.w / r->width;
1693 h_ratio = ctx->out_q.h / r->height;
1695 scale_factor = w_ratio > h_ratio ? w_ratio : h_ratio;
1696 scale_factor = clamp_val(scale_factor, 1, 8);
1698 /* Align scale ratio to the nearest power of 2 */
1699 for (i = 0; i <= 3; ++i) {
1701 if (scale_factor <= cur_ratio) {
1702 ctx->scale_factor = cur_ratio;
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);
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;
1715 ctx->crop_altered = true;
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)
1723 if (a->left < b->left || a->top < b->top)
1725 if (a->left + a->width > b->left + b->width)
1727 if (a->top + a->height > b->top + b->height)
1733 static int exynos3250_jpeg_try_crop(struct s5p_jpeg_ctx *ctx,
1734 struct v4l2_rect *r)
1736 struct v4l2_rect base_rect;
1739 switch (ctx->cap_q.fmt->fourcc) {
1740 case V4L2_PIX_FMT_NV12:
1741 case V4L2_PIX_FMT_NV21:
1745 case V4L2_PIX_FMT_YUV420:
1757 base_rect.width = ctx->out_q.w;
1758 base_rect.height = ctx->out_q.h;
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);
1765 if (!enclosed_rectangle(r, &base_rect))
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;
1773 ctx->crop_altered = true;
1782 static int s5p_jpeg_g_selection(struct file *file, void *priv,
1783 struct v4l2_selection *s)
1785 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1787 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
1788 s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
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;
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;
1819 static int s5p_jpeg_s_selection(struct file *file, void *fh,
1820 struct v4l2_selection *s)
1822 struct s5p_jpeg_ctx *ctx = fh_to_ctx(file->private_data);
1823 struct v4l2_rect *rect = &s->r;
1826 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1829 if (s->target == V4L2_SEL_TGT_COMPOSE) {
1830 if (ctx->mode != S5P_JPEG_DECODE)
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)
1837 if (ctx->jpeg->variant->hw3250_compat)
1838 ret = exynos3250_jpeg_try_crop(ctx, rect);
1844 static int s5p_jpeg_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1846 struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl);
1847 struct s5p_jpeg *jpeg = ctx->jpeg;
1848 unsigned long flags;
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);
1861 static int s5p_jpeg_adjust_subs_ctrl(struct s5p_jpeg_ctx *ctx, int *ctrl_val)
1863 switch (ctx->jpeg->variant->version) {
1866 case SJPEG_EXYNOS3250:
1867 case SJPEG_EXYNOS5420:
1869 * The exynos3250/compatible device can produce JPEG image only
1870 * of 4:4:4 subsampling when given RGB32 source image.
1872 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB32)
1877 * The exynos4x12 device requires input raw image fourcc
1878 * to be V4L2_PIX_FMT_GREY if gray jpeg format
1881 if (ctx->out_q.fmt->fourcc != V4L2_PIX_FMT_GREY &&
1882 *ctrl_val == V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY)
1888 * The exynos4x12 and exynos3250/compatible devices require resulting
1889 * jpeg subsampling not to be lower than the input raw image
1892 if (ctx->out_q.fmt->subsampling > *ctrl_val)
1893 *ctrl_val = ctx->out_q.fmt->subsampling;
1898 static int s5p_jpeg_try_ctrl(struct v4l2_ctrl *ctrl)
1900 struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl);
1901 unsigned long flags;
1904 spin_lock_irqsave(&ctx->jpeg->slock, flags);
1906 if (ctrl->id == V4L2_CID_JPEG_CHROMA_SUBSAMPLING)
1907 ret = s5p_jpeg_adjust_subs_ctrl(ctx, &ctrl->val);
1909 spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
1913 static int s5p_jpeg_s_ctrl(struct v4l2_ctrl *ctrl)
1915 struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl);
1916 unsigned long flags;
1918 spin_lock_irqsave(&ctx->jpeg->slock, flags);
1921 case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1922 ctx->compr_quality = ctrl->val;
1924 case V4L2_CID_JPEG_RESTART_INTERVAL:
1925 ctx->restart_interval = ctrl->val;
1927 case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1928 ctx->subsampling = ctrl->val;
1932 spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
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,
1942 static int s5p_jpeg_controls_create(struct s5p_jpeg_ctx *ctx)
1944 unsigned int mask = ~0x27; /* 444, 422, 420, GRAY */
1945 struct v4l2_ctrl *ctrl;
1948 v4l2_ctrl_handler_init(&ctx->ctrl_handler, 3);
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);
1955 v4l2_ctrl_new_std(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops,
1956 V4L2_CID_JPEG_RESTART_INTERVAL,
1958 if (ctx->jpeg->variant->version == SJPEG_S5P)
1959 mask = ~0x06; /* 422, 420 */
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);
1967 if (ctx->ctrl_handler.error) {
1968 ret = ctx->ctrl_handler.error;
1972 if (ctx->mode == S5P_JPEG_DECODE)
1973 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE |
1974 V4L2_CTRL_FLAG_READ_ONLY;
1976 ret = v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
1983 v4l2_ctrl_handler_free(&ctx->ctrl_handler);
1987 static const struct v4l2_ioctl_ops s5p_jpeg_ioctl_ops = {
1988 .vidioc_querycap = s5p_jpeg_querycap,
1990 .vidioc_enum_fmt_vid_cap = s5p_jpeg_enum_fmt_vid_cap,
1991 .vidioc_enum_fmt_vid_out = s5p_jpeg_enum_fmt_vid_out,
1993 .vidioc_g_fmt_vid_cap = s5p_jpeg_g_fmt,
1994 .vidioc_g_fmt_vid_out = s5p_jpeg_g_fmt,
1996 .vidioc_try_fmt_vid_cap = s5p_jpeg_try_fmt_vid_cap,
1997 .vidioc_try_fmt_vid_out = s5p_jpeg_try_fmt_vid_out,
1999 .vidioc_s_fmt_vid_cap = s5p_jpeg_s_fmt_vid_cap,
2000 .vidioc_s_fmt_vid_out = s5p_jpeg_s_fmt_vid_out,
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,
2007 .vidioc_streamon = v4l2_m2m_ioctl_streamon,
2008 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
2010 .vidioc_g_selection = s5p_jpeg_g_selection,
2011 .vidioc_s_selection = s5p_jpeg_s_selection,
2015 * ============================================================================
2017 * ============================================================================
2020 static void s5p_jpeg_device_run(void *priv)
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;
2027 spin_lock_irqsave(&ctx->jpeg->slock, flags);
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);
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);
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);
2051 /* ultimately comes from sizeimage from userspace */
2052 s5p_jpeg_enc_stream_int(jpeg->regs, ctx->cap_q.size);
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);
2066 * JPEG IP allows storing 4 quantization tables
2067 * We fill table 0 for luma and table 1 for chroma
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);
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);
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);
2096 s5p_jpeg_start(jpeg->regs);
2098 spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
2101 static void exynos4_jpeg_set_img_addr(struct s5p_jpeg_ctx *ctx)
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;
2112 pix_size = ctx->cap_q.w * ctx->cap_q.h;
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;
2120 fmt = ctx->cap_q.fmt;
2121 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2124 jpeg_addr.y = vb2_dma_contig_plane_dma_addr(vb, 0);
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;
2133 jpeg_addr.cr = jpeg_addr.cb + pix_size / 2;
2136 exynos4_jpeg_set_frame_buf_address(jpeg->regs, &jpeg_addr);
2139 static void exynos4_jpeg_set_jpeg_addr(struct s5p_jpeg_ctx *ctx)
2141 struct s5p_jpeg *jpeg = ctx->jpeg;
2142 struct vb2_buffer *vb;
2143 unsigned int jpeg_addr = 0;
2145 if (ctx->mode == S5P_JPEG_ENCODE)
2146 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2148 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
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);
2157 static inline void exynos4_jpeg_set_img_fmt(void __iomem *base,
2158 unsigned int img_fmt)
2160 __exynos4_jpeg_set_img_fmt(base, img_fmt, SJPEG_EXYNOS4);
2163 static inline void exynos5433_jpeg_set_img_fmt(void __iomem *base,
2164 unsigned int img_fmt)
2166 __exynos4_jpeg_set_img_fmt(base, img_fmt, SJPEG_EXYNOS5433);
2169 static inline void exynos4_jpeg_set_enc_out_fmt(void __iomem *base,
2170 unsigned int out_fmt)
2172 __exynos4_jpeg_set_enc_out_fmt(base, out_fmt, SJPEG_EXYNOS4);
2175 static inline void exynos5433_jpeg_set_enc_out_fmt(void __iomem *base,
2176 unsigned int out_fmt)
2178 __exynos4_jpeg_set_enc_out_fmt(base, out_fmt, SJPEG_EXYNOS5433);
2181 static void exynos4_jpeg_device_run(void *priv)
2183 struct s5p_jpeg_ctx *ctx = priv;
2184 struct s5p_jpeg *jpeg = ctx->jpeg;
2185 unsigned int bitstream_size;
2186 unsigned long flags;
2188 spin_lock_irqsave(&jpeg->slock, flags);
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);
2195 exynos4_jpeg_set_huff_tbl(jpeg->regs);
2198 * JPEG IP allows storing 4 quantization tables
2199 * We fill table 0 for luma and table 1 for chroma
2201 exynos4_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality);
2202 exynos4_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality);
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,
2209 if (ctx->jpeg->variant->version == SJPEG_EXYNOS4) {
2210 exynos4_jpeg_set_enc_out_fmt(jpeg->regs,
2212 exynos4_jpeg_set_img_fmt(jpeg->regs,
2213 ctx->out_q.fmt->fourcc);
2215 exynos5433_jpeg_set_enc_out_fmt(jpeg->regs,
2217 exynos5433_jpeg_set_img_fmt(jpeg->regs,
2218 ctx->out_q.fmt->fourcc);
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);
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);
2231 if (jpeg->variant->version == SJPEG_EXYNOS5433) {
2232 exynos4_jpeg_parse_huff_tbl(ctx);
2233 exynos4_jpeg_parse_decode_h_tbl(ctx);
2235 exynos4_jpeg_parse_q_tbl(ctx);
2236 exynos4_jpeg_parse_decode_q_tbl(ctx);
2238 exynos4_jpeg_set_huf_table_enable(jpeg->regs, 1);
2240 exynos4_jpeg_set_stream_size(jpeg->regs, ctx->cap_q.w,
2242 exynos5433_jpeg_set_enc_out_fmt(jpeg->regs,
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);
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);
2253 exynos4_jpeg_set_dec_bitstream_size(jpeg->regs, bitstream_size);
2256 exynos4_jpeg_set_enc_dec_mode(jpeg->regs, ctx->mode);
2258 spin_unlock_irqrestore(&jpeg->slock, flags);
2261 static void exynos3250_jpeg_set_img_addr(struct s5p_jpeg_ctx *ctx)
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 = {};
2269 pix_size = ctx->cap_q.w * ctx->cap_q.h;
2271 if (ctx->mode == S5P_JPEG_ENCODE) {
2272 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2273 fmt = ctx->out_q.fmt;
2275 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2276 fmt = ctx->cap_q.fmt;
2279 jpeg_addr.y = vb2_dma_contig_plane_dma_addr(vb, 0);
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;
2288 jpeg_addr.cr = jpeg_addr.cb + pix_size / 2;
2291 exynos3250_jpeg_imgadr(jpeg->regs, &jpeg_addr);
2294 static void exynos3250_jpeg_set_jpeg_addr(struct s5p_jpeg_ctx *ctx)
2296 struct s5p_jpeg *jpeg = ctx->jpeg;
2297 struct vb2_buffer *vb;
2298 unsigned int jpeg_addr = 0;
2300 if (ctx->mode == S5P_JPEG_ENCODE)
2301 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2303 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2305 jpeg_addr = vb2_dma_contig_plane_dma_addr(vb, 0);
2306 exynos3250_jpeg_jpgadr(jpeg->regs, jpeg_addr);
2309 static void exynos3250_jpeg_device_run(void *priv)
2311 struct s5p_jpeg_ctx *ctx = priv;
2312 struct s5p_jpeg *jpeg = ctx->jpeg;
2313 unsigned long flags;
2315 spin_lock_irqsave(&ctx->jpeg->slock, flags);
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);
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);
2329 * JPEG IP allows storing 4 quantization tables
2330 * We fill table 0 for luma and table 1 for chroma
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);
2341 * Some SoCs require setting Huffman tables before each run
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);
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);
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,
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);
2368 /* ultimately comes from sizeimage from userspace */
2369 exynos3250_jpeg_enc_stream_bound(jpeg->regs, ctx->cap_q.size);
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);
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,
2380 exynos3250_jpeg_offset(jpeg->regs, 0, 0);
2381 exynos3250_jpeg_dec_scaling_ratio(jpeg->regs,
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);
2388 exynos3250_jpeg_interrupts_enable(jpeg->regs);
2390 /* JPEG RGB to YCbCr conversion matrix */
2391 exynos3250_jpeg_coef(jpeg->regs, ctx->mode);
2393 exynos3250_jpeg_set_timer(jpeg->regs, EXYNOS3250_IRQ_TIMEOUT);
2394 jpeg->irq_status = 0;
2395 exynos3250_jpeg_start(jpeg->regs);
2397 spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
2400 static int s5p_jpeg_job_ready(void *priv)
2402 struct s5p_jpeg_ctx *ctx = priv;
2404 if (ctx->mode == S5P_JPEG_DECODE)
2405 return ctx->hdr_parsed;
2409 static void s5p_jpeg_job_abort(void *priv)
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,
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,
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,
2432 * ============================================================================
2434 * ============================================================================
2437 static int s5p_jpeg_queue_setup(struct vb2_queue *vq,
2438 unsigned int *nbuffers, unsigned int *nplanes,
2439 unsigned int sizes[], void *alloc_ctxs[])
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;
2445 q_data = get_q_data(ctx, vq->type);
2446 BUG_ON(q_data == NULL);
2448 size = q_data->size;
2451 * header is parsed during decoding and parsed information stored
2452 * in the context so we do not allow another buffer to overwrite it
2454 if (ctx->mode == S5P_JPEG_DECODE)
2460 alloc_ctxs[0] = ctx->jpeg->alloc_ctx;
2465 static int s5p_jpeg_buf_prepare(struct vb2_buffer *vb)
2467 struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
2468 struct s5p_jpeg_q_data *q_data = NULL;
2470 q_data = get_q_data(ctx, vb->vb2_queue->type);
2471 BUG_ON(q_data == NULL);
2473 if (vb2_plane_size(vb, 0) < q_data->size) {
2474 pr_err("%s data will not fit into plane (%lu < %lu)\n",
2475 __func__, vb2_plane_size(vb, 0),
2476 (long)q_data->size);
2480 vb2_set_plane_payload(vb, 0, q_data->size);
2485 static void s5p_jpeg_buf_queue(struct vb2_buffer *vb)
2487 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
2488 struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
2490 if (ctx->mode == S5P_JPEG_DECODE &&
2491 vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
2492 struct s5p_jpeg_q_data tmp, *q_data;
2493 ctx->hdr_parsed = s5p_jpeg_parse_hdr(&tmp,
2494 (unsigned long)vb2_plane_vaddr(vb, 0),
2495 min((unsigned long)ctx->out_q.size,
2496 vb2_get_plane_payload(vb, 0)), ctx);
2497 if (!ctx->hdr_parsed) {
2498 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
2502 q_data = &ctx->out_q;
2505 q_data->sos = tmp.sos;
2506 memcpy(q_data->dht.marker, tmp.dht.marker,
2507 sizeof(tmp.dht.marker));
2508 memcpy(q_data->dht.len, tmp.dht.len, sizeof(tmp.dht.len));
2509 q_data->dht.n = tmp.dht.n;
2510 memcpy(q_data->dqt.marker, tmp.dqt.marker,
2511 sizeof(tmp.dqt.marker));
2512 memcpy(q_data->dqt.len, tmp.dqt.len, sizeof(tmp.dqt.len));
2513 q_data->dqt.n = tmp.dqt.n;
2514 q_data->sof = tmp.sof;
2515 q_data->sof_len = tmp.sof_len;
2517 q_data = &ctx->cap_q;
2522 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
2525 static int s5p_jpeg_start_streaming(struct vb2_queue *q, unsigned int count)
2527 struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q);
2530 ret = pm_runtime_get_sync(ctx->jpeg->dev);
2532 return ret > 0 ? 0 : ret;
2535 static void s5p_jpeg_stop_streaming(struct vb2_queue *q)
2537 struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q);
2539 pm_runtime_put(ctx->jpeg->dev);
2542 static struct vb2_ops s5p_jpeg_qops = {
2543 .queue_setup = s5p_jpeg_queue_setup,
2544 .buf_prepare = s5p_jpeg_buf_prepare,
2545 .buf_queue = s5p_jpeg_buf_queue,
2546 .wait_prepare = vb2_ops_wait_prepare,
2547 .wait_finish = vb2_ops_wait_finish,
2548 .start_streaming = s5p_jpeg_start_streaming,
2549 .stop_streaming = s5p_jpeg_stop_streaming,
2552 static int queue_init(void *priv, struct vb2_queue *src_vq,
2553 struct vb2_queue *dst_vq)
2555 struct s5p_jpeg_ctx *ctx = priv;
2558 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
2559 src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
2560 src_vq->drv_priv = ctx;
2561 src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
2562 src_vq->ops = &s5p_jpeg_qops;
2563 src_vq->mem_ops = &vb2_dma_contig_memops;
2564 src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
2565 src_vq->lock = &ctx->jpeg->lock;
2567 ret = vb2_queue_init(src_vq);
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;
2580 return vb2_queue_init(dst_vq);
2584 * ============================================================================
2586 * ============================================================================
2589 static irqreturn_t s5p_jpeg_irq(int irq, void *dev_id)
2591 struct s5p_jpeg *jpeg = dev_id;
2592 struct s5p_jpeg_ctx *curr_ctx;
2593 struct vb2_v4l2_buffer *src_buf, *dst_buf;
2594 unsigned long payload_size = 0;
2595 enum vb2_buffer_state state = VB2_BUF_STATE_DONE;
2596 bool enc_jpeg_too_large = false;
2597 bool timer_elapsed = false;
2598 bool op_completed = false;
2600 spin_lock(&jpeg->slock);
2602 curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2604 src_buf = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2605 dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2607 if (curr_ctx->mode == S5P_JPEG_ENCODE)
2608 enc_jpeg_too_large = s5p_jpeg_enc_stream_stat(jpeg->regs);
2609 timer_elapsed = s5p_jpeg_timer_stat(jpeg->regs);
2610 op_completed = s5p_jpeg_result_stat_ok(jpeg->regs);
2611 if (curr_ctx->mode == S5P_JPEG_DECODE)
2612 op_completed = op_completed &&
2613 s5p_jpeg_stream_stat_ok(jpeg->regs);
2615 if (enc_jpeg_too_large) {
2616 state = VB2_BUF_STATE_ERROR;
2617 s5p_jpeg_clear_enc_stream_stat(jpeg->regs);
2618 } else if (timer_elapsed) {
2619 state = VB2_BUF_STATE_ERROR;
2620 s5p_jpeg_clear_timer_stat(jpeg->regs);
2621 } else if (!op_completed) {
2622 state = VB2_BUF_STATE_ERROR;
2624 payload_size = s5p_jpeg_compressed_size(jpeg->regs);
2627 dst_buf->timecode = src_buf->timecode;
2628 dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp;
2629 dst_buf->flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
2631 src_buf->flags & V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
2633 v4l2_m2m_buf_done(src_buf, state);
2634 if (curr_ctx->mode == S5P_JPEG_ENCODE)
2635 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload_size);
2636 v4l2_m2m_buf_done(dst_buf, state);
2637 v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2639 curr_ctx->subsampling = s5p_jpeg_get_subsampling_mode(jpeg->regs);
2640 spin_unlock(&jpeg->slock);
2642 s5p_jpeg_clear_int(jpeg->regs);
2647 static irqreturn_t exynos4_jpeg_irq(int irq, void *priv)
2649 unsigned int int_status;
2650 struct vb2_v4l2_buffer *src_vb, *dst_vb;
2651 struct s5p_jpeg *jpeg = priv;
2652 struct s5p_jpeg_ctx *curr_ctx;
2653 unsigned long payload_size = 0;
2655 spin_lock(&jpeg->slock);
2657 curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2659 src_vb = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2660 dst_vb = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2662 int_status = exynos4_jpeg_get_int_status(jpeg->regs);
2665 switch (int_status & 0x1f) {
2667 jpeg->irq_ret = ERR_PROT;
2670 jpeg->irq_ret = OK_ENC_OR_DEC;
2673 jpeg->irq_ret = ERR_DEC_INVALID_FORMAT;
2676 jpeg->irq_ret = ERR_MULTI_SCAN;
2679 jpeg->irq_ret = ERR_FRAME;
2682 jpeg->irq_ret = ERR_UNKNOWN;
2686 jpeg->irq_ret = ERR_UNKNOWN;
2689 if (jpeg->irq_ret == OK_ENC_OR_DEC) {
2690 if (curr_ctx->mode == S5P_JPEG_ENCODE) {
2691 payload_size = exynos4_jpeg_get_stream_size(jpeg->regs);
2692 vb2_set_plane_payload(&dst_vb->vb2_buf,
2695 v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_DONE);
2696 v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_DONE);
2698 v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_ERROR);
2699 v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_ERROR);
2702 v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2703 if (jpeg->variant->version == SJPEG_EXYNOS4)
2704 curr_ctx->subsampling = exynos4_jpeg_get_frame_fmt(jpeg->regs);
2706 spin_unlock(&jpeg->slock);
2710 static irqreturn_t exynos3250_jpeg_irq(int irq, void *dev_id)
2712 struct s5p_jpeg *jpeg = dev_id;
2713 struct s5p_jpeg_ctx *curr_ctx;
2714 struct vb2_v4l2_buffer *src_buf, *dst_buf;
2715 unsigned long payload_size = 0;
2716 enum vb2_buffer_state state = VB2_BUF_STATE_DONE;
2717 bool interrupt_timeout = false;
2720 spin_lock(&jpeg->slock);
2722 irq_status = exynos3250_jpeg_get_timer_status(jpeg->regs);
2723 if (irq_status & EXYNOS3250_TIMER_INT_STAT) {
2724 exynos3250_jpeg_clear_timer_status(jpeg->regs);
2725 interrupt_timeout = true;
2726 dev_err(jpeg->dev, "Interrupt timeout occurred.\n");
2729 irq_status = exynos3250_jpeg_get_int_status(jpeg->regs);
2730 exynos3250_jpeg_clear_int_status(jpeg->regs, irq_status);
2732 jpeg->irq_status |= irq_status;
2734 curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2739 if ((irq_status & EXYNOS3250_HEADER_STAT) &&
2740 (curr_ctx->mode == S5P_JPEG_DECODE)) {
2741 exynos3250_jpeg_rstart(jpeg->regs);
2745 if (jpeg->irq_status & (EXYNOS3250_JPEG_DONE |
2746 EXYNOS3250_WDMA_DONE |
2747 EXYNOS3250_RDMA_DONE |
2748 EXYNOS3250_RESULT_STAT))
2749 payload_size = exynos3250_jpeg_compressed_size(jpeg->regs);
2750 else if (interrupt_timeout)
2751 state = VB2_BUF_STATE_ERROR;
2755 src_buf = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2756 dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2758 dst_buf->timecode = src_buf->timecode;
2759 dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp;
2761 v4l2_m2m_buf_done(src_buf, state);
2762 if (curr_ctx->mode == S5P_JPEG_ENCODE)
2763 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload_size);
2764 v4l2_m2m_buf_done(dst_buf, state);
2765 v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2767 curr_ctx->subsampling =
2768 exynos3250_jpeg_get_subsampling_mode(jpeg->regs);
2770 spin_unlock(&jpeg->slock);
2774 static void *jpeg_get_drv_data(struct device *dev);
2777 * ============================================================================
2778 * Driver basic infrastructure
2779 * ============================================================================
2782 static int s5p_jpeg_probe(struct platform_device *pdev)
2784 struct s5p_jpeg *jpeg;
2785 struct resource *res;
2788 /* JPEG IP abstraction struct */
2789 jpeg = devm_kzalloc(&pdev->dev, sizeof(struct s5p_jpeg), GFP_KERNEL);
2793 jpeg->variant = jpeg_get_drv_data(&pdev->dev);
2795 mutex_init(&jpeg->lock);
2796 spin_lock_init(&jpeg->slock);
2797 jpeg->dev = &pdev->dev;
2799 /* memory-mapped registers */
2800 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2802 jpeg->regs = devm_ioremap_resource(&pdev->dev, res);
2803 if (IS_ERR(jpeg->regs))
2804 return PTR_ERR(jpeg->regs);
2806 /* interrupt service routine registration */
2807 jpeg->irq = ret = platform_get_irq(pdev, 0);
2809 dev_err(&pdev->dev, "cannot find IRQ\n");
2813 ret = devm_request_irq(&pdev->dev, jpeg->irq, jpeg->variant->jpeg_irq,
2814 0, dev_name(&pdev->dev), jpeg);
2816 dev_err(&pdev->dev, "cannot claim IRQ %d\n", jpeg->irq);
2821 for (i = 0; i < jpeg->variant->num_clocks; i++) {
2822 jpeg->clocks[i] = devm_clk_get(&pdev->dev,
2823 jpeg->variant->clk_names[i]);
2824 if (IS_ERR(jpeg->clocks[i])) {
2825 dev_err(&pdev->dev, "failed to get clock: %s\n",
2826 jpeg->variant->clk_names[i]);
2827 return PTR_ERR(jpeg->clocks[i]);
2832 ret = v4l2_device_register(&pdev->dev, &jpeg->v4l2_dev);
2834 dev_err(&pdev->dev, "Failed to register v4l2 device\n");
2838 /* mem2mem device */
2839 jpeg->m2m_dev = v4l2_m2m_init(jpeg->variant->m2m_ops);
2840 if (IS_ERR(jpeg->m2m_dev)) {
2841 v4l2_err(&jpeg->v4l2_dev, "Failed to init mem2mem device\n");
2842 ret = PTR_ERR(jpeg->m2m_dev);
2843 goto device_register_rollback;
2846 jpeg->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
2847 if (IS_ERR(jpeg->alloc_ctx)) {
2848 v4l2_err(&jpeg->v4l2_dev, "Failed to init memory allocator\n");
2849 ret = PTR_ERR(jpeg->alloc_ctx);
2850 goto m2m_init_rollback;
2853 /* JPEG encoder /dev/videoX node */
2854 jpeg->vfd_encoder = video_device_alloc();
2855 if (!jpeg->vfd_encoder) {
2856 v4l2_err(&jpeg->v4l2_dev, "Failed to allocate video device\n");
2858 goto vb2_allocator_rollback;
2860 snprintf(jpeg->vfd_encoder->name, sizeof(jpeg->vfd_encoder->name),
2861 "%s-enc", S5P_JPEG_M2M_NAME);
2862 jpeg->vfd_encoder->fops = &s5p_jpeg_fops;
2863 jpeg->vfd_encoder->ioctl_ops = &s5p_jpeg_ioctl_ops;
2864 jpeg->vfd_encoder->minor = -1;
2865 jpeg->vfd_encoder->release = video_device_release;
2866 jpeg->vfd_encoder->lock = &jpeg->lock;
2867 jpeg->vfd_encoder->v4l2_dev = &jpeg->v4l2_dev;
2868 jpeg->vfd_encoder->vfl_dir = VFL_DIR_M2M;
2870 ret = video_register_device(jpeg->vfd_encoder, VFL_TYPE_GRABBER, -1);
2872 v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n");
2873 video_device_release(jpeg->vfd_encoder);
2874 goto vb2_allocator_rollback;
2877 video_set_drvdata(jpeg->vfd_encoder, jpeg);
2878 v4l2_info(&jpeg->v4l2_dev,
2879 "encoder device registered as /dev/video%d\n",
2880 jpeg->vfd_encoder->num);
2882 /* JPEG decoder /dev/videoX node */
2883 jpeg->vfd_decoder = video_device_alloc();
2884 if (!jpeg->vfd_decoder) {
2885 v4l2_err(&jpeg->v4l2_dev, "Failed to allocate video device\n");
2887 goto enc_vdev_register_rollback;
2889 snprintf(jpeg->vfd_decoder->name, sizeof(jpeg->vfd_decoder->name),
2890 "%s-dec", S5P_JPEG_M2M_NAME);
2891 jpeg->vfd_decoder->fops = &s5p_jpeg_fops;
2892 jpeg->vfd_decoder->ioctl_ops = &s5p_jpeg_ioctl_ops;
2893 jpeg->vfd_decoder->minor = -1;
2894 jpeg->vfd_decoder->release = video_device_release;
2895 jpeg->vfd_decoder->lock = &jpeg->lock;
2896 jpeg->vfd_decoder->v4l2_dev = &jpeg->v4l2_dev;
2897 jpeg->vfd_decoder->vfl_dir = VFL_DIR_M2M;
2899 ret = video_register_device(jpeg->vfd_decoder, VFL_TYPE_GRABBER, -1);
2901 v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n");
2902 video_device_release(jpeg->vfd_decoder);
2903 goto enc_vdev_register_rollback;
2906 video_set_drvdata(jpeg->vfd_decoder, jpeg);
2907 v4l2_info(&jpeg->v4l2_dev,
2908 "decoder device registered as /dev/video%d\n",
2909 jpeg->vfd_decoder->num);
2911 /* final statements & power management */
2912 platform_set_drvdata(pdev, jpeg);
2914 pm_runtime_enable(&pdev->dev);
2916 v4l2_info(&jpeg->v4l2_dev, "Samsung S5P JPEG codec\n");
2920 enc_vdev_register_rollback:
2921 video_unregister_device(jpeg->vfd_encoder);
2923 vb2_allocator_rollback:
2924 vb2_dma_contig_cleanup_ctx(jpeg->alloc_ctx);
2927 v4l2_m2m_release(jpeg->m2m_dev);
2929 device_register_rollback:
2930 v4l2_device_unregister(&jpeg->v4l2_dev);
2935 static int s5p_jpeg_remove(struct platform_device *pdev)
2937 struct s5p_jpeg *jpeg = platform_get_drvdata(pdev);
2940 pm_runtime_disable(jpeg->dev);
2942 video_unregister_device(jpeg->vfd_decoder);
2943 video_unregister_device(jpeg->vfd_encoder);
2944 vb2_dma_contig_cleanup_ctx(jpeg->alloc_ctx);
2945 v4l2_m2m_release(jpeg->m2m_dev);
2946 v4l2_device_unregister(&jpeg->v4l2_dev);
2948 if (!pm_runtime_status_suspended(&pdev->dev)) {
2949 for (i = jpeg->variant->num_clocks - 1; i >= 0; i--)
2950 clk_disable_unprepare(jpeg->clocks[i]);
2957 static int s5p_jpeg_runtime_suspend(struct device *dev)
2959 struct s5p_jpeg *jpeg = dev_get_drvdata(dev);
2962 for (i = jpeg->variant->num_clocks - 1; i >= 0; i--)
2963 clk_disable_unprepare(jpeg->clocks[i]);
2968 static int s5p_jpeg_runtime_resume(struct device *dev)
2970 struct s5p_jpeg *jpeg = dev_get_drvdata(dev);
2971 unsigned long flags;
2974 for (i = 0; i < jpeg->variant->num_clocks; i++) {
2975 ret = clk_prepare_enable(jpeg->clocks[i]);
2978 clk_disable_unprepare(jpeg->clocks[i]);
2983 spin_lock_irqsave(&jpeg->slock, flags);
2986 * JPEG IP allows storing two Huffman tables for each component.
2987 * We fill table 0 for each component and do this here only
2988 * for S5PC210 and Exynos3250 SoCs. Exynos4x12 and Exynos542x SoC
2989 * require programming their Huffman tables each time the encoding
2990 * process is initialized, and thus it is accomplished in the
2991 * device_run callback of m2m_ops.
2993 if (!jpeg->variant->htbl_reinit) {
2994 s5p_jpeg_set_hdctbl(jpeg->regs);
2995 s5p_jpeg_set_hdctblg(jpeg->regs);
2996 s5p_jpeg_set_hactbl(jpeg->regs);
2997 s5p_jpeg_set_hactblg(jpeg->regs);
3000 spin_unlock_irqrestore(&jpeg->slock, flags);
3004 #endif /* CONFIG_PM */
3006 #ifdef CONFIG_PM_SLEEP
3007 static int s5p_jpeg_suspend(struct device *dev)
3009 if (pm_runtime_suspended(dev))
3012 return s5p_jpeg_runtime_suspend(dev);
3015 static int s5p_jpeg_resume(struct device *dev)
3017 if (pm_runtime_suspended(dev))
3020 return s5p_jpeg_runtime_resume(dev);
3024 static const struct dev_pm_ops s5p_jpeg_pm_ops = {
3025 SET_SYSTEM_SLEEP_PM_OPS(s5p_jpeg_suspend, s5p_jpeg_resume)
3026 SET_RUNTIME_PM_OPS(s5p_jpeg_runtime_suspend, s5p_jpeg_runtime_resume, NULL)
3029 static struct s5p_jpeg_variant s5p_jpeg_drvdata = {
3030 .version = SJPEG_S5P,
3031 .jpeg_irq = s5p_jpeg_irq,
3032 .m2m_ops = &s5p_jpeg_m2m_ops,
3033 .fmt_ver_flag = SJPEG_FMT_FLAG_S5P,
3034 .clk_names = {"jpeg"},
3038 static struct s5p_jpeg_variant exynos3250_jpeg_drvdata = {
3039 .version = SJPEG_EXYNOS3250,
3040 .jpeg_irq = exynos3250_jpeg_irq,
3041 .m2m_ops = &exynos3250_jpeg_m2m_ops,
3042 .fmt_ver_flag = SJPEG_FMT_FLAG_EXYNOS3250,
3044 .clk_names = {"jpeg", "sclk"},
3048 static struct s5p_jpeg_variant exynos4_jpeg_drvdata = {
3049 .version = SJPEG_EXYNOS4,
3050 .jpeg_irq = exynos4_jpeg_irq,
3051 .m2m_ops = &exynos4_jpeg_m2m_ops,
3052 .fmt_ver_flag = SJPEG_FMT_FLAG_EXYNOS4,
3054 .clk_names = {"jpeg"},
3059 static struct s5p_jpeg_variant exynos5420_jpeg_drvdata = {
3060 .version = SJPEG_EXYNOS5420,
3061 .jpeg_irq = exynos3250_jpeg_irq, /* intentionally 3250 */
3062 .m2m_ops = &exynos3250_jpeg_m2m_ops, /* intentionally 3250 */
3063 .fmt_ver_flag = SJPEG_FMT_FLAG_EXYNOS3250, /* intentionally 3250 */
3066 .clk_names = {"jpeg"},
3070 static struct s5p_jpeg_variant exynos5433_jpeg_drvdata = {
3071 .version = SJPEG_EXYNOS5433,
3072 .jpeg_irq = exynos4_jpeg_irq,
3073 .m2m_ops = &exynos4_jpeg_m2m_ops,
3074 .fmt_ver_flag = SJPEG_FMT_FLAG_EXYNOS4,
3076 .clk_names = {"pclk", "aclk", "aclk_xiu", "sclk"},
3081 static const struct of_device_id samsung_jpeg_match[] = {
3083 .compatible = "samsung,s5pv210-jpeg",
3084 .data = &s5p_jpeg_drvdata,
3086 .compatible = "samsung,exynos3250-jpeg",
3087 .data = &exynos3250_jpeg_drvdata,
3089 .compatible = "samsung,exynos4210-jpeg",
3090 .data = &exynos4_jpeg_drvdata,
3092 .compatible = "samsung,exynos4212-jpeg",
3093 .data = &exynos4_jpeg_drvdata,
3095 .compatible = "samsung,exynos5420-jpeg",
3096 .data = &exynos5420_jpeg_drvdata,
3098 .compatible = "samsung,exynos5433-jpeg",
3099 .data = &exynos5433_jpeg_drvdata,
3104 MODULE_DEVICE_TABLE(of, samsung_jpeg_match);
3106 static void *jpeg_get_drv_data(struct device *dev)
3108 struct s5p_jpeg_variant *driver_data = NULL;
3109 const struct of_device_id *match;
3111 if (!IS_ENABLED(CONFIG_OF) || !dev->of_node)
3112 return &s5p_jpeg_drvdata;
3114 match = of_match_node(samsung_jpeg_match, dev->of_node);
3117 driver_data = (struct s5p_jpeg_variant *)match->data;
3122 static struct platform_driver s5p_jpeg_driver = {
3123 .probe = s5p_jpeg_probe,
3124 .remove = s5p_jpeg_remove,
3126 .of_match_table = of_match_ptr(samsung_jpeg_match),
3127 .name = S5P_JPEG_M2M_NAME,
3128 .pm = &s5p_jpeg_pm_ops,
3132 module_platform_driver(s5p_jpeg_driver);
3134 MODULE_AUTHOR("Andrzej Pietrasiewicz <andrzej.p@samsung.com>");
3135 MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>");
3136 MODULE_DESCRIPTION("Samsung JPEG codec driver");
3137 MODULE_LICENSE("GPL");