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)
541 for (i = 0; i < ARRAY_SIZE(fourcc_to_dwngrd_schema_id); ++i) {
542 if (fourcc_to_dwngrd_schema_id[i] == fourcc)
549 static int s5p_jpeg_adjust_fourcc_to_subsampling(
550 enum v4l2_jpeg_chroma_subsampling subs,
553 struct s5p_jpeg_ctx *ctx)
557 if (ctx->subsampling != V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY) {
559 s5p_jpeg_get_dwngrd_sch_id_by_fourcc(in_fourcc);
560 if (dwngrd_sch_id < 0)
564 switch (ctx->subsampling) {
565 case V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY:
566 *out_fourcc = V4L2_PIX_FMT_GREY;
568 case V4L2_JPEG_CHROMA_SUBSAMPLING_420:
570 ARRAY_SIZE(subs420_fourcc_dwngrd_schema) - 1)
572 *out_fourcc = subs420_fourcc_dwngrd_schema[dwngrd_sch_id];
574 case V4L2_JPEG_CHROMA_SUBSAMPLING_422:
576 ARRAY_SIZE(subs422_fourcc_dwngrd_schema) - 1)
578 *out_fourcc = subs422_fourcc_dwngrd_schema[dwngrd_sch_id];
581 *out_fourcc = V4L2_PIX_FMT_GREY;
588 static int exynos4x12_decoded_subsampling[] = {
589 V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY,
590 V4L2_JPEG_CHROMA_SUBSAMPLING_444,
591 V4L2_JPEG_CHROMA_SUBSAMPLING_422,
592 V4L2_JPEG_CHROMA_SUBSAMPLING_420,
595 static int exynos3250_decoded_subsampling[] = {
596 V4L2_JPEG_CHROMA_SUBSAMPLING_444,
597 V4L2_JPEG_CHROMA_SUBSAMPLING_422,
598 V4L2_JPEG_CHROMA_SUBSAMPLING_420,
599 V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY,
602 V4L2_JPEG_CHROMA_SUBSAMPLING_411,
605 static inline struct s5p_jpeg_ctx *ctrl_to_ctx(struct v4l2_ctrl *c)
607 return container_of(c->handler, struct s5p_jpeg_ctx, ctrl_handler);
610 static inline struct s5p_jpeg_ctx *fh_to_ctx(struct v4l2_fh *fh)
612 return container_of(fh, struct s5p_jpeg_ctx, fh);
615 static int s5p_jpeg_to_user_subsampling(struct s5p_jpeg_ctx *ctx)
617 WARN_ON(ctx->subsampling > 3);
619 switch (ctx->jpeg->variant->version) {
621 if (ctx->subsampling > 2)
622 return V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY;
623 return ctx->subsampling;
624 case SJPEG_EXYNOS3250:
625 case SJPEG_EXYNOS5420:
626 if (ctx->subsampling > 3)
627 return V4L2_JPEG_CHROMA_SUBSAMPLING_411;
628 return exynos3250_decoded_subsampling[ctx->subsampling];
630 case SJPEG_EXYNOS5433:
631 if (ctx->subsampling > 2)
632 return V4L2_JPEG_CHROMA_SUBSAMPLING_420;
633 return exynos4x12_decoded_subsampling[ctx->subsampling];
635 return V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY;
639 static inline void s5p_jpeg_set_qtbl(void __iomem *regs,
640 const unsigned char *qtbl,
641 unsigned long tab, int len)
645 for (i = 0; i < len; i++)
646 writel((unsigned int)qtbl[i], regs + tab + (i * 0x04));
649 static inline void s5p_jpeg_set_qtbl_lum(void __iomem *regs, int quality)
651 /* this driver fills quantisation table 0 with data for luma */
652 s5p_jpeg_set_qtbl(regs, qtbl_luminance[quality],
653 S5P_JPG_QTBL_CONTENT(0),
654 ARRAY_SIZE(qtbl_luminance[quality]));
657 static inline void s5p_jpeg_set_qtbl_chr(void __iomem *regs, int quality)
659 /* this driver fills quantisation table 1 with data for chroma */
660 s5p_jpeg_set_qtbl(regs, qtbl_chrominance[quality],
661 S5P_JPG_QTBL_CONTENT(1),
662 ARRAY_SIZE(qtbl_chrominance[quality]));
665 static inline void s5p_jpeg_set_htbl(void __iomem *regs,
666 const unsigned char *htbl,
667 unsigned long tab, int len)
671 for (i = 0; i < len; i++)
672 writel((unsigned int)htbl[i], regs + tab + (i * 0x04));
675 static inline void s5p_jpeg_set_hdctbl(void __iomem *regs)
677 /* this driver fills table 0 for this component */
678 s5p_jpeg_set_htbl(regs, hdctbl0, S5P_JPG_HDCTBL(0),
679 ARRAY_SIZE(hdctbl0));
682 static inline void s5p_jpeg_set_hdctblg(void __iomem *regs)
684 /* this driver fills table 0 for this component */
685 s5p_jpeg_set_htbl(regs, hdctblg0, S5P_JPG_HDCTBLG(0),
686 ARRAY_SIZE(hdctblg0));
689 static inline void s5p_jpeg_set_hactbl(void __iomem *regs)
691 /* this driver fills table 0 for this component */
692 s5p_jpeg_set_htbl(regs, hactbl0, S5P_JPG_HACTBL(0),
693 ARRAY_SIZE(hactbl0));
696 static inline void s5p_jpeg_set_hactblg(void __iomem *regs)
698 /* this driver fills table 0 for this component */
699 s5p_jpeg_set_htbl(regs, hactblg0, S5P_JPG_HACTBLG(0),
700 ARRAY_SIZE(hactblg0));
703 static inline void exynos4_jpeg_set_tbl(void __iomem *regs,
704 const unsigned char *tbl,
705 unsigned long tab, int len)
710 for (i = 0; i < len; i += 4) {
715 writel(dword, regs + tab + i);
719 static inline void exynos4_jpeg_set_qtbl_lum(void __iomem *regs, int quality)
721 /* this driver fills quantisation table 0 with data for luma */
722 exynos4_jpeg_set_tbl(regs, qtbl_luminance[quality],
723 EXYNOS4_QTBL_CONTENT(0),
724 ARRAY_SIZE(qtbl_luminance[quality]));
727 static inline void exynos4_jpeg_set_qtbl_chr(void __iomem *regs, int quality)
729 /* this driver fills quantisation table 1 with data for chroma */
730 exynos4_jpeg_set_tbl(regs, qtbl_chrominance[quality],
731 EXYNOS4_QTBL_CONTENT(1),
732 ARRAY_SIZE(qtbl_chrominance[quality]));
735 static void exynos4_jpeg_set_huff_tbl(void __iomem *base)
737 exynos4_jpeg_set_tbl(base, hdctbl0, EXYNOS4_HUFF_TBL_HDCLL,
738 ARRAY_SIZE(hdctbl0));
739 exynos4_jpeg_set_tbl(base, hdctbl0, EXYNOS4_HUFF_TBL_HDCCL,
740 ARRAY_SIZE(hdctbl0));
741 exynos4_jpeg_set_tbl(base, hdctblg0, EXYNOS4_HUFF_TBL_HDCLV,
742 ARRAY_SIZE(hdctblg0));
743 exynos4_jpeg_set_tbl(base, hdctblg0, EXYNOS4_HUFF_TBL_HDCCV,
744 ARRAY_SIZE(hdctblg0));
745 exynos4_jpeg_set_tbl(base, hactbl0, EXYNOS4_HUFF_TBL_HACLL,
746 ARRAY_SIZE(hactbl0));
747 exynos4_jpeg_set_tbl(base, hactbl0, EXYNOS4_HUFF_TBL_HACCL,
748 ARRAY_SIZE(hactbl0));
749 exynos4_jpeg_set_tbl(base, hactblg0, EXYNOS4_HUFF_TBL_HACLV,
750 ARRAY_SIZE(hactblg0));
751 exynos4_jpeg_set_tbl(base, hactblg0, EXYNOS4_HUFF_TBL_HACCV,
752 ARRAY_SIZE(hactblg0));
755 static inline int __exynos4_huff_tbl(int class, int id, bool lenval)
758 * class: 0 - DC, 1 - AC
759 * id: 0 - Y, 1 - Cb/Cr
763 return lenval ? EXYNOS4_HUFF_TBL_HACCL :
764 EXYNOS4_HUFF_TBL_HACCV;
765 return lenval ? EXYNOS4_HUFF_TBL_HACLL : EXYNOS4_HUFF_TBL_HACLV;
770 return lenval ? EXYNOS4_HUFF_TBL_HDCCL : EXYNOS4_HUFF_TBL_HDCCV;
772 return lenval ? EXYNOS4_HUFF_TBL_HDCLL : EXYNOS4_HUFF_TBL_HDCLV;
775 static inline int exynos4_huff_tbl_len(int class, int id)
777 return __exynos4_huff_tbl(class, id, true);
780 static inline int exynos4_huff_tbl_val(int class, int id)
782 return __exynos4_huff_tbl(class, id, false);
785 static int get_byte(struct s5p_jpeg_buffer *buf);
786 static int get_word_be(struct s5p_jpeg_buffer *buf, unsigned int *word);
787 static void skip(struct s5p_jpeg_buffer *buf, long len);
789 static void exynos4_jpeg_parse_decode_h_tbl(struct s5p_jpeg_ctx *ctx)
791 struct s5p_jpeg *jpeg = ctx->jpeg;
792 struct vb2_v4l2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
793 struct s5p_jpeg_buffer jpeg_buffer;
795 int c, x, components;
797 jpeg_buffer.size = 2; /* Ls */
799 (unsigned long)vb2_plane_vaddr(&vb->vb2_buf, 0) + ctx->out_q.sos + 2;
800 jpeg_buffer.curr = 0;
804 if (get_word_be(&jpeg_buffer, &word))
806 jpeg_buffer.size = (long)word - 2;
807 jpeg_buffer.data += 2;
808 jpeg_buffer.curr = 0;
810 components = get_byte(&jpeg_buffer);
811 if (components == -1)
813 while (components--) {
814 c = get_byte(&jpeg_buffer);
817 x = get_byte(&jpeg_buffer);
820 exynos4_jpeg_select_dec_h_tbl(jpeg->regs, c,
821 (((x >> 4) & 0x1) << 1) | (x & 0x1));
826 static void exynos4_jpeg_parse_huff_tbl(struct s5p_jpeg_ctx *ctx)
828 struct s5p_jpeg *jpeg = ctx->jpeg;
829 struct vb2_v4l2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
830 struct s5p_jpeg_buffer jpeg_buffer;
834 for (j = 0; j < ctx->out_q.dht.n; ++j) {
835 jpeg_buffer.size = ctx->out_q.dht.len[j];
836 jpeg_buffer.data = (unsigned long)vb2_plane_vaddr(&vb->vb2_buf, 0) +
837 ctx->out_q.dht.marker[j];
838 jpeg_buffer.curr = 0;
841 while (jpeg_buffer.curr < jpeg_buffer.size) {
844 c = get_byte(&jpeg_buffer);
848 class = (c >> 4) & 0xf;
850 for (i = 0; i < 16; ++i) {
851 c = get_byte(&jpeg_buffer);
854 word |= c << ((i % 4) * 8);
855 if ((i + 1) % 4 == 0) {
856 writel(word, jpeg->regs +
857 exynos4_huff_tbl_len(class, id) +
864 for (i = 0; i < n; ++i) {
865 c = get_byte(&jpeg_buffer);
868 word |= c << ((i % 4) * 8);
869 if ((i + 1) % 4 == 0) {
870 writel(word, jpeg->regs +
871 exynos4_huff_tbl_val(class, id) +
877 writel(word, jpeg->regs +
878 exynos4_huff_tbl_val(class, id) + (i / 4) * 4);
885 static void exynos4_jpeg_parse_decode_q_tbl(struct s5p_jpeg_ctx *ctx)
887 struct s5p_jpeg *jpeg = ctx->jpeg;
888 struct vb2_v4l2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
889 struct s5p_jpeg_buffer jpeg_buffer;
890 int c, x, components;
892 jpeg_buffer.size = ctx->out_q.sof_len;
894 (unsigned long)vb2_plane_vaddr(&vb->vb2_buf, 0) + ctx->out_q.sof;
895 jpeg_buffer.curr = 0;
897 skip(&jpeg_buffer, 5); /* P, Y, X */
898 components = get_byte(&jpeg_buffer);
899 if (components == -1)
902 exynos4_jpeg_set_dec_components(jpeg->regs, components);
904 while (components--) {
905 c = get_byte(&jpeg_buffer);
908 skip(&jpeg_buffer, 1);
909 x = get_byte(&jpeg_buffer);
912 exynos4_jpeg_select_dec_q_tbl(jpeg->regs, c, x);
916 static void exynos4_jpeg_parse_q_tbl(struct s5p_jpeg_ctx *ctx)
918 struct s5p_jpeg *jpeg = ctx->jpeg;
919 struct vb2_v4l2_buffer *vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
920 struct s5p_jpeg_buffer jpeg_buffer;
924 for (j = 0; j < ctx->out_q.dqt.n; ++j) {
925 jpeg_buffer.size = ctx->out_q.dqt.len[j];
926 jpeg_buffer.data = (unsigned long)vb2_plane_vaddr(&vb->vb2_buf, 0) +
927 ctx->out_q.dqt.marker[j];
928 jpeg_buffer.curr = 0;
931 while (jpeg_buffer.size - jpeg_buffer.curr >= 65) {
934 c = get_byte(&jpeg_buffer);
938 /* nonzero means extended mode - not supported */
941 for (i = 0; i < 64; ++i) {
942 c = get_byte(&jpeg_buffer);
945 word |= c << ((i % 4) * 8);
946 if ((i + 1) % 4 == 0) {
947 writel(word, jpeg->regs +
948 EXYNOS4_QTBL_CONTENT(id) + (i / 4) * 4);
958 * ============================================================================
959 * Device file operations
960 * ============================================================================
963 static int queue_init(void *priv, struct vb2_queue *src_vq,
964 struct vb2_queue *dst_vq);
965 static struct s5p_jpeg_fmt *s5p_jpeg_find_format(struct s5p_jpeg_ctx *ctx,
966 __u32 pixelformat, unsigned int fmt_type);
967 static int s5p_jpeg_controls_create(struct s5p_jpeg_ctx *ctx);
969 static int s5p_jpeg_open(struct file *file)
971 struct s5p_jpeg *jpeg = video_drvdata(file);
972 struct video_device *vfd = video_devdata(file);
973 struct s5p_jpeg_ctx *ctx;
974 struct s5p_jpeg_fmt *out_fmt, *cap_fmt;
977 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
981 if (mutex_lock_interruptible(&jpeg->lock)) {
986 v4l2_fh_init(&ctx->fh, vfd);
987 /* Use separate control handler per file handle */
988 ctx->fh.ctrl_handler = &ctx->ctrl_handler;
989 file->private_data = &ctx->fh;
990 v4l2_fh_add(&ctx->fh);
993 if (vfd == jpeg->vfd_encoder) {
994 ctx->mode = S5P_JPEG_ENCODE;
995 out_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_RGB565,
997 cap_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_JPEG,
1000 ctx->mode = S5P_JPEG_DECODE;
1001 out_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_JPEG,
1003 cap_fmt = s5p_jpeg_find_format(ctx, V4L2_PIX_FMT_YUYV,
1005 ctx->scale_factor = EXYNOS3250_DEC_SCALE_FACTOR_8_8;
1008 ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(jpeg->m2m_dev, ctx, queue_init);
1009 if (IS_ERR(ctx->fh.m2m_ctx)) {
1010 ret = PTR_ERR(ctx->fh.m2m_ctx);
1014 ctx->out_q.fmt = out_fmt;
1015 ctx->cap_q.fmt = cap_fmt;
1017 ret = s5p_jpeg_controls_create(ctx);
1021 mutex_unlock(&jpeg->lock);
1025 v4l2_fh_del(&ctx->fh);
1026 v4l2_fh_exit(&ctx->fh);
1027 mutex_unlock(&jpeg->lock);
1033 static int s5p_jpeg_release(struct file *file)
1035 struct s5p_jpeg *jpeg = video_drvdata(file);
1036 struct s5p_jpeg_ctx *ctx = fh_to_ctx(file->private_data);
1038 mutex_lock(&jpeg->lock);
1039 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
1040 v4l2_ctrl_handler_free(&ctx->ctrl_handler);
1041 v4l2_fh_del(&ctx->fh);
1042 v4l2_fh_exit(&ctx->fh);
1044 mutex_unlock(&jpeg->lock);
1049 static const struct v4l2_file_operations s5p_jpeg_fops = {
1050 .owner = THIS_MODULE,
1051 .open = s5p_jpeg_open,
1052 .release = s5p_jpeg_release,
1053 .poll = v4l2_m2m_fop_poll,
1054 .unlocked_ioctl = video_ioctl2,
1055 .mmap = v4l2_m2m_fop_mmap,
1059 * ============================================================================
1060 * video ioctl operations
1061 * ============================================================================
1064 static int get_byte(struct s5p_jpeg_buffer *buf)
1066 if (buf->curr >= buf->size)
1069 return ((unsigned char *)buf->data)[buf->curr++];
1072 static int get_word_be(struct s5p_jpeg_buffer *buf, unsigned int *word)
1077 byte = get_byte(buf);
1081 byte = get_byte(buf);
1084 *word = (unsigned int)byte | temp;
1088 static void skip(struct s5p_jpeg_buffer *buf, long len)
1097 static bool s5p_jpeg_parse_hdr(struct s5p_jpeg_q_data *result,
1098 unsigned long buffer, unsigned long size,
1099 struct s5p_jpeg_ctx *ctx)
1101 int c, components = 0, notfound, n_dht = 0, n_dqt = 0;
1102 unsigned int height = 0, width = 0, word, subsampling = 0;
1103 unsigned int sos = 0, sof = 0, sof_len = 0;
1104 unsigned int dht[S5P_JPEG_MAX_MARKER], dht_len[S5P_JPEG_MAX_MARKER];
1105 unsigned int dqt[S5P_JPEG_MAX_MARKER], dqt_len[S5P_JPEG_MAX_MARKER];
1107 struct s5p_jpeg_buffer jpeg_buffer;
1109 jpeg_buffer.size = size;
1110 jpeg_buffer.data = buffer;
1111 jpeg_buffer.curr = 0;
1114 while (notfound || !sos) {
1115 c = get_byte(&jpeg_buffer);
1121 c = get_byte(&jpeg_buffer);
1129 /* SOF0: baseline JPEG */
1131 if (get_word_be(&jpeg_buffer, &word))
1133 length = (long)word - 2;
1136 sof = jpeg_buffer.curr; /* after 0xffc0 */
1138 if (get_byte(&jpeg_buffer) == -1)
1140 if (get_word_be(&jpeg_buffer, &height))
1142 if (get_word_be(&jpeg_buffer, &width))
1144 components = get_byte(&jpeg_buffer);
1145 if (components == -1)
1148 if (components == 1) {
1151 skip(&jpeg_buffer, 1);
1152 subsampling = get_byte(&jpeg_buffer);
1153 skip(&jpeg_buffer, 1);
1157 skip(&jpeg_buffer, components * 2);
1162 if (get_word_be(&jpeg_buffer, &word))
1164 length = (long)word - 2;
1167 if (n_dqt >= S5P_JPEG_MAX_MARKER)
1169 dqt[n_dqt] = jpeg_buffer.curr; /* after 0xffdb */
1170 dqt_len[n_dqt++] = length;
1171 skip(&jpeg_buffer, length);
1175 if (get_word_be(&jpeg_buffer, &word))
1177 length = (long)word - 2;
1180 if (n_dht >= S5P_JPEG_MAX_MARKER)
1182 dht[n_dht] = jpeg_buffer.curr; /* after 0xffc4 */
1183 dht_len[n_dht++] = length;
1184 skip(&jpeg_buffer, length);
1188 sos = jpeg_buffer.curr - 2; /* 0xffda */
1191 /* skip payload-less markers */
1192 case RST ... RST + 7:
1198 /* skip uninteresting payload markers */
1200 if (get_word_be(&jpeg_buffer, &word))
1202 length = (long)word - 2;
1203 skip(&jpeg_buffer, length);
1210 result->dht.n = n_dht;
1212 result->dht.marker[n_dht] = dht[n_dht];
1213 result->dht.len[n_dht] = dht_len[n_dht];
1215 result->dqt.n = n_dqt;
1217 result->dqt.marker[n_dqt] = dqt[n_dqt];
1218 result->dqt.len[n_dqt] = dqt_len[n_dqt];
1221 result->sof_len = sof_len;
1222 result->size = result->components = components;
1224 switch (subsampling) {
1226 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_444;
1229 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_422;
1232 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_420;
1235 ctx->subsampling = V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY;
1241 return !notfound && sos;
1244 static int s5p_jpeg_querycap(struct file *file, void *priv,
1245 struct v4l2_capability *cap)
1247 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1249 if (ctx->mode == S5P_JPEG_ENCODE) {
1250 strlcpy(cap->driver, S5P_JPEG_M2M_NAME,
1251 sizeof(cap->driver));
1252 strlcpy(cap->card, S5P_JPEG_M2M_NAME " encoder",
1255 strlcpy(cap->driver, S5P_JPEG_M2M_NAME,
1256 sizeof(cap->driver));
1257 strlcpy(cap->card, S5P_JPEG_M2M_NAME " decoder",
1260 snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
1261 dev_name(ctx->jpeg->dev));
1262 cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M;
1263 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1267 static int enum_fmt(struct s5p_jpeg_ctx *ctx,
1268 struct s5p_jpeg_fmt *sjpeg_formats, int n,
1269 struct v4l2_fmtdesc *f, u32 type)
1272 unsigned int fmt_ver_flag = ctx->jpeg->variant->fmt_ver_flag;
1274 for (i = 0; i < n; ++i) {
1275 if (sjpeg_formats[i].flags & type &&
1276 sjpeg_formats[i].flags & fmt_ver_flag) {
1277 /* index-th format of type type found ? */
1278 if (num == f->index)
1280 /* Correct type but haven't reached our index yet,
1281 * just increment per-type index
1287 /* Format not found */
1291 strlcpy(f->description, sjpeg_formats[i].name, sizeof(f->description));
1292 f->pixelformat = sjpeg_formats[i].fourcc;
1297 static int s5p_jpeg_enum_fmt_vid_cap(struct file *file, void *priv,
1298 struct v4l2_fmtdesc *f)
1300 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1302 if (ctx->mode == S5P_JPEG_ENCODE)
1303 return enum_fmt(ctx, sjpeg_formats, SJPEG_NUM_FORMATS, f,
1304 SJPEG_FMT_FLAG_ENC_CAPTURE);
1306 return enum_fmt(ctx, sjpeg_formats, SJPEG_NUM_FORMATS, f,
1307 SJPEG_FMT_FLAG_DEC_CAPTURE);
1310 static int s5p_jpeg_enum_fmt_vid_out(struct file *file, void *priv,
1311 struct v4l2_fmtdesc *f)
1313 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1315 if (ctx->mode == S5P_JPEG_ENCODE)
1316 return enum_fmt(ctx, sjpeg_formats, SJPEG_NUM_FORMATS, f,
1317 SJPEG_FMT_FLAG_ENC_OUTPUT);
1319 return enum_fmt(ctx, sjpeg_formats, SJPEG_NUM_FORMATS, f,
1320 SJPEG_FMT_FLAG_DEC_OUTPUT);
1323 static struct s5p_jpeg_q_data *get_q_data(struct s5p_jpeg_ctx *ctx,
1324 enum v4l2_buf_type type)
1326 if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
1328 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1334 static int s5p_jpeg_g_fmt(struct file *file, void *priv, struct v4l2_format *f)
1336 struct vb2_queue *vq;
1337 struct s5p_jpeg_q_data *q_data = NULL;
1338 struct v4l2_pix_format *pix = &f->fmt.pix;
1339 struct s5p_jpeg_ctx *ct = fh_to_ctx(priv);
1341 vq = v4l2_m2m_get_vq(ct->fh.m2m_ctx, f->type);
1345 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1346 ct->mode == S5P_JPEG_DECODE && !ct->hdr_parsed)
1348 q_data = get_q_data(ct, f->type);
1349 BUG_ON(q_data == NULL);
1351 pix->width = q_data->w;
1352 pix->height = q_data->h;
1353 pix->field = V4L2_FIELD_NONE;
1354 pix->pixelformat = q_data->fmt->fourcc;
1355 pix->bytesperline = 0;
1356 if (q_data->fmt->fourcc != V4L2_PIX_FMT_JPEG) {
1357 u32 bpl = q_data->w;
1359 if (q_data->fmt->colplanes == 1)
1360 bpl = (bpl * q_data->fmt->depth) >> 3;
1361 pix->bytesperline = bpl;
1363 pix->sizeimage = q_data->size;
1368 static struct s5p_jpeg_fmt *s5p_jpeg_find_format(struct s5p_jpeg_ctx *ctx,
1369 u32 pixelformat, unsigned int fmt_type)
1371 unsigned int k, fmt_flag;
1373 if (ctx->mode == S5P_JPEG_ENCODE)
1374 fmt_flag = (fmt_type == FMT_TYPE_OUTPUT) ?
1375 SJPEG_FMT_FLAG_ENC_OUTPUT :
1376 SJPEG_FMT_FLAG_ENC_CAPTURE;
1378 fmt_flag = (fmt_type == FMT_TYPE_OUTPUT) ?
1379 SJPEG_FMT_FLAG_DEC_OUTPUT :
1380 SJPEG_FMT_FLAG_DEC_CAPTURE;
1382 for (k = 0; k < ARRAY_SIZE(sjpeg_formats); k++) {
1383 struct s5p_jpeg_fmt *fmt = &sjpeg_formats[k];
1385 if (fmt->fourcc == pixelformat &&
1386 fmt->flags & fmt_flag &&
1387 fmt->flags & ctx->jpeg->variant->fmt_ver_flag) {
1395 static void jpeg_bound_align_image(struct s5p_jpeg_ctx *ctx,
1396 u32 *w, unsigned int wmin, unsigned int wmax,
1397 unsigned int walign,
1398 u32 *h, unsigned int hmin, unsigned int hmax,
1399 unsigned int halign)
1401 int width, height, w_step, h_step;
1406 w_step = 1 << walign;
1407 h_step = 1 << halign;
1409 if (ctx->jpeg->variant->hw3250_compat) {
1411 * Rightmost and bottommost pixels are cropped by the
1412 * Exynos3250/compatible JPEG IP for RGB formats, for the
1413 * specific width and height values respectively. This
1414 * assignment will result in v4l_bound_align_image returning
1415 * dimensions reduced by 1 for the aforementioned cases.
1417 if (w_step == 4 && ((width & 3) == 1)) {
1423 v4l_bound_align_image(w, wmin, wmax, walign, h, hmin, hmax, halign, 0);
1425 if (*w < width && (*w + w_step) < wmax)
1427 if (*h < height && (*h + h_step) < hmax)
1431 static int vidioc_try_fmt(struct v4l2_format *f, struct s5p_jpeg_fmt *fmt,
1432 struct s5p_jpeg_ctx *ctx, int q_type)
1434 struct v4l2_pix_format *pix = &f->fmt.pix;
1436 if (pix->field == V4L2_FIELD_ANY)
1437 pix->field = V4L2_FIELD_NONE;
1438 else if (pix->field != V4L2_FIELD_NONE)
1441 /* V4L2 specification suggests the driver corrects the format struct
1442 * if any of the dimensions is unsupported
1444 if (q_type == FMT_TYPE_OUTPUT)
1445 jpeg_bound_align_image(ctx, &pix->width, S5P_JPEG_MIN_WIDTH,
1446 S5P_JPEG_MAX_WIDTH, 0,
1447 &pix->height, S5P_JPEG_MIN_HEIGHT,
1448 S5P_JPEG_MAX_HEIGHT, 0);
1450 jpeg_bound_align_image(ctx, &pix->width, S5P_JPEG_MIN_WIDTH,
1451 S5P_JPEG_MAX_WIDTH, fmt->h_align,
1452 &pix->height, S5P_JPEG_MIN_HEIGHT,
1453 S5P_JPEG_MAX_HEIGHT, fmt->v_align);
1455 if (fmt->fourcc == V4L2_PIX_FMT_JPEG) {
1456 if (pix->sizeimage <= 0)
1457 pix->sizeimage = PAGE_SIZE;
1458 pix->bytesperline = 0;
1460 u32 bpl = pix->bytesperline;
1462 if (fmt->colplanes > 1 && bpl < pix->width)
1463 bpl = pix->width; /* planar */
1465 if (fmt->colplanes == 1 && /* packed */
1466 (bpl << 3) / fmt->depth < pix->width)
1467 bpl = (pix->width * fmt->depth) >> 3;
1469 pix->bytesperline = bpl;
1470 pix->sizeimage = (pix->width * pix->height * fmt->depth) >> 3;
1476 static int s5p_jpeg_try_fmt_vid_cap(struct file *file, void *priv,
1477 struct v4l2_format *f)
1479 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1480 struct v4l2_pix_format *pix = &f->fmt.pix;
1481 struct s5p_jpeg_fmt *fmt;
1484 fmt = s5p_jpeg_find_format(ctx, f->fmt.pix.pixelformat,
1487 v4l2_err(&ctx->jpeg->v4l2_dev,
1488 "Fourcc format (0x%08x) invalid.\n",
1489 f->fmt.pix.pixelformat);
1493 if (!ctx->jpeg->variant->hw_ex4_compat || ctx->mode != S5P_JPEG_DECODE)
1497 * The exynos4x12 device requires resulting YUV image
1498 * subsampling not to be lower than the input jpeg subsampling.
1499 * If this requirement is not met then downgrade the requested
1500 * capture format to the one with subsampling equal to the input jpeg.
1502 if ((fmt->flags & SJPEG_FMT_NON_RGB) &&
1503 (fmt->subsampling < ctx->subsampling)) {
1504 ret = s5p_jpeg_adjust_fourcc_to_subsampling(ctx->subsampling,
1509 pix->pixelformat = V4L2_PIX_FMT_GREY;
1511 fmt = s5p_jpeg_find_format(ctx, pix->pixelformat,
1516 * Decompression of a JPEG file with 4:2:0 subsampling and odd
1517 * width to the YUV 4:2:0 compliant formats produces a raw image
1518 * with broken luma component. Adjust capture format to RGB565
1521 if (ctx->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_420 &&
1522 (ctx->out_q.w & 1) &&
1523 (pix->pixelformat == V4L2_PIX_FMT_NV12 ||
1524 pix->pixelformat == V4L2_PIX_FMT_NV21 ||
1525 pix->pixelformat == V4L2_PIX_FMT_YUV420)) {
1526 pix->pixelformat = V4L2_PIX_FMT_RGB565;
1527 fmt = s5p_jpeg_find_format(ctx, pix->pixelformat,
1532 return vidioc_try_fmt(f, fmt, ctx, FMT_TYPE_CAPTURE);
1535 static int s5p_jpeg_try_fmt_vid_out(struct file *file, void *priv,
1536 struct v4l2_format *f)
1538 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1539 struct s5p_jpeg_fmt *fmt;
1541 fmt = s5p_jpeg_find_format(ctx, f->fmt.pix.pixelformat,
1544 v4l2_err(&ctx->jpeg->v4l2_dev,
1545 "Fourcc format (0x%08x) invalid.\n",
1546 f->fmt.pix.pixelformat);
1550 return vidioc_try_fmt(f, fmt, ctx, FMT_TYPE_OUTPUT);
1553 static int exynos4_jpeg_get_output_buffer_size(struct s5p_jpeg_ctx *ctx,
1554 struct v4l2_format *f,
1557 struct v4l2_pix_format *pix = &f->fmt.pix;
1558 u32 pix_fmt = f->fmt.pix.pixelformat;
1559 int w = pix->width, h = pix->height, wh_align;
1562 if (pix_fmt == V4L2_PIX_FMT_RGB32 ||
1563 pix_fmt == V4L2_PIX_FMT_RGB565 ||
1564 pix_fmt == V4L2_PIX_FMT_NV24 ||
1565 pix_fmt == V4L2_PIX_FMT_NV42 ||
1566 pix_fmt == V4L2_PIX_FMT_NV12 ||
1567 pix_fmt == V4L2_PIX_FMT_NV21 ||
1568 pix_fmt == V4L2_PIX_FMT_YUV420)
1573 jpeg_bound_align_image(ctx, &w, S5P_JPEG_MIN_WIDTH,
1574 S5P_JPEG_MAX_WIDTH, wh_align,
1575 &h, S5P_JPEG_MIN_HEIGHT,
1576 S5P_JPEG_MAX_HEIGHT, wh_align);
1578 if (ctx->jpeg->variant->version == SJPEG_EXYNOS4)
1579 padding = PAGE_SIZE;
1581 return (w * h * fmt_depth >> 3) + padding;
1584 static int exynos3250_jpeg_try_downscale(struct s5p_jpeg_ctx *ctx,
1585 struct v4l2_rect *r);
1587 static int s5p_jpeg_s_fmt(struct s5p_jpeg_ctx *ct, struct v4l2_format *f)
1589 struct vb2_queue *vq;
1590 struct s5p_jpeg_q_data *q_data = NULL;
1591 struct v4l2_pix_format *pix = &f->fmt.pix;
1592 struct v4l2_ctrl *ctrl_subs;
1593 struct v4l2_rect scale_rect;
1594 unsigned int f_type;
1596 vq = v4l2_m2m_get_vq(ct->fh.m2m_ctx, f->type);
1600 q_data = get_q_data(ct, f->type);
1601 BUG_ON(q_data == NULL);
1603 if (vb2_is_busy(vq)) {
1604 v4l2_err(&ct->jpeg->v4l2_dev, "%s queue busy\n", __func__);
1608 f_type = V4L2_TYPE_IS_OUTPUT(f->type) ?
1609 FMT_TYPE_OUTPUT : FMT_TYPE_CAPTURE;
1611 q_data->fmt = s5p_jpeg_find_format(ct, pix->pixelformat, f_type);
1612 q_data->w = pix->width;
1613 q_data->h = pix->height;
1614 if (q_data->fmt->fourcc != V4L2_PIX_FMT_JPEG) {
1616 * During encoding Exynos4x12 SoCs access wider memory area
1617 * than it results from Image_x and Image_y values written to
1618 * the JPEG_IMAGE_SIZE register. In order to avoid sysmmu
1619 * page fault calculate proper buffer size in such a case.
1621 if (ct->jpeg->variant->hw_ex4_compat &&
1622 f_type == FMT_TYPE_OUTPUT && ct->mode == S5P_JPEG_ENCODE)
1623 q_data->size = exynos4_jpeg_get_output_buffer_size(ct,
1625 q_data->fmt->depth);
1627 q_data->size = q_data->w * q_data->h *
1628 q_data->fmt->depth >> 3;
1630 q_data->size = pix->sizeimage;
1633 if (f_type == FMT_TYPE_OUTPUT) {
1634 ctrl_subs = v4l2_ctrl_find(&ct->ctrl_handler,
1635 V4L2_CID_JPEG_CHROMA_SUBSAMPLING);
1637 v4l2_ctrl_s_ctrl(ctrl_subs, q_data->fmt->subsampling);
1638 ct->crop_altered = false;
1642 * For decoding init crop_rect with capture buffer dimmensions which
1643 * contain aligned dimensions of the input JPEG image and do it only
1644 * if crop rectangle hasn't been altered by the user space e.g. with
1645 * S_SELECTION ioctl. For encoding assign output buffer dimensions.
1647 if (!ct->crop_altered &&
1648 ((ct->mode == S5P_JPEG_DECODE && f_type == FMT_TYPE_CAPTURE) ||
1649 (ct->mode == S5P_JPEG_ENCODE && f_type == FMT_TYPE_OUTPUT))) {
1650 ct->crop_rect.width = pix->width;
1651 ct->crop_rect.height = pix->height;
1655 * Prevent downscaling to YUV420 format by more than 2
1656 * for Exynos3250/compatible SoC as it produces broken raw image
1659 if (ct->mode == S5P_JPEG_DECODE &&
1660 f_type == FMT_TYPE_CAPTURE &&
1661 ct->jpeg->variant->hw3250_compat &&
1662 pix->pixelformat == V4L2_PIX_FMT_YUV420 &&
1663 ct->scale_factor > 2) {
1664 scale_rect.width = ct->out_q.w / 2;
1665 scale_rect.height = ct->out_q.h / 2;
1666 exynos3250_jpeg_try_downscale(ct, &scale_rect);
1672 static int s5p_jpeg_s_fmt_vid_cap(struct file *file, void *priv,
1673 struct v4l2_format *f)
1677 ret = s5p_jpeg_try_fmt_vid_cap(file, priv, f);
1681 return s5p_jpeg_s_fmt(fh_to_ctx(priv), f);
1684 static int s5p_jpeg_s_fmt_vid_out(struct file *file, void *priv,
1685 struct v4l2_format *f)
1689 ret = s5p_jpeg_try_fmt_vid_out(file, priv, f);
1693 return s5p_jpeg_s_fmt(fh_to_ctx(priv), f);
1696 static int exynos3250_jpeg_try_downscale(struct s5p_jpeg_ctx *ctx,
1697 struct v4l2_rect *r)
1699 int w_ratio, h_ratio, scale_factor, cur_ratio, i;
1701 w_ratio = ctx->out_q.w / r->width;
1702 h_ratio = ctx->out_q.h / r->height;
1704 scale_factor = w_ratio > h_ratio ? w_ratio : h_ratio;
1705 scale_factor = clamp_val(scale_factor, 1, 8);
1707 /* Align scale ratio to the nearest power of 2 */
1708 for (i = 0; i <= 3; ++i) {
1710 if (scale_factor <= cur_ratio) {
1711 ctx->scale_factor = cur_ratio;
1716 r->width = round_down(ctx->out_q.w / ctx->scale_factor, 2);
1717 r->height = round_down(ctx->out_q.h / ctx->scale_factor, 2);
1719 ctx->crop_rect.width = r->width;
1720 ctx->crop_rect.height = r->height;
1721 ctx->crop_rect.left = 0;
1722 ctx->crop_rect.top = 0;
1724 ctx->crop_altered = true;
1729 /* Return 1 if rectangle a is enclosed in rectangle b, or 0 otherwise. */
1730 static int enclosed_rectangle(struct v4l2_rect *a, struct v4l2_rect *b)
1732 if (a->left < b->left || a->top < b->top)
1734 if (a->left + a->width > b->left + b->width)
1736 if (a->top + a->height > b->top + b->height)
1742 static int exynos3250_jpeg_try_crop(struct s5p_jpeg_ctx *ctx,
1743 struct v4l2_rect *r)
1745 struct v4l2_rect base_rect;
1748 switch (ctx->cap_q.fmt->fourcc) {
1749 case V4L2_PIX_FMT_NV12:
1750 case V4L2_PIX_FMT_NV21:
1754 case V4L2_PIX_FMT_YUV420:
1766 base_rect.width = ctx->out_q.w;
1767 base_rect.height = ctx->out_q.h;
1769 r->width = round_down(r->width, w_step);
1770 r->height = round_down(r->height, h_step);
1771 r->left = round_down(r->left, 2);
1772 r->top = round_down(r->top, 2);
1774 if (!enclosed_rectangle(r, &base_rect))
1777 ctx->crop_rect.left = r->left;
1778 ctx->crop_rect.top = r->top;
1779 ctx->crop_rect.width = r->width;
1780 ctx->crop_rect.height = r->height;
1782 ctx->crop_altered = true;
1791 static int s5p_jpeg_g_selection(struct file *file, void *priv,
1792 struct v4l2_selection *s)
1794 struct s5p_jpeg_ctx *ctx = fh_to_ctx(priv);
1796 if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT &&
1797 s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1800 /* For JPEG blob active == default == bounds */
1801 switch (s->target) {
1802 case V4L2_SEL_TGT_CROP:
1803 case V4L2_SEL_TGT_CROP_BOUNDS:
1804 case V4L2_SEL_TGT_CROP_DEFAULT:
1805 case V4L2_SEL_TGT_COMPOSE_DEFAULT:
1806 s->r.width = ctx->out_q.w;
1807 s->r.height = ctx->out_q.h;
1811 case V4L2_SEL_TGT_COMPOSE:
1812 case V4L2_SEL_TGT_COMPOSE_BOUNDS:
1813 case V4L2_SEL_TGT_COMPOSE_PADDED:
1814 s->r.width = ctx->crop_rect.width;
1815 s->r.height = ctx->crop_rect.height;
1816 s->r.left = ctx->crop_rect.left;
1817 s->r.top = ctx->crop_rect.top;
1828 static int s5p_jpeg_s_selection(struct file *file, void *fh,
1829 struct v4l2_selection *s)
1831 struct s5p_jpeg_ctx *ctx = fh_to_ctx(file->private_data);
1832 struct v4l2_rect *rect = &s->r;
1835 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1838 if (s->target == V4L2_SEL_TGT_COMPOSE) {
1839 if (ctx->mode != S5P_JPEG_DECODE)
1841 if (ctx->jpeg->variant->hw3250_compat)
1842 ret = exynos3250_jpeg_try_downscale(ctx, rect);
1843 } else if (s->target == V4L2_SEL_TGT_CROP) {
1844 if (ctx->mode != S5P_JPEG_ENCODE)
1846 if (ctx->jpeg->variant->hw3250_compat)
1847 ret = exynos3250_jpeg_try_crop(ctx, rect);
1853 static int s5p_jpeg_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1855 struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl);
1856 struct s5p_jpeg *jpeg = ctx->jpeg;
1857 unsigned long flags;
1860 case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1861 spin_lock_irqsave(&jpeg->slock, flags);
1862 ctrl->val = s5p_jpeg_to_user_subsampling(ctx);
1863 spin_unlock_irqrestore(&jpeg->slock, flags);
1870 static int s5p_jpeg_adjust_subs_ctrl(struct s5p_jpeg_ctx *ctx, int *ctrl_val)
1872 switch (ctx->jpeg->variant->version) {
1875 case SJPEG_EXYNOS3250:
1876 case SJPEG_EXYNOS5420:
1878 * The exynos3250/compatible device can produce JPEG image only
1879 * of 4:4:4 subsampling when given RGB32 source image.
1881 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB32)
1886 * The exynos4x12 device requires input raw image fourcc
1887 * to be V4L2_PIX_FMT_GREY if gray jpeg format
1890 if (ctx->out_q.fmt->fourcc != V4L2_PIX_FMT_GREY &&
1891 *ctrl_val == V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY)
1897 * The exynos4x12 and exynos3250/compatible devices require resulting
1898 * jpeg subsampling not to be lower than the input raw image
1901 if (ctx->out_q.fmt->subsampling > *ctrl_val)
1902 *ctrl_val = ctx->out_q.fmt->subsampling;
1907 static int s5p_jpeg_try_ctrl(struct v4l2_ctrl *ctrl)
1909 struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl);
1910 unsigned long flags;
1913 spin_lock_irqsave(&ctx->jpeg->slock, flags);
1915 if (ctrl->id == V4L2_CID_JPEG_CHROMA_SUBSAMPLING)
1916 ret = s5p_jpeg_adjust_subs_ctrl(ctx, &ctrl->val);
1918 spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
1922 static int s5p_jpeg_s_ctrl(struct v4l2_ctrl *ctrl)
1924 struct s5p_jpeg_ctx *ctx = ctrl_to_ctx(ctrl);
1925 unsigned long flags;
1927 spin_lock_irqsave(&ctx->jpeg->slock, flags);
1930 case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1931 ctx->compr_quality = ctrl->val;
1933 case V4L2_CID_JPEG_RESTART_INTERVAL:
1934 ctx->restart_interval = ctrl->val;
1936 case V4L2_CID_JPEG_CHROMA_SUBSAMPLING:
1937 ctx->subsampling = ctrl->val;
1941 spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
1945 static const struct v4l2_ctrl_ops s5p_jpeg_ctrl_ops = {
1946 .g_volatile_ctrl = s5p_jpeg_g_volatile_ctrl,
1947 .try_ctrl = s5p_jpeg_try_ctrl,
1948 .s_ctrl = s5p_jpeg_s_ctrl,
1951 static int s5p_jpeg_controls_create(struct s5p_jpeg_ctx *ctx)
1953 unsigned int mask = ~0x27; /* 444, 422, 420, GRAY */
1954 struct v4l2_ctrl *ctrl;
1957 v4l2_ctrl_handler_init(&ctx->ctrl_handler, 3);
1959 if (ctx->mode == S5P_JPEG_ENCODE) {
1960 v4l2_ctrl_new_std(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops,
1961 V4L2_CID_JPEG_COMPRESSION_QUALITY,
1962 0, 3, 1, S5P_JPEG_COMPR_QUAL_WORST);
1964 v4l2_ctrl_new_std(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops,
1965 V4L2_CID_JPEG_RESTART_INTERVAL,
1967 if (ctx->jpeg->variant->version == SJPEG_S5P)
1968 mask = ~0x06; /* 422, 420 */
1971 ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrl_handler, &s5p_jpeg_ctrl_ops,
1972 V4L2_CID_JPEG_CHROMA_SUBSAMPLING,
1973 V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY, mask,
1974 V4L2_JPEG_CHROMA_SUBSAMPLING_422);
1976 if (ctx->ctrl_handler.error) {
1977 ret = ctx->ctrl_handler.error;
1981 if (ctx->mode == S5P_JPEG_DECODE)
1982 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE |
1983 V4L2_CTRL_FLAG_READ_ONLY;
1985 ret = v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
1992 v4l2_ctrl_handler_free(&ctx->ctrl_handler);
1996 static const struct v4l2_ioctl_ops s5p_jpeg_ioctl_ops = {
1997 .vidioc_querycap = s5p_jpeg_querycap,
1999 .vidioc_enum_fmt_vid_cap = s5p_jpeg_enum_fmt_vid_cap,
2000 .vidioc_enum_fmt_vid_out = s5p_jpeg_enum_fmt_vid_out,
2002 .vidioc_g_fmt_vid_cap = s5p_jpeg_g_fmt,
2003 .vidioc_g_fmt_vid_out = s5p_jpeg_g_fmt,
2005 .vidioc_try_fmt_vid_cap = s5p_jpeg_try_fmt_vid_cap,
2006 .vidioc_try_fmt_vid_out = s5p_jpeg_try_fmt_vid_out,
2008 .vidioc_s_fmt_vid_cap = s5p_jpeg_s_fmt_vid_cap,
2009 .vidioc_s_fmt_vid_out = s5p_jpeg_s_fmt_vid_out,
2011 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
2012 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
2013 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf,
2014 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,
2016 .vidioc_streamon = v4l2_m2m_ioctl_streamon,
2017 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
2019 .vidioc_g_selection = s5p_jpeg_g_selection,
2020 .vidioc_s_selection = s5p_jpeg_s_selection,
2024 * ============================================================================
2026 * ============================================================================
2029 static void s5p_jpeg_device_run(void *priv)
2031 struct s5p_jpeg_ctx *ctx = priv;
2032 struct s5p_jpeg *jpeg = ctx->jpeg;
2033 struct vb2_v4l2_buffer *src_buf, *dst_buf;
2034 unsigned long src_addr, dst_addr, flags;
2036 spin_lock_irqsave(&ctx->jpeg->slock, flags);
2038 src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2039 dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2040 src_addr = vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf, 0);
2041 dst_addr = vb2_dma_contig_plane_dma_addr(&dst_buf->vb2_buf, 0);
2043 s5p_jpeg_reset(jpeg->regs);
2044 s5p_jpeg_poweron(jpeg->regs);
2045 s5p_jpeg_proc_mode(jpeg->regs, ctx->mode);
2046 if (ctx->mode == S5P_JPEG_ENCODE) {
2047 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565)
2048 s5p_jpeg_input_raw_mode(jpeg->regs,
2049 S5P_JPEG_RAW_IN_565);
2051 s5p_jpeg_input_raw_mode(jpeg->regs,
2052 S5P_JPEG_RAW_IN_422);
2053 s5p_jpeg_subsampling_mode(jpeg->regs, ctx->subsampling);
2054 s5p_jpeg_dri(jpeg->regs, ctx->restart_interval);
2055 s5p_jpeg_x(jpeg->regs, ctx->out_q.w);
2056 s5p_jpeg_y(jpeg->regs, ctx->out_q.h);
2057 s5p_jpeg_imgadr(jpeg->regs, src_addr);
2058 s5p_jpeg_jpgadr(jpeg->regs, dst_addr);
2060 /* ultimately comes from sizeimage from userspace */
2061 s5p_jpeg_enc_stream_int(jpeg->regs, ctx->cap_q.size);
2063 /* JPEG RGB to YCbCr conversion matrix */
2064 s5p_jpeg_coef(jpeg->regs, 1, 1, S5P_JPEG_COEF11);
2065 s5p_jpeg_coef(jpeg->regs, 1, 2, S5P_JPEG_COEF12);
2066 s5p_jpeg_coef(jpeg->regs, 1, 3, S5P_JPEG_COEF13);
2067 s5p_jpeg_coef(jpeg->regs, 2, 1, S5P_JPEG_COEF21);
2068 s5p_jpeg_coef(jpeg->regs, 2, 2, S5P_JPEG_COEF22);
2069 s5p_jpeg_coef(jpeg->regs, 2, 3, S5P_JPEG_COEF23);
2070 s5p_jpeg_coef(jpeg->regs, 3, 1, S5P_JPEG_COEF31);
2071 s5p_jpeg_coef(jpeg->regs, 3, 2, S5P_JPEG_COEF32);
2072 s5p_jpeg_coef(jpeg->regs, 3, 3, S5P_JPEG_COEF33);
2075 * JPEG IP allows storing 4 quantization tables
2076 * We fill table 0 for luma and table 1 for chroma
2078 s5p_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality);
2079 s5p_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality);
2080 /* use table 0 for Y */
2081 s5p_jpeg_qtbl(jpeg->regs, 1, 0);
2082 /* use table 1 for Cb and Cr*/
2083 s5p_jpeg_qtbl(jpeg->regs, 2, 1);
2084 s5p_jpeg_qtbl(jpeg->regs, 3, 1);
2086 /* Y, Cb, Cr use Huffman table 0 */
2087 s5p_jpeg_htbl_ac(jpeg->regs, 1);
2088 s5p_jpeg_htbl_dc(jpeg->regs, 1);
2089 s5p_jpeg_htbl_ac(jpeg->regs, 2);
2090 s5p_jpeg_htbl_dc(jpeg->regs, 2);
2091 s5p_jpeg_htbl_ac(jpeg->regs, 3);
2092 s5p_jpeg_htbl_dc(jpeg->regs, 3);
2093 } else { /* S5P_JPEG_DECODE */
2094 s5p_jpeg_rst_int_enable(jpeg->regs, true);
2095 s5p_jpeg_data_num_int_enable(jpeg->regs, true);
2096 s5p_jpeg_final_mcu_num_int_enable(jpeg->regs, true);
2097 if (ctx->cap_q.fmt->fourcc == V4L2_PIX_FMT_YUYV)
2098 s5p_jpeg_outform_raw(jpeg->regs, S5P_JPEG_RAW_OUT_422);
2100 s5p_jpeg_outform_raw(jpeg->regs, S5P_JPEG_RAW_OUT_420);
2101 s5p_jpeg_jpgadr(jpeg->regs, src_addr);
2102 s5p_jpeg_imgadr(jpeg->regs, dst_addr);
2105 s5p_jpeg_start(jpeg->regs);
2107 spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
2110 static void exynos4_jpeg_set_img_addr(struct s5p_jpeg_ctx *ctx)
2112 struct s5p_jpeg *jpeg = ctx->jpeg;
2113 struct s5p_jpeg_fmt *fmt;
2114 struct vb2_v4l2_buffer *vb;
2115 struct s5p_jpeg_addr jpeg_addr = {};
2116 u32 pix_size, padding_bytes = 0;
2121 pix_size = ctx->cap_q.w * ctx->cap_q.h;
2123 if (ctx->mode == S5P_JPEG_ENCODE) {
2124 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2125 fmt = ctx->out_q.fmt;
2126 if (ctx->out_q.w % 2 && fmt->h_align > 0)
2127 padding_bytes = ctx->out_q.h;
2129 fmt = ctx->cap_q.fmt;
2130 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2133 jpeg_addr.y = vb2_dma_contig_plane_dma_addr(&vb->vb2_buf, 0);
2135 if (fmt->colplanes == 2) {
2136 jpeg_addr.cb = jpeg_addr.y + pix_size - padding_bytes;
2137 } else if (fmt->colplanes == 3) {
2138 jpeg_addr.cb = jpeg_addr.y + pix_size;
2139 if (fmt->fourcc == V4L2_PIX_FMT_YUV420)
2140 jpeg_addr.cr = jpeg_addr.cb + pix_size / 4;
2142 jpeg_addr.cr = jpeg_addr.cb + pix_size / 2;
2145 exynos4_jpeg_set_frame_buf_address(jpeg->regs, &jpeg_addr);
2148 static void exynos4_jpeg_set_jpeg_addr(struct s5p_jpeg_ctx *ctx)
2150 struct s5p_jpeg *jpeg = ctx->jpeg;
2151 struct vb2_v4l2_buffer *vb;
2152 unsigned int jpeg_addr = 0;
2154 if (ctx->mode == S5P_JPEG_ENCODE)
2155 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2157 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2159 jpeg_addr = vb2_dma_contig_plane_dma_addr(&vb->vb2_buf, 0);
2160 if (jpeg->variant->version == SJPEG_EXYNOS5433 &&
2161 ctx->mode == S5P_JPEG_DECODE)
2162 jpeg_addr += ctx->out_q.sos;
2163 exynos4_jpeg_set_stream_buf_address(jpeg->regs, jpeg_addr);
2166 static inline void exynos4_jpeg_set_img_fmt(void __iomem *base,
2167 unsigned int img_fmt)
2169 __exynos4_jpeg_set_img_fmt(base, img_fmt, SJPEG_EXYNOS4);
2172 static inline void exynos5433_jpeg_set_img_fmt(void __iomem *base,
2173 unsigned int img_fmt)
2175 __exynos4_jpeg_set_img_fmt(base, img_fmt, SJPEG_EXYNOS5433);
2178 static inline void exynos4_jpeg_set_enc_out_fmt(void __iomem *base,
2179 unsigned int out_fmt)
2181 __exynos4_jpeg_set_enc_out_fmt(base, out_fmt, SJPEG_EXYNOS4);
2184 static inline void exynos5433_jpeg_set_enc_out_fmt(void __iomem *base,
2185 unsigned int out_fmt)
2187 __exynos4_jpeg_set_enc_out_fmt(base, out_fmt, SJPEG_EXYNOS5433);
2190 static void exynos4_jpeg_device_run(void *priv)
2192 struct s5p_jpeg_ctx *ctx = priv;
2193 struct s5p_jpeg *jpeg = ctx->jpeg;
2194 unsigned int bitstream_size;
2195 unsigned long flags;
2197 spin_lock_irqsave(&jpeg->slock, flags);
2199 if (ctx->mode == S5P_JPEG_ENCODE) {
2200 exynos4_jpeg_sw_reset(jpeg->regs);
2201 exynos4_jpeg_set_interrupt(jpeg->regs, jpeg->variant->version);
2202 exynos4_jpeg_set_huf_table_enable(jpeg->regs, 1);
2204 exynos4_jpeg_set_huff_tbl(jpeg->regs);
2207 * JPEG IP allows storing 4 quantization tables
2208 * We fill table 0 for luma and table 1 for chroma
2210 exynos4_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality);
2211 exynos4_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality);
2213 exynos4_jpeg_set_encode_tbl_select(jpeg->regs,
2214 ctx->compr_quality);
2215 exynos4_jpeg_set_stream_size(jpeg->regs, ctx->cap_q.w,
2218 if (ctx->jpeg->variant->version == SJPEG_EXYNOS4) {
2219 exynos4_jpeg_set_enc_out_fmt(jpeg->regs,
2221 exynos4_jpeg_set_img_fmt(jpeg->regs,
2222 ctx->out_q.fmt->fourcc);
2224 exynos5433_jpeg_set_enc_out_fmt(jpeg->regs,
2226 exynos5433_jpeg_set_img_fmt(jpeg->regs,
2227 ctx->out_q.fmt->fourcc);
2229 exynos4_jpeg_set_img_addr(ctx);
2230 exynos4_jpeg_set_jpeg_addr(ctx);
2231 exynos4_jpeg_set_encode_hoff_cnt(jpeg->regs,
2232 ctx->out_q.fmt->fourcc);
2234 exynos4_jpeg_sw_reset(jpeg->regs);
2235 exynos4_jpeg_set_interrupt(jpeg->regs,
2236 jpeg->variant->version);
2237 exynos4_jpeg_set_img_addr(ctx);
2238 exynos4_jpeg_set_jpeg_addr(ctx);
2240 if (jpeg->variant->version == SJPEG_EXYNOS5433) {
2241 exynos4_jpeg_parse_huff_tbl(ctx);
2242 exynos4_jpeg_parse_decode_h_tbl(ctx);
2244 exynos4_jpeg_parse_q_tbl(ctx);
2245 exynos4_jpeg_parse_decode_q_tbl(ctx);
2247 exynos4_jpeg_set_huf_table_enable(jpeg->regs, 1);
2249 exynos4_jpeg_set_stream_size(jpeg->regs, ctx->cap_q.w,
2251 exynos5433_jpeg_set_enc_out_fmt(jpeg->regs,
2253 exynos5433_jpeg_set_img_fmt(jpeg->regs,
2254 ctx->cap_q.fmt->fourcc);
2255 bitstream_size = DIV_ROUND_UP(ctx->out_q.size, 16);
2257 exynos4_jpeg_set_img_fmt(jpeg->regs,
2258 ctx->cap_q.fmt->fourcc);
2259 bitstream_size = DIV_ROUND_UP(ctx->out_q.size, 32);
2262 exynos4_jpeg_set_dec_bitstream_size(jpeg->regs, bitstream_size);
2265 exynos4_jpeg_set_enc_dec_mode(jpeg->regs, ctx->mode);
2267 spin_unlock_irqrestore(&jpeg->slock, flags);
2270 static void exynos3250_jpeg_set_img_addr(struct s5p_jpeg_ctx *ctx)
2272 struct s5p_jpeg *jpeg = ctx->jpeg;
2273 struct s5p_jpeg_fmt *fmt;
2274 struct vb2_v4l2_buffer *vb;
2275 struct s5p_jpeg_addr jpeg_addr = {};
2278 pix_size = ctx->cap_q.w * ctx->cap_q.h;
2280 if (ctx->mode == S5P_JPEG_ENCODE) {
2281 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2282 fmt = ctx->out_q.fmt;
2284 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2285 fmt = ctx->cap_q.fmt;
2288 jpeg_addr.y = vb2_dma_contig_plane_dma_addr(&vb->vb2_buf, 0);
2290 if (fmt->colplanes == 2) {
2291 jpeg_addr.cb = jpeg_addr.y + pix_size;
2292 } else if (fmt->colplanes == 3) {
2293 jpeg_addr.cb = jpeg_addr.y + pix_size;
2294 if (fmt->fourcc == V4L2_PIX_FMT_YUV420)
2295 jpeg_addr.cr = jpeg_addr.cb + pix_size / 4;
2297 jpeg_addr.cr = jpeg_addr.cb + pix_size / 2;
2300 exynos3250_jpeg_imgadr(jpeg->regs, &jpeg_addr);
2303 static void exynos3250_jpeg_set_jpeg_addr(struct s5p_jpeg_ctx *ctx)
2305 struct s5p_jpeg *jpeg = ctx->jpeg;
2306 struct vb2_v4l2_buffer *vb;
2307 unsigned int jpeg_addr = 0;
2309 if (ctx->mode == S5P_JPEG_ENCODE)
2310 vb = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
2312 vb = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
2314 jpeg_addr = vb2_dma_contig_plane_dma_addr(&vb->vb2_buf, 0);
2315 exynos3250_jpeg_jpgadr(jpeg->regs, jpeg_addr);
2318 static void exynos3250_jpeg_device_run(void *priv)
2320 struct s5p_jpeg_ctx *ctx = priv;
2321 struct s5p_jpeg *jpeg = ctx->jpeg;
2322 unsigned long flags;
2324 spin_lock_irqsave(&ctx->jpeg->slock, flags);
2326 exynos3250_jpeg_reset(jpeg->regs);
2327 exynos3250_jpeg_set_dma_num(jpeg->regs);
2328 exynos3250_jpeg_poweron(jpeg->regs);
2329 exynos3250_jpeg_clk_set(jpeg->regs);
2330 exynos3250_jpeg_proc_mode(jpeg->regs, ctx->mode);
2332 if (ctx->mode == S5P_JPEG_ENCODE) {
2333 exynos3250_jpeg_input_raw_fmt(jpeg->regs,
2334 ctx->out_q.fmt->fourcc);
2335 exynos3250_jpeg_dri(jpeg->regs, ctx->restart_interval);
2338 * JPEG IP allows storing 4 quantization tables
2339 * We fill table 0 for luma and table 1 for chroma
2341 s5p_jpeg_set_qtbl_lum(jpeg->regs, ctx->compr_quality);
2342 s5p_jpeg_set_qtbl_chr(jpeg->regs, ctx->compr_quality);
2343 /* use table 0 for Y */
2344 exynos3250_jpeg_qtbl(jpeg->regs, 1, 0);
2345 /* use table 1 for Cb and Cr*/
2346 exynos3250_jpeg_qtbl(jpeg->regs, 2, 1);
2347 exynos3250_jpeg_qtbl(jpeg->regs, 3, 1);
2350 * Some SoCs require setting Huffman tables before each run
2352 if (jpeg->variant->htbl_reinit) {
2353 s5p_jpeg_set_hdctbl(jpeg->regs);
2354 s5p_jpeg_set_hdctblg(jpeg->regs);
2355 s5p_jpeg_set_hactbl(jpeg->regs);
2356 s5p_jpeg_set_hactblg(jpeg->regs);
2359 /* Y, Cb, Cr use Huffman table 0 */
2360 exynos3250_jpeg_htbl_ac(jpeg->regs, 1);
2361 exynos3250_jpeg_htbl_dc(jpeg->regs, 1);
2362 exynos3250_jpeg_htbl_ac(jpeg->regs, 2);
2363 exynos3250_jpeg_htbl_dc(jpeg->regs, 2);
2364 exynos3250_jpeg_htbl_ac(jpeg->regs, 3);
2365 exynos3250_jpeg_htbl_dc(jpeg->regs, 3);
2367 exynos3250_jpeg_set_x(jpeg->regs, ctx->crop_rect.width);
2368 exynos3250_jpeg_set_y(jpeg->regs, ctx->crop_rect.height);
2369 exynos3250_jpeg_stride(jpeg->regs, ctx->out_q.fmt->fourcc,
2371 exynos3250_jpeg_offset(jpeg->regs, ctx->crop_rect.left,
2372 ctx->crop_rect.top);
2373 exynos3250_jpeg_set_img_addr(ctx);
2374 exynos3250_jpeg_set_jpeg_addr(ctx);
2375 exynos3250_jpeg_subsampling_mode(jpeg->regs, ctx->subsampling);
2377 /* ultimately comes from sizeimage from userspace */
2378 exynos3250_jpeg_enc_stream_bound(jpeg->regs, ctx->cap_q.size);
2380 if (ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565 ||
2381 ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB565X ||
2382 ctx->out_q.fmt->fourcc == V4L2_PIX_FMT_RGB32)
2383 exynos3250_jpeg_set_y16(jpeg->regs, true);
2385 exynos3250_jpeg_set_img_addr(ctx);
2386 exynos3250_jpeg_set_jpeg_addr(ctx);
2387 exynos3250_jpeg_stride(jpeg->regs, ctx->cap_q.fmt->fourcc,
2389 exynos3250_jpeg_offset(jpeg->regs, 0, 0);
2390 exynos3250_jpeg_dec_scaling_ratio(jpeg->regs,
2392 exynos3250_jpeg_dec_stream_size(jpeg->regs, ctx->out_q.size);
2393 exynos3250_jpeg_output_raw_fmt(jpeg->regs,
2394 ctx->cap_q.fmt->fourcc);
2397 exynos3250_jpeg_interrupts_enable(jpeg->regs);
2399 /* JPEG RGB to YCbCr conversion matrix */
2400 exynos3250_jpeg_coef(jpeg->regs, ctx->mode);
2402 exynos3250_jpeg_set_timer(jpeg->regs, EXYNOS3250_IRQ_TIMEOUT);
2403 jpeg->irq_status = 0;
2404 exynos3250_jpeg_start(jpeg->regs);
2406 spin_unlock_irqrestore(&ctx->jpeg->slock, flags);
2409 static int s5p_jpeg_job_ready(void *priv)
2411 struct s5p_jpeg_ctx *ctx = priv;
2413 if (ctx->mode == S5P_JPEG_DECODE)
2414 return ctx->hdr_parsed;
2418 static void s5p_jpeg_job_abort(void *priv)
2422 static struct v4l2_m2m_ops s5p_jpeg_m2m_ops = {
2423 .device_run = s5p_jpeg_device_run,
2424 .job_ready = s5p_jpeg_job_ready,
2425 .job_abort = s5p_jpeg_job_abort,
2428 static struct v4l2_m2m_ops exynos3250_jpeg_m2m_ops = {
2429 .device_run = exynos3250_jpeg_device_run,
2430 .job_ready = s5p_jpeg_job_ready,
2431 .job_abort = s5p_jpeg_job_abort,
2434 static struct v4l2_m2m_ops exynos4_jpeg_m2m_ops = {
2435 .device_run = exynos4_jpeg_device_run,
2436 .job_ready = s5p_jpeg_job_ready,
2437 .job_abort = s5p_jpeg_job_abort,
2441 * ============================================================================
2443 * ============================================================================
2446 static int s5p_jpeg_queue_setup(struct vb2_queue *vq,
2447 unsigned int *nbuffers, unsigned int *nplanes,
2448 unsigned int sizes[], struct device *alloc_devs[])
2450 struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vq);
2451 struct s5p_jpeg_q_data *q_data = NULL;
2452 unsigned int size, count = *nbuffers;
2454 q_data = get_q_data(ctx, vq->type);
2455 BUG_ON(q_data == NULL);
2457 size = q_data->size;
2460 * header is parsed during decoding and parsed information stored
2461 * in the context so we do not allow another buffer to overwrite it
2463 if (ctx->mode == S5P_JPEG_DECODE)
2473 static int s5p_jpeg_buf_prepare(struct vb2_buffer *vb)
2475 struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
2476 struct s5p_jpeg_q_data *q_data = NULL;
2478 q_data = get_q_data(ctx, vb->vb2_queue->type);
2479 BUG_ON(q_data == NULL);
2481 if (vb2_plane_size(vb, 0) < q_data->size) {
2482 pr_err("%s data will not fit into plane (%lu < %lu)\n",
2483 __func__, vb2_plane_size(vb, 0),
2484 (long)q_data->size);
2488 vb2_set_plane_payload(vb, 0, q_data->size);
2493 static void s5p_jpeg_buf_queue(struct vb2_buffer *vb)
2495 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
2496 struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
2498 if (ctx->mode == S5P_JPEG_DECODE &&
2499 vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
2500 struct s5p_jpeg_q_data tmp, *q_data;
2502 ctx->hdr_parsed = s5p_jpeg_parse_hdr(&tmp,
2503 (unsigned long)vb2_plane_vaddr(vb, 0),
2504 min((unsigned long)ctx->out_q.size,
2505 vb2_get_plane_payload(vb, 0)), ctx);
2506 if (!ctx->hdr_parsed) {
2507 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
2511 q_data = &ctx->out_q;
2514 q_data->sos = tmp.sos;
2515 memcpy(q_data->dht.marker, tmp.dht.marker,
2516 sizeof(tmp.dht.marker));
2517 memcpy(q_data->dht.len, tmp.dht.len, sizeof(tmp.dht.len));
2518 q_data->dht.n = tmp.dht.n;
2519 memcpy(q_data->dqt.marker, tmp.dqt.marker,
2520 sizeof(tmp.dqt.marker));
2521 memcpy(q_data->dqt.len, tmp.dqt.len, sizeof(tmp.dqt.len));
2522 q_data->dqt.n = tmp.dqt.n;
2523 q_data->sof = tmp.sof;
2524 q_data->sof_len = tmp.sof_len;
2526 q_data = &ctx->cap_q;
2531 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
2534 static int s5p_jpeg_start_streaming(struct vb2_queue *q, unsigned int count)
2536 struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q);
2539 ret = pm_runtime_get_sync(ctx->jpeg->dev);
2541 return ret > 0 ? 0 : ret;
2544 static void s5p_jpeg_stop_streaming(struct vb2_queue *q)
2546 struct s5p_jpeg_ctx *ctx = vb2_get_drv_priv(q);
2548 pm_runtime_put(ctx->jpeg->dev);
2551 static const struct vb2_ops s5p_jpeg_qops = {
2552 .queue_setup = s5p_jpeg_queue_setup,
2553 .buf_prepare = s5p_jpeg_buf_prepare,
2554 .buf_queue = s5p_jpeg_buf_queue,
2555 .wait_prepare = vb2_ops_wait_prepare,
2556 .wait_finish = vb2_ops_wait_finish,
2557 .start_streaming = s5p_jpeg_start_streaming,
2558 .stop_streaming = s5p_jpeg_stop_streaming,
2561 static int queue_init(void *priv, struct vb2_queue *src_vq,
2562 struct vb2_queue *dst_vq)
2564 struct s5p_jpeg_ctx *ctx = priv;
2567 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
2568 src_vq->io_modes = VB2_MMAP | VB2_USERPTR;
2569 src_vq->drv_priv = ctx;
2570 src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
2571 src_vq->ops = &s5p_jpeg_qops;
2572 src_vq->mem_ops = &vb2_dma_contig_memops;
2573 src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
2574 src_vq->lock = &ctx->jpeg->lock;
2575 src_vq->dev = ctx->jpeg->dev;
2577 ret = vb2_queue_init(src_vq);
2581 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2582 dst_vq->io_modes = VB2_MMAP | VB2_USERPTR;
2583 dst_vq->drv_priv = ctx;
2584 dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
2585 dst_vq->ops = &s5p_jpeg_qops;
2586 dst_vq->mem_ops = &vb2_dma_contig_memops;
2587 dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
2588 dst_vq->lock = &ctx->jpeg->lock;
2589 dst_vq->dev = ctx->jpeg->dev;
2591 return vb2_queue_init(dst_vq);
2595 * ============================================================================
2597 * ============================================================================
2600 static irqreturn_t s5p_jpeg_irq(int irq, void *dev_id)
2602 struct s5p_jpeg *jpeg = dev_id;
2603 struct s5p_jpeg_ctx *curr_ctx;
2604 struct vb2_v4l2_buffer *src_buf, *dst_buf;
2605 unsigned long payload_size = 0;
2606 enum vb2_buffer_state state = VB2_BUF_STATE_DONE;
2607 bool enc_jpeg_too_large = false;
2608 bool timer_elapsed = false;
2609 bool op_completed = false;
2611 spin_lock(&jpeg->slock);
2613 curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2615 src_buf = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2616 dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2618 if (curr_ctx->mode == S5P_JPEG_ENCODE)
2619 enc_jpeg_too_large = s5p_jpeg_enc_stream_stat(jpeg->regs);
2620 timer_elapsed = s5p_jpeg_timer_stat(jpeg->regs);
2621 op_completed = s5p_jpeg_result_stat_ok(jpeg->regs);
2622 if (curr_ctx->mode == S5P_JPEG_DECODE)
2623 op_completed = op_completed &&
2624 s5p_jpeg_stream_stat_ok(jpeg->regs);
2626 if (enc_jpeg_too_large) {
2627 state = VB2_BUF_STATE_ERROR;
2628 s5p_jpeg_clear_enc_stream_stat(jpeg->regs);
2629 } else if (timer_elapsed) {
2630 state = VB2_BUF_STATE_ERROR;
2631 s5p_jpeg_clear_timer_stat(jpeg->regs);
2632 } else if (!op_completed) {
2633 state = VB2_BUF_STATE_ERROR;
2635 payload_size = s5p_jpeg_compressed_size(jpeg->regs);
2638 dst_buf->timecode = src_buf->timecode;
2639 dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp;
2640 dst_buf->flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
2642 src_buf->flags & V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
2644 v4l2_m2m_buf_done(src_buf, state);
2645 if (curr_ctx->mode == S5P_JPEG_ENCODE)
2646 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload_size);
2647 v4l2_m2m_buf_done(dst_buf, state);
2648 v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2650 curr_ctx->subsampling = s5p_jpeg_get_subsampling_mode(jpeg->regs);
2651 spin_unlock(&jpeg->slock);
2653 s5p_jpeg_clear_int(jpeg->regs);
2658 static irqreturn_t exynos4_jpeg_irq(int irq, void *priv)
2660 unsigned int int_status;
2661 struct vb2_v4l2_buffer *src_vb, *dst_vb;
2662 struct s5p_jpeg *jpeg = priv;
2663 struct s5p_jpeg_ctx *curr_ctx;
2664 unsigned long payload_size = 0;
2666 spin_lock(&jpeg->slock);
2668 curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2670 src_vb = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2671 dst_vb = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2673 int_status = exynos4_jpeg_get_int_status(jpeg->regs);
2676 switch (int_status & 0x1f) {
2678 jpeg->irq_ret = ERR_PROT;
2681 jpeg->irq_ret = OK_ENC_OR_DEC;
2684 jpeg->irq_ret = ERR_DEC_INVALID_FORMAT;
2687 jpeg->irq_ret = ERR_MULTI_SCAN;
2690 jpeg->irq_ret = ERR_FRAME;
2693 jpeg->irq_ret = ERR_UNKNOWN;
2697 jpeg->irq_ret = ERR_UNKNOWN;
2700 if (jpeg->irq_ret == OK_ENC_OR_DEC) {
2701 if (curr_ctx->mode == S5P_JPEG_ENCODE) {
2702 payload_size = exynos4_jpeg_get_stream_size(jpeg->regs);
2703 vb2_set_plane_payload(&dst_vb->vb2_buf,
2706 v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_DONE);
2707 v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_DONE);
2709 v4l2_m2m_buf_done(src_vb, VB2_BUF_STATE_ERROR);
2710 v4l2_m2m_buf_done(dst_vb, VB2_BUF_STATE_ERROR);
2713 v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2714 if (jpeg->variant->version == SJPEG_EXYNOS4)
2715 curr_ctx->subsampling = exynos4_jpeg_get_frame_fmt(jpeg->regs);
2717 spin_unlock(&jpeg->slock);
2721 static irqreturn_t exynos3250_jpeg_irq(int irq, void *dev_id)
2723 struct s5p_jpeg *jpeg = dev_id;
2724 struct s5p_jpeg_ctx *curr_ctx;
2725 struct vb2_v4l2_buffer *src_buf, *dst_buf;
2726 unsigned long payload_size = 0;
2727 enum vb2_buffer_state state = VB2_BUF_STATE_DONE;
2728 bool interrupt_timeout = false;
2731 spin_lock(&jpeg->slock);
2733 irq_status = exynos3250_jpeg_get_timer_status(jpeg->regs);
2734 if (irq_status & EXYNOS3250_TIMER_INT_STAT) {
2735 exynos3250_jpeg_clear_timer_status(jpeg->regs);
2736 interrupt_timeout = true;
2737 dev_err(jpeg->dev, "Interrupt timeout occurred.\n");
2740 irq_status = exynos3250_jpeg_get_int_status(jpeg->regs);
2741 exynos3250_jpeg_clear_int_status(jpeg->regs, irq_status);
2743 jpeg->irq_status |= irq_status;
2745 curr_ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
2750 if ((irq_status & EXYNOS3250_HEADER_STAT) &&
2751 (curr_ctx->mode == S5P_JPEG_DECODE)) {
2752 exynos3250_jpeg_rstart(jpeg->regs);
2756 if (jpeg->irq_status & (EXYNOS3250_JPEG_DONE |
2757 EXYNOS3250_WDMA_DONE |
2758 EXYNOS3250_RDMA_DONE |
2759 EXYNOS3250_RESULT_STAT))
2760 payload_size = exynos3250_jpeg_compressed_size(jpeg->regs);
2761 else if (interrupt_timeout)
2762 state = VB2_BUF_STATE_ERROR;
2766 src_buf = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
2767 dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
2769 dst_buf->timecode = src_buf->timecode;
2770 dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp;
2772 v4l2_m2m_buf_done(src_buf, state);
2773 if (curr_ctx->mode == S5P_JPEG_ENCODE)
2774 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload_size);
2775 v4l2_m2m_buf_done(dst_buf, state);
2776 v4l2_m2m_job_finish(jpeg->m2m_dev, curr_ctx->fh.m2m_ctx);
2778 curr_ctx->subsampling =
2779 exynos3250_jpeg_get_subsampling_mode(jpeg->regs);
2781 spin_unlock(&jpeg->slock);
2785 static void *jpeg_get_drv_data(struct device *dev);
2788 * ============================================================================
2789 * Driver basic infrastructure
2790 * ============================================================================
2793 static int s5p_jpeg_probe(struct platform_device *pdev)
2795 struct s5p_jpeg *jpeg;
2796 struct resource *res;
2799 /* JPEG IP abstraction struct */
2800 jpeg = devm_kzalloc(&pdev->dev, sizeof(struct s5p_jpeg), GFP_KERNEL);
2804 jpeg->variant = jpeg_get_drv_data(&pdev->dev);
2806 mutex_init(&jpeg->lock);
2807 spin_lock_init(&jpeg->slock);
2808 jpeg->dev = &pdev->dev;
2810 /* memory-mapped registers */
2811 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2813 jpeg->regs = devm_ioremap_resource(&pdev->dev, res);
2814 if (IS_ERR(jpeg->regs))
2815 return PTR_ERR(jpeg->regs);
2817 /* interrupt service routine registration */
2818 jpeg->irq = ret = platform_get_irq(pdev, 0);
2820 dev_err(&pdev->dev, "cannot find IRQ\n");
2824 ret = devm_request_irq(&pdev->dev, jpeg->irq, jpeg->variant->jpeg_irq,
2825 0, dev_name(&pdev->dev), jpeg);
2827 dev_err(&pdev->dev, "cannot claim IRQ %d\n", jpeg->irq);
2832 for (i = 0; i < jpeg->variant->num_clocks; i++) {
2833 jpeg->clocks[i] = devm_clk_get(&pdev->dev,
2834 jpeg->variant->clk_names[i]);
2835 if (IS_ERR(jpeg->clocks[i])) {
2836 dev_err(&pdev->dev, "failed to get clock: %s\n",
2837 jpeg->variant->clk_names[i]);
2838 return PTR_ERR(jpeg->clocks[i]);
2843 ret = v4l2_device_register(&pdev->dev, &jpeg->v4l2_dev);
2845 dev_err(&pdev->dev, "Failed to register v4l2 device\n");
2849 /* mem2mem device */
2850 jpeg->m2m_dev = v4l2_m2m_init(jpeg->variant->m2m_ops);
2851 if (IS_ERR(jpeg->m2m_dev)) {
2852 v4l2_err(&jpeg->v4l2_dev, "Failed to init mem2mem device\n");
2853 ret = PTR_ERR(jpeg->m2m_dev);
2854 goto device_register_rollback;
2857 vb2_dma_contig_set_max_seg_size(&pdev->dev, DMA_BIT_MASK(32));
2859 /* JPEG encoder /dev/videoX node */
2860 jpeg->vfd_encoder = video_device_alloc();
2861 if (!jpeg->vfd_encoder) {
2862 v4l2_err(&jpeg->v4l2_dev, "Failed to allocate video device\n");
2864 goto m2m_init_rollback;
2866 snprintf(jpeg->vfd_encoder->name, sizeof(jpeg->vfd_encoder->name),
2867 "%s-enc", S5P_JPEG_M2M_NAME);
2868 jpeg->vfd_encoder->fops = &s5p_jpeg_fops;
2869 jpeg->vfd_encoder->ioctl_ops = &s5p_jpeg_ioctl_ops;
2870 jpeg->vfd_encoder->minor = -1;
2871 jpeg->vfd_encoder->release = video_device_release;
2872 jpeg->vfd_encoder->lock = &jpeg->lock;
2873 jpeg->vfd_encoder->v4l2_dev = &jpeg->v4l2_dev;
2874 jpeg->vfd_encoder->vfl_dir = VFL_DIR_M2M;
2876 ret = video_register_device(jpeg->vfd_encoder, VFL_TYPE_GRABBER, -1);
2878 v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n");
2879 video_device_release(jpeg->vfd_encoder);
2880 goto m2m_init_rollback;
2883 video_set_drvdata(jpeg->vfd_encoder, jpeg);
2884 v4l2_info(&jpeg->v4l2_dev,
2885 "encoder device registered as /dev/video%d\n",
2886 jpeg->vfd_encoder->num);
2888 /* JPEG decoder /dev/videoX node */
2889 jpeg->vfd_decoder = video_device_alloc();
2890 if (!jpeg->vfd_decoder) {
2891 v4l2_err(&jpeg->v4l2_dev, "Failed to allocate video device\n");
2893 goto enc_vdev_register_rollback;
2895 snprintf(jpeg->vfd_decoder->name, sizeof(jpeg->vfd_decoder->name),
2896 "%s-dec", S5P_JPEG_M2M_NAME);
2897 jpeg->vfd_decoder->fops = &s5p_jpeg_fops;
2898 jpeg->vfd_decoder->ioctl_ops = &s5p_jpeg_ioctl_ops;
2899 jpeg->vfd_decoder->minor = -1;
2900 jpeg->vfd_decoder->release = video_device_release;
2901 jpeg->vfd_decoder->lock = &jpeg->lock;
2902 jpeg->vfd_decoder->v4l2_dev = &jpeg->v4l2_dev;
2903 jpeg->vfd_decoder->vfl_dir = VFL_DIR_M2M;
2905 ret = video_register_device(jpeg->vfd_decoder, VFL_TYPE_GRABBER, -1);
2907 v4l2_err(&jpeg->v4l2_dev, "Failed to register video device\n");
2908 video_device_release(jpeg->vfd_decoder);
2909 goto enc_vdev_register_rollback;
2912 video_set_drvdata(jpeg->vfd_decoder, jpeg);
2913 v4l2_info(&jpeg->v4l2_dev,
2914 "decoder device registered as /dev/video%d\n",
2915 jpeg->vfd_decoder->num);
2917 /* final statements & power management */
2918 platform_set_drvdata(pdev, jpeg);
2920 pm_runtime_enable(&pdev->dev);
2922 v4l2_info(&jpeg->v4l2_dev, "Samsung S5P JPEG codec\n");
2926 enc_vdev_register_rollback:
2927 video_unregister_device(jpeg->vfd_encoder);
2930 v4l2_m2m_release(jpeg->m2m_dev);
2932 device_register_rollback:
2933 v4l2_device_unregister(&jpeg->v4l2_dev);
2938 static int s5p_jpeg_remove(struct platform_device *pdev)
2940 struct s5p_jpeg *jpeg = platform_get_drvdata(pdev);
2943 pm_runtime_disable(jpeg->dev);
2945 video_unregister_device(jpeg->vfd_decoder);
2946 video_unregister_device(jpeg->vfd_encoder);
2947 vb2_dma_contig_clear_max_seg_size(&pdev->dev);
2948 v4l2_m2m_release(jpeg->m2m_dev);
2949 v4l2_device_unregister(&jpeg->v4l2_dev);
2951 if (!pm_runtime_status_suspended(&pdev->dev)) {
2952 for (i = jpeg->variant->num_clocks - 1; i >= 0; i--)
2953 clk_disable_unprepare(jpeg->clocks[i]);
2960 static int s5p_jpeg_runtime_suspend(struct device *dev)
2962 struct s5p_jpeg *jpeg = dev_get_drvdata(dev);
2965 for (i = jpeg->variant->num_clocks - 1; i >= 0; i--)
2966 clk_disable_unprepare(jpeg->clocks[i]);
2971 static int s5p_jpeg_runtime_resume(struct device *dev)
2973 struct s5p_jpeg *jpeg = dev_get_drvdata(dev);
2974 unsigned long flags;
2977 for (i = 0; i < jpeg->variant->num_clocks; i++) {
2978 ret = clk_prepare_enable(jpeg->clocks[i]);
2981 clk_disable_unprepare(jpeg->clocks[i]);
2986 spin_lock_irqsave(&jpeg->slock, flags);
2989 * JPEG IP allows storing two Huffman tables for each component.
2990 * We fill table 0 for each component and do this here only
2991 * for S5PC210 and Exynos3250 SoCs. Exynos4x12 and Exynos542x SoC
2992 * require programming their Huffman tables each time the encoding
2993 * process is initialized, and thus it is accomplished in the
2994 * device_run callback of m2m_ops.
2996 if (!jpeg->variant->htbl_reinit) {
2997 s5p_jpeg_set_hdctbl(jpeg->regs);
2998 s5p_jpeg_set_hdctblg(jpeg->regs);
2999 s5p_jpeg_set_hactbl(jpeg->regs);
3000 s5p_jpeg_set_hactblg(jpeg->regs);
3003 spin_unlock_irqrestore(&jpeg->slock, flags);
3007 #endif /* CONFIG_PM */
3009 static const struct dev_pm_ops s5p_jpeg_pm_ops = {
3010 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
3011 pm_runtime_force_resume)
3012 SET_RUNTIME_PM_OPS(s5p_jpeg_runtime_suspend, s5p_jpeg_runtime_resume,
3016 static struct s5p_jpeg_variant s5p_jpeg_drvdata = {
3017 .version = SJPEG_S5P,
3018 .jpeg_irq = s5p_jpeg_irq,
3019 .m2m_ops = &s5p_jpeg_m2m_ops,
3020 .fmt_ver_flag = SJPEG_FMT_FLAG_S5P,
3021 .clk_names = {"jpeg"},
3025 static struct s5p_jpeg_variant exynos3250_jpeg_drvdata = {
3026 .version = SJPEG_EXYNOS3250,
3027 .jpeg_irq = exynos3250_jpeg_irq,
3028 .m2m_ops = &exynos3250_jpeg_m2m_ops,
3029 .fmt_ver_flag = SJPEG_FMT_FLAG_EXYNOS3250,
3031 .clk_names = {"jpeg", "sclk"},
3035 static struct s5p_jpeg_variant exynos4_jpeg_drvdata = {
3036 .version = SJPEG_EXYNOS4,
3037 .jpeg_irq = exynos4_jpeg_irq,
3038 .m2m_ops = &exynos4_jpeg_m2m_ops,
3039 .fmt_ver_flag = SJPEG_FMT_FLAG_EXYNOS4,
3041 .clk_names = {"jpeg"},
3046 static struct s5p_jpeg_variant exynos5420_jpeg_drvdata = {
3047 .version = SJPEG_EXYNOS5420,
3048 .jpeg_irq = exynos3250_jpeg_irq, /* intentionally 3250 */
3049 .m2m_ops = &exynos3250_jpeg_m2m_ops, /* intentionally 3250 */
3050 .fmt_ver_flag = SJPEG_FMT_FLAG_EXYNOS3250, /* intentionally 3250 */
3053 .clk_names = {"jpeg"},
3057 static struct s5p_jpeg_variant exynos5433_jpeg_drvdata = {
3058 .version = SJPEG_EXYNOS5433,
3059 .jpeg_irq = exynos4_jpeg_irq,
3060 .m2m_ops = &exynos4_jpeg_m2m_ops,
3061 .fmt_ver_flag = SJPEG_FMT_FLAG_EXYNOS4,
3063 .clk_names = {"pclk", "aclk", "aclk_xiu", "sclk"},
3068 static const struct of_device_id samsung_jpeg_match[] = {
3070 .compatible = "samsung,s5pv210-jpeg",
3071 .data = &s5p_jpeg_drvdata,
3073 .compatible = "samsung,exynos3250-jpeg",
3074 .data = &exynos3250_jpeg_drvdata,
3076 .compatible = "samsung,exynos4210-jpeg",
3077 .data = &exynos4_jpeg_drvdata,
3079 .compatible = "samsung,exynos4212-jpeg",
3080 .data = &exynos4_jpeg_drvdata,
3082 .compatible = "samsung,exynos5420-jpeg",
3083 .data = &exynos5420_jpeg_drvdata,
3085 .compatible = "samsung,exynos5433-jpeg",
3086 .data = &exynos5433_jpeg_drvdata,
3091 MODULE_DEVICE_TABLE(of, samsung_jpeg_match);
3093 static void *jpeg_get_drv_data(struct device *dev)
3095 struct s5p_jpeg_variant *driver_data = NULL;
3096 const struct of_device_id *match;
3098 if (!IS_ENABLED(CONFIG_OF) || !dev->of_node)
3099 return &s5p_jpeg_drvdata;
3101 match = of_match_node(samsung_jpeg_match, dev->of_node);
3104 driver_data = (struct s5p_jpeg_variant *)match->data;
3109 static struct platform_driver s5p_jpeg_driver = {
3110 .probe = s5p_jpeg_probe,
3111 .remove = s5p_jpeg_remove,
3113 .of_match_table = of_match_ptr(samsung_jpeg_match),
3114 .name = S5P_JPEG_M2M_NAME,
3115 .pm = &s5p_jpeg_pm_ops,
3119 module_platform_driver(s5p_jpeg_driver);
3121 MODULE_AUTHOR("Andrzej Pietrasiewicz <andrzej.p@samsung.com>");
3122 MODULE_AUTHOR("Jacek Anaszewski <j.anaszewski@samsung.com>");
3123 MODULE_DESCRIPTION("Samsung JPEG codec driver");
3124 MODULE_LICENSE("GPL");