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