1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Coda multi-standard codec IP - JPEG support functions
5 * Copyright (C) 2014 Philipp Zabel, Pengutronix
8 #include <asm/unaligned.h>
9 #include <linux/irqreturn.h>
10 #include <linux/kernel.h>
11 #include <linux/ktime.h>
12 #include <linux/slab.h>
13 #include <linux/swab.h>
14 #include <linux/videodev2.h>
16 #include <media/v4l2-common.h>
17 #include <media/v4l2-fh.h>
18 #include <media/v4l2-jpeg.h>
19 #include <media/v4l2-mem2mem.h>
20 #include <media/videobuf2-core.h>
21 #include <media/videobuf2-dma-contig.h>
26 #define SOI_MARKER 0xffd8
27 #define APP9_MARKER 0xffe9
28 #define DRI_MARKER 0xffdd
29 #define DQT_MARKER 0xffdb
30 #define DHT_MARKER 0xffc4
31 #define SOF_MARKER 0xffc0
32 #define SOS_MARKER 0xffda
33 #define EOI_MARKER 0xffd9
36 CODA9_JPEG_FORMAT_420,
37 CODA9_JPEG_FORMAT_422,
38 CODA9_JPEG_FORMAT_224,
39 CODA9_JPEG_FORMAT_444,
40 CODA9_JPEG_FORMAT_400,
43 struct coda_huff_tab {
45 u8 chroma_dc[16 + 12];
47 u8 chroma_ac[16 + 162];
49 /* DC Luma, DC Chroma, AC Luma, AC Chroma */
55 #define CODA9_JPEG_ENC_HUFF_DATA_SIZE (256 + 256 + 16 + 16)
58 * Typical Huffman tables for 8-bit precision luminance and
59 * chrominance from JPEG ITU-T.81 (ISO/IEC 10918-1) Annex K.3
62 static const unsigned char luma_dc[16 + 12] = {
64 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01,
65 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
67 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
68 0x08, 0x09, 0x0a, 0x0b,
71 static const unsigned char chroma_dc[16 + 12] = {
73 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
74 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
76 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
77 0x08, 0x09, 0x0a, 0x0b,
80 static const unsigned char luma_ac[16 + 162 + 2] = {
82 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03,
83 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7d,
85 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
86 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
87 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
88 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
89 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
90 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
91 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
92 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
93 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
94 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
95 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
96 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
97 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
98 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
99 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
100 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
101 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
102 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
103 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
104 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
105 0xf9, 0xfa, /* padded to 32-bit */
108 static const unsigned char chroma_ac[16 + 162 + 2] = {
110 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04,
111 0x07, 0x05, 0x04, 0x04, 0x00, 0x01, 0x02, 0x77,
113 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
114 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
115 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
116 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
117 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
118 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
119 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
120 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
121 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
122 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
123 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
124 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
125 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
126 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
127 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
128 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
129 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
130 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
131 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
132 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
133 0xf9, 0xfa, /* padded to 32-bit */
137 * Quantization tables for luminance and chrominance components in
138 * zig-zag scan order from the Freescale i.MX VPU libraries
141 static unsigned char luma_q[64] = {
142 0x06, 0x04, 0x04, 0x04, 0x05, 0x04, 0x06, 0x05,
143 0x05, 0x06, 0x09, 0x06, 0x05, 0x06, 0x09, 0x0b,
144 0x08, 0x06, 0x06, 0x08, 0x0b, 0x0c, 0x0a, 0x0a,
145 0x0b, 0x0a, 0x0a, 0x0c, 0x10, 0x0c, 0x0c, 0x0c,
146 0x0c, 0x0c, 0x0c, 0x10, 0x0c, 0x0c, 0x0c, 0x0c,
147 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
148 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
149 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
152 static unsigned char chroma_q[64] = {
153 0x07, 0x07, 0x07, 0x0d, 0x0c, 0x0d, 0x18, 0x10,
154 0x10, 0x18, 0x14, 0x0e, 0x0e, 0x0e, 0x14, 0x14,
155 0x0e, 0x0e, 0x0e, 0x0e, 0x14, 0x11, 0x0c, 0x0c,
156 0x0c, 0x0c, 0x0c, 0x11, 0x11, 0x0c, 0x0c, 0x0c,
157 0x0c, 0x0c, 0x0c, 0x11, 0x0c, 0x0c, 0x0c, 0x0c,
158 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
159 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
160 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
163 static const unsigned char width_align[] = {
164 [CODA9_JPEG_FORMAT_420] = 16,
165 [CODA9_JPEG_FORMAT_422] = 16,
166 [CODA9_JPEG_FORMAT_224] = 8,
167 [CODA9_JPEG_FORMAT_444] = 8,
168 [CODA9_JPEG_FORMAT_400] = 8,
171 static const unsigned char height_align[] = {
172 [CODA9_JPEG_FORMAT_420] = 16,
173 [CODA9_JPEG_FORMAT_422] = 8,
174 [CODA9_JPEG_FORMAT_224] = 16,
175 [CODA9_JPEG_FORMAT_444] = 8,
176 [CODA9_JPEG_FORMAT_400] = 8,
179 static int coda9_jpeg_chroma_format(u32 pixfmt)
182 case V4L2_PIX_FMT_YUV420:
183 case V4L2_PIX_FMT_NV12:
184 return CODA9_JPEG_FORMAT_420;
185 case V4L2_PIX_FMT_YUV422P:
186 return CODA9_JPEG_FORMAT_422;
187 case V4L2_PIX_FMT_YUV444:
188 return CODA9_JPEG_FORMAT_444;
189 case V4L2_PIX_FMT_GREY:
190 return CODA9_JPEG_FORMAT_400;
195 struct coda_memcpy_desc {
201 static void coda_memcpy_parabuf(void *parabuf,
202 const struct coda_memcpy_desc *desc)
204 u32 *dst = parabuf + desc->offset;
205 const u32 *src = desc->src;
206 int len = desc->len / 4;
209 for (i = 0; i < len; i += 2) {
210 dst[i + 1] = swab32(src[i]);
211 dst[i] = swab32(src[i + 1]);
215 int coda_jpeg_write_tables(struct coda_ctx *ctx)
218 static const struct coda_memcpy_desc huff[8] = {
219 { 0, luma_dc, sizeof(luma_dc) },
220 { 32, luma_ac, sizeof(luma_ac) },
221 { 216, chroma_dc, sizeof(chroma_dc) },
222 { 248, chroma_ac, sizeof(chroma_ac) },
224 struct coda_memcpy_desc qmat[3] = {
225 { 512, ctx->params.jpeg_qmat_tab[0], 64 },
226 { 576, ctx->params.jpeg_qmat_tab[1], 64 },
227 { 640, ctx->params.jpeg_qmat_tab[1], 64 },
230 /* Write huffman tables to parameter memory */
231 for (i = 0; i < ARRAY_SIZE(huff); i++)
232 coda_memcpy_parabuf(ctx->parabuf.vaddr, huff + i);
234 /* Write Q-matrix to parameter memory */
235 for (i = 0; i < ARRAY_SIZE(qmat); i++)
236 coda_memcpy_parabuf(ctx->parabuf.vaddr, qmat + i);
241 bool coda_jpeg_check_buffer(struct coda_ctx *ctx, struct vb2_buffer *vb)
243 void *vaddr = vb2_plane_vaddr(vb, 0);
247 soi = be16_to_cpup((__be16 *)vaddr);
248 if (soi != SOI_MARKER)
251 len = vb2_get_plane_payload(vb, 0);
253 for (i = 0; i < 32; i++) {
254 eoi = be16_to_cpup((__be16 *)(vaddr - i));
255 if (eoi == EOI_MARKER) {
257 vb2_set_plane_payload(vb, 0, len - i);
265 static int coda9_jpeg_gen_dec_huff_tab(struct coda_ctx *ctx, int tab_num);
267 int coda_jpeg_decode_header(struct coda_ctx *ctx, struct vb2_buffer *vb)
269 struct coda_dev *dev = ctx->dev;
270 u8 *buf = vb2_plane_vaddr(vb, 0);
271 size_t len = vb2_get_plane_payload(vb, 0);
272 struct v4l2_jpeg_scan_header scan_header;
273 struct v4l2_jpeg_reference quantization_tables[4] = { };
274 struct v4l2_jpeg_reference huffman_tables[4] = { };
275 struct v4l2_jpeg_header header = {
276 .scan = &scan_header,
277 .quantization_tables = quantization_tables,
278 .huffman_tables = huffman_tables,
280 struct coda_q_data *q_data_src;
281 struct coda_huff_tab *huff_tab;
284 ret = v4l2_jpeg_parse_header(buf, len, &header);
286 v4l2_err(&dev->v4l2_dev, "failed to parse header\n");
290 ctx->params.jpeg_restart_interval = header.restart_interval;
292 /* check frame header */
293 if (header.frame.height > ctx->codec->max_h ||
294 header.frame.width > ctx->codec->max_w) {
295 v4l2_err(&dev->v4l2_dev, "invalid dimensions: %dx%d\n",
296 header.frame.width, header.frame.height);
300 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
301 if (header.frame.height != q_data_src->height ||
302 header.frame.width != q_data_src->width) {
303 v4l2_err(&dev->v4l2_dev,
304 "dimensions don't match format: %dx%d\n",
305 header.frame.width, header.frame.height);
309 if (header.frame.num_components != 3) {
310 v4l2_err(&dev->v4l2_dev,
311 "unsupported number of components: %d\n",
312 header.frame.num_components);
316 /* install quantization tables */
317 if (quantization_tables[3].start) {
318 v4l2_err(&dev->v4l2_dev,
319 "only 3 quantization tables supported\n");
322 for (i = 0; i < 3; i++) {
323 if (!quantization_tables[i].start)
325 if (quantization_tables[i].length != 64) {
326 v4l2_err(&dev->v4l2_dev,
327 "only 8-bit quantization tables supported\n");
330 if (!ctx->params.jpeg_qmat_tab[i]) {
331 ctx->params.jpeg_qmat_tab[i] = kmalloc(64, GFP_KERNEL);
332 if (!ctx->params.jpeg_qmat_tab[i])
335 memcpy(ctx->params.jpeg_qmat_tab[i],
336 quantization_tables[i].start, 64);
339 /* install Huffman tables */
340 for (i = 0; i < 4; i++) {
341 if (!huffman_tables[i].start) {
342 v4l2_err(&dev->v4l2_dev, "missing Huffman table\n");
345 /* AC tables should be between 17 -> 178, DC between 17 -> 28 */
346 if (huffman_tables[i].length < 17 ||
347 huffman_tables[i].length > 178 ||
348 ((i & 2) == 0 && huffman_tables[i].length > 28)) {
349 v4l2_err(&dev->v4l2_dev,
350 "invalid Huffman table %d length: %zu\n",
351 i, huffman_tables[i].length);
355 huff_tab = ctx->params.jpeg_huff_tab;
357 huff_tab = kzalloc(sizeof(struct coda_huff_tab), GFP_KERNEL);
360 ctx->params.jpeg_huff_tab = huff_tab;
363 memset(huff_tab, 0, sizeof(*huff_tab));
364 memcpy(huff_tab->luma_dc, huffman_tables[0].start, huffman_tables[0].length);
365 memcpy(huff_tab->chroma_dc, huffman_tables[1].start, huffman_tables[1].length);
366 memcpy(huff_tab->luma_ac, huffman_tables[2].start, huffman_tables[2].length);
367 memcpy(huff_tab->chroma_ac, huffman_tables[3].start, huffman_tables[3].length);
369 /* check scan header */
370 for (i = 0; i < scan_header.num_components; i++) {
371 struct v4l2_jpeg_scan_component_spec *scan_component;
373 scan_component = &scan_header.component[i];
374 for (j = 0; j < header.frame.num_components; j++) {
375 if (header.frame.component[j].component_identifier ==
376 scan_component->component_selector)
379 if (j == header.frame.num_components)
382 ctx->params.jpeg_huff_dc_index[j] =
383 scan_component->dc_entropy_coding_table_selector;
384 ctx->params.jpeg_huff_ac_index[j] =
385 scan_component->ac_entropy_coding_table_selector;
388 /* Generate Huffman table information */
389 for (i = 0; i < 4; i++)
390 coda9_jpeg_gen_dec_huff_tab(ctx, i);
392 /* start of entropy coded segment */
393 ctx->jpeg_ecs_offset = header.ecs_offset;
395 switch (header.frame.subsampling) {
396 case V4L2_JPEG_CHROMA_SUBSAMPLING_420:
397 case V4L2_JPEG_CHROMA_SUBSAMPLING_422:
398 ctx->params.jpeg_chroma_subsampling = header.frame.subsampling;
401 v4l2_err(&dev->v4l2_dev, "chroma subsampling not supported: %d",
402 header.frame.subsampling);
409 static inline void coda9_jpeg_write_huff_values(struct coda_dev *dev, u8 *bits,
412 s8 *values = (s8 *)(bits + 16);
415 for (huff_length = 0, i = 0; i < 16; i++)
416 huff_length += bits[i];
417 for (i = huff_length; i < num_values; i++)
419 for (i = 0; i < num_values; i++)
420 coda_write(dev, (s32)values[i], CODA9_REG_JPEG_HUFF_DATA);
423 static int coda9_jpeg_dec_huff_setup(struct coda_ctx *ctx)
425 struct coda_huff_tab *huff_tab = ctx->params.jpeg_huff_tab;
426 struct coda_dev *dev = ctx->dev;
427 s16 *huff_min = huff_tab->min;
428 s16 *huff_max = huff_tab->max;
429 s8 *huff_ptr = huff_tab->ptr;
433 coda_write(dev, 0x003, CODA9_REG_JPEG_HUFF_CTRL);
434 coda_write(dev, 0x000, CODA9_REG_JPEG_HUFF_ADDR);
435 for (i = 0; i < 4 * 16; i++)
436 coda_write(dev, (s32)huff_min[i], CODA9_REG_JPEG_HUFF_DATA);
439 coda_write(dev, 0x403, CODA9_REG_JPEG_HUFF_CTRL);
440 coda_write(dev, 0x440, CODA9_REG_JPEG_HUFF_ADDR);
441 for (i = 0; i < 4 * 16; i++)
442 coda_write(dev, (s32)huff_max[i], CODA9_REG_JPEG_HUFF_DATA);
445 coda_write(dev, 0x803, CODA9_REG_JPEG_HUFF_CTRL);
446 coda_write(dev, 0x880, CODA9_REG_JPEG_HUFF_ADDR);
447 for (i = 0; i < 4 * 16; i++)
448 coda_write(dev, (s32)huff_ptr[i], CODA9_REG_JPEG_HUFF_DATA);
450 /* VAL Tables: DC Luma, DC Chroma, AC Luma, AC Chroma */
451 coda_write(dev, 0xc03, CODA9_REG_JPEG_HUFF_CTRL);
452 coda9_jpeg_write_huff_values(dev, huff_tab->luma_dc, 12);
453 coda9_jpeg_write_huff_values(dev, huff_tab->chroma_dc, 12);
454 coda9_jpeg_write_huff_values(dev, huff_tab->luma_ac, 162);
455 coda9_jpeg_write_huff_values(dev, huff_tab->chroma_ac, 162);
456 coda_write(dev, 0x000, CODA9_REG_JPEG_HUFF_CTRL);
460 static inline void coda9_jpeg_write_qmat_tab(struct coda_dev *dev,
465 coda_write(dev, index | 0x3, CODA9_REG_JPEG_QMAT_CTRL);
466 for (i = 0; i < 64; i++)
467 coda_write(dev, qmat[i], CODA9_REG_JPEG_QMAT_DATA);
468 coda_write(dev, 0, CODA9_REG_JPEG_QMAT_CTRL);
471 static void coda9_jpeg_qmat_setup(struct coda_ctx *ctx)
473 struct coda_dev *dev = ctx->dev;
474 int *qmat_index = ctx->params.jpeg_qmat_index;
475 u8 **qmat_tab = ctx->params.jpeg_qmat_tab;
477 coda9_jpeg_write_qmat_tab(dev, qmat_tab[qmat_index[0]], 0x00);
478 coda9_jpeg_write_qmat_tab(dev, qmat_tab[qmat_index[1]], 0x40);
479 coda9_jpeg_write_qmat_tab(dev, qmat_tab[qmat_index[2]], 0x80);
482 static void coda9_jpeg_dec_bbc_gbu_setup(struct coda_ctx *ctx,
483 struct vb2_buffer *buf, u32 ecs_offset)
485 struct coda_dev *dev = ctx->dev;
486 int page_ptr, word_ptr, bit_ptr;
487 u32 bbc_base_addr, end_addr;
491 bbc_base_addr = vb2_dma_contig_plane_dma_addr(buf, 0);
492 end_addr = bbc_base_addr + vb2_get_plane_payload(buf, 0);
494 page_ptr = ecs_offset / 256;
495 word_ptr = (ecs_offset % 256) / 4;
498 bit_ptr = (ecs_offset % 4) * 8;
503 coda_write(dev, end_addr, CODA9_REG_JPEG_BBC_WR_PTR);
504 coda_write(dev, bbc_base_addr, CODA9_REG_JPEG_BBC_BAS_ADDR);
506 /* Leave 3 256-byte page margin to avoid a BBC interrupt */
507 coda_write(dev, end_addr + 256 * 3 + 256, CODA9_REG_JPEG_BBC_END_ADDR);
508 val = DIV_ROUND_UP(vb2_plane_size(buf, 0), 256) + 3;
509 coda_write(dev, BIT(31) | val, CODA9_REG_JPEG_BBC_STRM_CTRL);
511 bbc_cur_pos = page_ptr;
512 coda_write(dev, bbc_cur_pos, CODA9_REG_JPEG_BBC_CUR_POS);
513 coda_write(dev, bbc_base_addr + (bbc_cur_pos << 8),
514 CODA9_REG_JPEG_BBC_EXT_ADDR);
515 coda_write(dev, (bbc_cur_pos & 1) << 6, CODA9_REG_JPEG_BBC_INT_ADDR);
516 coda_write(dev, 64, CODA9_REG_JPEG_BBC_DATA_CNT);
517 coda_write(dev, 0, CODA9_REG_JPEG_BBC_COMMAND);
519 ret = coda_read(dev, CODA9_REG_JPEG_BBC_BUSY);
523 coda_write(dev, bbc_cur_pos, CODA9_REG_JPEG_BBC_CUR_POS);
524 coda_write(dev, bbc_base_addr + (bbc_cur_pos << 8),
525 CODA9_REG_JPEG_BBC_EXT_ADDR);
526 coda_write(dev, (bbc_cur_pos & 1) << 6, CODA9_REG_JPEG_BBC_INT_ADDR);
527 coda_write(dev, 64, CODA9_REG_JPEG_BBC_DATA_CNT);
528 coda_write(dev, 0, CODA9_REG_JPEG_BBC_COMMAND);
530 ret = coda_read(dev, CODA9_REG_JPEG_BBC_BUSY);
534 coda_write(dev, bbc_cur_pos, CODA9_REG_JPEG_BBC_CUR_POS);
535 coda_write(dev, 1, CODA9_REG_JPEG_BBC_CTRL);
537 coda_write(dev, 0, CODA9_REG_JPEG_GBU_TT_CNT);
538 coda_write(dev, word_ptr, CODA9_REG_JPEG_GBU_WD_PTR);
539 coda_write(dev, 0, CODA9_REG_JPEG_GBU_BBSR);
540 coda_write(dev, 127, CODA9_REG_JPEG_GBU_BBER);
542 coda_write(dev, 0, CODA9_REG_JPEG_GBU_BBIR);
543 coda_write(dev, 0, CODA9_REG_JPEG_GBU_BBHR);
545 coda_write(dev, 64, CODA9_REG_JPEG_GBU_BBIR);
546 coda_write(dev, 64, CODA9_REG_JPEG_GBU_BBHR);
548 coda_write(dev, 4, CODA9_REG_JPEG_GBU_CTRL);
549 coda_write(dev, bit_ptr, CODA9_REG_JPEG_GBU_FF_RPTR);
550 coda_write(dev, 3, CODA9_REG_JPEG_GBU_CTRL);
553 static const int bus_req_num[] = {
554 [CODA9_JPEG_FORMAT_420] = 2,
555 [CODA9_JPEG_FORMAT_422] = 3,
556 [CODA9_JPEG_FORMAT_224] = 3,
557 [CODA9_JPEG_FORMAT_444] = 4,
558 [CODA9_JPEG_FORMAT_400] = 4,
561 #define MCU_INFO(mcu_block_num, comp_num, comp0_info, comp1_info, comp2_info) \
562 (((mcu_block_num) << CODA9_JPEG_MCU_BLOCK_NUM_OFFSET) | \
563 ((comp_num) << CODA9_JPEG_COMP_NUM_OFFSET) | \
564 ((comp0_info) << CODA9_JPEG_COMP0_INFO_OFFSET) | \
565 ((comp1_info) << CODA9_JPEG_COMP1_INFO_OFFSET) | \
566 ((comp2_info) << CODA9_JPEG_COMP2_INFO_OFFSET))
568 static const u32 mcu_info[] = {
569 [CODA9_JPEG_FORMAT_420] = MCU_INFO(6, 3, 10, 5, 5),
570 [CODA9_JPEG_FORMAT_422] = MCU_INFO(4, 3, 9, 5, 5),
571 [CODA9_JPEG_FORMAT_224] = MCU_INFO(4, 3, 6, 5, 5),
572 [CODA9_JPEG_FORMAT_444] = MCU_INFO(3, 3, 5, 5, 5),
573 [CODA9_JPEG_FORMAT_400] = MCU_INFO(1, 1, 5, 0, 0),
577 * Convert Huffman table specifcations to tables of codes and code lengths.
578 * For reference, see JPEG ITU-T.81 (ISO/IEC 10918-1) [1]
580 * [1] https://www.w3.org/Graphics/JPEG/itu-t81.pdf
582 static int coda9_jpeg_gen_enc_huff_tab(struct coda_ctx *ctx, int tab_num,
583 int *ehufsi, int *ehufco)
585 int i, j, k, lastk, si, code, maxsymbol;
586 const u8 *bits, *huffval;
591 static const unsigned char *huff_tabs[4] = {
592 luma_dc, luma_ac, chroma_dc, chroma_ac,
596 huff = kzalloc(sizeof(*huff), GFP_KERNEL);
600 bits = huff_tabs[tab_num];
601 huffval = huff_tabs[tab_num] + 16;
603 maxsymbol = tab_num & 1 ? 256 : 16;
605 /* Figure C.1 - Generation of table of Huffman code sizes */
607 for (i = 1; i <= 16; i++) {
609 if (k + j > maxsymbol)
616 /* Figure C.2 - Generation of table of Huffman codes */
621 while (huff->size[k] == si) {
622 huff->code[k++] = code;
625 if (code >= (1 << si))
631 /* Figure C.3 - Ordering procedure for encoding procedure code tables */
632 for (k = 0; k < lastk; k++) {
634 if (i >= maxsymbol || ehufsi[i])
636 ehufco[i] = huff->code[k];
637 ehufsi[i] = huff->size[k];
646 #define DC_TABLE_INDEX0 0
647 #define AC_TABLE_INDEX0 1
648 #define DC_TABLE_INDEX1 2
649 #define AC_TABLE_INDEX1 3
651 static u8 *coda9_jpeg_get_huff_bits(struct coda_ctx *ctx, int tab_num)
653 struct coda_huff_tab *huff_tab = ctx->params.jpeg_huff_tab;
659 case DC_TABLE_INDEX0: return huff_tab->luma_dc;
660 case AC_TABLE_INDEX0: return huff_tab->luma_ac;
661 case DC_TABLE_INDEX1: return huff_tab->chroma_dc;
662 case AC_TABLE_INDEX1: return huff_tab->chroma_ac;
668 static int coda9_jpeg_gen_dec_huff_tab(struct coda_ctx *ctx, int tab_num)
670 int ptr_cnt = 0, huff_code = 0, zero_flag = 0, data_flag = 0;
678 huff_bits = coda9_jpeg_get_huff_bits(ctx, tab_num);
682 /* DC/AC Luma, DC/AC Chroma -> DC Luma/Chroma, AC Luma/Chroma */
683 ofs = ((tab_num & 1) << 1) | ((tab_num >> 1) & 1);
686 huff_ptr = ctx->params.jpeg_huff_tab->ptr + ofs;
687 huff_max = ctx->params.jpeg_huff_tab->max + ofs;
688 huff_min = ctx->params.jpeg_huff_tab->min + ofs;
690 for (i = 0; i < 16; i++) {
692 huff_ptr[i] = ptr_cnt;
693 ptr_cnt += huff_bits[i];
694 huff_min[i] = huff_code;
695 huff_max[i] = huff_code + (huff_bits[i] - 1);
705 if (data_flag == 1) {
709 huff_code = (huff_max[i] + 1) << 1;
716 static int coda9_jpeg_load_huff_tab(struct coda_ctx *ctx)
726 huff = kzalloc(sizeof(*huff), GFP_KERNEL);
730 /* Generate all four (luma/chroma DC/AC) code/size lookup tables */
731 for (i = 0; i < 4; i++) {
732 ret = coda9_jpeg_gen_enc_huff_tab(ctx, i, huff->size[i],
738 if (!ctx->params.jpeg_huff_data) {
739 ctx->params.jpeg_huff_data =
740 kzalloc(sizeof(u32) * CODA9_JPEG_ENC_HUFF_DATA_SIZE,
742 if (!ctx->params.jpeg_huff_data) {
747 huff_data = ctx->params.jpeg_huff_data;
749 for (j = 0; j < 4; j++) {
750 /* Store Huffman lookup tables in AC0, AC1, DC0, DC1 order */
751 int t = (j == 0) ? AC_TABLE_INDEX0 :
752 (j == 1) ? AC_TABLE_INDEX1 :
753 (j == 2) ? DC_TABLE_INDEX0 :
755 /* DC tables only have 16 entries */
756 int len = (j < 2) ? 256 : 16;
758 for (i = 0; i < len; i++) {
759 if (huff->size[t][i] == 0 && huff->code[t][i] == 0)
763 ((huff->size[t][i] - 1) << 16) |
774 static void coda9_jpeg_write_huff_tab(struct coda_ctx *ctx)
776 struct coda_dev *dev = ctx->dev;
777 u32 *huff_data = ctx->params.jpeg_huff_data;
780 /* Write Huffman size/code lookup tables in AC0, AC1, DC0, DC1 order */
781 coda_write(dev, 0x3, CODA9_REG_JPEG_HUFF_CTRL);
782 for (i = 0; i < CODA9_JPEG_ENC_HUFF_DATA_SIZE; i++)
783 coda_write(dev, *(huff_data++), CODA9_REG_JPEG_HUFF_DATA);
784 coda_write(dev, 0x0, CODA9_REG_JPEG_HUFF_CTRL);
787 static inline void coda9_jpeg_write_qmat_quotients(struct coda_dev *dev,
792 coda_write(dev, index | 0x3, CODA9_REG_JPEG_QMAT_CTRL);
793 for (i = 0; i < 64; i++)
794 coda_write(dev, 0x80000 / qmat[i], CODA9_REG_JPEG_QMAT_DATA);
795 coda_write(dev, index, CODA9_REG_JPEG_QMAT_CTRL);
798 static void coda9_jpeg_load_qmat_tab(struct coda_ctx *ctx)
800 struct coda_dev *dev = ctx->dev;
804 luma_tab = ctx->params.jpeg_qmat_tab[0];
808 chroma_tab = ctx->params.jpeg_qmat_tab[1];
810 chroma_tab = chroma_q;
812 coda9_jpeg_write_qmat_quotients(dev, luma_tab, 0x00);
813 coda9_jpeg_write_qmat_quotients(dev, chroma_tab, 0x40);
814 coda9_jpeg_write_qmat_quotients(dev, chroma_tab, 0x80);
817 struct coda_jpeg_stream {
822 static inline int coda_jpeg_put_byte(u8 byte, struct coda_jpeg_stream *stream)
824 if (stream->curr >= stream->end)
827 *stream->curr++ = byte;
832 static inline int coda_jpeg_put_word(u16 word, struct coda_jpeg_stream *stream)
834 if (stream->curr + sizeof(__be16) > stream->end)
837 put_unaligned_be16(word, stream->curr);
838 stream->curr += sizeof(__be16);
843 static int coda_jpeg_put_table(u16 marker, u8 index, const u8 *table,
844 size_t len, struct coda_jpeg_stream *stream)
848 ret = coda_jpeg_put_word(marker, stream);
851 ret = coda_jpeg_put_word(3 + len, stream);
854 ret = coda_jpeg_put_byte(index, stream);
855 for (i = 0; i < len && ret == 0; i++)
856 ret = coda_jpeg_put_byte(table[i], stream);
861 static int coda_jpeg_define_quantization_table(struct coda_ctx *ctx, u8 index,
862 struct coda_jpeg_stream *stream)
864 return coda_jpeg_put_table(DQT_MARKER, index,
865 ctx->params.jpeg_qmat_tab[index], 64,
869 static int coda_jpeg_define_huffman_table(u8 index, const u8 *table, size_t len,
870 struct coda_jpeg_stream *stream)
872 return coda_jpeg_put_table(DHT_MARKER, index, table, len, stream);
875 static int coda9_jpeg_encode_header(struct coda_ctx *ctx, int len, u8 *buf)
877 struct coda_jpeg_stream stream = { buf, buf + len };
878 struct coda_q_data *q_data_src;
879 int chroma_format, comp_num;
882 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
883 chroma_format = coda9_jpeg_chroma_format(q_data_src->fourcc);
884 if (chroma_format < 0)
888 ret = coda_jpeg_put_word(SOI_MARKER, &stream);
892 /* Define Restart Interval */
893 if (ctx->params.jpeg_restart_interval) {
894 ret = coda_jpeg_put_word(DRI_MARKER, &stream);
897 ret = coda_jpeg_put_word(4, &stream);
900 ret = coda_jpeg_put_word(ctx->params.jpeg_restart_interval,
906 /* Define Quantization Tables */
907 ret = coda_jpeg_define_quantization_table(ctx, 0x00, &stream);
910 if (chroma_format != CODA9_JPEG_FORMAT_400) {
911 ret = coda_jpeg_define_quantization_table(ctx, 0x01, &stream);
916 /* Define Huffman Tables */
917 ret = coda_jpeg_define_huffman_table(0x00, luma_dc, 16 + 12, &stream);
920 ret = coda_jpeg_define_huffman_table(0x10, luma_ac, 16 + 162, &stream);
923 if (chroma_format != CODA9_JPEG_FORMAT_400) {
924 ret = coda_jpeg_define_huffman_table(0x01, chroma_dc, 16 + 12,
928 ret = coda_jpeg_define_huffman_table(0x11, chroma_ac, 16 + 162,
935 ret = coda_jpeg_put_word(SOF_MARKER, &stream);
938 comp_num = (chroma_format == CODA9_JPEG_FORMAT_400) ? 1 : 3;
939 ret = coda_jpeg_put_word(8 + comp_num * 3, &stream);
942 ret = coda_jpeg_put_byte(0x08, &stream);
945 ret = coda_jpeg_put_word(q_data_src->height, &stream);
948 ret = coda_jpeg_put_word(q_data_src->width, &stream);
951 ret = coda_jpeg_put_byte(comp_num, &stream);
954 for (i = 0; i < comp_num; i++) {
955 static unsigned char subsampling[5][3] = {
956 [CODA9_JPEG_FORMAT_420] = { 0x22, 0x11, 0x11 },
957 [CODA9_JPEG_FORMAT_422] = { 0x21, 0x11, 0x11 },
958 [CODA9_JPEG_FORMAT_224] = { 0x12, 0x11, 0x11 },
959 [CODA9_JPEG_FORMAT_444] = { 0x11, 0x11, 0x11 },
960 [CODA9_JPEG_FORMAT_400] = { 0x11 },
963 /* Component identifier, matches SOS */
964 ret = coda_jpeg_put_byte(i + 1, &stream);
967 ret = coda_jpeg_put_byte(subsampling[chroma_format][i],
971 /* Chroma table index */
972 ret = coda_jpeg_put_byte((i == 0) ? 0 : 1, &stream);
977 /* Pad to multiple of 8 bytes */
978 pad = (stream.curr - buf) % 8;
982 ret = coda_jpeg_put_byte(0x00, &stream);
988 return stream.curr - buf;
992 * Scale quantization table using nonlinear scaling factor
993 * u8 qtab[64], scale [50,190]
995 static void coda_scale_quant_table(u8 *q_tab, int scale)
1000 for (i = 0; i < 64; i++) {
1001 temp = DIV_ROUND_CLOSEST((unsigned int)q_tab[i] * scale, 100);
1006 q_tab[i] = (unsigned char)temp;
1010 void coda_set_jpeg_compression_quality(struct coda_ctx *ctx, int quality)
1014 ctx->params.jpeg_quality = quality;
1016 /* Clip quality setting to [5,100] interval */
1023 * Non-linear scaling factor:
1024 * [5,50] -> [1000..100], [51,100] -> [98..0]
1027 scale = 5000 / quality;
1029 scale = 200 - 2 * quality;
1031 if (ctx->params.jpeg_qmat_tab[0]) {
1032 memcpy(ctx->params.jpeg_qmat_tab[0], luma_q, 64);
1033 coda_scale_quant_table(ctx->params.jpeg_qmat_tab[0], scale);
1035 if (ctx->params.jpeg_qmat_tab[1]) {
1036 memcpy(ctx->params.jpeg_qmat_tab[1], chroma_q, 64);
1037 coda_scale_quant_table(ctx->params.jpeg_qmat_tab[1], scale);
1042 * Encoder context operations
1045 static int coda9_jpeg_start_encoding(struct coda_ctx *ctx)
1047 struct coda_dev *dev = ctx->dev;
1050 ret = coda9_jpeg_load_huff_tab(ctx);
1052 v4l2_err(&dev->v4l2_dev, "error loading Huffman tables\n");
1055 if (!ctx->params.jpeg_qmat_tab[0]) {
1056 ctx->params.jpeg_qmat_tab[0] = kmalloc(64, GFP_KERNEL);
1057 if (!ctx->params.jpeg_qmat_tab[0])
1060 if (!ctx->params.jpeg_qmat_tab[1]) {
1061 ctx->params.jpeg_qmat_tab[1] = kmalloc(64, GFP_KERNEL);
1062 if (!ctx->params.jpeg_qmat_tab[1])
1065 coda_set_jpeg_compression_quality(ctx, ctx->params.jpeg_quality);
1070 static int coda9_jpeg_prepare_encode(struct coda_ctx *ctx)
1072 struct coda_q_data *q_data_src;
1073 struct vb2_v4l2_buffer *src_buf, *dst_buf;
1074 struct coda_dev *dev = ctx->dev;
1075 u32 start_addr, end_addr;
1076 u16 aligned_width, aligned_height;
1077 bool chroma_interleave;
1083 src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
1084 dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
1085 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
1087 if (vb2_get_plane_payload(&src_buf->vb2_buf, 0) == 0)
1088 vb2_set_plane_payload(&src_buf->vb2_buf, 0,
1089 vb2_plane_size(&src_buf->vb2_buf, 0));
1091 src_buf->sequence = ctx->osequence;
1092 dst_buf->sequence = ctx->osequence;
1095 src_buf->flags |= V4L2_BUF_FLAG_KEYFRAME;
1096 src_buf->flags &= ~V4L2_BUF_FLAG_PFRAME;
1098 coda_set_gdi_regs(ctx);
1100 start_addr = vb2_dma_contig_plane_dma_addr(&dst_buf->vb2_buf, 0);
1101 end_addr = start_addr + vb2_plane_size(&dst_buf->vb2_buf, 0);
1103 chroma_format = coda9_jpeg_chroma_format(q_data_src->fourcc);
1104 if (chroma_format < 0)
1105 return chroma_format;
1107 /* Round image dimensions to multiple of MCU size */
1108 aligned_width = round_up(q_data_src->width, width_align[chroma_format]);
1109 aligned_height = round_up(q_data_src->height,
1110 height_align[chroma_format]);
1111 if (aligned_width != q_data_src->bytesperline) {
1112 v4l2_err(&dev->v4l2_dev, "wrong stride: %d instead of %d\n",
1113 aligned_width, q_data_src->bytesperline);
1117 coda9_jpeg_encode_header(ctx,
1118 vb2_plane_size(&dst_buf->vb2_buf, 0),
1119 vb2_plane_vaddr(&dst_buf->vb2_buf, 0));
1123 coda_write(dev, start_addr + header_len, CODA9_REG_JPEG_BBC_BAS_ADDR);
1124 coda_write(dev, end_addr, CODA9_REG_JPEG_BBC_END_ADDR);
1125 coda_write(dev, start_addr + header_len, CODA9_REG_JPEG_BBC_WR_PTR);
1126 coda_write(dev, start_addr + header_len, CODA9_REG_JPEG_BBC_RD_PTR);
1127 coda_write(dev, 0, CODA9_REG_JPEG_BBC_CUR_POS);
1128 /* 64 words per 256-byte page */
1129 coda_write(dev, 64, CODA9_REG_JPEG_BBC_DATA_CNT);
1130 coda_write(dev, start_addr, CODA9_REG_JPEG_BBC_EXT_ADDR);
1131 coda_write(dev, 0, CODA9_REG_JPEG_BBC_INT_ADDR);
1133 coda_write(dev, 0, CODA9_REG_JPEG_GBU_BT_PTR);
1134 coda_write(dev, 0, CODA9_REG_JPEG_GBU_WD_PTR);
1135 coda_write(dev, 0, CODA9_REG_JPEG_GBU_BBSR);
1136 coda_write(dev, BIT(31) | ((end_addr - start_addr - header_len) / 256),
1137 CODA9_REG_JPEG_BBC_STRM_CTRL);
1138 coda_write(dev, 0, CODA9_REG_JPEG_GBU_CTRL);
1139 coda_write(dev, 0, CODA9_REG_JPEG_GBU_FF_RPTR);
1140 coda_write(dev, 127, CODA9_REG_JPEG_GBU_BBER);
1141 coda_write(dev, 64, CODA9_REG_JPEG_GBU_BBIR);
1142 coda_write(dev, 64, CODA9_REG_JPEG_GBU_BBHR);
1144 chroma_interleave = (q_data_src->fourcc == V4L2_PIX_FMT_NV12);
1145 coda_write(dev, CODA9_JPEG_PIC_CTRL_TC_DIRECTION |
1146 CODA9_JPEG_PIC_CTRL_ENCODER_EN, CODA9_REG_JPEG_PIC_CTRL);
1147 coda_write(dev, 0, CODA9_REG_JPEG_SCL_INFO);
1148 coda_write(dev, chroma_interleave, CODA9_REG_JPEG_DPB_CONFIG);
1149 coda_write(dev, ctx->params.jpeg_restart_interval,
1150 CODA9_REG_JPEG_RST_INTVAL);
1151 coda_write(dev, 1, CODA9_REG_JPEG_BBC_CTRL);
1153 coda_write(dev, bus_req_num[chroma_format], CODA9_REG_JPEG_OP_INFO);
1155 coda9_jpeg_write_huff_tab(ctx);
1156 coda9_jpeg_load_qmat_tab(ctx);
1158 if (ctx->params.rot_mode & CODA_ROT_90) {
1159 aligned_width = aligned_height;
1160 aligned_height = q_data_src->bytesperline;
1161 if (chroma_format == CODA9_JPEG_FORMAT_422)
1162 chroma_format = CODA9_JPEG_FORMAT_224;
1163 else if (chroma_format == CODA9_JPEG_FORMAT_224)
1164 chroma_format = CODA9_JPEG_FORMAT_422;
1166 /* These need to be multiples of MCU size */
1167 coda_write(dev, aligned_width << 16 | aligned_height,
1168 CODA9_REG_JPEG_PIC_SIZE);
1169 coda_write(dev, ctx->params.rot_mode ?
1170 (CODA_ROT_MIR_ENABLE | ctx->params.rot_mode) : 0,
1171 CODA9_REG_JPEG_ROT_INFO);
1173 coda_write(dev, mcu_info[chroma_format], CODA9_REG_JPEG_MCU_INFO);
1175 coda_write(dev, 1, CODA9_GDI_CONTROL);
1176 timeout = ktime_add_us(ktime_get(), 100000);
1178 ret = coda_read(dev, CODA9_GDI_STATUS);
1179 if (ktime_compare(ktime_get(), timeout) > 0) {
1180 v4l2_err(&dev->v4l2_dev, "timeout waiting for GDI\n");
1185 coda_write(dev, (chroma_format << 17) | (chroma_interleave << 16) |
1186 q_data_src->bytesperline, CODA9_GDI_INFO_CONTROL);
1187 /* The content of this register seems to be irrelevant: */
1188 coda_write(dev, aligned_width << 16 | aligned_height,
1189 CODA9_GDI_INFO_PIC_SIZE);
1191 coda_write_base(ctx, q_data_src, src_buf, CODA9_GDI_INFO_BASE_Y);
1193 coda_write(dev, 0, CODA9_REG_JPEG_DPB_BASE00);
1194 coda_write(dev, 0, CODA9_GDI_CONTROL);
1195 coda_write(dev, 1, CODA9_GDI_PIC_INIT_HOST);
1197 coda_write(dev, 1, CODA9_GDI_WPROT_ERR_CLR);
1198 coda_write(dev, 0, CODA9_GDI_WPROT_RGN_EN);
1200 trace_coda_jpeg_run(ctx, src_buf);
1202 coda_write(dev, 1, CODA9_REG_JPEG_PIC_START);
1207 static void coda9_jpeg_finish_encode(struct coda_ctx *ctx)
1209 struct vb2_v4l2_buffer *src_buf, *dst_buf;
1210 struct coda_dev *dev = ctx->dev;
1211 u32 wr_ptr, start_ptr;
1214 if (ctx->aborting) {
1215 coda_write(ctx->dev, 0, CODA9_REG_JPEG_BBC_FLUSH_CMD);
1220 * Lock to make sure that an encoder stop command running in parallel
1221 * will either already have marked src_buf as last, or it will wake up
1222 * the capture queue after the buffers are returned.
1224 mutex_lock(&ctx->wakeup_mutex);
1225 src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
1226 dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
1228 trace_coda_jpeg_done(ctx, dst_buf);
1231 * Set plane payload to the number of bytes written out
1232 * by the JPEG processing unit
1234 start_ptr = vb2_dma_contig_plane_dma_addr(&dst_buf->vb2_buf, 0);
1235 wr_ptr = coda_read(dev, CODA9_REG_JPEG_BBC_WR_PTR);
1236 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, wr_ptr - start_ptr);
1238 err_mb = coda_read(dev, CODA9_REG_JPEG_PIC_ERRMB);
1240 coda_dbg(1, ctx, "ERRMB: 0x%x\n", err_mb);
1242 coda_write(dev, 0, CODA9_REG_JPEG_BBC_FLUSH_CMD);
1244 dst_buf->flags &= ~(V4L2_BUF_FLAG_PFRAME | V4L2_BUF_FLAG_LAST);
1245 dst_buf->flags |= V4L2_BUF_FLAG_KEYFRAME;
1246 dst_buf->flags |= src_buf->flags & V4L2_BUF_FLAG_LAST;
1248 v4l2_m2m_buf_copy_metadata(src_buf, dst_buf, false);
1250 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_DONE);
1251 coda_m2m_buf_done(ctx, dst_buf, err_mb ? VB2_BUF_STATE_ERROR :
1252 VB2_BUF_STATE_DONE);
1253 mutex_unlock(&ctx->wakeup_mutex);
1255 coda_dbg(1, ctx, "job finished: encoded frame (%u)%s\n",
1257 (dst_buf->flags & V4L2_BUF_FLAG_LAST) ? " (last)" : "");
1260 * Reset JPEG processing unit after each encode run to work
1261 * around hangups when switching context between encoder and
1267 static void coda9_jpeg_encode_timeout(struct coda_ctx *ctx)
1269 struct coda_dev *dev = ctx->dev;
1270 u32 end_addr, wr_ptr;
1272 /* Handle missing BBC overflow interrupt via timeout */
1273 end_addr = coda_read(dev, CODA9_REG_JPEG_BBC_END_ADDR);
1274 wr_ptr = coda_read(dev, CODA9_REG_JPEG_BBC_WR_PTR);
1275 if (wr_ptr >= end_addr - 256) {
1276 v4l2_err(&dev->v4l2_dev, "JPEG too large for capture buffer\n");
1277 coda9_jpeg_finish_encode(ctx);
1284 static void coda9_jpeg_release(struct coda_ctx *ctx)
1288 if (ctx->params.jpeg_qmat_tab[0] == luma_q)
1289 ctx->params.jpeg_qmat_tab[0] = NULL;
1290 if (ctx->params.jpeg_qmat_tab[1] == chroma_q)
1291 ctx->params.jpeg_qmat_tab[1] = NULL;
1292 for (i = 0; i < 3; i++)
1293 kfree(ctx->params.jpeg_qmat_tab[i]);
1294 kfree(ctx->params.jpeg_huff_data);
1295 kfree(ctx->params.jpeg_huff_tab);
1298 const struct coda_context_ops coda9_jpeg_encode_ops = {
1299 .queue_init = coda_encoder_queue_init,
1300 .start_streaming = coda9_jpeg_start_encoding,
1301 .prepare_run = coda9_jpeg_prepare_encode,
1302 .finish_run = coda9_jpeg_finish_encode,
1303 .run_timeout = coda9_jpeg_encode_timeout,
1304 .release = coda9_jpeg_release,
1308 * Decoder context operations
1311 static int coda9_jpeg_start_decoding(struct coda_ctx *ctx)
1313 ctx->params.jpeg_qmat_index[0] = 0;
1314 ctx->params.jpeg_qmat_index[1] = 1;
1315 ctx->params.jpeg_qmat_index[2] = 1;
1316 ctx->params.jpeg_qmat_tab[0] = luma_q;
1317 ctx->params.jpeg_qmat_tab[1] = chroma_q;
1318 /* nothing more to do here */
1320 /* TODO: we could already scan the first header to get the chroma
1327 static int coda9_jpeg_prepare_decode(struct coda_ctx *ctx)
1329 struct coda_dev *dev = ctx->dev;
1330 int aligned_width, aligned_height;
1333 u32 val, dst_fourcc;
1334 struct coda_q_data *q_data_src, *q_data_dst;
1335 struct vb2_v4l2_buffer *src_buf, *dst_buf;
1336 int chroma_interleave;
1338 src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
1339 dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
1340 q_data_src = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
1341 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
1342 dst_fourcc = q_data_dst->fourcc;
1344 if (vb2_get_plane_payload(&src_buf->vb2_buf, 0) == 0)
1345 vb2_set_plane_payload(&src_buf->vb2_buf, 0,
1346 vb2_plane_size(&src_buf->vb2_buf, 0));
1348 chroma_format = coda9_jpeg_chroma_format(q_data_dst->fourcc);
1349 if (chroma_format < 0) {
1350 v4l2_m2m_job_finish(ctx->dev->m2m_dev, ctx->fh.m2m_ctx);
1351 return chroma_format;
1354 ret = coda_jpeg_decode_header(ctx, &src_buf->vb2_buf);
1356 v4l2_err(&dev->v4l2_dev, "failed to decode JPEG header: %d\n",
1359 src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
1360 dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
1361 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_DONE);
1362 v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_DONE);
1364 v4l2_m2m_job_finish(ctx->dev->m2m_dev, ctx->fh.m2m_ctx);
1368 /* Round image dimensions to multiple of MCU size */
1369 aligned_width = round_up(q_data_src->width, width_align[chroma_format]);
1370 aligned_height = round_up(q_data_src->height, height_align[chroma_format]);
1371 if (aligned_width != q_data_dst->bytesperline) {
1372 v4l2_err(&dev->v4l2_dev, "stride mismatch: %d != %d\n",
1373 aligned_width, q_data_dst->bytesperline);
1376 coda_set_gdi_regs(ctx);
1378 val = ctx->params.jpeg_huff_ac_index[0] << 12 |
1379 ctx->params.jpeg_huff_ac_index[1] << 11 |
1380 ctx->params.jpeg_huff_ac_index[2] << 10 |
1381 ctx->params.jpeg_huff_dc_index[0] << 9 |
1382 ctx->params.jpeg_huff_dc_index[1] << 8 |
1383 ctx->params.jpeg_huff_dc_index[2] << 7;
1384 if (ctx->params.jpeg_huff_tab)
1385 val |= CODA9_JPEG_PIC_CTRL_USER_HUFFMAN_EN;
1386 coda_write(dev, val, CODA9_REG_JPEG_PIC_CTRL);
1388 coda_write(dev, aligned_width << 16 | aligned_height,
1389 CODA9_REG_JPEG_PIC_SIZE);
1391 chroma_interleave = (dst_fourcc == V4L2_PIX_FMT_NV12);
1392 coda_write(dev, 0, CODA9_REG_JPEG_ROT_INFO);
1393 coda_write(dev, bus_req_num[chroma_format], CODA9_REG_JPEG_OP_INFO);
1394 coda_write(dev, mcu_info[chroma_format], CODA9_REG_JPEG_MCU_INFO);
1395 coda_write(dev, 0, CODA9_REG_JPEG_SCL_INFO);
1396 coda_write(dev, chroma_interleave, CODA9_REG_JPEG_DPB_CONFIG);
1397 coda_write(dev, ctx->params.jpeg_restart_interval,
1398 CODA9_REG_JPEG_RST_INTVAL);
1400 if (ctx->params.jpeg_huff_tab) {
1401 ret = coda9_jpeg_dec_huff_setup(ctx);
1403 v4l2_err(&dev->v4l2_dev,
1404 "failed to set up Huffman tables: %d\n", ret);
1405 v4l2_m2m_job_finish(ctx->dev->m2m_dev, ctx->fh.m2m_ctx);
1410 coda9_jpeg_qmat_setup(ctx);
1412 coda9_jpeg_dec_bbc_gbu_setup(ctx, &src_buf->vb2_buf,
1413 ctx->jpeg_ecs_offset);
1415 coda_write(dev, 0, CODA9_REG_JPEG_RST_INDEX);
1416 coda_write(dev, 0, CODA9_REG_JPEG_RST_COUNT);
1418 coda_write(dev, 0, CODA9_REG_JPEG_DPCM_DIFF_Y);
1419 coda_write(dev, 0, CODA9_REG_JPEG_DPCM_DIFF_CB);
1420 coda_write(dev, 0, CODA9_REG_JPEG_DPCM_DIFF_CR);
1422 coda_write(dev, 0, CODA9_REG_JPEG_ROT_INFO);
1424 coda_write(dev, 1, CODA9_GDI_CONTROL);
1426 ret = coda_read(dev, CODA9_GDI_STATUS);
1429 val = (chroma_format << 17) | (chroma_interleave << 16) |
1430 q_data_dst->bytesperline;
1431 if (ctx->tiled_map_type == GDI_TILED_FRAME_MB_RASTER_MAP)
1433 coda_write(dev, val, CODA9_GDI_INFO_CONTROL);
1435 coda_write(dev, aligned_width << 16 | aligned_height,
1436 CODA9_GDI_INFO_PIC_SIZE);
1438 coda_write_base(ctx, q_data_dst, dst_buf, CODA9_GDI_INFO_BASE_Y);
1440 coda_write(dev, 0, CODA9_REG_JPEG_DPB_BASE00);
1441 coda_write(dev, 0, CODA9_GDI_CONTROL);
1442 coda_write(dev, 1, CODA9_GDI_PIC_INIT_HOST);
1444 trace_coda_jpeg_run(ctx, src_buf);
1446 coda_write(dev, 1, CODA9_REG_JPEG_PIC_START);
1451 static void coda9_jpeg_finish_decode(struct coda_ctx *ctx)
1453 struct coda_dev *dev = ctx->dev;
1454 struct vb2_v4l2_buffer *dst_buf, *src_buf;
1455 struct coda_q_data *q_data_dst;
1458 err_mb = coda_read(dev, CODA9_REG_JPEG_PIC_ERRMB);
1460 v4l2_err(&dev->v4l2_dev, "ERRMB: 0x%x\n", err_mb);
1462 coda_write(dev, 0, CODA9_REG_JPEG_BBC_FLUSH_CMD);
1465 * Lock to make sure that a decoder stop command running in parallel
1466 * will either already have marked src_buf as last, or it will wake up
1467 * the capture queue after the buffers are returned.
1469 mutex_lock(&ctx->wakeup_mutex);
1470 src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
1471 dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
1472 dst_buf->sequence = ctx->osequence++;
1474 trace_coda_jpeg_done(ctx, dst_buf);
1476 dst_buf->flags &= ~(V4L2_BUF_FLAG_PFRAME | V4L2_BUF_FLAG_LAST);
1477 dst_buf->flags |= V4L2_BUF_FLAG_KEYFRAME;
1478 dst_buf->flags |= src_buf->flags & V4L2_BUF_FLAG_LAST;
1480 v4l2_m2m_buf_copy_metadata(src_buf, dst_buf, false);
1482 q_data_dst = get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
1483 vb2_set_plane_payload(&dst_buf->vb2_buf, 0, q_data_dst->sizeimage);
1485 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_DONE);
1486 coda_m2m_buf_done(ctx, dst_buf, err_mb ? VB2_BUF_STATE_ERROR :
1487 VB2_BUF_STATE_DONE);
1489 mutex_unlock(&ctx->wakeup_mutex);
1491 coda_dbg(1, ctx, "job finished: decoded frame (%u)%s\n",
1493 (dst_buf->flags & V4L2_BUF_FLAG_LAST) ? " (last)" : "");
1496 * Reset JPEG processing unit after each decode run to work
1497 * around hangups when switching context between encoder and
1503 const struct coda_context_ops coda9_jpeg_decode_ops = {
1504 .queue_init = coda_encoder_queue_init, /* non-bitstream operation */
1505 .start_streaming = coda9_jpeg_start_decoding,
1506 .prepare_run = coda9_jpeg_prepare_decode,
1507 .finish_run = coda9_jpeg_finish_decode,
1508 .release = coda9_jpeg_release,
1511 irqreturn_t coda9_jpeg_irq_handler(int irq, void *data)
1513 struct coda_dev *dev = data;
1514 struct coda_ctx *ctx;
1518 status = coda_read(dev, CODA9_REG_JPEG_PIC_STATUS);
1521 coda_write(dev, status, CODA9_REG_JPEG_PIC_STATUS);
1523 if (status & CODA9_JPEG_STATUS_OVERFLOW)
1524 v4l2_err(&dev->v4l2_dev, "JPEG overflow\n");
1526 if (status & CODA9_JPEG_STATUS_BBC_INT)
1527 v4l2_err(&dev->v4l2_dev, "JPEG BBC interrupt\n");
1529 if (status & CODA9_JPEG_STATUS_ERROR) {
1530 v4l2_err(&dev->v4l2_dev, "JPEG error\n");
1532 err_mb = coda_read(dev, CODA9_REG_JPEG_PIC_ERRMB);
1534 v4l2_err(&dev->v4l2_dev,
1535 "ERRMB: 0x%x: rst idx %d, mcu pos (%d,%d)\n",
1536 err_mb, err_mb >> 24, (err_mb >> 12) & 0xfff,
1541 ctx = v4l2_m2m_get_curr_priv(dev->m2m_dev);
1543 v4l2_err(&dev->v4l2_dev,
1544 "Instance released before the end of transaction\n");
1545 mutex_unlock(&dev->coda_mutex);
1549 complete(&ctx->completion);