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