1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * V4L2 driver for the JPEG encoder/decoder from i.MX8QXP/i.MX8QM application
4  * processors.
5  *
6  * The multi-planar buffers API is used.
7  *
8  * Baseline and extended sequential jpeg decoding is supported.
9  * Progressive jpeg decoding is not supported by the IP.
10  * Supports encode and decode of various formats:
11  *     YUV444, YUV422, YUV420, BGR, ABGR, Gray
12  * YUV420 is the only multi-planar format supported.
13  * Minimum resolution is 64 x 64, maximum 8192 x 8192.
14  * To achieve 8192 x 8192, modify in defconfig: CONFIG_CMA_SIZE_MBYTES=320
15  * The alignment requirements for the resolution depend on the format,
16  * multiple of 16 resolutions should work for all formats.
17  * Special workarounds are made in the driver to support NV12 1080p.
18  * When decoding, the driver detects image resolution and pixel format
19  * from the jpeg stream, by parsing the jpeg markers.
20  *
21  * The IP has 4 slots available for context switching, but only slot 0
22  * was fully tested to work. Context switching is not used by the driver.
23  * Each driver instance (context) allocates a slot for itself, but this
24  * is postponed until device_run, to allow unlimited opens.
25  *
26  * The driver submits jobs to the IP by setting up a descriptor for the
27  * used slot, and then validating it. The encoder has an additional descriptor
28  * for the configuration phase. The driver expects FRM_DONE interrupt from
29  * IP to mark the job as finished.
30  *
31  * The decoder IP has some limitations regarding the component ID's,
32  * but the driver works around this by replacing them in the jpeg stream.
33  *
34  * A module parameter is available for debug purpose (jpeg_tracing), to enable
35  * it, enable dynamic debug for this module and:
36  * echo 1 > /sys/module/mxc_jpeg_encdec/parameters/jpeg_tracing
37  *
38  * This is inspired by the drivers/media/platform/samsung/s5p-jpeg driver
39  *
40  * Copyright 2018-2019 NXP
41  */
42 
43 #include <linux/kernel.h>
44 #include <linux/module.h>
45 #include <linux/io.h>
46 #include <linux/clk.h>
47 #include <linux/of_platform.h>
48 #include <linux/platform_device.h>
49 #include <linux/slab.h>
50 #include <linux/irqreturn.h>
51 #include <linux/interrupt.h>
52 #include <linux/pm_runtime.h>
53 #include <linux/pm_domain.h>
54 #include <linux/string.h>
55 
56 #include <media/v4l2-jpeg.h>
57 #include <media/v4l2-mem2mem.h>
58 #include <media/v4l2-ioctl.h>
59 #include <media/v4l2-common.h>
60 #include <media/v4l2-event.h>
61 #include <media/videobuf2-dma-contig.h>
62 
63 #include "mxc-jpeg-hw.h"
64 #include "mxc-jpeg.h"
65 
66 static const struct mxc_jpeg_fmt mxc_formats[] = {
67 	{
68 		.name		= "JPEG",
69 		.fourcc		= V4L2_PIX_FMT_JPEG,
70 		.subsampling	= -1,
71 		.nc		= -1,
72 		.mem_planes	= 1,
73 		.comp_planes	= 1,
74 		.flags		= MXC_JPEG_FMT_TYPE_ENC,
75 	},
76 	{
77 		.name		= "BGR", /*BGR packed format*/
78 		.fourcc		= V4L2_PIX_FMT_BGR24,
79 		.subsampling	= V4L2_JPEG_CHROMA_SUBSAMPLING_444,
80 		.nc		= 3,
81 		.depth		= 24,
82 		.mem_planes	= 1,
83 		.comp_planes	= 1,
84 		.h_align	= 3,
85 		.v_align	= 3,
86 		.flags		= MXC_JPEG_FMT_TYPE_RAW,
87 		.precision	= 8,
88 		.is_rgb		= 1,
89 	},
90 	{
91 		.name		= "BGR 12bit", /*12-bit BGR packed format*/
92 		.fourcc		= V4L2_PIX_FMT_BGR48_12,
93 		.subsampling	= V4L2_JPEG_CHROMA_SUBSAMPLING_444,
94 		.nc		= 3,
95 		.depth		= 36,
96 		.mem_planes	= 1,
97 		.comp_planes	= 1,
98 		.h_align	= 3,
99 		.v_align	= 3,
100 		.flags		= MXC_JPEG_FMT_TYPE_RAW,
101 		.precision	= 12,
102 		.is_rgb		= 1,
103 	},
104 	{
105 		.name		= "ABGR", /* ABGR packed format */
106 		.fourcc		= V4L2_PIX_FMT_ABGR32,
107 		.subsampling	= V4L2_JPEG_CHROMA_SUBSAMPLING_444,
108 		.nc		= 4,
109 		.depth		= 32,
110 		.mem_planes	= 1,
111 		.comp_planes	= 1,
112 		.h_align	= 3,
113 		.v_align	= 3,
114 		.flags		= MXC_JPEG_FMT_TYPE_RAW,
115 		.precision	= 8,
116 		.is_rgb		= 1,
117 	},
118 	{
119 		.name		= "ABGR 12bit", /* 12-bit ABGR packed format */
120 		.fourcc		= V4L2_PIX_FMT_ABGR64_12,
121 		.subsampling	= V4L2_JPEG_CHROMA_SUBSAMPLING_444,
122 		.nc		= 4,
123 		.depth		= 48,
124 		.mem_planes	= 1,
125 		.comp_planes	= 1,
126 		.h_align	= 3,
127 		.v_align	= 3,
128 		.flags		= MXC_JPEG_FMT_TYPE_RAW,
129 		.precision	= 12,
130 		.is_rgb		= 1,
131 	},
132 	{
133 		.name		= "YUV420", /* 1st plane = Y, 2nd plane = UV */
134 		.fourcc		= V4L2_PIX_FMT_NV12M,
135 		.subsampling	= V4L2_JPEG_CHROMA_SUBSAMPLING_420,
136 		.nc		= 3,
137 		.depth		= 12, /* 6 bytes (4Y + UV) for 4 pixels */
138 		.mem_planes	= 2,
139 		.comp_planes	= 2, /* 1 plane Y, 1 plane UV interleaved */
140 		.h_align	= 4,
141 		.v_align	= 4,
142 		.flags		= MXC_JPEG_FMT_TYPE_RAW,
143 		.precision	= 8,
144 	},
145 	{
146 		.name		= "YUV420", /* 1st plane = Y, 2nd plane = UV */
147 		.fourcc		= V4L2_PIX_FMT_NV12,
148 		.subsampling	= V4L2_JPEG_CHROMA_SUBSAMPLING_420,
149 		.nc		= 3,
150 		.depth		= 12, /* 6 bytes (4Y + UV) for 4 pixels */
151 		.mem_planes	= 1,
152 		.comp_planes	= 2, /* 1 plane Y, 1 plane UV interleaved */
153 		.h_align	= 4,
154 		.v_align	= 4,
155 		.flags		= MXC_JPEG_FMT_TYPE_RAW,
156 		.precision	= 8,
157 	},
158 	{
159 		.name		= "YUV420 12bit", /* 1st plane = Y, 2nd plane = UV */
160 		.fourcc		= V4L2_PIX_FMT_P012M,
161 		.subsampling	= V4L2_JPEG_CHROMA_SUBSAMPLING_420,
162 		.nc		= 3,
163 		.depth		= 18, /* 6 x 12 bits (4Y + UV) for 4 pixels */
164 		.mem_planes	= 2,
165 		.comp_planes	= 2, /* 1 plane Y, 1 plane UV interleaved */
166 		.h_align	= 4,
167 		.v_align	= 4,
168 		.flags		= MXC_JPEG_FMT_TYPE_RAW,
169 		.precision	= 12,
170 	},
171 	{
172 		.name		= "YUV420 12bit", /* 1st plane = Y, 2nd plane = UV */
173 		.fourcc		= V4L2_PIX_FMT_P012,
174 		.subsampling	= V4L2_JPEG_CHROMA_SUBSAMPLING_420,
175 		.nc		= 3,
176 		.depth		= 18, /* 6 x 12 bits (4Y + UV) for 4 pixels */
177 		.mem_planes	= 1,
178 		.comp_planes	= 2, /* 1 plane Y, 1 plane UV interleaved */
179 		.h_align	= 4,
180 		.v_align	= 4,
181 		.flags		= MXC_JPEG_FMT_TYPE_RAW,
182 		.precision	= 12,
183 	},
184 	{
185 		.name		= "YUV422", /* YUYV */
186 		.fourcc		= V4L2_PIX_FMT_YUYV,
187 		.subsampling	= V4L2_JPEG_CHROMA_SUBSAMPLING_422,
188 		.nc		= 3,
189 		.depth		= 16,
190 		.mem_planes	= 1,
191 		.comp_planes	= 1,
192 		.h_align	= 4,
193 		.v_align	= 3,
194 		.flags		= MXC_JPEG_FMT_TYPE_RAW,
195 		.precision	= 8,
196 	},
197 	{
198 		.name		= "YUV422 12bit", /* YUYV */
199 		.fourcc		= V4L2_PIX_FMT_Y212,
200 		.subsampling	= V4L2_JPEG_CHROMA_SUBSAMPLING_422,
201 		.nc		= 3,
202 		.depth		= 24,
203 		.mem_planes	= 1,
204 		.comp_planes	= 1,
205 		.h_align	= 4,
206 		.v_align	= 3,
207 		.flags		= MXC_JPEG_FMT_TYPE_RAW,
208 		.precision	= 12,
209 	},
210 	{
211 		.name		= "YUV444", /* YUVYUV */
212 		.fourcc		= V4L2_PIX_FMT_YUV24,
213 		.subsampling	= V4L2_JPEG_CHROMA_SUBSAMPLING_444,
214 		.nc		= 3,
215 		.depth		= 24,
216 		.mem_planes	= 1,
217 		.comp_planes	= 1,
218 		.h_align	= 3,
219 		.v_align	= 3,
220 		.flags		= MXC_JPEG_FMT_TYPE_RAW,
221 		.precision	= 8,
222 	},
223 	{
224 		.name		= "YUV444 12bit", /* YUVYUV */
225 		.fourcc		= V4L2_PIX_FMT_YUV48_12,
226 		.subsampling	= V4L2_JPEG_CHROMA_SUBSAMPLING_444,
227 		.nc		= 3,
228 		.depth		= 36,
229 		.mem_planes	= 1,
230 		.comp_planes	= 1,
231 		.h_align	= 3,
232 		.v_align	= 3,
233 		.flags		= MXC_JPEG_FMT_TYPE_RAW,
234 		.precision	= 12,
235 	},
236 	{
237 		.name		= "Gray", /* Gray (Y8/Y12) or Single Comp */
238 		.fourcc		= V4L2_PIX_FMT_GREY,
239 		.subsampling	= V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY,
240 		.nc		= 1,
241 		.depth		= 8,
242 		.mem_planes	= 1,
243 		.comp_planes	= 1,
244 		.h_align	= 3,
245 		.v_align	= 3,
246 		.flags		= MXC_JPEG_FMT_TYPE_RAW,
247 		.precision	= 8,
248 	},
249 	{
250 		.name		= "Gray 12bit", /* Gray (Y8/Y12) or Single Comp */
251 		.fourcc		= V4L2_PIX_FMT_Y012,
252 		.subsampling	= V4L2_JPEG_CHROMA_SUBSAMPLING_GRAY,
253 		.nc		= 1,
254 		.depth		= 12,
255 		.mem_planes	= 1,
256 		.comp_planes	= 1,
257 		.h_align	= 3,
258 		.v_align	= 3,
259 		.flags		= MXC_JPEG_FMT_TYPE_RAW,
260 		.precision	= 12,
261 	},
262 };
263 
264 #define MXC_JPEG_NUM_FORMATS ARRAY_SIZE(mxc_formats)
265 
266 static const int mxc_decode_mode = MXC_JPEG_DECODE;
267 static const int mxc_encode_mode = MXC_JPEG_ENCODE;
268 
269 static const struct of_device_id mxc_jpeg_match[] = {
270 	{
271 		.compatible = "nxp,imx8qxp-jpgdec",
272 		.data       = &mxc_decode_mode,
273 	},
274 	{
275 		.compatible = "nxp,imx8qxp-jpgenc",
276 		.data       = &mxc_encode_mode,
277 	},
278 	{ },
279 };
280 
281 /*
282  * default configuration stream, 64x64 yuv422
283  * split by JPEG marker, so it's easier to modify & use
284  */
285 static const unsigned char jpeg_soi[] = {
286 	0xFF, 0xD8
287 };
288 
289 static const unsigned char jpeg_app0[] = {
290 	0xFF, 0xE0,
291 	0x00, 0x10, 0x4A, 0x46, 0x49, 0x46, 0x00,
292 	0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01,
293 	0x00, 0x00
294 };
295 
296 static const unsigned char jpeg_app14[] = {
297 	0xFF, 0xEE,
298 	0x00, 0x0E, 0x41, 0x64, 0x6F, 0x62, 0x65,
299 	0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00
300 };
301 
302 static const unsigned char jpeg_dqt[] = {
303 	0xFF, 0xDB,
304 	0x00, 0x84, 0x00, 0x10, 0x0B, 0x0C, 0x0E,
305 	0x0C, 0x0A, 0x10, 0x0E, 0x0D, 0x0E, 0x12,
306 	0x11, 0x10, 0x13, 0x18, 0x28, 0x1A, 0x18,
307 	0x16, 0x16, 0x18, 0x31, 0x23, 0x25, 0x1D,
308 	0x28, 0x3A, 0x33, 0x3D, 0x3C, 0x39, 0x33,
309 	0x38, 0x37, 0x40, 0x48, 0x5C, 0x4E, 0x40,
310 	0x44, 0x57, 0x45, 0x37, 0x38, 0x50, 0x6D,
311 	0x51, 0x57, 0x5F, 0x62, 0x67, 0x68, 0x67,
312 	0x3E, 0x4D, 0x71, 0x79, 0x70, 0x64, 0x78,
313 	0x5C, 0x65, 0x67, 0x63, 0x01, 0x11, 0x12,
314 	0x12, 0x18, 0x15, 0x18, 0x2F, 0x1A, 0x1A,
315 	0x2F, 0x63, 0x42, 0x38, 0x42, 0x63, 0x63,
316 	0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
317 	0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
318 	0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
319 	0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
320 	0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
321 	0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
322 	0x63, 0x63, 0x63, 0x63, 0x63, 0x63
323 };
324 
325 static const unsigned char jpeg_dqt_extseq[] = {
326 	0xFF, 0xDB,
327 	0x01, 0x04,
328 	0x10,
329 	0x00, 0x80, 0x00, 0x58, 0x00, 0x60, 0x00, 0x70,
330 	0x00, 0x60, 0x00, 0x50, 0x00, 0x80, 0x00, 0x70,
331 	0x00, 0x68, 0x00, 0x70, 0x00, 0x90, 0x00, 0x88,
332 	0x00, 0x80, 0x00, 0x98, 0x00, 0xC0, 0x01, 0x40,
333 	0x00, 0xD0, 0x00, 0xC0, 0x00, 0xB0, 0x00, 0xB0,
334 	0x00, 0xC0, 0x01, 0x88, 0x01, 0x18, 0x01, 0x28,
335 	0x00, 0xE8, 0x01, 0x40, 0x01, 0xD0, 0x01, 0x98,
336 	0x01, 0xE8, 0x01, 0xE0, 0x01, 0xC8, 0x01, 0x98,
337 	0x01, 0xC0, 0x01, 0xB8, 0x02, 0x00, 0x02, 0x40,
338 	0x02, 0xE0, 0x02, 0x70, 0x02, 0x00, 0x02, 0x20,
339 	0x02, 0xB8, 0x02, 0x28, 0x01, 0xB8, 0x01, 0xC0,
340 	0x02, 0x80, 0x03, 0x68, 0x02, 0x88, 0x02, 0xB8,
341 	0x02, 0xF8, 0x03, 0x10, 0x03, 0x38, 0x03, 0x40,
342 	0x03, 0x38, 0x01, 0xF0, 0x02, 0x68, 0x03, 0x88,
343 	0x03, 0xC8, 0x03, 0x80, 0x03, 0x20, 0x03, 0xC0,
344 	0x02, 0xE0, 0x03, 0x28, 0x03, 0x38, 0x03, 0x18,
345 	0x11,
346 	0x00, 0x88, 0x00, 0x90, 0x00, 0x90, 0x00, 0xC0,
347 	0x00, 0xA8, 0x00, 0xC0, 0x01, 0x78, 0x00, 0xD0,
348 	0x00, 0xD0, 0x01, 0x78, 0x03, 0x18, 0x02, 0x10,
349 	0x01, 0xC0, 0x02, 0x10, 0x03, 0x18, 0x03, 0x18,
350 	0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18,
351 	0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18,
352 	0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18,
353 	0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18,
354 	0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18,
355 	0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18,
356 	0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18,
357 	0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18,
358 	0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18,
359 	0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18,
360 	0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18,
361 	0x03, 0x18, 0x03, 0x18, 0x03, 0x18, 0x03, 0x18,
362 };
363 
364 static const unsigned char jpeg_sof_maximal[] = {
365 	0xFF, 0xC0,
366 	0x00, 0x14, 0x08, 0x00, 0x40, 0x00, 0x40,
367 	0x04, 0x01, 0x11, 0x00, 0x02, 0x11, 0x01,
368 	0x03, 0x11, 0x01, 0x04, 0x11, 0x01
369 };
370 
371 static const unsigned char jpeg_sof_extseq[] = {
372 	0xFF, 0xC1,
373 	0x00, 0x14, 0x08, 0x00, 0x40, 0x00, 0x40,
374 	0x04, 0x01, 0x11, 0x00, 0x02, 0x11, 0x01,
375 	0x03, 0x11, 0x01, 0x04, 0x11, 0x01
376 };
377 
378 static const unsigned char jpeg_dht[] = {
379 	0xFF, 0xC4,
380 	0x01, 0xA2, 0x00, 0x00, 0x01, 0x05, 0x01,
381 	0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,
382 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
383 	0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
384 	0x09, 0x0A, 0x0B, 0x10, 0x00, 0x02, 0x01,
385 	0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05,
386 	0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01,
387 	0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
388 	0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61,
389 	0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91,
390 	0xA1, 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15,
391 	0x52, 0xD1, 0xF0, 0x24, 0x33, 0x62, 0x72,
392 	0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19,
393 	0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A,
394 	0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A,
395 	0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
396 	0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
397 	0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67,
398 	0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76,
399 	0x77, 0x78, 0x79, 0x7A, 0x83, 0x84, 0x85,
400 	0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93,
401 	0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A,
402 	0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
403 	0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6,
404 	0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4,
405 	0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2,
406 	0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9,
407 	0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6,
408 	0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3,
409 	0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA,
410 	0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01,
411 	0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,
412 	0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03,
413 	0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A,
414 	0x0B, 0x11, 0x00, 0x02, 0x01, 0x02, 0x04,
415 	0x04, 0x03, 0x04, 0x07, 0x05, 0x04, 0x04,
416 	0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02,
417 	0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06,
418 	0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 0x13,
419 	0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
420 	0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52,
421 	0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16,
422 	0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18,
423 	0x19, 0x1A, 0x26, 0x27, 0x28, 0x29, 0x2A,
424 	0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43,
425 	0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A,
426 	0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
427 	0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
428 	0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77,
429 	0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85,
430 	0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93,
431 	0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A,
432 	0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
433 	0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6,
434 	0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4,
435 	0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2,
436 	0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9,
437 	0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
438 	0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5,
439 	0xF6, 0xF7, 0xF8, 0xF9, 0xFA
440 };
441 
442 static const unsigned char jpeg_dht_extseq[] = {
443 	0xFF, 0xC4,
444 	0x02, 0x2a, 0x00, 0x00, 0x01, 0x05, 0x01,
445 	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
446 	0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01,
447 	0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
448 	0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
449 	0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02,
450 	0x04, 0x03, 0x05, 0x05, 0x02, 0x03, 0x02,
451 	0x00, 0x00, 0xbf, 0x01, 0x02, 0x03, 0x00,
452 	0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41,
453 	0x06, 0x13, 0x51, 0x61, 0x07, 0x22, 0x71,
454 	0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 0x23,
455 	0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
456 	0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a,
457 	0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26,
458 	0x27, 0x28, 0x29, 0x2a, 0x34, 0x35, 0x36,
459 	0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45,
460 	0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54,
461 	0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x63,
462 	0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
463 	0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
464 	0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88,
465 	0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
466 	0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4,
467 	0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2,
468 	0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
469 	0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
470 	0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5,
471 	0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
472 	0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
473 	0xea, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6,
474 	0xf7, 0xf8, 0xf9, 0xfa, 0x0b, 0x0c, 0x0d,
475 	0x0e, 0x1b, 0x1c, 0x1d, 0x1e, 0x2b, 0x2c,
476 	0x2d, 0x2e, 0x3b, 0x3c, 0x3d, 0x3e, 0x4b,
477 	0x4c, 0x4d, 0x4e, 0x5b, 0x5c, 0x5d, 0x5e,
478 	0x6b, 0x6c, 0x6d, 0x6e, 0x7b, 0x7c, 0x7d,
479 	0x7e, 0x8b, 0x8c, 0x8d, 0x8e, 0x9b, 0x9c,
480 	0x9d, 0x9e, 0xab, 0xac, 0xad, 0xae, 0xbb,
481 	0xbc, 0xbd, 0xbe, 0xcb, 0xcc, 0xcd, 0xce,
482 	0xdb, 0xdc, 0xdd, 0xde, 0xeb, 0xec, 0xed,
483 	0xee, 0xfb, 0xfc, 0xfd, 0xfe, 0x01, 0x00,
484 	0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01,
485 	0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,
486 	0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
487 	0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c,
488 	0x0d, 0x0e, 0x0f, 0x11, 0x00, 0x02, 0x01,
489 	0x03, 0x03, 0x02, 0x04, 0x03, 0x05, 0x05,
490 	0x02, 0x03, 0x02, 0x00, 0x00, 0xbf, 0x01,
491 	0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
492 	0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61,
493 	0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91,
494 	0xa1, 0x08, 0x23, 0x42, 0xb1, 0xc1, 0x15,
495 	0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72,
496 	0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19,
497 	0x1a, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
498 	0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a,
499 	0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
500 	0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
501 	0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67,
502 	0x68, 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76,
503 	0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85,
504 	0x86, 0x87, 0x88, 0x89, 0x8a, 0x92, 0x93,
505 	0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a,
506 	0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8,
507 	0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
508 	0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4,
509 	0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
510 	0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9,
511 	0xda, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6,
512 	0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3,
513 	0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa,
514 	0x0b, 0x0c, 0x0d, 0x0e, 0x1b, 0x1c, 0x1d,
515 	0x1e, 0x2b, 0x2c, 0x2d, 0x2e, 0x3b, 0x3c,
516 	0x3d, 0x3e, 0x4b, 0x4c, 0x4d, 0x4e, 0x5b,
517 	0x5c, 0x5d, 0x5e, 0x6b, 0x6c, 0x6d, 0x6e,
518 	0x7b, 0x7c, 0x7d, 0x7e, 0x8b, 0x8c, 0x8d,
519 	0x8e, 0x9b, 0x9c, 0x9d, 0x9e, 0xab, 0xac,
520 	0xad, 0xae, 0xbb, 0xbc, 0xbd, 0xbe, 0xcb,
521 	0xcc, 0xcd, 0xce, 0xdb, 0xdc, 0xdd, 0xde,
522 	0xeb, 0xec, 0xed, 0xee, 0xfb, 0xfc, 0xfd,
523 	0xfe,
524 };
525 
526 static const unsigned char jpeg_dri[] = {
527 	0xFF, 0xDD,
528 	0x00, 0x04, 0x00, 0x20
529 };
530 
531 static const unsigned char jpeg_sos_maximal[] = {
532 	0xFF, 0xDA,
533 	0x00, 0x0C, 0x04, 0x01, 0x00, 0x02, 0x11, 0x03,
534 	0x11, 0x04, 0x11, 0x00, 0x3F, 0x00
535 };
536 
537 static const unsigned char jpeg_image_red[] = {
538 	0xFC, 0x5F, 0xA2, 0xBF, 0xCA, 0x73, 0xFE, 0xFE,
539 	0x02, 0x8A, 0x00, 0x28, 0xA0, 0x02, 0x8A, 0x00,
540 	0x28, 0xA0, 0x02, 0x8A, 0x00, 0x28, 0xA0, 0x02,
541 	0x8A, 0x00, 0x28, 0xA0, 0x02, 0x8A, 0x00, 0x28,
542 	0xA0, 0x02, 0x8A, 0x00, 0x28, 0xA0, 0x02, 0x8A,
543 	0x00, 0x28, 0xA0, 0x02, 0x8A, 0x00, 0x28, 0xA0,
544 	0x02, 0x8A, 0x00, 0x28, 0xA0, 0x02, 0x8A, 0x00,
545 	0x28, 0xA0, 0x02, 0x8A, 0x00, 0x28, 0xA0, 0x02,
546 	0x8A, 0x00, 0x28, 0xA0, 0x02, 0x8A, 0x00, 0x28,
547 	0xA0, 0x02, 0x8A, 0x00, 0x28, 0xA0, 0x02, 0x8A,
548 	0x00, 0x28, 0xA0, 0x02, 0x8A, 0x00
549 };
550 
551 static const unsigned char jpeg_eoi[] = {
552 	0xFF, 0xD9
553 };
554 
555 struct mxc_jpeg_src_buf {
556 	/* common v4l buffer stuff -- must be first */
557 	struct vb2_v4l2_buffer	b;
558 	struct list_head	list;
559 
560 	/* mxc-jpeg specific */
561 	bool			dht_needed;
562 	bool			jpeg_parse_error;
563 	const struct mxc_jpeg_fmt	*fmt;
564 	int			w;
565 	int			h;
566 };
567 
568 static inline struct mxc_jpeg_src_buf *vb2_to_mxc_buf(struct vb2_buffer *vb)
569 {
570 	return container_of(to_vb2_v4l2_buffer(vb),
571 			    struct mxc_jpeg_src_buf, b);
572 }
573 
574 static unsigned int debug;
575 module_param(debug, int, 0644);
576 MODULE_PARM_DESC(debug, "Debug level (0-3)");
577 
578 static unsigned int hw_timeout = 2000;
579 module_param(hw_timeout, int, 0644);
580 MODULE_PARM_DESC(hw_timeout, "MXC JPEG hw timeout, the number of milliseconds");
581 
582 static void mxc_jpeg_bytesperline(struct mxc_jpeg_q_data *q, u32 precision);
583 static void mxc_jpeg_sizeimage(struct mxc_jpeg_q_data *q);
584 
585 static void _bswap16(u16 *a)
586 {
587 	*a = ((*a & 0x00FF) << 8) | ((*a & 0xFF00) >> 8);
588 }
589 
590 static void print_mxc_buf(struct mxc_jpeg_dev *jpeg, struct vb2_buffer *buf,
591 			  unsigned long len)
592 {
593 	unsigned int plane_no;
594 	u32 dma_addr;
595 	void *vaddr;
596 	unsigned long payload;
597 
598 	if (debug < 3)
599 		return;
600 
601 	for (plane_no = 0; plane_no < buf->num_planes; plane_no++) {
602 		payload = vb2_get_plane_payload(buf, plane_no);
603 		if (len == 0)
604 			len = payload;
605 		dma_addr = vb2_dma_contig_plane_dma_addr(buf, plane_no);
606 		vaddr = vb2_plane_vaddr(buf, plane_no);
607 		v4l2_dbg(3, debug, &jpeg->v4l2_dev,
608 			 "plane %d (vaddr=%p dma_addr=%x payload=%ld):",
609 			  plane_no, vaddr, dma_addr, payload);
610 		print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
611 			       vaddr, len, false);
612 	}
613 }
614 
615 static inline struct mxc_jpeg_ctx *mxc_jpeg_fh_to_ctx(struct v4l2_fh *fh)
616 {
617 	return container_of(fh, struct mxc_jpeg_ctx, fh);
618 }
619 
620 static int enum_fmt(const struct mxc_jpeg_fmt *mxc_formats, int n,
621 		    struct v4l2_fmtdesc *f, u32 type)
622 {
623 	int i, num = 0;
624 
625 	for (i = 0; i < n; ++i) {
626 		if (mxc_formats[i].flags == type) {
627 			/* index-th format of searched type found ? */
628 			if (num == f->index)
629 				break;
630 			/* Correct type but haven't reached our index yet,
631 			 * just increment per-type index
632 			 */
633 			++num;
634 		}
635 	}
636 
637 	/* Format not found */
638 	if (i >= n)
639 		return -EINVAL;
640 
641 	f->pixelformat = mxc_formats[i].fourcc;
642 
643 	return 0;
644 }
645 
646 static const struct mxc_jpeg_fmt *mxc_jpeg_find_format(u32 pixelformat)
647 {
648 	unsigned int k;
649 
650 	for (k = 0; k < MXC_JPEG_NUM_FORMATS; k++) {
651 		const struct mxc_jpeg_fmt *fmt = &mxc_formats[k];
652 
653 		if (fmt->fourcc == pixelformat)
654 			return fmt;
655 	}
656 	return NULL;
657 }
658 
659 static enum mxc_jpeg_image_format mxc_jpeg_fourcc_to_imgfmt(u32 fourcc)
660 {
661 	switch (fourcc) {
662 	case V4L2_PIX_FMT_GREY:
663 	case V4L2_PIX_FMT_Y012:
664 		return MXC_JPEG_GRAY;
665 	case V4L2_PIX_FMT_YUYV:
666 	case V4L2_PIX_FMT_Y212:
667 		return MXC_JPEG_YUV422;
668 	case V4L2_PIX_FMT_NV12:
669 	case V4L2_PIX_FMT_NV12M:
670 	case V4L2_PIX_FMT_P012:
671 	case V4L2_PIX_FMT_P012M:
672 		return MXC_JPEG_YUV420;
673 	case V4L2_PIX_FMT_YUV24:
674 	case V4L2_PIX_FMT_YUV48_12:
675 		return MXC_JPEG_YUV444;
676 	case V4L2_PIX_FMT_BGR24:
677 	case V4L2_PIX_FMT_BGR48_12:
678 		return MXC_JPEG_BGR;
679 	case V4L2_PIX_FMT_ABGR32:
680 	case V4L2_PIX_FMT_ABGR64_12:
681 		return MXC_JPEG_ABGR;
682 	default:
683 		return MXC_JPEG_INVALID;
684 	}
685 }
686 
687 static struct mxc_jpeg_q_data *mxc_jpeg_get_q_data(struct mxc_jpeg_ctx *ctx,
688 						   enum v4l2_buf_type type)
689 {
690 	if (V4L2_TYPE_IS_OUTPUT(type))
691 		return &ctx->out_q;
692 	return &ctx->cap_q;
693 }
694 
695 static void mxc_jpeg_addrs(struct mxc_jpeg_desc *desc,
696 			   struct vb2_buffer *raw_buf,
697 			   struct vb2_buffer *jpeg_buf, int offset)
698 {
699 	int img_fmt = desc->stm_ctrl & STM_CTRL_IMAGE_FORMAT_MASK;
700 	struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(raw_buf->vb2_queue);
701 	struct mxc_jpeg_q_data *q_data;
702 
703 	q_data = mxc_jpeg_get_q_data(ctx, raw_buf->type);
704 	desc->buf_base0 = vb2_dma_contig_plane_dma_addr(raw_buf, 0);
705 	desc->buf_base1 = 0;
706 	if (img_fmt == STM_CTRL_IMAGE_FORMAT(MXC_JPEG_YUV420)) {
707 		if (raw_buf->num_planes == 2)
708 			desc->buf_base1 = vb2_dma_contig_plane_dma_addr(raw_buf, 1);
709 		else
710 			desc->buf_base1 = desc->buf_base0 + q_data->sizeimage[0];
711 	}
712 	desc->stm_bufbase = vb2_dma_contig_plane_dma_addr(jpeg_buf, 0) +
713 		offset;
714 }
715 
716 static bool mxc_jpeg_is_extended_sequential(const struct mxc_jpeg_fmt *fmt)
717 {
718 	if (!fmt || !(fmt->flags & MXC_JPEG_FMT_TYPE_RAW))
719 		return false;
720 
721 	if (fmt->precision > 8)
722 		return true;
723 
724 	return false;
725 }
726 
727 static void notify_eos(struct mxc_jpeg_ctx *ctx)
728 {
729 	const struct v4l2_event ev = {
730 		.type = V4L2_EVENT_EOS
731 	};
732 
733 	dev_dbg(ctx->mxc_jpeg->dev, "Notify app event EOS reached");
734 	v4l2_event_queue_fh(&ctx->fh, &ev);
735 }
736 
737 static void notify_src_chg(struct mxc_jpeg_ctx *ctx)
738 {
739 	const struct v4l2_event ev = {
740 		.type = V4L2_EVENT_SOURCE_CHANGE,
741 		.u.src_change.changes = V4L2_EVENT_SRC_CH_RESOLUTION,
742 	};
743 
744 	dev_dbg(ctx->mxc_jpeg->dev, "Notify app event SRC_CH_RESOLUTION");
745 	v4l2_event_queue_fh(&ctx->fh, &ev);
746 }
747 
748 static int mxc_get_free_slot(struct mxc_jpeg_slot_data *slot_data)
749 {
750 	if (!slot_data->used)
751 		return slot_data->slot;
752 	return -1;
753 }
754 
755 static bool mxc_jpeg_alloc_slot_data(struct mxc_jpeg_dev *jpeg)
756 {
757 	struct mxc_jpeg_desc *desc;
758 	struct mxc_jpeg_desc *cfg_desc;
759 	void *cfg_stm;
760 
761 	if (jpeg->slot_data.desc)
762 		goto skip_alloc; /* already allocated, reuse it */
763 
764 	/* allocate descriptor for decoding/encoding phase */
765 	desc = dma_alloc_coherent(jpeg->dev,
766 				  sizeof(struct mxc_jpeg_desc),
767 				  &jpeg->slot_data.desc_handle,
768 				  GFP_ATOMIC);
769 	if (!desc)
770 		goto err;
771 	jpeg->slot_data.desc = desc;
772 
773 	/* allocate descriptor for configuration phase (encoder only) */
774 	cfg_desc = dma_alloc_coherent(jpeg->dev,
775 				      sizeof(struct mxc_jpeg_desc),
776 				      &jpeg->slot_data.cfg_desc_handle,
777 				      GFP_ATOMIC);
778 	if (!cfg_desc)
779 		goto err;
780 	jpeg->slot_data.cfg_desc = cfg_desc;
781 
782 	/* allocate configuration stream */
783 	cfg_stm = dma_alloc_coherent(jpeg->dev,
784 				     MXC_JPEG_MAX_CFG_STREAM,
785 				     &jpeg->slot_data.cfg_stream_handle,
786 				     GFP_ATOMIC);
787 	if (!cfg_stm)
788 		goto err;
789 	jpeg->slot_data.cfg_stream_vaddr = cfg_stm;
790 
791 skip_alloc:
792 	jpeg->slot_data.used = true;
793 
794 	return true;
795 err:
796 	dev_err(jpeg->dev, "Could not allocate descriptors for slot %d", jpeg->slot_data.slot);
797 
798 	return false;
799 }
800 
801 static void mxc_jpeg_free_slot_data(struct mxc_jpeg_dev *jpeg)
802 {
803 	/* free descriptor for decoding/encoding phase */
804 	dma_free_coherent(jpeg->dev, sizeof(struct mxc_jpeg_desc),
805 			  jpeg->slot_data.desc,
806 			  jpeg->slot_data.desc_handle);
807 
808 	/* free descriptor for encoder configuration phase / decoder DHT */
809 	dma_free_coherent(jpeg->dev, sizeof(struct mxc_jpeg_desc),
810 			  jpeg->slot_data.cfg_desc,
811 			  jpeg->slot_data.cfg_desc_handle);
812 
813 	/* free configuration stream */
814 	dma_free_coherent(jpeg->dev, MXC_JPEG_MAX_CFG_STREAM,
815 			  jpeg->slot_data.cfg_stream_vaddr,
816 			  jpeg->slot_data.cfg_stream_handle);
817 
818 	jpeg->slot_data.used = false;
819 }
820 
821 static void mxc_jpeg_check_and_set_last_buffer(struct mxc_jpeg_ctx *ctx,
822 					       struct vb2_v4l2_buffer *src_buf,
823 					       struct vb2_v4l2_buffer *dst_buf)
824 {
825 	if (v4l2_m2m_is_last_draining_src_buf(ctx->fh.m2m_ctx, src_buf)) {
826 		dst_buf->flags |= V4L2_BUF_FLAG_LAST;
827 		v4l2_m2m_mark_stopped(ctx->fh.m2m_ctx);
828 		notify_eos(ctx);
829 		ctx->header_parsed = false;
830 	}
831 }
832 
833 static void mxc_jpeg_job_finish(struct mxc_jpeg_ctx *ctx, enum vb2_buffer_state state, bool reset)
834 {
835 	struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;
836 	void __iomem *reg = jpeg->base_reg;
837 	struct vb2_v4l2_buffer *src_buf, *dst_buf;
838 
839 	dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
840 	src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
841 	mxc_jpeg_check_and_set_last_buffer(ctx, src_buf, dst_buf);
842 	v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
843 	v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
844 	v4l2_m2m_buf_done(src_buf, state);
845 	v4l2_m2m_buf_done(dst_buf, state);
846 
847 	mxc_jpeg_disable_irq(reg, ctx->slot);
848 	jpeg->slot_data.used = false;
849 	if (reset)
850 		mxc_jpeg_sw_reset(reg);
851 }
852 
853 static u32 mxc_jpeg_get_plane_size(struct mxc_jpeg_q_data *q_data, u32 plane_no)
854 {
855 	const struct mxc_jpeg_fmt *fmt = q_data->fmt;
856 	u32 size;
857 	int i;
858 
859 	if (plane_no >= fmt->mem_planes)
860 		return 0;
861 
862 	if (fmt->mem_planes == fmt->comp_planes)
863 		return q_data->sizeimage[plane_no];
864 
865 	if (plane_no < fmt->mem_planes - 1)
866 		return q_data->sizeimage[plane_no];
867 
868 	size = q_data->sizeimage[fmt->mem_planes - 1];
869 
870 	/* Should be impossible given mxc_formats. */
871 	if (WARN_ON_ONCE(fmt->comp_planes > ARRAY_SIZE(q_data->sizeimage)))
872 		return size;
873 
874 	for (i = fmt->mem_planes; i < fmt->comp_planes; i++)
875 		size += q_data->sizeimage[i];
876 
877 	return size;
878 }
879 
880 static irqreturn_t mxc_jpeg_dec_irq(int irq, void *priv)
881 {
882 	struct mxc_jpeg_dev *jpeg = priv;
883 	struct mxc_jpeg_ctx *ctx;
884 	void __iomem *reg = jpeg->base_reg;
885 	struct device *dev = jpeg->dev;
886 	struct vb2_v4l2_buffer *src_buf, *dst_buf;
887 	struct mxc_jpeg_src_buf *jpeg_src_buf;
888 	enum vb2_buffer_state buf_state;
889 	u32 dec_ret, com_status;
890 	unsigned long payload;
891 	struct mxc_jpeg_q_data *q_data;
892 	enum v4l2_buf_type cap_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
893 	unsigned int slot;
894 
895 	spin_lock(&jpeg->hw_lock);
896 
897 	com_status = readl(reg + COM_STATUS);
898 	slot = COM_STATUS_CUR_SLOT(com_status);
899 	dev_dbg(dev, "Irq %d on slot %d.\n", irq, slot);
900 
901 	ctx = v4l2_m2m_get_curr_priv(jpeg->m2m_dev);
902 	if (WARN_ON(!ctx))
903 		goto job_unlock;
904 
905 	if (slot != ctx->slot) {
906 		/* TODO investigate when adding multi-instance support */
907 		dev_warn(dev, "IRQ slot %d != context slot %d.\n",
908 			 slot, ctx->slot);
909 		goto job_unlock;
910 	}
911 
912 	if (!jpeg->slot_data.used)
913 		goto job_unlock;
914 
915 	dec_ret = readl(reg + MXC_SLOT_OFFSET(slot, SLOT_STATUS));
916 	writel(dec_ret, reg + MXC_SLOT_OFFSET(slot, SLOT_STATUS)); /* w1c */
917 
918 	dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
919 	src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
920 	if (!dst_buf || !src_buf) {
921 		dev_err(dev, "No source or destination buffer.\n");
922 		goto job_unlock;
923 	}
924 	jpeg_src_buf = vb2_to_mxc_buf(&src_buf->vb2_buf);
925 
926 	if (dec_ret & SLOT_STATUS_ENC_CONFIG_ERR) {
927 		u32 ret = readl(reg + CAST_STATUS12);
928 
929 		dev_err(dev, "Encoder/decoder error, dec_ret = 0x%08x, status=0x%08x",
930 			dec_ret, ret);
931 		mxc_jpeg_clr_desc(reg, slot);
932 		mxc_jpeg_sw_reset(reg);
933 		buf_state = VB2_BUF_STATE_ERROR;
934 		goto buffers_done;
935 	}
936 
937 	if (!(dec_ret & SLOT_STATUS_FRMDONE))
938 		goto job_unlock;
939 
940 	if (jpeg->mode == MXC_JPEG_ENCODE &&
941 	    ctx->enc_state == MXC_JPEG_ENC_CONF) {
942 		q_data = mxc_jpeg_get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
943 		ctx->enc_state = MXC_JPEG_ENCODING;
944 		dev_dbg(dev, "Encoder config finished. Start encoding...\n");
945 		mxc_jpeg_enc_set_quality(dev, reg, ctx->jpeg_quality);
946 		mxc_jpeg_enc_mode_go(dev, reg, mxc_jpeg_is_extended_sequential(q_data->fmt));
947 		goto job_unlock;
948 	}
949 	if (jpeg->mode == MXC_JPEG_DECODE && jpeg_src_buf->dht_needed) {
950 		jpeg_src_buf->dht_needed = false;
951 		dev_dbg(dev, "Decoder DHT cfg finished. Start decoding...\n");
952 		goto job_unlock;
953 	}
954 
955 	if (jpeg->mode == MXC_JPEG_ENCODE) {
956 		payload = readl(reg + MXC_SLOT_OFFSET(slot, SLOT_BUF_PTR));
957 		vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload);
958 		dev_dbg(dev, "Encoding finished, payload size: %ld\n",
959 			payload);
960 	} else {
961 		q_data = mxc_jpeg_get_q_data(ctx, cap_type);
962 		payload = mxc_jpeg_get_plane_size(q_data, 0);
963 		vb2_set_plane_payload(&dst_buf->vb2_buf, 0, payload);
964 		vb2_set_plane_payload(&dst_buf->vb2_buf, 1, 0);
965 		if (q_data->fmt->mem_planes == 2) {
966 			payload = mxc_jpeg_get_plane_size(q_data, 1);
967 			vb2_set_plane_payload(&dst_buf->vb2_buf, 1, payload);
968 		}
969 		dev_dbg(dev, "Decoding finished, payload size: %ld + %ld\n",
970 			vb2_get_plane_payload(&dst_buf->vb2_buf, 0),
971 			vb2_get_plane_payload(&dst_buf->vb2_buf, 1));
972 	}
973 
974 	/* short preview of the results */
975 	dev_dbg(dev, "src_buf preview: ");
976 	print_mxc_buf(jpeg, &src_buf->vb2_buf, 32);
977 	dev_dbg(dev, "dst_buf preview: ");
978 	print_mxc_buf(jpeg, &dst_buf->vb2_buf, 32);
979 	buf_state = VB2_BUF_STATE_DONE;
980 
981 buffers_done:
982 	mxc_jpeg_job_finish(ctx, buf_state, false);
983 	spin_unlock(&jpeg->hw_lock);
984 	cancel_delayed_work(&ctx->task_timer);
985 	v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx);
986 	return IRQ_HANDLED;
987 job_unlock:
988 	spin_unlock(&jpeg->hw_lock);
989 	return IRQ_HANDLED;
990 }
991 
992 static int mxc_jpeg_fixup_sof(struct mxc_jpeg_sof *sof,
993 			      u32 fourcc,
994 			      u16 w, u16 h)
995 {
996 	int sof_length;
997 	const struct mxc_jpeg_fmt *fmt = mxc_jpeg_find_format(fourcc);
998 
999 	if (fmt)
1000 		sof->precision = fmt->precision;
1001 	else
1002 		sof->precision = 8; /* TODO allow 8/12 bit precision*/
1003 	sof->height = h;
1004 	_bswap16(&sof->height);
1005 	sof->width = w;
1006 	_bswap16(&sof->width);
1007 
1008 	switch (fourcc) {
1009 	case V4L2_PIX_FMT_NV12:
1010 	case V4L2_PIX_FMT_NV12M:
1011 	case V4L2_PIX_FMT_P012:
1012 	case V4L2_PIX_FMT_P012M:
1013 		sof->components_no = 3;
1014 		sof->comp[0].v = 0x2;
1015 		sof->comp[0].h = 0x2;
1016 		break;
1017 	case V4L2_PIX_FMT_YUYV:
1018 	case V4L2_PIX_FMT_Y212:
1019 		sof->components_no = 3;
1020 		sof->comp[0].v = 0x1;
1021 		sof->comp[0].h = 0x2;
1022 		break;
1023 	case V4L2_PIX_FMT_YUV24:
1024 	case V4L2_PIX_FMT_YUV48_12:
1025 	case V4L2_PIX_FMT_BGR24:
1026 	case V4L2_PIX_FMT_BGR48_12:
1027 	default:
1028 		sof->components_no = 3;
1029 		break;
1030 	case V4L2_PIX_FMT_ABGR32:
1031 	case V4L2_PIX_FMT_ABGR64_12:
1032 		sof->components_no = 4;
1033 		break;
1034 	case V4L2_PIX_FMT_GREY:
1035 	case V4L2_PIX_FMT_Y012:
1036 		sof->components_no = 1;
1037 		break;
1038 	}
1039 	sof_length = 8 + 3 * sof->components_no;
1040 	sof->length = sof_length;
1041 	_bswap16(&sof->length);
1042 
1043 	return sof_length; /* not swaped */
1044 }
1045 
1046 static int mxc_jpeg_fixup_sos(struct mxc_jpeg_sos *sos,
1047 			      u32 fourcc)
1048 {
1049 	int sos_length;
1050 	u8 *sof_u8 = (u8 *)sos;
1051 
1052 	switch (fourcc) {
1053 	case V4L2_PIX_FMT_NV12:
1054 	case V4L2_PIX_FMT_NV12M:
1055 	case V4L2_PIX_FMT_P012:
1056 	case V4L2_PIX_FMT_P012M:
1057 		sos->components_no = 3;
1058 		break;
1059 	case V4L2_PIX_FMT_YUYV:
1060 	case V4L2_PIX_FMT_Y212:
1061 		sos->components_no = 3;
1062 		break;
1063 	case V4L2_PIX_FMT_YUV24:
1064 	case V4L2_PIX_FMT_YUV48_12:
1065 	case V4L2_PIX_FMT_BGR24:
1066 	case V4L2_PIX_FMT_BGR48_12:
1067 	default:
1068 		sos->components_no = 3;
1069 		break;
1070 	case V4L2_PIX_FMT_ABGR32:
1071 	case V4L2_PIX_FMT_ABGR64_12:
1072 		sos->components_no = 4;
1073 		break;
1074 	case V4L2_PIX_FMT_GREY:
1075 	case V4L2_PIX_FMT_Y012:
1076 		sos->components_no = 1;
1077 		break;
1078 	}
1079 	sos_length = 6 + 2 * sos->components_no;
1080 	sos->length = sos_length;
1081 	_bswap16(&sos->length);
1082 
1083 	/* SOS ignorable bytes, not so ignorable after all */
1084 	sof_u8[sos_length - 1] = 0x0;
1085 	sof_u8[sos_length - 2] = 0x3f;
1086 	sof_u8[sos_length - 3] = 0x0;
1087 
1088 	return sos_length; /* not swaped */
1089 }
1090 
1091 static unsigned int mxc_jpeg_setup_cfg_stream(void *cfg_stream_vaddr,
1092 					      u32 fourcc,
1093 					      u16 w, u16 h)
1094 {
1095 	/*
1096 	 * There is a hardware issue that first 128 bytes of configuration data
1097 	 * can't be loaded correctly.
1098 	 * To avoid this issue, we need to write the configuration from
1099 	 * an offset which should be no less than 0x80 (128 bytes).
1100 	 */
1101 	unsigned int offset = 0x80;
1102 	u8 *cfg = (u8 *)cfg_stream_vaddr;
1103 	struct mxc_jpeg_sof *sof;
1104 	struct mxc_jpeg_sos *sos;
1105 	const struct mxc_jpeg_fmt *fmt = mxc_jpeg_find_format(fourcc);
1106 
1107 	if (!fmt)
1108 		return 0;
1109 
1110 	memcpy(cfg + offset, jpeg_soi, ARRAY_SIZE(jpeg_soi));
1111 	offset += ARRAY_SIZE(jpeg_soi);
1112 
1113 	if (fmt->is_rgb) {
1114 		memcpy(cfg + offset, jpeg_app14, sizeof(jpeg_app14));
1115 		offset += sizeof(jpeg_app14);
1116 	} else {
1117 		memcpy(cfg + offset, jpeg_app0, sizeof(jpeg_app0));
1118 		offset += sizeof(jpeg_app0);
1119 	}
1120 
1121 	if (mxc_jpeg_is_extended_sequential(fmt)) {
1122 		memcpy(cfg + offset, jpeg_dqt_extseq, sizeof(jpeg_dqt_extseq));
1123 		offset += sizeof(jpeg_dqt_extseq);
1124 
1125 		memcpy(cfg + offset, jpeg_sof_extseq, sizeof(jpeg_sof_extseq));
1126 	} else {
1127 		memcpy(cfg + offset, jpeg_dqt, sizeof(jpeg_dqt));
1128 		offset += sizeof(jpeg_dqt);
1129 
1130 		memcpy(cfg + offset, jpeg_sof_maximal, sizeof(jpeg_sof_maximal));
1131 	}
1132 	offset += 2; /* skip marker ID */
1133 	sof = (struct mxc_jpeg_sof *)(cfg + offset);
1134 	offset += mxc_jpeg_fixup_sof(sof, fourcc, w, h);
1135 
1136 	if (mxc_jpeg_is_extended_sequential(fmt)) {
1137 		memcpy(cfg + offset, jpeg_dht_extseq, sizeof(jpeg_dht_extseq));
1138 		offset += sizeof(jpeg_dht_extseq);
1139 	} else {
1140 		memcpy(cfg + offset, jpeg_dht, sizeof(jpeg_dht));
1141 		offset += sizeof(jpeg_dht);
1142 	}
1143 
1144 	memcpy(cfg + offset, jpeg_dri, sizeof(jpeg_dri));
1145 	offset += sizeof(jpeg_dri);
1146 
1147 	memcpy(cfg + offset, jpeg_sos_maximal, sizeof(jpeg_sos_maximal));
1148 	offset += 2; /* skip marker ID */
1149 	sos = (struct mxc_jpeg_sos *)(cfg + offset);
1150 	offset += mxc_jpeg_fixup_sos(sos, fourcc);
1151 
1152 	memcpy(cfg + offset, jpeg_image_red, sizeof(jpeg_image_red));
1153 	offset += sizeof(jpeg_image_red);
1154 
1155 	memcpy(cfg + offset, jpeg_eoi, sizeof(jpeg_eoi));
1156 	offset += sizeof(jpeg_eoi);
1157 
1158 	return offset;
1159 }
1160 
1161 static void mxc_jpeg_config_dec_desc(struct vb2_buffer *out_buf,
1162 				     struct mxc_jpeg_ctx *ctx,
1163 				     struct vb2_buffer *src_buf,
1164 				     struct vb2_buffer *dst_buf)
1165 {
1166 	enum v4l2_buf_type cap_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1167 	struct mxc_jpeg_q_data *q_data_cap;
1168 	enum mxc_jpeg_image_format img_fmt;
1169 	struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;
1170 	void __iomem *reg = jpeg->base_reg;
1171 	unsigned int slot = ctx->slot;
1172 	struct mxc_jpeg_desc *desc = jpeg->slot_data.desc;
1173 	struct mxc_jpeg_desc *cfg_desc = jpeg->slot_data.cfg_desc;
1174 	dma_addr_t desc_handle = jpeg->slot_data.desc_handle;
1175 	dma_addr_t cfg_desc_handle = jpeg->slot_data.cfg_desc_handle;
1176 	dma_addr_t cfg_stream_handle = jpeg->slot_data.cfg_stream_handle;
1177 	unsigned int *cfg_size = &jpeg->slot_data.cfg_stream_size;
1178 	void *cfg_stream_vaddr = jpeg->slot_data.cfg_stream_vaddr;
1179 	struct mxc_jpeg_src_buf *jpeg_src_buf;
1180 
1181 	jpeg_src_buf = vb2_to_mxc_buf(src_buf);
1182 
1183 	/* setup the decoding descriptor */
1184 	desc->next_descpt_ptr = 0; /* end of chain */
1185 	q_data_cap = mxc_jpeg_get_q_data(ctx, cap_type);
1186 	desc->imgsize = q_data_cap->w_adjusted << 16 | q_data_cap->h_adjusted;
1187 	img_fmt = mxc_jpeg_fourcc_to_imgfmt(q_data_cap->fmt->fourcc);
1188 	desc->stm_ctrl &= ~STM_CTRL_IMAGE_FORMAT(0xF); /* clear image format */
1189 	desc->stm_ctrl |= STM_CTRL_IMAGE_FORMAT(img_fmt);
1190 	desc->stm_ctrl |= STM_CTRL_BITBUF_PTR_CLR(1);
1191 	if (mxc_jpeg_is_extended_sequential(jpeg_src_buf->fmt))
1192 		desc->stm_ctrl |= STM_CTRL_PIXEL_PRECISION;
1193 	else
1194 		desc->stm_ctrl &= ~STM_CTRL_PIXEL_PRECISION;
1195 	desc->line_pitch = q_data_cap->bytesperline[0];
1196 	mxc_jpeg_addrs(desc, dst_buf, src_buf, 0);
1197 	mxc_jpeg_set_bufsize(desc, ALIGN(vb2_plane_size(src_buf, 0), 1024));
1198 	print_descriptor_info(jpeg->dev, desc);
1199 
1200 	if (!jpeg_src_buf->dht_needed) {
1201 		/* validate the decoding descriptor */
1202 		mxc_jpeg_set_desc(desc_handle, reg, slot);
1203 		return;
1204 	}
1205 
1206 	/*
1207 	 * if a default huffman table is needed, use the config descriptor to
1208 	 * inject a DHT, by chaining it before the decoding descriptor
1209 	 */
1210 	*cfg_size = mxc_jpeg_setup_cfg_stream(cfg_stream_vaddr,
1211 					      V4L2_PIX_FMT_YUYV,
1212 					      MXC_JPEG_MIN_WIDTH,
1213 					      MXC_JPEG_MIN_HEIGHT);
1214 	cfg_desc->next_descpt_ptr = desc_handle | MXC_NXT_DESCPT_EN;
1215 	cfg_desc->buf_base0 = vb2_dma_contig_plane_dma_addr(dst_buf, 0);
1216 	cfg_desc->buf_base1 = 0;
1217 	cfg_desc->imgsize = MXC_JPEG_MIN_WIDTH << 16;
1218 	cfg_desc->imgsize |= MXC_JPEG_MIN_HEIGHT;
1219 	cfg_desc->line_pitch = MXC_JPEG_MIN_WIDTH * 2;
1220 	cfg_desc->stm_ctrl = STM_CTRL_IMAGE_FORMAT(MXC_JPEG_YUV422);
1221 	cfg_desc->stm_ctrl |= STM_CTRL_BITBUF_PTR_CLR(1);
1222 	cfg_desc->stm_bufbase = cfg_stream_handle;
1223 	cfg_desc->stm_bufsize = ALIGN(*cfg_size, 1024);
1224 	print_descriptor_info(jpeg->dev, cfg_desc);
1225 
1226 	/* validate the configuration descriptor */
1227 	mxc_jpeg_set_desc(cfg_desc_handle, reg, slot);
1228 }
1229 
1230 static void mxc_jpeg_config_enc_desc(struct vb2_buffer *out_buf,
1231 				     struct mxc_jpeg_ctx *ctx,
1232 				     struct vb2_buffer *src_buf,
1233 				     struct vb2_buffer *dst_buf)
1234 {
1235 	struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;
1236 	void __iomem *reg = jpeg->base_reg;
1237 	unsigned int slot = ctx->slot;
1238 	struct mxc_jpeg_desc *desc = jpeg->slot_data.desc;
1239 	struct mxc_jpeg_desc *cfg_desc = jpeg->slot_data.cfg_desc;
1240 	dma_addr_t desc_handle = jpeg->slot_data.desc_handle;
1241 	dma_addr_t cfg_desc_handle = jpeg->slot_data.cfg_desc_handle;
1242 	void *cfg_stream_vaddr = jpeg->slot_data.cfg_stream_vaddr;
1243 	struct mxc_jpeg_q_data *q_data;
1244 	enum mxc_jpeg_image_format img_fmt;
1245 	int w, h;
1246 
1247 	q_data = mxc_jpeg_get_q_data(ctx, src_buf->vb2_queue->type);
1248 
1249 	jpeg->slot_data.cfg_stream_size =
1250 			mxc_jpeg_setup_cfg_stream(cfg_stream_vaddr,
1251 						  q_data->fmt->fourcc,
1252 						  q_data->crop.width,
1253 						  q_data->crop.height);
1254 
1255 	/* chain the config descriptor with the encoding descriptor */
1256 	cfg_desc->next_descpt_ptr = desc_handle | MXC_NXT_DESCPT_EN;
1257 
1258 	cfg_desc->buf_base0 = jpeg->slot_data.cfg_stream_handle;
1259 	cfg_desc->buf_base1 = 0;
1260 	cfg_desc->line_pitch = 0;
1261 	cfg_desc->stm_bufbase = 0; /* no output expected */
1262 	cfg_desc->stm_bufsize = 0x0;
1263 	cfg_desc->imgsize = 0;
1264 	cfg_desc->stm_ctrl = STM_CTRL_CONFIG_MOD(1);
1265 	cfg_desc->stm_ctrl |= STM_CTRL_BITBUF_PTR_CLR(1);
1266 
1267 	desc->next_descpt_ptr = 0; /* end of chain */
1268 
1269 	/* use adjusted resolution for CAST IP job */
1270 	w = q_data->crop.width;
1271 	h = q_data->crop.height;
1272 	v4l_bound_align_image(&w, w, MXC_JPEG_MAX_WIDTH, q_data->fmt->h_align,
1273 			      &h, h, MXC_JPEG_MAX_HEIGHT, q_data->fmt->v_align, 0);
1274 	mxc_jpeg_set_res(desc, w, h);
1275 	mxc_jpeg_set_line_pitch(desc, q_data->bytesperline[0]);
1276 	mxc_jpeg_set_bufsize(desc, ALIGN(vb2_plane_size(dst_buf, 0), 1024));
1277 	img_fmt = mxc_jpeg_fourcc_to_imgfmt(q_data->fmt->fourcc);
1278 	if (img_fmt == MXC_JPEG_INVALID)
1279 		dev_err(jpeg->dev, "No valid image format detected\n");
1280 	desc->stm_ctrl = STM_CTRL_CONFIG_MOD(0) |
1281 			 STM_CTRL_IMAGE_FORMAT(img_fmt);
1282 	desc->stm_ctrl |= STM_CTRL_BITBUF_PTR_CLR(1);
1283 	if (mxc_jpeg_is_extended_sequential(q_data->fmt))
1284 		desc->stm_ctrl |= STM_CTRL_PIXEL_PRECISION;
1285 	else
1286 		desc->stm_ctrl &= ~STM_CTRL_PIXEL_PRECISION;
1287 	mxc_jpeg_addrs(desc, src_buf, dst_buf, 0);
1288 	dev_dbg(jpeg->dev, "cfg_desc:\n");
1289 	print_descriptor_info(jpeg->dev, cfg_desc);
1290 	dev_dbg(jpeg->dev, "enc desc:\n");
1291 	print_descriptor_info(jpeg->dev, desc);
1292 	print_wrapper_info(jpeg->dev, reg);
1293 	print_cast_status(jpeg->dev, reg, MXC_JPEG_ENCODE);
1294 
1295 	/* validate the configuration descriptor */
1296 	mxc_jpeg_set_desc(cfg_desc_handle, reg, slot);
1297 }
1298 
1299 static const struct mxc_jpeg_fmt *mxc_jpeg_get_sibling_format(const struct mxc_jpeg_fmt *fmt)
1300 {
1301 	int i;
1302 
1303 	for (i = 0; i < MXC_JPEG_NUM_FORMATS; i++) {
1304 		if (mxc_formats[i].subsampling == fmt->subsampling &&
1305 		    mxc_formats[i].nc == fmt->nc &&
1306 		    mxc_formats[i].precision == fmt->precision &&
1307 		    mxc_formats[i].is_rgb == fmt->is_rgb &&
1308 		    mxc_formats[i].fourcc != fmt->fourcc)
1309 			return &mxc_formats[i];
1310 	}
1311 
1312 	return NULL;
1313 }
1314 
1315 static bool mxc_jpeg_compare_format(const struct mxc_jpeg_fmt *fmt1,
1316 				    const struct mxc_jpeg_fmt *fmt2)
1317 {
1318 	if (fmt1 == fmt2)
1319 		return true;
1320 	if (mxc_jpeg_get_sibling_format(fmt1) == fmt2)
1321 		return true;
1322 	return false;
1323 }
1324 
1325 static void mxc_jpeg_set_last_buffer(struct mxc_jpeg_ctx *ctx)
1326 {
1327 	struct vb2_v4l2_buffer *next_dst_buf;
1328 
1329 	next_dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
1330 	if (!next_dst_buf) {
1331 		ctx->fh.m2m_ctx->is_draining = true;
1332 		ctx->fh.m2m_ctx->next_buf_last = true;
1333 		return;
1334 	}
1335 
1336 	v4l2_m2m_last_buffer_done(ctx->fh.m2m_ctx, next_dst_buf);
1337 }
1338 
1339 static bool mxc_jpeg_source_change(struct mxc_jpeg_ctx *ctx,
1340 				   struct mxc_jpeg_src_buf *jpeg_src_buf)
1341 {
1342 	struct device *dev = ctx->mxc_jpeg->dev;
1343 	struct mxc_jpeg_q_data *q_data_cap;
1344 
1345 	if (!jpeg_src_buf->fmt)
1346 		return false;
1347 
1348 	q_data_cap = mxc_jpeg_get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
1349 	if (mxc_jpeg_compare_format(q_data_cap->fmt, jpeg_src_buf->fmt))
1350 		jpeg_src_buf->fmt = q_data_cap->fmt;
1351 	if (ctx->need_initial_source_change_evt ||
1352 	    q_data_cap->fmt != jpeg_src_buf->fmt ||
1353 	    q_data_cap->w != jpeg_src_buf->w ||
1354 	    q_data_cap->h != jpeg_src_buf->h) {
1355 		dev_dbg(dev, "Detected jpeg res=(%dx%d)->(%dx%d), pixfmt=%c%c%c%c\n",
1356 			q_data_cap->w, q_data_cap->h,
1357 			jpeg_src_buf->w, jpeg_src_buf->h,
1358 			(jpeg_src_buf->fmt->fourcc & 0xff),
1359 			(jpeg_src_buf->fmt->fourcc >>  8) & 0xff,
1360 			(jpeg_src_buf->fmt->fourcc >> 16) & 0xff,
1361 			(jpeg_src_buf->fmt->fourcc >> 24) & 0xff);
1362 
1363 		/*
1364 		 * set-up the capture queue with the pixelformat and resolution
1365 		 * detected from the jpeg output stream
1366 		 */
1367 		q_data_cap->w = jpeg_src_buf->w;
1368 		q_data_cap->h = jpeg_src_buf->h;
1369 		q_data_cap->fmt = jpeg_src_buf->fmt;
1370 		q_data_cap->w_adjusted = q_data_cap->w;
1371 		q_data_cap->h_adjusted = q_data_cap->h;
1372 		q_data_cap->crop.left = 0;
1373 		q_data_cap->crop.top = 0;
1374 		q_data_cap->crop.width = jpeg_src_buf->w;
1375 		q_data_cap->crop.height = jpeg_src_buf->h;
1376 
1377 		/*
1378 		 * align up the resolution for CAST IP,
1379 		 * but leave the buffer resolution unchanged
1380 		 */
1381 		v4l_bound_align_image(&q_data_cap->w_adjusted,
1382 				      q_data_cap->w_adjusted,  /* adjust up */
1383 				      MXC_JPEG_MAX_WIDTH,
1384 				      q_data_cap->fmt->h_align,
1385 				      &q_data_cap->h_adjusted,
1386 				      q_data_cap->h_adjusted, /* adjust up */
1387 				      MXC_JPEG_MAX_HEIGHT,
1388 				      q_data_cap->fmt->v_align,
1389 				      0);
1390 
1391 		/* setup bytesperline/sizeimage for capture queue */
1392 		mxc_jpeg_bytesperline(q_data_cap, jpeg_src_buf->fmt->precision);
1393 		mxc_jpeg_sizeimage(q_data_cap);
1394 		notify_src_chg(ctx);
1395 		ctx->source_change = 1;
1396 		ctx->need_initial_source_change_evt = false;
1397 		if (vb2_is_streaming(v4l2_m2m_get_dst_vq(ctx->fh.m2m_ctx)))
1398 			mxc_jpeg_set_last_buffer(ctx);
1399 	}
1400 
1401 	return ctx->source_change ? true : false;
1402 }
1403 
1404 static int mxc_jpeg_job_ready(void *priv)
1405 {
1406 	struct mxc_jpeg_ctx *ctx = priv;
1407 
1408 	return ctx->source_change ? 0 : 1;
1409 }
1410 
1411 static void mxc_jpeg_device_run_timeout(struct work_struct *work)
1412 {
1413 	struct delayed_work *dwork = to_delayed_work(work);
1414 	struct mxc_jpeg_ctx *ctx = container_of(dwork, struct mxc_jpeg_ctx, task_timer);
1415 	struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;
1416 	unsigned long flags;
1417 
1418 	spin_lock_irqsave(&ctx->mxc_jpeg->hw_lock, flags);
1419 	if (ctx->mxc_jpeg->slot_data.used) {
1420 		dev_warn(jpeg->dev, "%s timeout, cancel it\n",
1421 			 ctx->mxc_jpeg->mode == MXC_JPEG_DECODE ? "decode" : "encode");
1422 		mxc_jpeg_job_finish(ctx, VB2_BUF_STATE_ERROR, true);
1423 		v4l2_m2m_job_finish(ctx->mxc_jpeg->m2m_dev, ctx->fh.m2m_ctx);
1424 	}
1425 	spin_unlock_irqrestore(&ctx->mxc_jpeg->hw_lock, flags);
1426 }
1427 
1428 static void mxc_jpeg_device_run(void *priv)
1429 {
1430 	struct mxc_jpeg_ctx *ctx = priv;
1431 	struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;
1432 	void __iomem *reg = jpeg->base_reg;
1433 	struct device *dev = jpeg->dev;
1434 	struct vb2_v4l2_buffer *src_buf, *dst_buf;
1435 	unsigned long flags;
1436 	struct mxc_jpeg_q_data *q_data_cap, *q_data_out;
1437 	struct mxc_jpeg_src_buf *jpeg_src_buf;
1438 
1439 	spin_lock_irqsave(&ctx->mxc_jpeg->hw_lock, flags);
1440 	src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
1441 	dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
1442 	if (!src_buf || !dst_buf) {
1443 		dev_err(dev, "Null src or dst buf\n");
1444 		goto end;
1445 	}
1446 
1447 	q_data_cap = mxc_jpeg_get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE);
1448 	if (!q_data_cap)
1449 		goto end;
1450 	q_data_out = mxc_jpeg_get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT);
1451 	if (!q_data_out)
1452 		goto end;
1453 	src_buf->sequence = q_data_out->sequence++;
1454 	dst_buf->sequence = q_data_cap->sequence++;
1455 
1456 	v4l2_m2m_buf_copy_metadata(src_buf, dst_buf, true);
1457 
1458 	jpeg_src_buf = vb2_to_mxc_buf(&src_buf->vb2_buf);
1459 	if (q_data_cap->fmt->mem_planes != dst_buf->vb2_buf.num_planes) {
1460 		dev_err(dev, "Capture format %s has %d planes, but capture buffer has %d planes\n",
1461 			q_data_cap->fmt->name, q_data_cap->fmt->mem_planes,
1462 			dst_buf->vb2_buf.num_planes);
1463 		jpeg_src_buf->jpeg_parse_error = true;
1464 	}
1465 	if (jpeg_src_buf->jpeg_parse_error) {
1466 		mxc_jpeg_check_and_set_last_buffer(ctx, src_buf, dst_buf);
1467 		v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
1468 		v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
1469 		v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_ERROR);
1470 		v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_ERROR);
1471 		spin_unlock_irqrestore(&ctx->mxc_jpeg->hw_lock, flags);
1472 		v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx);
1473 
1474 		return;
1475 	}
1476 	if (ctx->mxc_jpeg->mode == MXC_JPEG_DECODE) {
1477 		if (ctx->source_change || mxc_jpeg_source_change(ctx, jpeg_src_buf)) {
1478 			spin_unlock_irqrestore(&ctx->mxc_jpeg->hw_lock, flags);
1479 			v4l2_m2m_job_finish(jpeg->m2m_dev, ctx->fh.m2m_ctx);
1480 			return;
1481 		}
1482 	}
1483 
1484 	mxc_jpeg_enable(reg);
1485 	mxc_jpeg_set_l_endian(reg, 1);
1486 
1487 	ctx->slot = mxc_get_free_slot(&jpeg->slot_data);
1488 	if (ctx->slot < 0) {
1489 		dev_err(dev, "No more free slots\n");
1490 		goto end;
1491 	}
1492 	if (!mxc_jpeg_alloc_slot_data(jpeg)) {
1493 		dev_err(dev, "Cannot allocate slot data\n");
1494 		goto end;
1495 	}
1496 
1497 	mxc_jpeg_enable_slot(reg, ctx->slot);
1498 	mxc_jpeg_enable_irq(reg, ctx->slot);
1499 
1500 	if (jpeg->mode == MXC_JPEG_ENCODE) {
1501 		dev_dbg(dev, "Encoding on slot %d\n", ctx->slot);
1502 		ctx->enc_state = MXC_JPEG_ENC_CONF;
1503 		mxc_jpeg_config_enc_desc(&dst_buf->vb2_buf, ctx,
1504 					 &src_buf->vb2_buf, &dst_buf->vb2_buf);
1505 		/* start config phase */
1506 		mxc_jpeg_enc_mode_conf(dev, reg,
1507 				       mxc_jpeg_is_extended_sequential(q_data_out->fmt));
1508 	} else {
1509 		dev_dbg(dev, "Decoding on slot %d\n", ctx->slot);
1510 		print_mxc_buf(jpeg, &src_buf->vb2_buf, 0);
1511 		mxc_jpeg_config_dec_desc(&dst_buf->vb2_buf, ctx,
1512 					 &src_buf->vb2_buf, &dst_buf->vb2_buf);
1513 		mxc_jpeg_dec_mode_go(dev, reg);
1514 	}
1515 	schedule_delayed_work(&ctx->task_timer, msecs_to_jiffies(hw_timeout));
1516 end:
1517 	spin_unlock_irqrestore(&ctx->mxc_jpeg->hw_lock, flags);
1518 }
1519 
1520 static int mxc_jpeg_decoder_cmd(struct file *file, void *priv,
1521 				struct v4l2_decoder_cmd *cmd)
1522 {
1523 	struct v4l2_fh *fh = file->private_data;
1524 	struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(fh);
1525 	unsigned long flags;
1526 	int ret;
1527 
1528 	ret = v4l2_m2m_ioctl_try_decoder_cmd(file, fh, cmd);
1529 	if (ret < 0)
1530 		return ret;
1531 
1532 	if (!vb2_is_streaming(v4l2_m2m_get_src_vq(fh->m2m_ctx)))
1533 		return 0;
1534 
1535 	spin_lock_irqsave(&ctx->mxc_jpeg->hw_lock, flags);
1536 	ret = v4l2_m2m_ioctl_decoder_cmd(file, priv, cmd);
1537 	spin_unlock_irqrestore(&ctx->mxc_jpeg->hw_lock, flags);
1538 	if (ret < 0)
1539 		return ret;
1540 
1541 	if (cmd->cmd == V4L2_DEC_CMD_STOP &&
1542 	    v4l2_m2m_has_stopped(fh->m2m_ctx)) {
1543 		notify_eos(ctx);
1544 		ctx->header_parsed = false;
1545 	}
1546 
1547 	if (cmd->cmd == V4L2_DEC_CMD_START &&
1548 	    v4l2_m2m_has_stopped(fh->m2m_ctx))
1549 		vb2_clear_last_buffer_dequeued(&fh->m2m_ctx->cap_q_ctx.q);
1550 	return 0;
1551 }
1552 
1553 static int mxc_jpeg_encoder_cmd(struct file *file, void *priv,
1554 				struct v4l2_encoder_cmd *cmd)
1555 {
1556 	struct v4l2_fh *fh = file->private_data;
1557 	struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(fh);
1558 	unsigned long flags;
1559 	int ret;
1560 
1561 	ret = v4l2_m2m_ioctl_try_encoder_cmd(file, fh, cmd);
1562 	if (ret < 0)
1563 		return ret;
1564 
1565 	if (!vb2_is_streaming(v4l2_m2m_get_src_vq(fh->m2m_ctx)) ||
1566 	    !vb2_is_streaming(v4l2_m2m_get_dst_vq(fh->m2m_ctx)))
1567 		return 0;
1568 
1569 	spin_lock_irqsave(&ctx->mxc_jpeg->hw_lock, flags);
1570 	ret = v4l2_m2m_ioctl_encoder_cmd(file, fh, cmd);
1571 	spin_unlock_irqrestore(&ctx->mxc_jpeg->hw_lock, flags);
1572 	if (ret < 0)
1573 		return 0;
1574 
1575 	if (cmd->cmd == V4L2_ENC_CMD_STOP &&
1576 	    v4l2_m2m_has_stopped(fh->m2m_ctx))
1577 		notify_eos(ctx);
1578 
1579 	if (cmd->cmd == V4L2_ENC_CMD_START &&
1580 	    v4l2_m2m_has_stopped(fh->m2m_ctx))
1581 		vb2_clear_last_buffer_dequeued(&fh->m2m_ctx->cap_q_ctx.q);
1582 
1583 	return 0;
1584 }
1585 
1586 static int mxc_jpeg_queue_setup(struct vb2_queue *q,
1587 				unsigned int *nbuffers,
1588 				unsigned int *nplanes,
1589 				unsigned int sizes[],
1590 				struct device *alloc_ctxs[])
1591 {
1592 	struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(q);
1593 	struct mxc_jpeg_q_data *q_data = NULL;
1594 	int i;
1595 
1596 	q_data = mxc_jpeg_get_q_data(ctx, q->type);
1597 	if (!q_data)
1598 		return -EINVAL;
1599 
1600 	/* Handle CREATE_BUFS situation - *nplanes != 0 */
1601 	if (*nplanes) {
1602 		if (*nplanes != q_data->fmt->mem_planes)
1603 			return -EINVAL;
1604 		for (i = 0; i < *nplanes; i++) {
1605 			if (sizes[i] < mxc_jpeg_get_plane_size(q_data, i))
1606 				return -EINVAL;
1607 		}
1608 		return 0;
1609 	}
1610 
1611 	/* Handle REQBUFS situation */
1612 	*nplanes = q_data->fmt->mem_planes;
1613 	for (i = 0; i < *nplanes; i++)
1614 		sizes[i] = mxc_jpeg_get_plane_size(q_data, i);
1615 
1616 	if (V4L2_TYPE_IS_OUTPUT(q->type))
1617 		ctx->need_initial_source_change_evt = true;
1618 
1619 	return 0;
1620 }
1621 
1622 static int mxc_jpeg_start_streaming(struct vb2_queue *q, unsigned int count)
1623 {
1624 	struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(q);
1625 	struct mxc_jpeg_q_data *q_data = mxc_jpeg_get_q_data(ctx, q->type);
1626 	int ret;
1627 
1628 	v4l2_m2m_update_start_streaming_state(ctx->fh.m2m_ctx, q);
1629 
1630 	if (ctx->mxc_jpeg->mode == MXC_JPEG_DECODE && V4L2_TYPE_IS_CAPTURE(q->type))
1631 		ctx->source_change = 0;
1632 	dev_dbg(ctx->mxc_jpeg->dev, "Start streaming ctx=%p", ctx);
1633 	q_data->sequence = 0;
1634 
1635 	ret = pm_runtime_resume_and_get(ctx->mxc_jpeg->dev);
1636 	if (ret < 0) {
1637 		dev_err(ctx->mxc_jpeg->dev, "Failed to power up jpeg\n");
1638 		return ret;
1639 	}
1640 
1641 	return 0;
1642 }
1643 
1644 static void mxc_jpeg_stop_streaming(struct vb2_queue *q)
1645 {
1646 	struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(q);
1647 	struct vb2_v4l2_buffer *vbuf;
1648 
1649 	dev_dbg(ctx->mxc_jpeg->dev, "Stop streaming ctx=%p", ctx);
1650 
1651 	/* Release all active buffers */
1652 	for (;;) {
1653 		if (V4L2_TYPE_IS_OUTPUT(q->type))
1654 			vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
1655 		else
1656 			vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
1657 		if (!vbuf)
1658 			break;
1659 		v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
1660 	}
1661 
1662 	v4l2_m2m_update_stop_streaming_state(ctx->fh.m2m_ctx, q);
1663 	/* if V4L2_DEC_CMD_STOP is sent before the source change triggered,
1664 	 * restore the is_draining flag
1665 	 */
1666 	if (V4L2_TYPE_IS_CAPTURE(q->type) && ctx->source_change && ctx->fh.m2m_ctx->last_src_buf)
1667 		ctx->fh.m2m_ctx->is_draining = true;
1668 
1669 	if (V4L2_TYPE_IS_OUTPUT(q->type) &&
1670 	    v4l2_m2m_has_stopped(ctx->fh.m2m_ctx)) {
1671 		notify_eos(ctx);
1672 		ctx->header_parsed = false;
1673 	}
1674 
1675 	pm_runtime_put_sync(&ctx->mxc_jpeg->pdev->dev);
1676 }
1677 
1678 static int mxc_jpeg_valid_comp_id(struct device *dev,
1679 				  struct mxc_jpeg_sof *sof,
1680 				  struct mxc_jpeg_sos *sos)
1681 {
1682 	int valid = 1;
1683 	int i;
1684 
1685 	/*
1686 	 * there's a limitation in the IP that the component IDs must be
1687 	 * between 0..4, if they are not, let's patch them
1688 	 */
1689 	for (i = 0; i < sof->components_no; i++)
1690 		if (sof->comp[i].id > MXC_JPEG_MAX_COMPONENTS) {
1691 			valid = 0;
1692 			dev_err(dev, "Component %d has invalid ID: %d",
1693 				i, sof->comp[i].id);
1694 		}
1695 	if (!valid)
1696 		/* patch all comp IDs if at least one is invalid */
1697 		for (i = 0; i < sof->components_no; i++) {
1698 			dev_warn(dev, "Component %d ID patched to: %d",
1699 				 i, i + 1);
1700 			sof->comp[i].id = i + 1;
1701 			sos->comp[i].id = i + 1;
1702 		}
1703 
1704 	return valid;
1705 }
1706 
1707 static bool mxc_jpeg_match_image_format(const struct mxc_jpeg_fmt *fmt,
1708 					const struct v4l2_jpeg_header *header)
1709 {
1710 	if (fmt->subsampling != header->frame.subsampling ||
1711 	    fmt->nc != header->frame.num_components ||
1712 	    fmt->precision != header->frame.precision)
1713 		return false;
1714 
1715 	/*
1716 	 * If the transform flag from APP14 marker is 0, images that are
1717 	 * encoded with 3 components have RGB colorspace, see Recommendation
1718 	 * ITU-T T.872 chapter 6.5.3 APP14 marker segment for colour encoding
1719 	 */
1720 	if (header->frame.subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_444) {
1721 		u8 is_rgb = header->app14_tf == V4L2_JPEG_APP14_TF_CMYK_RGB ? 1 : 0;
1722 
1723 		if (is_rgb != fmt->is_rgb)
1724 			return false;
1725 	}
1726 	return true;
1727 }
1728 
1729 static u32 mxc_jpeg_get_image_format(struct device *dev,
1730 				     const struct v4l2_jpeg_header *header)
1731 {
1732 	int i;
1733 	u32 fourcc = 0;
1734 
1735 	for (i = 0; i < MXC_JPEG_NUM_FORMATS; i++) {
1736 		if (mxc_jpeg_match_image_format(&mxc_formats[i], header)) {
1737 			fourcc = mxc_formats[i].fourcc;
1738 			break;
1739 		}
1740 	}
1741 	if (fourcc == 0) {
1742 		dev_err(dev,
1743 			"Could not identify image format nc=%d, subsampling=%d, precision=%d\n",
1744 			header->frame.num_components,
1745 			header->frame.subsampling,
1746 			header->frame.precision);
1747 		return fourcc;
1748 	}
1749 
1750 	return fourcc;
1751 }
1752 
1753 static void mxc_jpeg_bytesperline(struct mxc_jpeg_q_data *q, u32 precision)
1754 {
1755 	/* Bytes distance between the leftmost pixels in two adjacent lines */
1756 	if (q->fmt->fourcc == V4L2_PIX_FMT_JPEG) {
1757 		/* bytesperline unused for compressed formats */
1758 		q->bytesperline[0] = 0;
1759 		q->bytesperline[1] = 0;
1760 	} else if (q->fmt->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_420) {
1761 		/* When the image format is planar the bytesperline value
1762 		 * applies to the first plane and is divided by the same factor
1763 		 * as the width field for the other planes
1764 		 */
1765 		q->bytesperline[0] = q->w_adjusted * DIV_ROUND_UP(precision, 8);
1766 		q->bytesperline[1] = q->bytesperline[0];
1767 	} else if (q->fmt->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_422) {
1768 		q->bytesperline[0] = q->w_adjusted * DIV_ROUND_UP(precision, 8) * 2;
1769 		q->bytesperline[1] = 0;
1770 	} else if (q->fmt->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_444) {
1771 		q->bytesperline[0] = q->w_adjusted * DIV_ROUND_UP(precision, 8) * q->fmt->nc;
1772 		q->bytesperline[1] = 0;
1773 	} else {
1774 		/* grayscale */
1775 		q->bytesperline[0] = q->w_adjusted * DIV_ROUND_UP(precision, 8);
1776 		q->bytesperline[1] = 0;
1777 	}
1778 }
1779 
1780 static void mxc_jpeg_sizeimage(struct mxc_jpeg_q_data *q)
1781 {
1782 	if (q->fmt->fourcc == V4L2_PIX_FMT_JPEG) {
1783 		/* if no sizeimage from user, assume worst jpeg compression */
1784 		if (!q->sizeimage[0])
1785 			q->sizeimage[0] = 6 * q->w * q->h;
1786 		q->sizeimage[1] = 0;
1787 
1788 		if (q->sizeimage[0] > MXC_JPEG_MAX_SIZEIMAGE)
1789 			q->sizeimage[0] = MXC_JPEG_MAX_SIZEIMAGE;
1790 
1791 		/* jpeg stream size must be multiple of 1K */
1792 		q->sizeimage[0] = ALIGN(q->sizeimage[0], 1024);
1793 	} else {
1794 		q->sizeimage[0] = q->bytesperline[0] * q->h_adjusted;
1795 		q->sizeimage[1] = 0;
1796 		if (q->fmt->subsampling == V4L2_JPEG_CHROMA_SUBSAMPLING_420)
1797 			q->sizeimage[1] = q->sizeimage[0] / 2;
1798 	}
1799 }
1800 
1801 static int mxc_jpeg_parse(struct mxc_jpeg_ctx *ctx, struct vb2_buffer *vb)
1802 {
1803 	struct device *dev = ctx->mxc_jpeg->dev;
1804 	struct mxc_jpeg_q_data *q_data_out;
1805 	struct mxc_jpeg_q_data *q_data_cap;
1806 	u32 fourcc;
1807 	struct v4l2_jpeg_header header;
1808 	struct mxc_jpeg_sof *psof = NULL;
1809 	struct mxc_jpeg_sos *psos = NULL;
1810 	struct mxc_jpeg_src_buf *jpeg_src_buf = vb2_to_mxc_buf(vb);
1811 	u8 *src_addr = (u8 *)vb2_plane_vaddr(vb, 0);
1812 	u32 size = vb2_get_plane_payload(vb, 0);
1813 	int ret;
1814 
1815 	memset(&header, 0, sizeof(header));
1816 	ret = v4l2_jpeg_parse_header((void *)src_addr, size, &header);
1817 	if (ret < 0) {
1818 		dev_err(dev, "Error parsing JPEG stream markers\n");
1819 		return ret;
1820 	}
1821 
1822 	/* if DHT marker present, no need to inject default one */
1823 	jpeg_src_buf->dht_needed = (header.num_dht == 0);
1824 
1825 	q_data_out = mxc_jpeg_get_q_data(ctx,
1826 					 V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
1827 	if (q_data_out->w == 0 && q_data_out->h == 0) {
1828 		dev_warn(dev, "Invalid user resolution 0x0");
1829 		dev_warn(dev, "Keeping resolution from JPEG: %dx%d",
1830 			 header.frame.width, header.frame.height);
1831 	} else if (header.frame.width != q_data_out->w ||
1832 		   header.frame.height != q_data_out->h) {
1833 		dev_err(dev,
1834 			"Resolution mismatch: %dx%d (JPEG) versus %dx%d(user)",
1835 			header.frame.width, header.frame.height,
1836 			q_data_out->w, q_data_out->h);
1837 	}
1838 	q_data_out->w = header.frame.width;
1839 	q_data_out->h = header.frame.height;
1840 	if (header.frame.width > MXC_JPEG_MAX_WIDTH ||
1841 	    header.frame.height > MXC_JPEG_MAX_HEIGHT) {
1842 		dev_err(dev, "JPEG width or height should be <= 8192: %dx%d\n",
1843 			header.frame.width, header.frame.height);
1844 		return -EINVAL;
1845 	}
1846 	if (header.frame.width < MXC_JPEG_MIN_WIDTH ||
1847 	    header.frame.height < MXC_JPEG_MIN_HEIGHT) {
1848 		dev_err(dev, "JPEG width or height should be > 64: %dx%d\n",
1849 			header.frame.width, header.frame.height);
1850 		return -EINVAL;
1851 	}
1852 	if (header.frame.num_components > V4L2_JPEG_MAX_COMPONENTS) {
1853 		dev_err(dev, "JPEG number of components should be <=%d",
1854 			V4L2_JPEG_MAX_COMPONENTS);
1855 		return -EINVAL;
1856 	}
1857 	/* check and, if necessary, patch component IDs*/
1858 	psof = (struct mxc_jpeg_sof *)header.sof.start;
1859 	psos = (struct mxc_jpeg_sos *)header.sos.start;
1860 	if (!mxc_jpeg_valid_comp_id(dev, psof, psos))
1861 		dev_warn(dev, "JPEG component ids should be 0-3 or 1-4");
1862 
1863 	q_data_cap = mxc_jpeg_get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
1864 	if (q_data_cap->fmt && mxc_jpeg_match_image_format(q_data_cap->fmt, &header))
1865 		fourcc = q_data_cap->fmt->fourcc;
1866 	else
1867 		fourcc = mxc_jpeg_get_image_format(dev, &header);
1868 	if (fourcc == 0)
1869 		return -EINVAL;
1870 
1871 	jpeg_src_buf->fmt = mxc_jpeg_find_format(fourcc);
1872 	jpeg_src_buf->w = header.frame.width;
1873 	jpeg_src_buf->h = header.frame.height;
1874 	ctx->header_parsed = true;
1875 
1876 	if (!v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx))
1877 		mxc_jpeg_source_change(ctx, jpeg_src_buf);
1878 
1879 	return 0;
1880 }
1881 
1882 static void mxc_jpeg_buf_queue(struct vb2_buffer *vb)
1883 {
1884 	int ret;
1885 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1886 	struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
1887 	struct mxc_jpeg_src_buf *jpeg_src_buf;
1888 
1889 	if (V4L2_TYPE_IS_CAPTURE(vb->vb2_queue->type) &&
1890 	    vb2_is_streaming(vb->vb2_queue) &&
1891 	    v4l2_m2m_dst_buf_is_last(ctx->fh.m2m_ctx)) {
1892 		struct mxc_jpeg_q_data *q_data;
1893 
1894 		q_data = mxc_jpeg_get_q_data(ctx, vb->vb2_queue->type);
1895 		vbuf->field = V4L2_FIELD_NONE;
1896 		vbuf->sequence = q_data->sequence++;
1897 		v4l2_m2m_last_buffer_done(ctx->fh.m2m_ctx, vbuf);
1898 		notify_eos(ctx);
1899 		ctx->header_parsed = false;
1900 		return;
1901 	}
1902 
1903 	if (vb->vb2_queue->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1904 		goto end;
1905 
1906 	/* for V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE */
1907 	if (ctx->mxc_jpeg->mode != MXC_JPEG_DECODE)
1908 		goto end;
1909 
1910 	jpeg_src_buf = vb2_to_mxc_buf(vb);
1911 	jpeg_src_buf->jpeg_parse_error = false;
1912 	ret = mxc_jpeg_parse(ctx, vb);
1913 	if (ret)
1914 		jpeg_src_buf->jpeg_parse_error = true;
1915 
1916 end:
1917 	v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
1918 }
1919 
1920 static int mxc_jpeg_buf_out_validate(struct vb2_buffer *vb)
1921 {
1922 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1923 
1924 	vbuf->field = V4L2_FIELD_NONE;
1925 
1926 	return 0;
1927 }
1928 
1929 static int mxc_jpeg_buf_prepare(struct vb2_buffer *vb)
1930 {
1931 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1932 	struct mxc_jpeg_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
1933 	struct mxc_jpeg_q_data *q_data = NULL;
1934 	struct device *dev = ctx->mxc_jpeg->dev;
1935 	unsigned long sizeimage;
1936 	int i;
1937 
1938 	vbuf->field = V4L2_FIELD_NONE;
1939 
1940 	q_data = mxc_jpeg_get_q_data(ctx, vb->vb2_queue->type);
1941 	if (!q_data)
1942 		return -EINVAL;
1943 	for (i = 0; i < q_data->fmt->mem_planes; i++) {
1944 		sizeimage = mxc_jpeg_get_plane_size(q_data, i);
1945 		if (!ctx->source_change && vb2_plane_size(vb, i) < sizeimage) {
1946 			dev_err(dev, "plane %d too small (%lu < %lu)",
1947 				i, vb2_plane_size(vb, i), sizeimage);
1948 			return -EINVAL;
1949 		}
1950 	}
1951 	if (V4L2_TYPE_IS_CAPTURE(vb->vb2_queue->type)) {
1952 		vb2_set_plane_payload(vb, 0, 0);
1953 		vb2_set_plane_payload(vb, 1, 0);
1954 	}
1955 	return 0;
1956 }
1957 
1958 static const struct vb2_ops mxc_jpeg_qops = {
1959 	.queue_setup		= mxc_jpeg_queue_setup,
1960 	.wait_prepare		= vb2_ops_wait_prepare,
1961 	.wait_finish		= vb2_ops_wait_finish,
1962 	.buf_out_validate	= mxc_jpeg_buf_out_validate,
1963 	.buf_prepare		= mxc_jpeg_buf_prepare,
1964 	.start_streaming	= mxc_jpeg_start_streaming,
1965 	.stop_streaming		= mxc_jpeg_stop_streaming,
1966 	.buf_queue		= mxc_jpeg_buf_queue,
1967 };
1968 
1969 static int mxc_jpeg_queue_init(void *priv, struct vb2_queue *src_vq,
1970 			       struct vb2_queue *dst_vq)
1971 {
1972 	struct mxc_jpeg_ctx *ctx = priv;
1973 	int ret;
1974 
1975 	src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1976 	src_vq->io_modes = VB2_MMAP | VB2_DMABUF;
1977 	src_vq->drv_priv = ctx;
1978 	src_vq->buf_struct_size = sizeof(struct mxc_jpeg_src_buf);
1979 	src_vq->ops = &mxc_jpeg_qops;
1980 	src_vq->mem_ops = &vb2_dma_contig_memops;
1981 	src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
1982 	src_vq->lock = &ctx->mxc_jpeg->lock;
1983 	src_vq->dev = ctx->mxc_jpeg->dev;
1984 
1985 	ret = vb2_queue_init(src_vq);
1986 	if (ret)
1987 		return ret;
1988 
1989 	dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1990 	dst_vq->io_modes = VB2_MMAP | VB2_DMABUF;
1991 	dst_vq->drv_priv = ctx;
1992 	dst_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
1993 	dst_vq->ops = &mxc_jpeg_qops;
1994 	dst_vq->mem_ops = &vb2_dma_contig_memops;
1995 	dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
1996 	dst_vq->lock = &ctx->mxc_jpeg->lock;
1997 	dst_vq->dev = ctx->mxc_jpeg->dev;
1998 
1999 	ret = vb2_queue_init(dst_vq);
2000 	return ret;
2001 }
2002 
2003 static void mxc_jpeg_set_default_params(struct mxc_jpeg_ctx *ctx)
2004 {
2005 	struct mxc_jpeg_q_data *out_q = &ctx->out_q;
2006 	struct mxc_jpeg_q_data *cap_q = &ctx->cap_q;
2007 	struct mxc_jpeg_q_data *q[2] = {out_q, cap_q};
2008 	int i;
2009 
2010 	if (ctx->mxc_jpeg->mode == MXC_JPEG_ENCODE) {
2011 		out_q->fmt = mxc_jpeg_find_format(MXC_JPEG_DEFAULT_PFMT);
2012 		cap_q->fmt = mxc_jpeg_find_format(V4L2_PIX_FMT_JPEG);
2013 	} else {
2014 		out_q->fmt = mxc_jpeg_find_format(V4L2_PIX_FMT_JPEG);
2015 		cap_q->fmt = mxc_jpeg_find_format(MXC_JPEG_DEFAULT_PFMT);
2016 	}
2017 
2018 	for (i = 0; i < 2; i++) {
2019 		q[i]->w = MXC_JPEG_DEFAULT_WIDTH;
2020 		q[i]->h = MXC_JPEG_DEFAULT_HEIGHT;
2021 		q[i]->w_adjusted = MXC_JPEG_DEFAULT_WIDTH;
2022 		q[i]->h_adjusted = MXC_JPEG_DEFAULT_HEIGHT;
2023 		q[i]->crop.left = 0;
2024 		q[i]->crop.top = 0;
2025 		q[i]->crop.width = MXC_JPEG_DEFAULT_WIDTH;
2026 		q[i]->crop.height = MXC_JPEG_DEFAULT_HEIGHT;
2027 		mxc_jpeg_bytesperline(q[i], q[i]->fmt->precision);
2028 		mxc_jpeg_sizeimage(q[i]);
2029 	}
2030 }
2031 
2032 static int mxc_jpeg_s_ctrl(struct v4l2_ctrl *ctrl)
2033 {
2034 	struct mxc_jpeg_ctx *ctx =
2035 		container_of(ctrl->handler, struct mxc_jpeg_ctx, ctrl_handler);
2036 
2037 	switch (ctrl->id) {
2038 	case V4L2_CID_JPEG_COMPRESSION_QUALITY:
2039 		ctx->jpeg_quality = ctrl->val;
2040 		break;
2041 	default:
2042 		dev_err(ctx->mxc_jpeg->dev, "Invalid control, id = %d, val = %d\n",
2043 			ctrl->id, ctrl->val);
2044 		return -EINVAL;
2045 	}
2046 
2047 	return 0;
2048 }
2049 
2050 static const struct v4l2_ctrl_ops mxc_jpeg_ctrl_ops = {
2051 	.s_ctrl = mxc_jpeg_s_ctrl,
2052 };
2053 
2054 static void mxc_jpeg_encode_ctrls(struct mxc_jpeg_ctx *ctx)
2055 {
2056 	v4l2_ctrl_new_std(&ctx->ctrl_handler, &mxc_jpeg_ctrl_ops,
2057 			  V4L2_CID_JPEG_COMPRESSION_QUALITY, 1, 100, 1, 75);
2058 }
2059 
2060 static int mxc_jpeg_ctrls_setup(struct mxc_jpeg_ctx *ctx)
2061 {
2062 	int err;
2063 
2064 	v4l2_ctrl_handler_init(&ctx->ctrl_handler, 2);
2065 
2066 	if (ctx->mxc_jpeg->mode == MXC_JPEG_ENCODE)
2067 		mxc_jpeg_encode_ctrls(ctx);
2068 
2069 	if (ctx->ctrl_handler.error) {
2070 		err = ctx->ctrl_handler.error;
2071 
2072 		v4l2_ctrl_handler_free(&ctx->ctrl_handler);
2073 		return err;
2074 	}
2075 
2076 	err = v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
2077 	if (err)
2078 		v4l2_ctrl_handler_free(&ctx->ctrl_handler);
2079 	return err;
2080 }
2081 
2082 static int mxc_jpeg_open(struct file *file)
2083 {
2084 	struct mxc_jpeg_dev *mxc_jpeg = video_drvdata(file);
2085 	struct video_device *mxc_vfd = video_devdata(file);
2086 	struct device *dev = mxc_jpeg->dev;
2087 	struct mxc_jpeg_ctx *ctx;
2088 	int ret = 0;
2089 
2090 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
2091 	if (!ctx)
2092 		return -ENOMEM;
2093 
2094 	if (mutex_lock_interruptible(&mxc_jpeg->lock)) {
2095 		ret = -ERESTARTSYS;
2096 		goto free;
2097 	}
2098 
2099 	v4l2_fh_init(&ctx->fh, mxc_vfd);
2100 	file->private_data = &ctx->fh;
2101 	v4l2_fh_add(&ctx->fh);
2102 
2103 	ctx->mxc_jpeg = mxc_jpeg;
2104 
2105 	ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(mxc_jpeg->m2m_dev, ctx,
2106 					    mxc_jpeg_queue_init);
2107 
2108 	if (IS_ERR(ctx->fh.m2m_ctx)) {
2109 		ret = PTR_ERR(ctx->fh.m2m_ctx);
2110 		goto error;
2111 	}
2112 
2113 	ret = mxc_jpeg_ctrls_setup(ctx);
2114 	if (ret) {
2115 		dev_err(ctx->mxc_jpeg->dev, "failed to setup mxc jpeg controls\n");
2116 		goto err_ctrls_setup;
2117 	}
2118 	ctx->fh.ctrl_handler = &ctx->ctrl_handler;
2119 	mxc_jpeg_set_default_params(ctx);
2120 	ctx->slot = -1; /* slot not allocated yet */
2121 	INIT_DELAYED_WORK(&ctx->task_timer, mxc_jpeg_device_run_timeout);
2122 
2123 	if (mxc_jpeg->mode == MXC_JPEG_DECODE)
2124 		dev_dbg(dev, "Opened JPEG decoder instance %p\n", ctx);
2125 	else
2126 		dev_dbg(dev, "Opened JPEG encoder instance %p\n", ctx);
2127 	mutex_unlock(&mxc_jpeg->lock);
2128 
2129 	return 0;
2130 
2131 err_ctrls_setup:
2132 	v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
2133 error:
2134 	v4l2_fh_del(&ctx->fh);
2135 	v4l2_fh_exit(&ctx->fh);
2136 	mutex_unlock(&mxc_jpeg->lock);
2137 free:
2138 	kfree(ctx);
2139 	return ret;
2140 }
2141 
2142 static int mxc_jpeg_querycap(struct file *file, void *priv,
2143 			     struct v4l2_capability *cap)
2144 {
2145 	strscpy(cap->driver, MXC_JPEG_NAME " codec", sizeof(cap->driver));
2146 	strscpy(cap->card, MXC_JPEG_NAME " codec", sizeof(cap->card));
2147 	cap->device_caps = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M_MPLANE;
2148 	cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
2149 
2150 	return 0;
2151 }
2152 
2153 static int mxc_jpeg_enum_fmt_vid_cap(struct file *file, void *priv,
2154 				     struct v4l2_fmtdesc *f)
2155 {
2156 	struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv);
2157 	struct mxc_jpeg_q_data *q_data = mxc_jpeg_get_q_data(ctx, f->type);
2158 
2159 	if (ctx->mxc_jpeg->mode == MXC_JPEG_ENCODE) {
2160 		return enum_fmt(mxc_formats, MXC_JPEG_NUM_FORMATS, f,
2161 			MXC_JPEG_FMT_TYPE_ENC);
2162 	} else if (!ctx->header_parsed) {
2163 		return enum_fmt(mxc_formats, MXC_JPEG_NUM_FORMATS, f,
2164 			MXC_JPEG_FMT_TYPE_RAW);
2165 	} else {
2166 		/* For the decoder CAPTURE queue, only enumerate the raw formats
2167 		 * supported for the format currently active on OUTPUT
2168 		 * (more precisely what was propagated on capture queue
2169 		 * after jpeg parse on the output buffer)
2170 		 */
2171 		int ret = -EINVAL;
2172 		const struct mxc_jpeg_fmt *sibling;
2173 
2174 		switch (f->index) {
2175 		case 0:
2176 			f->pixelformat = q_data->fmt->fourcc;
2177 			ret = 0;
2178 			break;
2179 		case 1:
2180 			sibling = mxc_jpeg_get_sibling_format(q_data->fmt);
2181 			if (sibling) {
2182 				f->pixelformat = sibling->fourcc;
2183 				ret = 0;
2184 			}
2185 			break;
2186 		default:
2187 			break;
2188 		}
2189 		return ret;
2190 	}
2191 }
2192 
2193 static int mxc_jpeg_enum_fmt_vid_out(struct file *file, void *priv,
2194 				     struct v4l2_fmtdesc *f)
2195 {
2196 	struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv);
2197 	u32 type = ctx->mxc_jpeg->mode == MXC_JPEG_DECODE ?  MXC_JPEG_FMT_TYPE_ENC :
2198 							     MXC_JPEG_FMT_TYPE_RAW;
2199 	int ret;
2200 
2201 	ret = enum_fmt(mxc_formats, MXC_JPEG_NUM_FORMATS, f, type);
2202 	if (ret)
2203 		return ret;
2204 	if (ctx->mxc_jpeg->mode == MXC_JPEG_DECODE)
2205 		f->flags = V4L2_FMT_FLAG_DYN_RESOLUTION;
2206 	return 0;
2207 }
2208 
2209 static u32 mxc_jpeg_get_fmt_type(struct mxc_jpeg_ctx *ctx, u32 type)
2210 {
2211 	if (ctx->mxc_jpeg->mode == MXC_JPEG_DECODE)
2212 		return V4L2_TYPE_IS_OUTPUT(type) ? MXC_JPEG_FMT_TYPE_ENC : MXC_JPEG_FMT_TYPE_RAW;
2213 	else
2214 		return V4L2_TYPE_IS_CAPTURE(type) ? MXC_JPEG_FMT_TYPE_ENC : MXC_JPEG_FMT_TYPE_RAW;
2215 }
2216 
2217 static u32 mxc_jpeg_get_default_fourcc(struct mxc_jpeg_ctx *ctx, u32 type)
2218 {
2219 	if (ctx->mxc_jpeg->mode == MXC_JPEG_DECODE)
2220 		return V4L2_TYPE_IS_OUTPUT(type) ? V4L2_PIX_FMT_JPEG : MXC_JPEG_DEFAULT_PFMT;
2221 	else
2222 		return V4L2_TYPE_IS_CAPTURE(type) ? V4L2_PIX_FMT_JPEG : MXC_JPEG_DEFAULT_PFMT;
2223 }
2224 
2225 static u32 mxc_jpeg_try_fourcc(struct mxc_jpeg_ctx *ctx, u32 fourcc)
2226 {
2227 	const struct mxc_jpeg_fmt *sibling;
2228 	struct mxc_jpeg_q_data *q_data_cap;
2229 
2230 	if (ctx->mxc_jpeg->mode != MXC_JPEG_DECODE)
2231 		return fourcc;
2232 	if (!ctx->header_parsed)
2233 		return fourcc;
2234 
2235 	q_data_cap = &ctx->cap_q;
2236 	if (q_data_cap->fmt->fourcc == fourcc)
2237 		return fourcc;
2238 
2239 	sibling = mxc_jpeg_get_sibling_format(q_data_cap->fmt);
2240 	if (sibling && sibling->fourcc == fourcc)
2241 		return sibling->fourcc;
2242 
2243 	return q_data_cap->fmt->fourcc;
2244 }
2245 
2246 static int mxc_jpeg_try_fmt(struct v4l2_format *f,
2247 			    struct mxc_jpeg_ctx *ctx, struct mxc_jpeg_q_data *q_data)
2248 {
2249 	const struct mxc_jpeg_fmt *fmt;
2250 	struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
2251 	struct v4l2_plane_pix_format *pfmt;
2252 	u32 fourcc = f->fmt.pix_mp.pixelformat;
2253 	u32 w = (pix_mp->width < MXC_JPEG_MAX_WIDTH) ?
2254 		 pix_mp->width : MXC_JPEG_MAX_WIDTH;
2255 	u32 h = (pix_mp->height < MXC_JPEG_MAX_HEIGHT) ?
2256 		 pix_mp->height : MXC_JPEG_MAX_HEIGHT;
2257 	int i;
2258 
2259 	fmt = mxc_jpeg_find_format(fourcc);
2260 	if (!fmt || fmt->flags != mxc_jpeg_get_fmt_type(ctx, f->type)) {
2261 		dev_warn(ctx->mxc_jpeg->dev, "Format not supported: %c%c%c%c, use the default.\n",
2262 			 (fourcc & 0xff),
2263 			 (fourcc >>  8) & 0xff,
2264 			 (fourcc >> 16) & 0xff,
2265 			 (fourcc >> 24) & 0xff);
2266 		fourcc = mxc_jpeg_get_default_fourcc(ctx, f->type);
2267 		fmt = mxc_jpeg_find_format(fourcc);
2268 		if (!fmt)
2269 			return -EINVAL;
2270 		f->fmt.pix_mp.pixelformat = fourcc;
2271 	}
2272 	q_data->fmt = fmt;
2273 
2274 	memset(pix_mp->reserved, 0, sizeof(pix_mp->reserved));
2275 	pix_mp->field = V4L2_FIELD_NONE;
2276 	pix_mp->num_planes = fmt->mem_planes;
2277 	pix_mp->pixelformat = fmt->fourcc;
2278 
2279 	q_data->w = w;
2280 	q_data->h = h;
2281 	q_data->w_adjusted = w;
2282 	q_data->h_adjusted = h;
2283 	v4l_bound_align_image(&q_data->w_adjusted,
2284 			      w, /* adjust upwards*/
2285 			      MXC_JPEG_MAX_WIDTH,
2286 			      fmt->h_align,
2287 			      &q_data->h_adjusted,
2288 			      h, /* adjust upwards*/
2289 			      MXC_JPEG_MAX_HEIGHT,
2290 			      fmt->v_align,
2291 			      0);
2292 	for (i = 0; i < pix_mp->num_planes; i++) {
2293 		pfmt = &pix_mp->plane_fmt[i];
2294 		q_data->bytesperline[i] = pfmt->bytesperline;
2295 		q_data->sizeimage[i] = pfmt->sizeimage;
2296 	}
2297 
2298 	/* calculate bytesperline & sizeimage */
2299 	mxc_jpeg_bytesperline(q_data, fmt->precision);
2300 	mxc_jpeg_sizeimage(q_data);
2301 
2302 	/* adjust user format according to our calculations */
2303 	for (i = 0; i < pix_mp->num_planes; i++) {
2304 		pfmt = &pix_mp->plane_fmt[i];
2305 		memset(pfmt->reserved, 0, sizeof(pfmt->reserved));
2306 		pfmt->bytesperline = q_data->bytesperline[i];
2307 		pfmt->sizeimage = mxc_jpeg_get_plane_size(q_data, i);
2308 	}
2309 
2310 	/* fix colorspace information to sRGB for both output & capture */
2311 	pix_mp->colorspace = V4L2_COLORSPACE_SRGB;
2312 	pix_mp->ycbcr_enc = V4L2_YCBCR_ENC_601;
2313 	pix_mp->xfer_func = V4L2_XFER_FUNC_SRGB;
2314 	/*
2315 	 * this hardware does not change the range of the samples
2316 	 * but since inside JPEG the YUV quantization is full-range,
2317 	 * this driver will always use full-range for the raw frames, too
2318 	 */
2319 	pix_mp->quantization = V4L2_QUANTIZATION_FULL_RANGE;
2320 
2321 	if (fmt->flags == MXC_JPEG_FMT_TYPE_RAW) {
2322 		q_data->crop.left = 0;
2323 		q_data->crop.top = 0;
2324 		q_data->crop.width = q_data->w;
2325 		q_data->crop.height = q_data->h;
2326 	}
2327 
2328 	pix_mp->width = q_data->w_adjusted;
2329 	pix_mp->height = q_data->h_adjusted;
2330 
2331 	return 0;
2332 }
2333 
2334 static int mxc_jpeg_try_fmt_vid_cap(struct file *file, void *priv,
2335 				    struct v4l2_format *f)
2336 {
2337 	struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv);
2338 	struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;
2339 	struct device *dev = jpeg->dev;
2340 	struct mxc_jpeg_q_data tmp_q;
2341 
2342 	if (!V4L2_TYPE_IS_MULTIPLANAR(f->type)) {
2343 		dev_err(dev, "TRY_FMT with Invalid type: %d\n", f->type);
2344 		return -EINVAL;
2345 	}
2346 
2347 	if (ctx->mxc_jpeg->mode != MXC_JPEG_DECODE && V4L2_TYPE_IS_CAPTURE(f->type))
2348 		f->fmt.pix_mp.pixelformat = mxc_jpeg_try_fourcc(ctx, f->fmt.pix_mp.pixelformat);
2349 
2350 	return mxc_jpeg_try_fmt(f, ctx, &tmp_q);
2351 }
2352 
2353 static int mxc_jpeg_try_fmt_vid_out(struct file *file, void *priv,
2354 				    struct v4l2_format *f)
2355 {
2356 	struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv);
2357 	struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;
2358 	struct device *dev = jpeg->dev;
2359 	struct mxc_jpeg_q_data tmp_q;
2360 
2361 	if (!V4L2_TYPE_IS_MULTIPLANAR(f->type)) {
2362 		dev_err(dev, "TRY_FMT with Invalid type: %d\n", f->type);
2363 		return -EINVAL;
2364 	}
2365 
2366 	return mxc_jpeg_try_fmt(f, ctx, &tmp_q);
2367 }
2368 
2369 static void mxc_jpeg_s_parsed_fmt(struct mxc_jpeg_ctx *ctx, struct v4l2_format *f)
2370 {
2371 	struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
2372 	struct mxc_jpeg_q_data *q_data_cap;
2373 
2374 	if (ctx->mxc_jpeg->mode != MXC_JPEG_DECODE || !V4L2_TYPE_IS_CAPTURE(f->type))
2375 		return;
2376 	if (!ctx->header_parsed)
2377 		return;
2378 
2379 	q_data_cap = mxc_jpeg_get_q_data(ctx, f->type);
2380 	pix_mp->pixelformat = mxc_jpeg_try_fourcc(ctx, pix_mp->pixelformat);
2381 	pix_mp->width = q_data_cap->w;
2382 	pix_mp->height = q_data_cap->h;
2383 }
2384 
2385 static int mxc_jpeg_s_fmt(struct mxc_jpeg_ctx *ctx,
2386 			  struct v4l2_format *f)
2387 {
2388 	struct vb2_queue *vq;
2389 	struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;
2390 
2391 	vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type);
2392 	if (!vq)
2393 		return -EINVAL;
2394 
2395 	if (vb2_is_busy(vq)) {
2396 		v4l2_err(&jpeg->v4l2_dev, "queue busy\n");
2397 		return -EBUSY;
2398 	}
2399 
2400 	mxc_jpeg_s_parsed_fmt(ctx, f);
2401 
2402 	return mxc_jpeg_try_fmt(f, ctx, mxc_jpeg_get_q_data(ctx, f->type));
2403 }
2404 
2405 static int mxc_jpeg_s_fmt_vid_cap(struct file *file, void *priv,
2406 				  struct v4l2_format *f)
2407 {
2408 	return mxc_jpeg_s_fmt(mxc_jpeg_fh_to_ctx(priv), f);
2409 }
2410 
2411 static int mxc_jpeg_s_fmt_vid_out(struct file *file, void *priv,
2412 				  struct v4l2_format *f)
2413 {
2414 	int ret;
2415 	struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv);
2416 	struct vb2_queue *dst_vq;
2417 	struct mxc_jpeg_q_data *q_data_cap;
2418 	enum v4l2_buf_type cap_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
2419 	struct v4l2_format fc;
2420 
2421 	ret = mxc_jpeg_s_fmt(mxc_jpeg_fh_to_ctx(priv), f);
2422 	if (ret)
2423 		return ret;
2424 
2425 	if (ctx->mxc_jpeg->mode != MXC_JPEG_DECODE)
2426 		return 0;
2427 
2428 	dst_vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx, cap_type);
2429 	if (!dst_vq)
2430 		return -EINVAL;
2431 
2432 	if (vb2_is_busy(dst_vq))
2433 		return 0;
2434 
2435 	q_data_cap = mxc_jpeg_get_q_data(ctx, cap_type);
2436 	if (q_data_cap->w == f->fmt.pix_mp.width && q_data_cap->h == f->fmt.pix_mp.height)
2437 		return 0;
2438 	memset(&fc, 0, sizeof(fc));
2439 	fc.type = cap_type;
2440 	fc.fmt.pix_mp.pixelformat = q_data_cap->fmt->fourcc;
2441 	fc.fmt.pix_mp.width = f->fmt.pix_mp.width;
2442 	fc.fmt.pix_mp.height = f->fmt.pix_mp.height;
2443 
2444 	return mxc_jpeg_s_fmt_vid_cap(file, priv, &fc);
2445 }
2446 
2447 static int mxc_jpeg_g_fmt_vid(struct file *file, void *priv,
2448 			      struct v4l2_format *f)
2449 {
2450 	struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(priv);
2451 	struct mxc_jpeg_dev *jpeg = ctx->mxc_jpeg;
2452 	struct device *dev = jpeg->dev;
2453 	struct v4l2_pix_format_mplane   *pix_mp = &f->fmt.pix_mp;
2454 	struct mxc_jpeg_q_data *q_data = mxc_jpeg_get_q_data(ctx, f->type);
2455 	int i;
2456 
2457 	if (!V4L2_TYPE_IS_MULTIPLANAR(f->type)) {
2458 		dev_err(dev, "G_FMT with Invalid type: %d\n", f->type);
2459 		return -EINVAL;
2460 	}
2461 
2462 	pix_mp->pixelformat = q_data->fmt->fourcc;
2463 	pix_mp->width = q_data->w;
2464 	pix_mp->height = q_data->h;
2465 	pix_mp->field = V4L2_FIELD_NONE;
2466 	if (q_data->fmt->flags == MXC_JPEG_FMT_TYPE_RAW) {
2467 		pix_mp->width = q_data->w_adjusted;
2468 		pix_mp->height = q_data->h_adjusted;
2469 	}
2470 
2471 	/* fix colorspace information to sRGB for both output & capture */
2472 	pix_mp->colorspace = V4L2_COLORSPACE_SRGB;
2473 	pix_mp->ycbcr_enc = V4L2_YCBCR_ENC_601;
2474 	pix_mp->xfer_func = V4L2_XFER_FUNC_SRGB;
2475 	pix_mp->quantization = V4L2_QUANTIZATION_FULL_RANGE;
2476 
2477 	pix_mp->num_planes = q_data->fmt->mem_planes;
2478 	for (i = 0; i < pix_mp->num_planes; i++) {
2479 		pix_mp->plane_fmt[i].bytesperline = q_data->bytesperline[i];
2480 		pix_mp->plane_fmt[i].sizeimage = mxc_jpeg_get_plane_size(q_data, i);
2481 	}
2482 
2483 	return 0;
2484 }
2485 
2486 static int mxc_jpeg_dec_g_selection(struct file *file, void *fh, struct v4l2_selection *s)
2487 {
2488 	struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(fh);
2489 	struct mxc_jpeg_q_data *q_data_cap;
2490 
2491 	if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
2492 		return -EINVAL;
2493 
2494 	q_data_cap = mxc_jpeg_get_q_data(ctx, s->type);
2495 
2496 	switch (s->target) {
2497 	case V4L2_SEL_TGT_COMPOSE:
2498 	case V4L2_SEL_TGT_COMPOSE_DEFAULT:
2499 		s->r = q_data_cap->crop;
2500 		break;
2501 	case V4L2_SEL_TGT_COMPOSE_PADDED:
2502 	case V4L2_SEL_TGT_COMPOSE_BOUNDS:
2503 		s->r.left = 0;
2504 		s->r.top = 0;
2505 		s->r.width = q_data_cap->w_adjusted;
2506 		s->r.height = q_data_cap->h_adjusted;
2507 		break;
2508 	default:
2509 		return -EINVAL;
2510 	}
2511 
2512 	return 0;
2513 }
2514 
2515 static int mxc_jpeg_enc_g_selection(struct file *file, void *fh, struct v4l2_selection *s)
2516 {
2517 	struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(fh);
2518 	struct mxc_jpeg_q_data *q_data_out;
2519 
2520 	if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
2521 		return -EINVAL;
2522 
2523 	q_data_out = mxc_jpeg_get_q_data(ctx, s->type);
2524 
2525 	switch (s->target) {
2526 	case V4L2_SEL_TGT_CROP_DEFAULT:
2527 	case V4L2_SEL_TGT_CROP_BOUNDS:
2528 		s->r.left = 0;
2529 		s->r.top = 0;
2530 		s->r.width = q_data_out->w;
2531 		s->r.height = q_data_out->h;
2532 		break;
2533 	case V4L2_SEL_TGT_CROP:
2534 		s->r = q_data_out->crop;
2535 		break;
2536 	default:
2537 		return -EINVAL;
2538 	}
2539 
2540 	return 0;
2541 }
2542 
2543 static int mxc_jpeg_g_selection(struct file *file, void *fh, struct v4l2_selection *s)
2544 {
2545 	struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(fh);
2546 
2547 	if (ctx->mxc_jpeg->mode == MXC_JPEG_DECODE)
2548 		return mxc_jpeg_dec_g_selection(file, fh, s);
2549 	else
2550 		return mxc_jpeg_enc_g_selection(file, fh, s);
2551 }
2552 
2553 static int mxc_jpeg_s_selection(struct file *file, void *fh, struct v4l2_selection *s)
2554 {
2555 	struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(fh);
2556 	struct mxc_jpeg_q_data *q_data_out;
2557 
2558 	if (ctx->mxc_jpeg->mode != MXC_JPEG_ENCODE)
2559 		return -ENOTTY;
2560 
2561 	if (s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT && s->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
2562 		return -EINVAL;
2563 	if (s->target != V4L2_SEL_TGT_CROP)
2564 		return -EINVAL;
2565 
2566 	q_data_out = mxc_jpeg_get_q_data(ctx, s->type);
2567 	if (s->r.left || s->r.top)
2568 		return -EINVAL;
2569 	if (s->r.width > q_data_out->w || s->r.height > q_data_out->h)
2570 		return -EINVAL;
2571 
2572 	q_data_out->crop.left = 0;
2573 	q_data_out->crop.top = 0;
2574 	q_data_out->crop.width = s->r.width;
2575 	q_data_out->crop.height = s->r.height;
2576 
2577 	return 0;
2578 }
2579 
2580 static int mxc_jpeg_subscribe_event(struct v4l2_fh *fh,
2581 				    const struct v4l2_event_subscription *sub)
2582 {
2583 	switch (sub->type) {
2584 	case V4L2_EVENT_EOS:
2585 		return v4l2_event_subscribe(fh, sub, 0, NULL);
2586 	case V4L2_EVENT_SOURCE_CHANGE:
2587 		return v4l2_src_change_event_subscribe(fh, sub);
2588 	case V4L2_EVENT_CTRL:
2589 		return v4l2_ctrl_subscribe_event(fh, sub);
2590 	default:
2591 		return -EINVAL;
2592 	}
2593 }
2594 
2595 static const struct v4l2_ioctl_ops mxc_jpeg_ioctl_ops = {
2596 	.vidioc_querycap		= mxc_jpeg_querycap,
2597 	.vidioc_enum_fmt_vid_cap	= mxc_jpeg_enum_fmt_vid_cap,
2598 	.vidioc_enum_fmt_vid_out	= mxc_jpeg_enum_fmt_vid_out,
2599 
2600 	.vidioc_try_fmt_vid_cap_mplane	= mxc_jpeg_try_fmt_vid_cap,
2601 	.vidioc_try_fmt_vid_out_mplane	= mxc_jpeg_try_fmt_vid_out,
2602 
2603 	.vidioc_s_fmt_vid_cap_mplane	= mxc_jpeg_s_fmt_vid_cap,
2604 	.vidioc_s_fmt_vid_out_mplane	= mxc_jpeg_s_fmt_vid_out,
2605 
2606 	.vidioc_g_fmt_vid_cap_mplane	= mxc_jpeg_g_fmt_vid,
2607 	.vidioc_g_fmt_vid_out_mplane	= mxc_jpeg_g_fmt_vid,
2608 
2609 	.vidioc_g_selection		= mxc_jpeg_g_selection,
2610 	.vidioc_s_selection		= mxc_jpeg_s_selection,
2611 
2612 	.vidioc_subscribe_event		= mxc_jpeg_subscribe_event,
2613 	.vidioc_unsubscribe_event	= v4l2_event_unsubscribe,
2614 
2615 	.vidioc_try_decoder_cmd		= v4l2_m2m_ioctl_try_decoder_cmd,
2616 	.vidioc_decoder_cmd		= mxc_jpeg_decoder_cmd,
2617 	.vidioc_try_encoder_cmd		= v4l2_m2m_ioctl_try_encoder_cmd,
2618 	.vidioc_encoder_cmd		= mxc_jpeg_encoder_cmd,
2619 
2620 	.vidioc_qbuf			= v4l2_m2m_ioctl_qbuf,
2621 	.vidioc_dqbuf			= v4l2_m2m_ioctl_dqbuf,
2622 
2623 	.vidioc_create_bufs		= v4l2_m2m_ioctl_create_bufs,
2624 	.vidioc_prepare_buf		= v4l2_m2m_ioctl_prepare_buf,
2625 	.vidioc_reqbufs			= v4l2_m2m_ioctl_reqbufs,
2626 	.vidioc_querybuf		= v4l2_m2m_ioctl_querybuf,
2627 	.vidioc_expbuf			= v4l2_m2m_ioctl_expbuf,
2628 	.vidioc_streamon		= v4l2_m2m_ioctl_streamon,
2629 	.vidioc_streamoff		= v4l2_m2m_ioctl_streamoff,
2630 };
2631 
2632 static int mxc_jpeg_release(struct file *file)
2633 {
2634 	struct mxc_jpeg_dev *mxc_jpeg = video_drvdata(file);
2635 	struct mxc_jpeg_ctx *ctx = mxc_jpeg_fh_to_ctx(file->private_data);
2636 	struct device *dev = mxc_jpeg->dev;
2637 
2638 	mutex_lock(&mxc_jpeg->lock);
2639 	if (mxc_jpeg->mode == MXC_JPEG_DECODE)
2640 		dev_dbg(dev, "Release JPEG decoder instance on slot %d.",
2641 			ctx->slot);
2642 	else
2643 		dev_dbg(dev, "Release JPEG encoder instance on slot %d.",
2644 			ctx->slot);
2645 	v4l2_ctrl_handler_free(&ctx->ctrl_handler);
2646 	v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
2647 	v4l2_fh_del(&ctx->fh);
2648 	v4l2_fh_exit(&ctx->fh);
2649 	kfree(ctx);
2650 	mutex_unlock(&mxc_jpeg->lock);
2651 
2652 	return 0;
2653 }
2654 
2655 static const struct v4l2_file_operations mxc_jpeg_fops = {
2656 	.owner		= THIS_MODULE,
2657 	.open		= mxc_jpeg_open,
2658 	.release	= mxc_jpeg_release,
2659 	.poll		= v4l2_m2m_fop_poll,
2660 	.unlocked_ioctl	= video_ioctl2,
2661 	.mmap		= v4l2_m2m_fop_mmap,
2662 };
2663 
2664 static const struct v4l2_m2m_ops mxc_jpeg_m2m_ops = {
2665 	.job_ready      = mxc_jpeg_job_ready,
2666 	.device_run	= mxc_jpeg_device_run,
2667 };
2668 
2669 static void mxc_jpeg_detach_pm_domains(struct mxc_jpeg_dev *jpeg)
2670 {
2671 	int i;
2672 
2673 	for (i = 0; i < jpeg->num_domains; i++) {
2674 		if (jpeg->pd_link[i] && !IS_ERR(jpeg->pd_link[i]))
2675 			device_link_del(jpeg->pd_link[i]);
2676 		if (jpeg->pd_dev[i] && !IS_ERR(jpeg->pd_dev[i]))
2677 			dev_pm_domain_detach(jpeg->pd_dev[i], true);
2678 		jpeg->pd_dev[i] = NULL;
2679 		jpeg->pd_link[i] = NULL;
2680 	}
2681 }
2682 
2683 static int mxc_jpeg_attach_pm_domains(struct mxc_jpeg_dev *jpeg)
2684 {
2685 	struct device *dev = jpeg->dev;
2686 	struct device_node *np = jpeg->pdev->dev.of_node;
2687 	int i;
2688 	int ret;
2689 
2690 	jpeg->num_domains = of_count_phandle_with_args(np, "power-domains",
2691 						       "#power-domain-cells");
2692 	if (jpeg->num_domains < 0) {
2693 		dev_err(dev, "No power domains defined for jpeg node\n");
2694 		return jpeg->num_domains;
2695 	}
2696 	if (jpeg->num_domains == 1) {
2697 		/* genpd_dev_pm_attach() attach automatically if power domains count is 1 */
2698 		jpeg->num_domains = 0;
2699 		return 0;
2700 	}
2701 
2702 	jpeg->pd_dev = devm_kmalloc_array(dev, jpeg->num_domains,
2703 					  sizeof(*jpeg->pd_dev), GFP_KERNEL);
2704 	if (!jpeg->pd_dev)
2705 		return -ENOMEM;
2706 
2707 	jpeg->pd_link = devm_kmalloc_array(dev, jpeg->num_domains,
2708 					   sizeof(*jpeg->pd_link), GFP_KERNEL);
2709 	if (!jpeg->pd_link)
2710 		return -ENOMEM;
2711 
2712 	for (i = 0; i < jpeg->num_domains; i++) {
2713 		jpeg->pd_dev[i] = dev_pm_domain_attach_by_id(dev, i);
2714 		if (IS_ERR(jpeg->pd_dev[i])) {
2715 			ret = PTR_ERR(jpeg->pd_dev[i]);
2716 			goto fail;
2717 		}
2718 
2719 		jpeg->pd_link[i] = device_link_add(dev, jpeg->pd_dev[i],
2720 						   DL_FLAG_STATELESS |
2721 						   DL_FLAG_PM_RUNTIME);
2722 		if (!jpeg->pd_link[i]) {
2723 			ret = -EINVAL;
2724 			goto fail;
2725 		}
2726 	}
2727 
2728 	return 0;
2729 fail:
2730 	mxc_jpeg_detach_pm_domains(jpeg);
2731 	return ret;
2732 }
2733 
2734 static int mxc_jpeg_probe(struct platform_device *pdev)
2735 {
2736 	struct mxc_jpeg_dev *jpeg;
2737 	struct device *dev = &pdev->dev;
2738 	int dec_irq;
2739 	int ret;
2740 	int mode;
2741 	const struct of_device_id *of_id;
2742 
2743 	of_id = of_match_node(mxc_jpeg_match, dev->of_node);
2744 	if (!of_id)
2745 		return -ENODEV;
2746 	mode = *(const int *)of_id->data;
2747 
2748 	jpeg = devm_kzalloc(dev, sizeof(struct mxc_jpeg_dev), GFP_KERNEL);
2749 	if (!jpeg)
2750 		return -ENOMEM;
2751 
2752 	mutex_init(&jpeg->lock);
2753 	spin_lock_init(&jpeg->hw_lock);
2754 
2755 	ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
2756 	if (ret) {
2757 		dev_err(&pdev->dev, "No suitable DMA available.\n");
2758 		goto err_irq;
2759 	}
2760 
2761 	jpeg->base_reg = devm_platform_ioremap_resource(pdev, 0);
2762 	if (IS_ERR(jpeg->base_reg))
2763 		return PTR_ERR(jpeg->base_reg);
2764 
2765 	ret = of_property_read_u32_index(pdev->dev.of_node, "slot", 0, &jpeg->slot_data.slot);
2766 	if (ret)
2767 		jpeg->slot_data.slot = 0;
2768 	dev_info(&pdev->dev, "choose slot %d\n", jpeg->slot_data.slot);
2769 	dec_irq = platform_get_irq(pdev, 0);
2770 	if (dec_irq < 0) {
2771 		ret = dec_irq;
2772 		goto err_irq;
2773 	}
2774 	ret = devm_request_irq(&pdev->dev, dec_irq, mxc_jpeg_dec_irq,
2775 			       0, pdev->name, jpeg);
2776 	if (ret) {
2777 		dev_err(&pdev->dev, "Failed to request irq %d (%d)\n",
2778 			dec_irq, ret);
2779 		goto err_irq;
2780 	}
2781 
2782 	jpeg->pdev = pdev;
2783 	jpeg->dev = dev;
2784 	jpeg->mode = mode;
2785 
2786 	/* Get clocks */
2787 	ret = devm_clk_bulk_get_all(&pdev->dev, &jpeg->clks);
2788 	if (ret < 0) {
2789 		dev_err(dev, "failed to get clock\n");
2790 		goto err_clk;
2791 	}
2792 	jpeg->num_clks = ret;
2793 
2794 	ret = mxc_jpeg_attach_pm_domains(jpeg);
2795 	if (ret < 0) {
2796 		dev_err(dev, "failed to attach power domains %d\n", ret);
2797 		return ret;
2798 	}
2799 
2800 	/* v4l2 */
2801 	ret = v4l2_device_register(dev, &jpeg->v4l2_dev);
2802 	if (ret) {
2803 		dev_err(dev, "failed to register v4l2 device\n");
2804 		goto err_register;
2805 	}
2806 	jpeg->m2m_dev = v4l2_m2m_init(&mxc_jpeg_m2m_ops);
2807 	if (IS_ERR(jpeg->m2m_dev)) {
2808 		dev_err(dev, "failed to register v4l2 device\n");
2809 		ret = PTR_ERR(jpeg->m2m_dev);
2810 		goto err_m2m;
2811 	}
2812 
2813 	jpeg->dec_vdev = video_device_alloc();
2814 	if (!jpeg->dec_vdev) {
2815 		dev_err(dev, "failed to register v4l2 device\n");
2816 		ret = -ENOMEM;
2817 		goto err_vdev_alloc;
2818 	}
2819 	if (mode == MXC_JPEG_ENCODE)
2820 		snprintf(jpeg->dec_vdev->name,
2821 			 sizeof(jpeg->dec_vdev->name),
2822 			 "%s-enc", MXC_JPEG_NAME);
2823 	else
2824 		snprintf(jpeg->dec_vdev->name,
2825 			 sizeof(jpeg->dec_vdev->name),
2826 			 "%s-dec", MXC_JPEG_NAME);
2827 
2828 	jpeg->dec_vdev->fops = &mxc_jpeg_fops;
2829 	jpeg->dec_vdev->ioctl_ops = &mxc_jpeg_ioctl_ops;
2830 	jpeg->dec_vdev->minor = -1;
2831 	jpeg->dec_vdev->release = video_device_release;
2832 	jpeg->dec_vdev->lock = &jpeg->lock; /* lock for ioctl serialization */
2833 	jpeg->dec_vdev->v4l2_dev = &jpeg->v4l2_dev;
2834 	jpeg->dec_vdev->vfl_dir = VFL_DIR_M2M;
2835 	jpeg->dec_vdev->device_caps = V4L2_CAP_STREAMING |
2836 					V4L2_CAP_VIDEO_M2M_MPLANE;
2837 	if (mode == MXC_JPEG_ENCODE) {
2838 		v4l2_disable_ioctl(jpeg->dec_vdev, VIDIOC_DECODER_CMD);
2839 		v4l2_disable_ioctl(jpeg->dec_vdev, VIDIOC_TRY_DECODER_CMD);
2840 	} else {
2841 		v4l2_disable_ioctl(jpeg->dec_vdev, VIDIOC_ENCODER_CMD);
2842 		v4l2_disable_ioctl(jpeg->dec_vdev, VIDIOC_TRY_ENCODER_CMD);
2843 	}
2844 	ret = video_register_device(jpeg->dec_vdev, VFL_TYPE_VIDEO, -1);
2845 	if (ret) {
2846 		dev_err(dev, "failed to register video device\n");
2847 		goto err_vdev_register;
2848 	}
2849 	video_set_drvdata(jpeg->dec_vdev, jpeg);
2850 	if (mode == MXC_JPEG_ENCODE)
2851 		v4l2_info(&jpeg->v4l2_dev,
2852 			  "encoder device registered as /dev/video%d (%d,%d)\n",
2853 			  jpeg->dec_vdev->num, VIDEO_MAJOR,
2854 			  jpeg->dec_vdev->minor);
2855 	else
2856 		v4l2_info(&jpeg->v4l2_dev,
2857 			  "decoder device registered as /dev/video%d (%d,%d)\n",
2858 			  jpeg->dec_vdev->num, VIDEO_MAJOR,
2859 			  jpeg->dec_vdev->minor);
2860 
2861 	platform_set_drvdata(pdev, jpeg);
2862 	pm_runtime_enable(dev);
2863 
2864 	return 0;
2865 
2866 err_vdev_register:
2867 	video_device_release(jpeg->dec_vdev);
2868 
2869 err_vdev_alloc:
2870 	v4l2_m2m_release(jpeg->m2m_dev);
2871 
2872 err_m2m:
2873 	v4l2_device_unregister(&jpeg->v4l2_dev);
2874 
2875 err_register:
2876 	mxc_jpeg_detach_pm_domains(jpeg);
2877 
2878 err_irq:
2879 err_clk:
2880 	return ret;
2881 }
2882 
2883 #ifdef CONFIG_PM
2884 static int mxc_jpeg_runtime_resume(struct device *dev)
2885 {
2886 	struct mxc_jpeg_dev *jpeg = dev_get_drvdata(dev);
2887 	int ret;
2888 
2889 	ret = clk_bulk_prepare_enable(jpeg->num_clks, jpeg->clks);
2890 	if (ret < 0) {
2891 		dev_err(dev, "failed to enable clock\n");
2892 		return ret;
2893 	}
2894 
2895 	return 0;
2896 }
2897 
2898 static int mxc_jpeg_runtime_suspend(struct device *dev)
2899 {
2900 	struct mxc_jpeg_dev *jpeg = dev_get_drvdata(dev);
2901 
2902 	clk_bulk_disable_unprepare(jpeg->num_clks, jpeg->clks);
2903 
2904 	return 0;
2905 }
2906 #endif
2907 
2908 #ifdef CONFIG_PM_SLEEP
2909 static int mxc_jpeg_suspend(struct device *dev)
2910 {
2911 	struct mxc_jpeg_dev *jpeg = dev_get_drvdata(dev);
2912 
2913 	v4l2_m2m_suspend(jpeg->m2m_dev);
2914 	return pm_runtime_force_suspend(dev);
2915 }
2916 
2917 static int mxc_jpeg_resume(struct device *dev)
2918 {
2919 	struct mxc_jpeg_dev *jpeg = dev_get_drvdata(dev);
2920 	int ret;
2921 
2922 	ret = pm_runtime_force_resume(dev);
2923 	if (ret < 0)
2924 		return ret;
2925 
2926 	v4l2_m2m_resume(jpeg->m2m_dev);
2927 	return ret;
2928 }
2929 #endif
2930 
2931 static const struct dev_pm_ops	mxc_jpeg_pm_ops = {
2932 	SET_RUNTIME_PM_OPS(mxc_jpeg_runtime_suspend,
2933 			   mxc_jpeg_runtime_resume, NULL)
2934 	SET_SYSTEM_SLEEP_PM_OPS(mxc_jpeg_suspend, mxc_jpeg_resume)
2935 };
2936 
2937 static void mxc_jpeg_remove(struct platform_device *pdev)
2938 {
2939 	struct mxc_jpeg_dev *jpeg = platform_get_drvdata(pdev);
2940 
2941 	mxc_jpeg_free_slot_data(jpeg);
2942 
2943 	pm_runtime_disable(&pdev->dev);
2944 	video_unregister_device(jpeg->dec_vdev);
2945 	v4l2_m2m_release(jpeg->m2m_dev);
2946 	v4l2_device_unregister(&jpeg->v4l2_dev);
2947 	mxc_jpeg_detach_pm_domains(jpeg);
2948 }
2949 
2950 MODULE_DEVICE_TABLE(of, mxc_jpeg_match);
2951 
2952 static struct platform_driver mxc_jpeg_driver = {
2953 	.probe = mxc_jpeg_probe,
2954 	.remove_new = mxc_jpeg_remove,
2955 	.driver = {
2956 		.name = "mxc-jpeg",
2957 		.of_match_table = mxc_jpeg_match,
2958 		.pm = &mxc_jpeg_pm_ops,
2959 	},
2960 };
2961 module_platform_driver(mxc_jpeg_driver);
2962 
2963 MODULE_AUTHOR("Zhengyu Shen <zhengyu.shen_1@nxp.com>");
2964 MODULE_AUTHOR("Mirela Rabulea <mirela.rabulea@nxp.com>");
2965 MODULE_DESCRIPTION("V4L2 driver for i.MX8 QXP/QM JPEG encoder/decoder");
2966 MODULE_LICENSE("GPL v2");
2967