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