?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gpio: rcar: Fix runtime PM imbalance on error
[linux/fpc-iii.git] / drivers / media / platform / rcar_jpu.c
blob5250a14324e917ce645a1122f0c0779aa8d98cc1
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Author: Mikhail Ulyanov
4 * Copyright (C) 2014-2015 Cogent Embedded, Inc. <source@cogentembedded.com>
5 * Copyright (C) 2014-2015 Renesas Electronics Corporation
6 *
7 * This is based on the drivers/media/platform/s5p-jpeg driver by
8 * Andrzej Pietrasiewicz and Jacek Anaszewski.
9 * Some portions of code inspired by VSP1 driver by Laurent Pinchart.
10 *
11 * TODO in order of priority:
12 * 1) Rotation
13 * 2) Cropping
14 * 3) V4L2_CID_JPEG_ACTIVE_MARKER
15 */
16
17 #include <asm/unaligned.h>
18 #include <linux/clk.h>
19 #include <linux/err.h>
20 #include <linux/interrupt.h>
21 #include <linux/io.h>
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/of.h>
25 #include <linux/of_device.h>
26 #include <linux/platform_device.h>
27 #include <linux/slab.h>
28 #include <linux/spinlock.h>
29 #include <linux/string.h>
30 #include <linux/videodev2.h>
31 #include <media/v4l2-ctrls.h>
32 #include <media/v4l2-device.h>
33 #include <media/v4l2-event.h>
34 #include <media/v4l2-fh.h>
35 #include <media/v4l2-mem2mem.h>
36 #include <media/v4l2-ioctl.h>
37 #include <media/videobuf2-v4l2.h>
38 #include <media/videobuf2-dma-contig.h>
39
40
41 #define DRV_NAME "rcar_jpu"
42
43 /*
44 * Align JPEG header end to cache line to make sure we will not have any issues
45 * with cache; additionally to requerment (33.3.27 R01UH0501EJ0100 Rev.1.00)
46 */
47 #define JPU_JPEG_HDR_SIZE (ALIGN(0x258, L1_CACHE_BYTES))
48 #define JPU_JPEG_MAX_BYTES_PER_PIXEL 2 /* 16 bit precision format */
49 #define JPU_JPEG_MIN_SIZE 25 /* SOI + SOF + EOI */
50 #define JPU_JPEG_QTBL_SIZE 0x40
51 #define JPU_JPEG_HDCTBL_SIZE 0x1c
52 #define JPU_JPEG_HACTBL_SIZE 0xb2
53 #define JPU_JPEG_HEIGHT_OFFSET 0x91
54 #define JPU_JPEG_WIDTH_OFFSET 0x93
55 #define JPU_JPEG_SUBS_OFFSET 0x97
56 #define JPU_JPEG_QTBL_LUM_OFFSET 0x07
57 #define JPU_JPEG_QTBL_CHR_OFFSET 0x4c
58 #define JPU_JPEG_HDCTBL_LUM_OFFSET 0xa4
59 #define JPU_JPEG_HACTBL_LUM_OFFSET 0xc5
60 #define JPU_JPEG_HDCTBL_CHR_OFFSET 0x17c
61 #define JPU_JPEG_HACTBL_CHR_OFFSET 0x19d
62 #define JPU_JPEG_PADDING_OFFSET 0x24f
63 #define JPU_JPEG_LUM 0x00
64 #define JPU_JPEG_CHR 0x01
65 #define JPU_JPEG_DC 0x00
66 #define JPU_JPEG_AC 0x10
67
68 #define JPU_JPEG_422 0x21
69 #define JPU_JPEG_420 0x22
70
71 #define JPU_JPEG_DEFAULT_422_PIX_FMT V4L2_PIX_FMT_NV16M
72 #define JPU_JPEG_DEFAULT_420_PIX_FMT V4L2_PIX_FMT_NV12M
73
74 /* JPEG markers */
75 #define TEM 0x01
76 #define SOF0 0xc0
77 #define RST 0xd0
78 #define SOI 0xd8
79 #define EOI 0xd9
80 #define DHP 0xde
81 #define DHT 0xc4
82 #define COM 0xfe
83 #define DQT 0xdb
84 #define DRI 0xdd
85 #define APP0 0xe0
86
87 #define JPU_RESET_TIMEOUT 100 /* ms */
88 #define JPU_JOB_TIMEOUT 300 /* ms */
89 #define JPU_MAX_QUALITY 4
90 #define JPU_WIDTH_MIN 16
91 #define JPU_HEIGHT_MIN 16
92 #define JPU_WIDTH_MAX 4096
93 #define JPU_HEIGHT_MAX 4096
94 #define JPU_MEMALIGN 8
95
96 /* Flags that indicate a format can be used for capture/output */
97 #define JPU_FMT_TYPE_OUTPUT 0
98 #define JPU_FMT_TYPE_CAPTURE 1
99 #define JPU_ENC_CAPTURE (1 << 0)
100 #define JPU_ENC_OUTPUT (1 << 1)
101 #define JPU_DEC_CAPTURE (1 << 2)
102 #define JPU_DEC_OUTPUT (1 << 3)
103
104 /*
105 * JPEG registers and bits
106 */
107
108 /* JPEG code mode register */
109 #define JCMOD 0x00
110 #define JCMOD_PCTR (1 << 7)
111 #define JCMOD_MSKIP_ENABLE (1 << 5)
112 #define JCMOD_DSP_ENC (0 << 3)
113 #define JCMOD_DSP_DEC (1 << 3)
114 #define JCMOD_REDU (7 << 0)
115 #define JCMOD_REDU_422 (1 << 0)
116 #define JCMOD_REDU_420 (2 << 0)
117
118 /* JPEG code command register */
119 #define JCCMD 0x04
120 #define JCCMD_SRST (1 << 12)
121 #define JCCMD_JEND (1 << 2)
122 #define JCCMD_JSRT (1 << 0)
123
124 /* JPEG code quantanization table number register */
125 #define JCQTN 0x0c
126 #define JCQTN_SHIFT(t) (((t) - 1) << 1)
127
128 /* JPEG code Huffman table number register */
129 #define JCHTN 0x10
130 #define JCHTN_AC_SHIFT(t) (((t) << 1) - 1)
131 #define JCHTN_DC_SHIFT(t) (((t) - 1) << 1)
132
133 #define JCVSZU 0x1c /* JPEG code vertical size upper register */
134 #define JCVSZD 0x20 /* JPEG code vertical size lower register */
135 #define JCHSZU 0x24 /* JPEG code horizontal size upper register */
136 #define JCHSZD 0x28 /* JPEG code horizontal size lower register */
137 #define JCSZ_MASK 0xff /* JPEG code h/v size register contains only 1 byte*/
138
139 #define JCDTCU 0x2c /* JPEG code data count upper register */
140 #define JCDTCM 0x30 /* JPEG code data count middle register */
141 #define JCDTCD 0x34 /* JPEG code data count lower register */
142
143 /* JPEG interrupt enable register */
144 #define JINTE 0x38
145 #define JINTE_ERR (7 << 5) /* INT5 + INT6 + INT7 */
146 #define JINTE_TRANSF_COMPL (1 << 10)
147
148 /* JPEG interrupt status register */
149 #define JINTS 0x3c
150 #define JINTS_MASK 0x7c68
151 #define JINTS_ERR (1 << 5)
152 #define JINTS_PROCESS_COMPL (1 << 6)
153 #define JINTS_TRANSF_COMPL (1 << 10)
154
155 #define JCDERR 0x40 /* JPEG code decode error register */
156 #define JCDERR_MASK 0xf /* JPEG code decode error register mask*/
157
158 /* JPEG interface encoding */
159 #define JIFECNT 0x70
160 #define JIFECNT_INFT_422 0
161 #define JIFECNT_INFT_420 1
162 #define JIFECNT_SWAP_WB (3 << 4) /* to JPU */
163
164 #define JIFESYA1 0x74 /* encode source Y address register 1 */
165 #define JIFESCA1 0x78 /* encode source C address register 1 */
166 #define JIFESYA2 0x7c /* encode source Y address register 2 */
167 #define JIFESCA2 0x80 /* encode source C address register 2 */
168 #define JIFESMW 0x84 /* encode source memory width register */
169 #define JIFESVSZ 0x88 /* encode source vertical size register */
170 #define JIFESHSZ 0x8c /* encode source horizontal size register */
171 #define JIFEDA1 0x90 /* encode destination address register 1 */
172 #define JIFEDA2 0x94 /* encode destination address register 2 */
173
174 /* JPEG decoding control register */
175 #define JIFDCNT 0xa0
176 #define JIFDCNT_SWAP_WB (3 << 1) /* from JPU */
177
178 #define JIFDSA1 0xa4 /* decode source address register 1 */
179 #define JIFDDMW 0xb0 /* decode destination memory width register */
180 #define JIFDDVSZ 0xb4 /* decode destination vert. size register */
181 #define JIFDDHSZ 0xb8 /* decode destination horiz. size register */
182 #define JIFDDYA1 0xbc /* decode destination Y address register 1 */
183 #define JIFDDCA1 0xc0 /* decode destination C address register 1 */
184
185 #define JCQTBL(n) (0x10000 + (n) * 0x40) /* quantization tables regs */
186 #define JCHTBD(n) (0x10100 + (n) * 0x100) /* Huffman table DC regs */
187 #define JCHTBA(n) (0x10120 + (n) * 0x100) /* Huffman table AC regs */
188
189 /**
190 * struct jpu - JPEG IP abstraction
191 * @mutex: the mutex protecting this structure
192 * @lock: spinlock protecting the device contexts
193 * @v4l2_dev: v4l2 device for mem2mem mode
194 * @vfd_encoder: video device node for encoder mem2mem mode
195 * @vfd_decoder: video device node for decoder mem2mem mode
196 * @m2m_dev: v4l2 mem2mem device data
197 * @curr: pointer to current context
198 * @regs: JPEG IP registers mapping
199 * @irq: JPEG IP irq
200 * @clk: JPEG IP clock
201 * @dev: JPEG IP struct device
202 * @ref_count: reference counter
203 */
204 struct jpu {
205 struct mutex mutex;
206 spinlock_t lock;
207 struct v4l2_device v4l2_dev;
208 struct video_device vfd_encoder;
209 struct video_device vfd_decoder;
210 struct v4l2_m2m_dev *m2m_dev;
211 struct jpu_ctx *curr;
212
213 void __iomem *regs;
214 unsigned int irq;
215 struct clk *clk;
216 struct device *dev;
217 int ref_count;
218 };
219
220 /**
221 * struct jpu_buffer - driver's specific video buffer
222 * @buf: m2m buffer
223 * @compr_quality: destination image quality in compression mode
224 * @subsampling: source image subsampling in decompression mode
225 */
226 struct jpu_buffer {
227 struct v4l2_m2m_buffer buf;
228 unsigned short compr_quality;
229 unsigned char subsampling;
230 };
231
232 /**
233 * struct jpu_fmt - driver's internal format data
234 * @fourcc: the fourcc code, 0 if not applicable
235 * @colorspace: the colorspace specifier
236 * @bpp: number of bits per pixel per plane
237 * @h_align: horizontal alignment order (align to 2^h_align)
238 * @v_align: vertical alignment order (align to 2^v_align)
239 * @subsampling: (horizontal:4 | vertical:4) subsampling factor
240 * @num_planes: number of planes
241 * @types: types of queue this format is applicable to
242 */
243 struct jpu_fmt {
244 u32 fourcc;
245 u32 colorspace;
246 u8 bpp[2];
247 u8 h_align;
248 u8 v_align;
249 u8 subsampling;
250 u8 num_planes;
251 u16 types;
252 };
253
254 /**
255 * struct jpu_q_data - parameters of one queue
256 * @fmtinfo: driver-specific format of this queue
257 * @format: multiplanar format of this queue
258 * @sequence: sequence number
259 */
260 struct jpu_q_data {
261 struct jpu_fmt *fmtinfo;
262 struct v4l2_pix_format_mplane format;
263 unsigned int sequence;
264 };
265
266 /**
267 * struct jpu_ctx - the device context data
268 * @jpu: JPEG IP device for this context
269 * @encoder: compression (encode) operation or decompression (decode)
270 * @compr_quality: destination image quality in compression (encode) mode
271 * @out_q: source (output) queue information
272 * @cap_q: destination (capture) queue information
273 * @fh: file handler
274 * @ctrl_handler: controls handler
275 */
276 struct jpu_ctx {
277 struct jpu *jpu;
278 bool encoder;
279 unsigned short compr_quality;
280 struct jpu_q_data out_q;
281 struct jpu_q_data cap_q;
282 struct v4l2_fh fh;
283 struct v4l2_ctrl_handler ctrl_handler;
284 };
285
286 /**
287 * jpeg_buffer - description of memory containing input JPEG data
288 * @end: end position in the buffer
289 * @curr: current position in the buffer
290 */
291 struct jpeg_buffer {
292 void *end;
293 void *curr;
294 };
295
296 static struct jpu_fmt jpu_formats[] = {
297 { V4L2_PIX_FMT_JPEG, V4L2_COLORSPACE_JPEG,
298 {0, 0}, 0, 0, 0, 1, JPU_ENC_CAPTURE | JPU_DEC_OUTPUT },
299 { V4L2_PIX_FMT_NV16M, V4L2_COLORSPACE_SRGB,
300 {8, 8}, 2, 2, JPU_JPEG_422, 2, JPU_ENC_OUTPUT | JPU_DEC_CAPTURE },
301 { V4L2_PIX_FMT_NV12M, V4L2_COLORSPACE_SRGB,
302 {8, 4}, 2, 2, JPU_JPEG_420, 2, JPU_ENC_OUTPUT | JPU_DEC_CAPTURE },
303 { V4L2_PIX_FMT_NV16, V4L2_COLORSPACE_SRGB,
304 {16, 0}, 2, 2, JPU_JPEG_422, 1, JPU_ENC_OUTPUT | JPU_DEC_CAPTURE },
305 { V4L2_PIX_FMT_NV12, V4L2_COLORSPACE_SRGB,
306 {12, 0}, 2, 2, JPU_JPEG_420, 1, JPU_ENC_OUTPUT | JPU_DEC_CAPTURE },
307 };
308
309 static const u8 zigzag[] = {
310 0x03, 0x02, 0x0b, 0x13, 0x0a, 0x01, 0x00, 0x09,
311 0x12, 0x1b, 0x23, 0x1a, 0x11, 0x08, 0x07, 0x06,
312 0x0f, 0x10, 0x19, 0x22, 0x2b, 0x33, 0x2a, 0x21,
313 0x18, 0x17, 0x0e, 0x05, 0x04, 0x0d, 0x16, 0x1f,
314 0x20, 0x29, 0x32, 0x3b, 0x3a, 0x31, 0x28, 0x27,
315 0x1e, 0x15, 0x0e, 0x14, 0x10, 0x26, 0x2f, 0x30,
316 0x39, 0x38, 0x37, 0x2e, 0x25, 0x1c, 0x24, 0x2b,
317 0x36, 0x3f, 0x3e, 0x35, 0x2c, 0x34, 0x3d, 0x3c
318 };
319
320 #define QTBL_SIZE (ALIGN(JPU_JPEG_QTBL_SIZE, \
321 sizeof(unsigned int)) / sizeof(unsigned int))
322 #define HDCTBL_SIZE (ALIGN(JPU_JPEG_HDCTBL_SIZE, \
323 sizeof(unsigned int)) / sizeof(unsigned int))
324 #define HACTBL_SIZE (ALIGN(JPU_JPEG_HACTBL_SIZE, \
325 sizeof(unsigned int)) / sizeof(unsigned int))
326 /*
327 * Start of image; Quantization tables
328 * SOF0 (17 bytes payload) is Baseline DCT - Sample precision, height, width,
329 * Number of image components, (Ci:8 - Hi:4 - Vi:4 - Tq:8) * 3 - Y,Cb,Cr;
330 * Huffman tables; Padding with 0xff (33.3.27 R01UH0501EJ0100 Rev.1.00)
331 */
332 #define JPU_JPEG_HDR_BLOB { \
333 0xff, SOI, 0xff, DQT, 0x00, JPU_JPEG_QTBL_SIZE + 0x3, JPU_JPEG_LUM, \
334 [JPU_JPEG_QTBL_LUM_OFFSET ... \
335 JPU_JPEG_QTBL_LUM_OFFSET + JPU_JPEG_QTBL_SIZE - 1] = 0x00, \
336 0xff, DQT, 0x00, JPU_JPEG_QTBL_SIZE + 0x3, JPU_JPEG_CHR, \
337 [JPU_JPEG_QTBL_CHR_OFFSET ... JPU_JPEG_QTBL_CHR_OFFSET + \
338 JPU_JPEG_QTBL_SIZE - 1] = 0x00, 0xff, SOF0, 0x00, 0x11, 0x08, \
339 [JPU_JPEG_HEIGHT_OFFSET ... JPU_JPEG_HEIGHT_OFFSET + 1] = 0x00, \
340 [JPU_JPEG_WIDTH_OFFSET ... JPU_JPEG_WIDTH_OFFSET + 1] = 0x00, \
341 0x03, 0x01, [JPU_JPEG_SUBS_OFFSET] = 0x00, JPU_JPEG_LUM, \
342 0x02, 0x11, JPU_JPEG_CHR, 0x03, 0x11, JPU_JPEG_CHR, \
343 0xff, DHT, 0x00, JPU_JPEG_HDCTBL_SIZE + 0x3, JPU_JPEG_LUM|JPU_JPEG_DC, \
344 [JPU_JPEG_HDCTBL_LUM_OFFSET ... \
345 JPU_JPEG_HDCTBL_LUM_OFFSET + JPU_JPEG_HDCTBL_SIZE - 1] = 0x00, \
346 0xff, DHT, 0x00, JPU_JPEG_HACTBL_SIZE + 0x3, JPU_JPEG_LUM|JPU_JPEG_AC, \
347 [JPU_JPEG_HACTBL_LUM_OFFSET ... \
348 JPU_JPEG_HACTBL_LUM_OFFSET + JPU_JPEG_HACTBL_SIZE - 1] = 0x00, \
349 0xff, DHT, 0x00, JPU_JPEG_HDCTBL_SIZE + 0x3, JPU_JPEG_CHR|JPU_JPEG_DC, \
350 [JPU_JPEG_HDCTBL_CHR_OFFSET ... \
351 JPU_JPEG_HDCTBL_CHR_OFFSET + JPU_JPEG_HDCTBL_SIZE - 1] = 0x00, \
352 0xff, DHT, 0x00, JPU_JPEG_HACTBL_SIZE + 0x3, JPU_JPEG_CHR|JPU_JPEG_AC, \
353 [JPU_JPEG_HACTBL_CHR_OFFSET ... \
354 JPU_JPEG_HACTBL_CHR_OFFSET + JPU_JPEG_HACTBL_SIZE - 1] = 0x00, \
355 [JPU_JPEG_PADDING_OFFSET ... JPU_JPEG_HDR_SIZE - 1] = 0xff \
356 }
357
358 static unsigned char jpeg_hdrs[JPU_MAX_QUALITY][JPU_JPEG_HDR_SIZE] = {
359 [0 ... JPU_MAX_QUALITY - 1] = JPU_JPEG_HDR_BLOB
360 };
361
362 static const unsigned int qtbl_lum[JPU_MAX_QUALITY][QTBL_SIZE] = {
363 {
364 0x14101927, 0x322e3e44, 0x10121726, 0x26354144,
365 0x19171f26, 0x35414444, 0x27262635, 0x41444444,
366 0x32263541, 0x44444444, 0x2e354144, 0x44444444,
367 0x3e414444, 0x44444444, 0x44444444, 0x44444444
368 },
369 {
370 0x100b0b10, 0x171b1f1e, 0x0b0c0c0f, 0x1417171e,
371 0x0b0c0d10, 0x171a232f, 0x100f1017, 0x1a252f40,
372 0x1714171a, 0x27334040, 0x1b171a25, 0x33404040,
373 0x1f17232f, 0x40404040, 0x1e1e2f40, 0x40404040
374 },
375 {
376 0x0c08080c, 0x11151817, 0x0809090b, 0x0f131217,
377 0x08090a0c, 0x13141b24, 0x0c0b0c15, 0x141c2435,
378 0x110f1314, 0x1e27333b, 0x1513141c, 0x27333b3b,
379 0x18121b24, 0x333b3b3b, 0x17172435, 0x3b3b3b3b
380 },
381 {
382 0x08060608, 0x0c0e1011, 0x06060608, 0x0a0d0c0f,
383 0x06060708, 0x0d0e1218, 0x0808080e, 0x0d131823,
384 0x0c0a0d0d, 0x141a2227, 0x0e0d0e13, 0x1a222727,
385 0x100c1318, 0x22272727, 0x110f1823, 0x27272727
386 }
387 };
388
389 static const unsigned int qtbl_chr[JPU_MAX_QUALITY][QTBL_SIZE] = {
390 {
391 0x15192026, 0x36444444, 0x191c1826, 0x36444444,
392 0x2018202b, 0x42444444, 0x26262b35, 0x44444444,
393 0x36424444, 0x44444444, 0x44444444, 0x44444444,
394 0x44444444, 0x44444444, 0x44444444, 0x44444444
395 },
396 {
397 0x110f1115, 0x141a2630, 0x0f131211, 0x141a232b,
398 0x11121416, 0x1a1e2e35, 0x1511161c, 0x1e273540,
399 0x14141a1e, 0x27304040, 0x1a1a1e27, 0x303f4040,
400 0x26232e35, 0x40404040, 0x302b3540, 0x40404040
401 },
402 {
403 0x0d0b0d10, 0x14141d25, 0x0b0e0e0e, 0x10141a20,
404 0x0d0e0f11, 0x14172328, 0x100e1115, 0x171e2832,
405 0x14101417, 0x1e25323b, 0x1414171e, 0x25303b3b,
406 0x1d1a2328, 0x323b3b3b, 0x25202832, 0x3b3b3b3b
407 },
408 {
409 0x0908090b, 0x0e111318, 0x080a090b, 0x0e0d1116,
410 0x09090d0e, 0x0d0f171a, 0x0b0b0e0e, 0x0f141a21,
411 0x0e0e0d0f, 0x14182127, 0x110d0f14, 0x18202727,
412 0x1311171a, 0x21272727, 0x18161a21, 0x27272727
413 }
414 };
415
416 static const unsigned int hdctbl_lum[HDCTBL_SIZE] = {
417 0x00010501, 0x01010101, 0x01000000, 0x00000000,
418 0x00010203, 0x04050607, 0x08090a0b
419 };
420
421 static const unsigned int hdctbl_chr[HDCTBL_SIZE] = {
422 0x00010501, 0x01010101, 0x01000000, 0x00000000,
423 0x00010203, 0x04050607, 0x08090a0b
424 };
425
426 static const unsigned int hactbl_lum[HACTBL_SIZE] = {
427 0x00020103, 0x03020403, 0x05050404, 0x0000017d, 0x01020300, 0x04110512,
428 0x21314106, 0x13516107, 0x22711432, 0x8191a108, 0x2342b1c1, 0x1552d1f0,
429 0x24336272, 0x82090a16, 0x1718191a, 0x25262728, 0x292a3435, 0x36373839,
430 0x3a434445, 0x46474849, 0x4a535455, 0x56575859, 0x5a636465, 0x66676869,
431 0x6a737475, 0x76777879, 0x7a838485, 0x86878889, 0x8a929394, 0x95969798,
432 0x999aa2a3, 0xa4a5a6a7, 0xa8a9aab2, 0xb3b4b5b6, 0xb7b8b9ba, 0xc2c3c4c5,
433 0xc6c7c8c9, 0xcad2d3d4, 0xd5d6d7d8, 0xd9dae1e2, 0xe3e4e5e6, 0xe7e8e9ea,
434 0xf1f2f3f4, 0xf5f6f7f8, 0xf9fa0000
435 };
436
437 static const unsigned int hactbl_chr[HACTBL_SIZE] = {
438 0x00020103, 0x03020403, 0x05050404, 0x0000017d, 0x01020300, 0x04110512,
439 0x21314106, 0x13516107, 0x22711432, 0x8191a108, 0x2342b1c1, 0x1552d1f0,
440 0x24336272, 0x82090a16, 0x1718191a, 0x25262728, 0x292a3435, 0x36373839,
441 0x3a434445, 0x46474849, 0x4a535455, 0x56575859, 0x5a636465, 0x66676869,
442 0x6a737475, 0x76777879, 0x7a838485, 0x86878889, 0x8a929394, 0x95969798,
443 0x999aa2a3, 0xa4a5a6a7, 0xa8a9aab2, 0xb3b4b5b6, 0xb7b8b9ba, 0xc2c3c4c5,
444 0xc6c7c8c9, 0xcad2d3d4, 0xd5d6d7d8, 0xd9dae1e2, 0xe3e4e5e6, 0xe7e8e9ea,
445 0xf1f2f3f4, 0xf5f6f7f8, 0xf9fa0000
446 };
447
448 static const char *error_to_text[16] = {
449 "Normal",
450 "SOI not detected",
451 "SOF1 to SOFF detected",
452 "Subsampling not detected",
453 "SOF accuracy error",
454 "DQT accuracy error",
455 "Component error 1",
456 "Component error 2",
457 "SOF0, DQT, and DHT not detected when SOS detected",
458 "SOS not detected",
459 "EOI not detected",
460 "Restart interval data number error detected",
461 "Image size error",
462 "Last MCU data number error",
463 "Block data number error",
464 "Unknown"
465 };
466
467 static struct jpu_buffer *vb2_to_jpu_buffer(struct vb2_v4l2_buffer *vb)
468 {
469 struct v4l2_m2m_buffer *b =
470 container_of(vb, struct v4l2_m2m_buffer, vb);
471
472 return container_of(b, struct jpu_buffer, buf);
473 }
474
475 static u32 jpu_read(struct jpu *jpu, unsigned int reg)
476 {
477 return ioread32(jpu->regs + reg);
478 }
479
480 static void jpu_write(struct jpu *jpu, u32 val, unsigned int reg)
481 {
482 iowrite32(val, jpu->regs + reg);
483 }
484
485 static struct jpu_ctx *ctrl_to_ctx(struct v4l2_ctrl *c)
486 {
487 return container_of(c->handler, struct jpu_ctx, ctrl_handler);
488 }
489
490 static struct jpu_ctx *fh_to_ctx(struct v4l2_fh *fh)
491 {
492 return container_of(fh, struct jpu_ctx, fh);
493 }
494
495 static void jpu_set_tbl(struct jpu *jpu, u32 reg, const unsigned int *tbl,
496 unsigned int len) {
497 unsigned int i;
498
499 for (i = 0; i < len; i++)
500 jpu_write(jpu, tbl[i], reg + (i << 2));
501 }
502
503 static void jpu_set_qtbl(struct jpu *jpu, unsigned short quality)
504 {
505 jpu_set_tbl(jpu, JCQTBL(0), qtbl_lum[quality], QTBL_SIZE);
506 jpu_set_tbl(jpu, JCQTBL(1), qtbl_chr[quality], QTBL_SIZE);
507 }
508
509 static void jpu_set_htbl(struct jpu *jpu)
510 {
511 jpu_set_tbl(jpu, JCHTBD(0), hdctbl_lum, HDCTBL_SIZE);
512 jpu_set_tbl(jpu, JCHTBA(0), hactbl_lum, HACTBL_SIZE);
513 jpu_set_tbl(jpu, JCHTBD(1), hdctbl_chr, HDCTBL_SIZE);
514 jpu_set_tbl(jpu, JCHTBA(1), hactbl_chr, HACTBL_SIZE);
515 }
516
517 static int jpu_wait_reset(struct jpu *jpu)
518 {
519 unsigned long timeout;
520
521 timeout = jiffies + msecs_to_jiffies(JPU_RESET_TIMEOUT);
522
523 while (jpu_read(jpu, JCCMD) & JCCMD_SRST) {
524 if (time_after(jiffies, timeout)) {
525 dev_err(jpu->dev, "timed out in reset\n");
526 return -ETIMEDOUT;
527 }
528 schedule();
529 }
530
531 return 0;
532 }
533
534 static int jpu_reset(struct jpu *jpu)
535 {
536 jpu_write(jpu, JCCMD_SRST, JCCMD);
537 return jpu_wait_reset(jpu);
538 }
539
540 /*
541 * ============================================================================
542 * video ioctl operations
543 * ============================================================================
544 */
545 static void put_qtbl(u8 *p, const u8 *qtbl)
546 {
547 unsigned int i;
548
549 for (i = 0; i < ARRAY_SIZE(zigzag); i++)
550 p[i] = *(qtbl + zigzag[i]);
551 }
552
553 static void put_htbl(u8 *p, const u8 *htbl, unsigned int len)
554 {
555 unsigned int i, j;
556
557 for (i = 0; i < len; i += 4)
558 for (j = 0; j < 4 && (i + j) < len; ++j)
559 p[i + j] = htbl[i + 3 - j];
560 }
561
562 static void jpu_generate_hdr(unsigned short quality, unsigned char *p)
563 {
564 put_qtbl(p + JPU_JPEG_QTBL_LUM_OFFSET, (const u8 *)qtbl_lum[quality]);
565 put_qtbl(p + JPU_JPEG_QTBL_CHR_OFFSET, (const u8 *)qtbl_chr[quality]);
566
567 put_htbl(p + JPU_JPEG_HDCTBL_LUM_OFFSET, (const u8 *)hdctbl_lum,
568 JPU_JPEG_HDCTBL_SIZE);
569 put_htbl(p + JPU_JPEG_HACTBL_LUM_OFFSET, (const u8 *)hactbl_lum,
570 JPU_JPEG_HACTBL_SIZE);
571
572 put_htbl(p + JPU_JPEG_HDCTBL_CHR_OFFSET, (const u8 *)hdctbl_chr,
573 JPU_JPEG_HDCTBL_SIZE);
574 put_htbl(p + JPU_JPEG_HACTBL_CHR_OFFSET, (const u8 *)hactbl_chr,
575 JPU_JPEG_HACTBL_SIZE);
576 }
577
578 static int get_byte(struct jpeg_buffer *buf)
579 {
580 if (buf->curr >= buf->end)
581 return -1;
582
583 return *(u8 *)buf->curr++;
584 }
585
586 static int get_word_be(struct jpeg_buffer *buf, unsigned int *word)
587 {
588 if (buf->end - buf->curr < 2)
589 return -1;
590
591 *word = get_unaligned_be16(buf->curr);
592 buf->curr += 2;
593
594 return 0;
595 }
596
597 static void skip(struct jpeg_buffer *buf, unsigned long len)
598 {
599 buf->curr += min((unsigned long)(buf->end - buf->curr), len);
600 }
601
602 static u8 jpu_parse_hdr(void *buffer, unsigned long size, unsigned int *width,
603 unsigned int *height)
604 {
605 struct jpeg_buffer jpeg_buffer;
606 unsigned int word;
607 bool soi = false;
608
609 jpeg_buffer.end = buffer + size;
610 jpeg_buffer.curr = buffer;
611
612 /*
613 * basic size check and EOI - we don't want to let JPU cross
614 * buffer bounds in any case. Hope it's stopping by EOI.
615 */
616 if (size < JPU_JPEG_MIN_SIZE || *(u8 *)(buffer + size - 1) != EOI)
617 return 0;
618
619 for (;;) {
620 int c;
621
622 /* skip preceding filler bytes */
623 do
624 c = get_byte(&jpeg_buffer);
625 while (c == 0xff || c == 0);
626
627 if (!soi && c == SOI) {
628 soi = true;
629 continue;
630 } else if (soi != (c != SOI))
631 return 0;
632
633 switch (c) {
634 case SOF0: /* SOF0: baseline JPEG */
635 skip(&jpeg_buffer, 3); /* segment length and bpp */
636 if (get_word_be(&jpeg_buffer, height) ||
637 get_word_be(&jpeg_buffer, width) ||
638 get_byte(&jpeg_buffer) != 3) /* YCbCr only */
639 return 0;
640
641 skip(&jpeg_buffer, 1);
642 return get_byte(&jpeg_buffer);
643 case DHT:
644 case DQT:
645 case COM:
646 case DRI:
647 case APP0 ... APP0 + 0x0f:
648 if (get_word_be(&jpeg_buffer, &word))
649 return 0;
650 skip(&jpeg_buffer, (long)word - 2);
651 case 0:
652 break;
653 default:
654 return 0;
655 }
656 }
657
658 return 0;
659 }
660
661 static int jpu_querycap(struct file *file, void *priv,
662 struct v4l2_capability *cap)
663 {
664 struct jpu_ctx *ctx = fh_to_ctx(priv);
665
666 if (ctx->encoder)
667 strscpy(cap->card, DRV_NAME " encoder", sizeof(cap->card));
668 else
669 strscpy(cap->card, DRV_NAME " decoder", sizeof(cap->card));
670
671 strscpy(cap->driver, DRV_NAME, sizeof(cap->driver));
672 snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
673 dev_name(ctx->jpu->dev));
674 memset(cap->reserved, 0, sizeof(cap->reserved));
675
676 return 0;
677 }
678
679 static struct jpu_fmt *jpu_find_format(bool encoder, u32 pixelformat,
680 unsigned int fmt_type)
681 {
682 unsigned int i, fmt_flag;
683
684 if (encoder)
685 fmt_flag = fmt_type == JPU_FMT_TYPE_OUTPUT ? JPU_ENC_OUTPUT :
686 JPU_ENC_CAPTURE;
687 else
688 fmt_flag = fmt_type == JPU_FMT_TYPE_OUTPUT ? JPU_DEC_OUTPUT :
689 JPU_DEC_CAPTURE;
690
691 for (i = 0; i < ARRAY_SIZE(jpu_formats); i++) {
692 struct jpu_fmt *fmt = &jpu_formats[i];
693
694 if (fmt->fourcc == pixelformat && fmt->types & fmt_flag)
695 return fmt;
696 }
697
698 return NULL;
699 }
700
701 static int jpu_enum_fmt(struct v4l2_fmtdesc *f, u32 type)
702 {
703 unsigned int i, num = 0;
704
705 for (i = 0; i < ARRAY_SIZE(jpu_formats); ++i) {
706 if (jpu_formats[i].types & type) {
707 if (num == f->index)
708 break;
709 ++num;
710 }
711 }
712
713 if (i >= ARRAY_SIZE(jpu_formats))
714 return -EINVAL;
715
716 f->pixelformat = jpu_formats[i].fourcc;
717
718 return 0;
719 }
720
721 static int jpu_enum_fmt_cap(struct file *file, void *priv,
722 struct v4l2_fmtdesc *f)
723 {
724 struct jpu_ctx *ctx = fh_to_ctx(priv);
725
726 return jpu_enum_fmt(f, ctx->encoder ? JPU_ENC_CAPTURE :
727 JPU_DEC_CAPTURE);
728 }
729
730 static int jpu_enum_fmt_out(struct file *file, void *priv,
731 struct v4l2_fmtdesc *f)
732 {
733 struct jpu_ctx *ctx = fh_to_ctx(priv);
734
735 return jpu_enum_fmt(f, ctx->encoder ? JPU_ENC_OUTPUT : JPU_DEC_OUTPUT);
736 }
737
738 static struct jpu_q_data *jpu_get_q_data(struct jpu_ctx *ctx,
739 enum v4l2_buf_type type)
740 {
741 if (V4L2_TYPE_IS_OUTPUT(type))
742 return &ctx->out_q;
743 else
744 return &ctx->cap_q;
745 }
746
747 static void jpu_bound_align_image(u32 *w, unsigned int w_min,
748 unsigned int w_max, unsigned int w_align,
749 u32 *h, unsigned int h_min,
750 unsigned int h_max, unsigned int h_align)
751 {
752 unsigned int width, height, w_step, h_step;
753
754 width = *w;
755 height = *h;
756
757 w_step = 1U << w_align;
758 h_step = 1U << h_align;
759 v4l_bound_align_image(w, w_min, w_max, w_align, h, h_min, h_max,
760 h_align, 3);
761
762 if (*w < width && *w + w_step < w_max)
763 *w += w_step;
764 if (*h < height && *h + h_step < h_max)
765 *h += h_step;
766 }
767
768 static int __jpu_try_fmt(struct jpu_ctx *ctx, struct jpu_fmt **fmtinfo,
769 struct v4l2_pix_format_mplane *pix,
770 enum v4l2_buf_type type)
771 {
772 struct jpu_fmt *fmt;
773 unsigned int f_type, w, h;
774
775 f_type = V4L2_TYPE_IS_OUTPUT(type) ? JPU_FMT_TYPE_OUTPUT :
776 JPU_FMT_TYPE_CAPTURE;
777
778 fmt = jpu_find_format(ctx->encoder, pix->pixelformat, f_type);
779 if (!fmt) {
780 unsigned int pixelformat;
781
782 dev_dbg(ctx->jpu->dev, "unknown format; set default format\n");
783 if (ctx->encoder)
784 pixelformat = f_type == JPU_FMT_TYPE_OUTPUT ?
785 V4L2_PIX_FMT_NV16M : V4L2_PIX_FMT_JPEG;
786 else
787 pixelformat = f_type == JPU_FMT_TYPE_CAPTURE ?
788 V4L2_PIX_FMT_NV16M : V4L2_PIX_FMT_JPEG;
789 fmt = jpu_find_format(ctx->encoder, pixelformat, f_type);
790 }
791
792 pix->pixelformat = fmt->fourcc;
793 pix->colorspace = fmt->colorspace;
794 pix->field = V4L2_FIELD_NONE;
795 pix->num_planes = fmt->num_planes;
796 memset(pix->reserved, 0, sizeof(pix->reserved));
797
798 jpu_bound_align_image(&pix->width, JPU_WIDTH_MIN, JPU_WIDTH_MAX,
799 fmt->h_align, &pix->height, JPU_HEIGHT_MIN,
800 JPU_HEIGHT_MAX, fmt->v_align);
801
802 w = pix->width;
803 h = pix->height;
804
805 if (fmt->fourcc == V4L2_PIX_FMT_JPEG) {
806 /* ignore userspaces's sizeimage for encoding */
807 if (pix->plane_fmt[0].sizeimage <= 0 || ctx->encoder)
808 pix->plane_fmt[0].sizeimage = JPU_JPEG_HDR_SIZE +
809 (JPU_JPEG_MAX_BYTES_PER_PIXEL * w * h);
810 pix->plane_fmt[0].bytesperline = 0;
811 memset(pix->plane_fmt[0].reserved, 0,
812 sizeof(pix->plane_fmt[0].reserved));
813 } else {
814 unsigned int i, bpl = 0;
815
816 for (i = 0; i < pix->num_planes; ++i)
817 bpl = max(bpl, pix->plane_fmt[i].bytesperline);
818
819 bpl = clamp_t(unsigned int, bpl, w, JPU_WIDTH_MAX);
820 bpl = round_up(bpl, JPU_MEMALIGN);
821
822 for (i = 0; i < pix->num_planes; ++i) {
823 pix->plane_fmt[i].bytesperline = bpl;
824 pix->plane_fmt[i].sizeimage = bpl * h * fmt->bpp[i] / 8;
825 memset(pix->plane_fmt[i].reserved, 0,
826 sizeof(pix->plane_fmt[i].reserved));
827 }
828 }
829
830 if (fmtinfo)
831 *fmtinfo = fmt;
832
833 return 0;
834 }
835
836 static int jpu_try_fmt(struct file *file, void *priv, struct v4l2_format *f)
837 {
838 struct jpu_ctx *ctx = fh_to_ctx(priv);
839
840 if (!v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type))
841 return -EINVAL;
842
843 return __jpu_try_fmt(ctx, NULL, &f->fmt.pix_mp, f->type);
844 }
845
846 static int jpu_s_fmt(struct file *file, void *priv, struct v4l2_format *f)
847 {
848 struct vb2_queue *vq;
849 struct jpu_ctx *ctx = fh_to_ctx(priv);
850 struct v4l2_m2m_ctx *m2m_ctx = ctx->fh.m2m_ctx;
851 struct jpu_fmt *fmtinfo;
852 struct jpu_q_data *q_data;
853 int ret;
854
855 vq = v4l2_m2m_get_vq(m2m_ctx, f->type);
856 if (!vq)
857 return -EINVAL;
858
859 if (vb2_is_busy(vq)) {
860 v4l2_err(&ctx->jpu->v4l2_dev, "%s queue busy\n", __func__);
861 return -EBUSY;
862 }
863
864 ret = __jpu_try_fmt(ctx, &fmtinfo, &f->fmt.pix_mp, f->type);
865 if (ret < 0)
866 return ret;
867
868 q_data = jpu_get_q_data(ctx, f->type);
869
870 q_data->format = f->fmt.pix_mp;
871 q_data->fmtinfo = fmtinfo;
872
873 return 0;
874 }
875
876 static int jpu_g_fmt(struct file *file, void *priv, struct v4l2_format *f)
877 {
878 struct jpu_q_data *q_data;
879 struct jpu_ctx *ctx = fh_to_ctx(priv);
880
881 if (!v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type))
882 return -EINVAL;
883
884 q_data = jpu_get_q_data(ctx, f->type);
885 f->fmt.pix_mp = q_data->format;
886
887 return 0;
888 }
889
890 /*
891 * V4L2 controls
892 */
893 static int jpu_s_ctrl(struct v4l2_ctrl *ctrl)
894 {
895 struct jpu_ctx *ctx = ctrl_to_ctx(ctrl);
896 unsigned long flags;
897
898 spin_lock_irqsave(&ctx->jpu->lock, flags);
899 if (ctrl->id == V4L2_CID_JPEG_COMPRESSION_QUALITY)
900 ctx->compr_quality = ctrl->val;
901 spin_unlock_irqrestore(&ctx->jpu->lock, flags);
902
903 return 0;
904 }
905
906 static const struct v4l2_ctrl_ops jpu_ctrl_ops = {
907 .s_ctrl = jpu_s_ctrl,
908 };
909
910 static int jpu_streamon(struct file *file, void *priv, enum v4l2_buf_type type)
911 {
912 struct jpu_ctx *ctx = fh_to_ctx(priv);
913 struct jpu_q_data *src_q_data, *dst_q_data, *orig, adj, *ref;
914 enum v4l2_buf_type adj_type;
915
916 src_q_data = jpu_get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
917 dst_q_data = jpu_get_q_data(ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
918
919 if (ctx->encoder) {
920 adj = *src_q_data;
921 orig = src_q_data;
922 ref = dst_q_data;
923 adj_type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
924 } else {
925 adj = *dst_q_data;
926 orig = dst_q_data;
927 ref = src_q_data;
928 adj_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
929 }
930
931 adj.format.width = ref->format.width;
932 adj.format.height = ref->format.height;
933
934 __jpu_try_fmt(ctx, NULL, &adj.format, adj_type);
935
936 if (adj.format.width != orig->format.width ||
937 adj.format.height != orig->format.height) {
938 dev_err(ctx->jpu->dev, "src and dst formats do not match.\n");
939 /* maybe we can return -EPIPE here? */
940 return -EINVAL;
941 }
942
943 return v4l2_m2m_streamon(file, ctx->fh.m2m_ctx, type);
944 }
945
946 static const struct v4l2_ioctl_ops jpu_ioctl_ops = {
947 .vidioc_querycap = jpu_querycap,
948
949 .vidioc_enum_fmt_vid_cap = jpu_enum_fmt_cap,
950 .vidioc_enum_fmt_vid_out = jpu_enum_fmt_out,
951 .vidioc_g_fmt_vid_cap_mplane = jpu_g_fmt,
952 .vidioc_g_fmt_vid_out_mplane = jpu_g_fmt,
953 .vidioc_try_fmt_vid_cap_mplane = jpu_try_fmt,
954 .vidioc_try_fmt_vid_out_mplane = jpu_try_fmt,
955 .vidioc_s_fmt_vid_cap_mplane = jpu_s_fmt,
956 .vidioc_s_fmt_vid_out_mplane = jpu_s_fmt,
957
958 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
959 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
960 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
961 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf,
962 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,
963 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
964
965 .vidioc_streamon = jpu_streamon,
966 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
967
968 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
969 .vidioc_unsubscribe_event = v4l2_event_unsubscribe
970 };
971
972 static int jpu_controls_create(struct jpu_ctx *ctx)
973 {
974 struct v4l2_ctrl *ctrl;
975 int ret;
976
977 v4l2_ctrl_handler_init(&ctx->ctrl_handler, 1);
978
979 ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler, &jpu_ctrl_ops,
980 V4L2_CID_JPEG_COMPRESSION_QUALITY,
981 0, JPU_MAX_QUALITY - 1, 1, 0);
982
983 if (ctx->ctrl_handler.error) {
984 ret = ctx->ctrl_handler.error;
985 goto error_free;
986 }
987
988 if (!ctx->encoder)
989 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE |
990 V4L2_CTRL_FLAG_READ_ONLY;
991
992 ret = v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
993 if (ret < 0)
994 goto error_free;
995
996 return 0;
997
998 error_free:
999 v4l2_ctrl_handler_free(&ctx->ctrl_handler);
1000 return ret;
1001 }
1002
1003 /*
1004 * ============================================================================
1005 * Queue operations
1006 * ============================================================================
1007 */
1008 static int jpu_queue_setup(struct vb2_queue *vq,
1009 unsigned int *nbuffers, unsigned int *nplanes,
1010 unsigned int sizes[], struct device *alloc_devs[])
1011 {
1012 struct jpu_ctx *ctx = vb2_get_drv_priv(vq);
1013 struct jpu_q_data *q_data;
1014 unsigned int i;
1015
1016 q_data = jpu_get_q_data(ctx, vq->type);
1017
1018 if (*nplanes) {
1019 if (*nplanes != q_data->format.num_planes)
1020 return -EINVAL;
1021
1022 for (i = 0; i < *nplanes; i++) {
1023 unsigned int q_size = q_data->format.plane_fmt[i].sizeimage;
1024
1025 if (sizes[i] < q_size)
1026 return -EINVAL;
1027 }
1028 return 0;
1029 }
1030
1031 *nplanes = q_data->format.num_planes;
1032
1033 for (i = 0; i < *nplanes; i++)
1034 sizes[i] = q_data->format.plane_fmt[i].sizeimage;
1035
1036 return 0;
1037 }
1038
1039 static int jpu_buf_prepare(struct vb2_buffer *vb)
1040 {
1041 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1042 struct jpu_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
1043 struct jpu_q_data *q_data;
1044 unsigned int i;
1045
1046 q_data = jpu_get_q_data(ctx, vb->vb2_queue->type);
1047
1048 if (V4L2_TYPE_IS_OUTPUT(vb->vb2_queue->type)) {
1049 if (vbuf->field == V4L2_FIELD_ANY)
1050 vbuf->field = V4L2_FIELD_NONE;
1051 if (vbuf->field != V4L2_FIELD_NONE) {
1052 dev_err(ctx->jpu->dev, "%s field isn't supported\n",
1053 __func__);
1054 return -EINVAL;
1055 }
1056 }
1057
1058 for (i = 0; i < q_data->format.num_planes; i++) {
1059 unsigned long size = q_data->format.plane_fmt[i].sizeimage;
1060
1061 if (vb2_plane_size(vb, i) < size) {
1062 dev_err(ctx->jpu->dev,
1063 "%s: data will not fit into plane (%lu < %lu)\n",
1064 __func__, vb2_plane_size(vb, i), size);
1065 return -EINVAL;
1066 }
1067
1068 /* decoder capture queue */
1069 if (!ctx->encoder && !V4L2_TYPE_IS_OUTPUT(vb->vb2_queue->type))
1070 vb2_set_plane_payload(vb, i, size);
1071 }
1072
1073 return 0;
1074 }
1075
1076 static void jpu_buf_queue(struct vb2_buffer *vb)
1077 {
1078 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1079 struct jpu_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
1080
1081 if (!ctx->encoder && V4L2_TYPE_IS_OUTPUT(vb->vb2_queue->type)) {
1082 struct jpu_buffer *jpu_buf = vb2_to_jpu_buffer(vbuf);
1083 struct jpu_q_data *q_data, adjust;
1084 void *buffer = vb2_plane_vaddr(vb, 0);
1085 unsigned long buf_size = vb2_get_plane_payload(vb, 0);
1086 unsigned int width, height;
1087
1088 u8 subsampling = jpu_parse_hdr(buffer, buf_size, &width,
1089 &height);
1090
1091 /* check if JPEG data basic parsing was successful */
1092 if (subsampling != JPU_JPEG_422 && subsampling != JPU_JPEG_420)
1093 goto format_error;
1094
1095 q_data = &ctx->out_q;
1096
1097 adjust = *q_data;
1098 adjust.format.width = width;
1099 adjust.format.height = height;
1100
1101 __jpu_try_fmt(ctx, &adjust.fmtinfo, &adjust.format,
1102 V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
1103
1104 if (adjust.format.width != q_data->format.width ||
1105 adjust.format.height != q_data->format.height)
1106 goto format_error;
1107
1108 /*
1109 * keep subsampling in buffer to check it
1110 * for compatibility in device_run
1111 */
1112 jpu_buf->subsampling = subsampling;
1113 }
1114
1115 if (ctx->fh.m2m_ctx)
1116 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
1117
1118 return;
1119
1120 format_error:
1121 dev_err(ctx->jpu->dev, "incompatible or corrupted JPEG data\n");
1122 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
1123 }
1124
1125 static void jpu_buf_finish(struct vb2_buffer *vb)
1126 {
1127 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1128 struct jpu_buffer *jpu_buf = vb2_to_jpu_buffer(vbuf);
1129 struct jpu_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
1130 struct jpu_q_data *q_data = &ctx->out_q;
1131 enum v4l2_buf_type type = vb->vb2_queue->type;
1132 u8 *buffer;
1133
1134 if (vb->state == VB2_BUF_STATE_DONE)
1135 vbuf->sequence = jpu_get_q_data(ctx, type)->sequence++;
1136
1137 if (!ctx->encoder || vb->state != VB2_BUF_STATE_DONE ||
1138 V4L2_TYPE_IS_OUTPUT(type))
1139 return;
1140
1141 buffer = vb2_plane_vaddr(vb, 0);
1142
1143 memcpy(buffer, jpeg_hdrs[jpu_buf->compr_quality], JPU_JPEG_HDR_SIZE);
1144 *(__be16 *)(buffer + JPU_JPEG_HEIGHT_OFFSET) =
1145 cpu_to_be16(q_data->format.height);
1146 *(__be16 *)(buffer + JPU_JPEG_WIDTH_OFFSET) =
1147 cpu_to_be16(q_data->format.width);
1148 *(buffer + JPU_JPEG_SUBS_OFFSET) = q_data->fmtinfo->subsampling;
1149 }
1150
1151 static int jpu_start_streaming(struct vb2_queue *vq, unsigned count)
1152 {
1153 struct jpu_ctx *ctx = vb2_get_drv_priv(vq);
1154 struct jpu_q_data *q_data = jpu_get_q_data(ctx, vq->type);
1155
1156 q_data->sequence = 0;
1157 return 0;
1158 }
1159
1160 static void jpu_stop_streaming(struct vb2_queue *vq)
1161 {
1162 struct jpu_ctx *ctx = vb2_get_drv_priv(vq);
1163 struct vb2_v4l2_buffer *vb;
1164 unsigned long flags;
1165
1166 for (;;) {
1167 if (V4L2_TYPE_IS_OUTPUT(vq->type))
1168 vb = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
1169 else
1170 vb = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
1171 if (vb == NULL)
1172 return;
1173 spin_lock_irqsave(&ctx->jpu->lock, flags);
1174 v4l2_m2m_buf_done(vb, VB2_BUF_STATE_ERROR);
1175 spin_unlock_irqrestore(&ctx->jpu->lock, flags);
1176 }
1177 }
1178
1179 static const struct vb2_ops jpu_qops = {
1180 .queue_setup = jpu_queue_setup,
1181 .buf_prepare = jpu_buf_prepare,
1182 .buf_queue = jpu_buf_queue,
1183 .buf_finish = jpu_buf_finish,
1184 .start_streaming = jpu_start_streaming,
1185 .stop_streaming = jpu_stop_streaming,
1186 .wait_prepare = vb2_ops_wait_prepare,
1187 .wait_finish = vb2_ops_wait_finish,
1188 };
1189
1190 static int jpu_queue_init(void *priv, struct vb2_queue *src_vq,
1191 struct vb2_queue *dst_vq)
1192 {
1193 struct jpu_ctx *ctx = priv;
1194 int ret;
1195
1196 memset(src_vq, 0, sizeof(*src_vq));
1197 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
1198 src_vq->io_modes = VB2_MMAP | VB2_DMABUF;
1199 src_vq->drv_priv = ctx;
1200 src_vq->buf_struct_size = sizeof(struct jpu_buffer);
1201 src_vq->ops = &jpu_qops;
1202 src_vq->mem_ops = &vb2_dma_contig_memops;
1203 src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
1204 src_vq->lock = &ctx->jpu->mutex;
1205 src_vq->dev = ctx->jpu->v4l2_dev.dev;
1206
1207 ret = vb2_queue_init(src_vq);
1208 if (ret)
1209 return ret;
1210
1211 memset(dst_vq, 0, sizeof(*dst_vq));
1212 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
1213 dst_vq->io_modes = VB2_MMAP | VB2_DMABUF;
1214 dst_vq->drv_priv = ctx;
1215 dst_vq->buf_struct_size = sizeof(struct jpu_buffer);
1216 dst_vq->ops = &jpu_qops;
1217 dst_vq->mem_ops = &vb2_dma_contig_memops;
1218 dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
1219 dst_vq->lock = &ctx->jpu->mutex;
1220 dst_vq->dev = ctx->jpu->v4l2_dev.dev;
1221
1222 return vb2_queue_init(dst_vq);
1223 }
1224
1225 /*
1226 * ============================================================================
1227 * Device file operations
1228 * ============================================================================
1229 */
1230 static int jpu_open(struct file *file)
1231 {
1232 struct jpu *jpu = video_drvdata(file);
1233 struct video_device *vfd = video_devdata(file);
1234 struct jpu_ctx *ctx;
1235 int ret;
1236
1237 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
1238 if (!ctx)
1239 return -ENOMEM;
1240
1241 v4l2_fh_init(&ctx->fh, vfd);
1242 ctx->fh.ctrl_handler = &ctx->ctrl_handler;
1243 file->private_data = &ctx->fh;
1244 v4l2_fh_add(&ctx->fh);
1245
1246 ctx->jpu = jpu;
1247 ctx->encoder = vfd == &jpu->vfd_encoder;
1248
1249 __jpu_try_fmt(ctx, &ctx->out_q.fmtinfo, &ctx->out_q.format,
1250 V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
1251 __jpu_try_fmt(ctx, &ctx->cap_q.fmtinfo, &ctx->cap_q.format,
1252 V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
1253
1254 ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(jpu->m2m_dev, ctx, jpu_queue_init);
1255 if (IS_ERR(ctx->fh.m2m_ctx)) {
1256 ret = PTR_ERR(ctx->fh.m2m_ctx);
1257 goto v4l_prepare_rollback;
1258 }
1259
1260 ret = jpu_controls_create(ctx);
1261 if (ret < 0)
1262 goto v4l_prepare_rollback;
1263
1264 if (mutex_lock_interruptible(&jpu->mutex)) {
1265 ret = -ERESTARTSYS;
1266 goto v4l_prepare_rollback;
1267 }
1268
1269 if (jpu->ref_count == 0) {
1270 ret = clk_prepare_enable(jpu->clk);
1271 if (ret < 0)
1272 goto device_prepare_rollback;
1273 /* ...issue software reset */
1274 ret = jpu_reset(jpu);
1275 if (ret)
1276 goto jpu_reset_rollback;
1277 }
1278
1279 jpu->ref_count++;
1280
1281 mutex_unlock(&jpu->mutex);
1282 return 0;
1283
1284 jpu_reset_rollback:
1285 clk_disable_unprepare(jpu->clk);
1286 device_prepare_rollback:
1287 mutex_unlock(&jpu->mutex);
1288 v4l_prepare_rollback:
1289 v4l2_fh_del(&ctx->fh);
1290 v4l2_fh_exit(&ctx->fh);
1291 kfree(ctx);
1292 return ret;
1293 }
1294
1295 static int jpu_release(struct file *file)
1296 {
1297 struct jpu *jpu = video_drvdata(file);
1298 struct jpu_ctx *ctx = fh_to_ctx(file->private_data);
1299
1300 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
1301 v4l2_ctrl_handler_free(&ctx->ctrl_handler);
1302 v4l2_fh_del(&ctx->fh);
1303 v4l2_fh_exit(&ctx->fh);
1304 kfree(ctx);
1305
1306 mutex_lock(&jpu->mutex);
1307 if (--jpu->ref_count == 0)
1308 clk_disable_unprepare(jpu->clk);
1309 mutex_unlock(&jpu->mutex);
1310
1311 return 0;
1312 }
1313
1314 static const struct v4l2_file_operations jpu_fops = {
1315 .owner = THIS_MODULE,
1316 .open = jpu_open,
1317 .release = jpu_release,
1318 .unlocked_ioctl = video_ioctl2,
1319 .poll = v4l2_m2m_fop_poll,
1320 .mmap = v4l2_m2m_fop_mmap,
1321 };
1322
1323 /*
1324 * ============================================================================
1325 * mem2mem callbacks
1326 * ============================================================================
1327 */
1328 static void jpu_cleanup(struct jpu_ctx *ctx, bool reset)
1329 {
1330 /* remove current buffers and finish job */
1331 struct vb2_v4l2_buffer *src_buf, *dst_buf;
1332 unsigned long flags;
1333
1334 spin_lock_irqsave(&ctx->jpu->lock, flags);
1335
1336 src_buf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
1337 dst_buf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
1338
1339 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_ERROR);
1340 v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_ERROR);
1341
1342 /* ...and give it a chance on next run */
1343 if (reset)
1344 jpu_write(ctx->jpu, JCCMD_SRST, JCCMD);
1345
1346 spin_unlock_irqrestore(&ctx->jpu->lock, flags);
1347
1348 v4l2_m2m_job_finish(ctx->jpu->m2m_dev, ctx->fh.m2m_ctx);
1349 }
1350
1351 static void jpu_device_run(void *priv)
1352 {
1353 struct jpu_ctx *ctx = priv;
1354 struct jpu *jpu = ctx->jpu;
1355 struct jpu_buffer *jpu_buf;
1356 struct jpu_q_data *q_data;
1357 struct vb2_v4l2_buffer *src_buf, *dst_buf;
1358 unsigned int w, h, bpl;
1359 unsigned char num_planes, subsampling;
1360 unsigned long flags;
1361
1362 /* ...wait until module reset completes; we have mutex locked here */
1363 if (jpu_wait_reset(jpu)) {
1364 jpu_cleanup(ctx, true);
1365 return;
1366 }
1367
1368 spin_lock_irqsave(&ctx->jpu->lock, flags);
1369
1370 jpu->curr = ctx;
1371
1372 src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
1373 dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
1374
1375 if (ctx->encoder) {
1376 jpu_buf = vb2_to_jpu_buffer(dst_buf);
1377 q_data = &ctx->out_q;
1378 } else {
1379 jpu_buf = vb2_to_jpu_buffer(src_buf);
1380 q_data = &ctx->cap_q;
1381 }
1382
1383 w = q_data->format.width;
1384 h = q_data->format.height;
1385 bpl = q_data->format.plane_fmt[0].bytesperline;
1386 num_planes = q_data->fmtinfo->num_planes;
1387 subsampling = q_data->fmtinfo->subsampling;
1388
1389 if (ctx->encoder) {
1390 unsigned long src_1_addr, src_2_addr, dst_addr;
1391 unsigned int redu, inft;
1392
1393 dst_addr = vb2_dma_contig_plane_dma_addr(&dst_buf->vb2_buf, 0);
1394 src_1_addr =
1395 vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf, 0);
1396 if (num_planes > 1)
1397 src_2_addr = vb2_dma_contig_plane_dma_addr(
1398 &src_buf->vb2_buf, 1);
1399 else
1400 src_2_addr = src_1_addr + w * h;
1401
1402 jpu_buf->compr_quality = ctx->compr_quality;
1403
1404 if (subsampling == JPU_JPEG_420) {
1405 redu = JCMOD_REDU_420;
1406 inft = JIFECNT_INFT_420;
1407 } else {
1408 redu = JCMOD_REDU_422;
1409 inft = JIFECNT_INFT_422;
1410 }
1411
1412 /* only no marker mode works for encoding */
1413 jpu_write(jpu, JCMOD_DSP_ENC | JCMOD_PCTR | redu |
1414 JCMOD_MSKIP_ENABLE, JCMOD);
1415
1416 jpu_write(jpu, JIFECNT_SWAP_WB | inft, JIFECNT);
1417 jpu_write(jpu, JIFDCNT_SWAP_WB, JIFDCNT);
1418 jpu_write(jpu, JINTE_TRANSF_COMPL, JINTE);
1419
1420 /* Y and C components source addresses */
1421 jpu_write(jpu, src_1_addr, JIFESYA1);
1422 jpu_write(jpu, src_2_addr, JIFESCA1);
1423
1424 /* memory width */
1425 jpu_write(jpu, bpl, JIFESMW);
1426
1427 jpu_write(jpu, (w >> 8) & JCSZ_MASK, JCHSZU);
1428 jpu_write(jpu, w & JCSZ_MASK, JCHSZD);
1429
1430 jpu_write(jpu, (h >> 8) & JCSZ_MASK, JCVSZU);
1431 jpu_write(jpu, h & JCSZ_MASK, JCVSZD);
1432
1433 jpu_write(jpu, w, JIFESHSZ);
1434 jpu_write(jpu, h, JIFESVSZ);
1435
1436 jpu_write(jpu, dst_addr + JPU_JPEG_HDR_SIZE, JIFEDA1);
1437
1438 jpu_write(jpu, 0 << JCQTN_SHIFT(1) | 1 << JCQTN_SHIFT(2) |
1439 1 << JCQTN_SHIFT(3), JCQTN);
1440
1441 jpu_write(jpu, 0 << JCHTN_AC_SHIFT(1) | 0 << JCHTN_DC_SHIFT(1) |
1442 1 << JCHTN_AC_SHIFT(2) | 1 << JCHTN_DC_SHIFT(2) |
1443 1 << JCHTN_AC_SHIFT(3) | 1 << JCHTN_DC_SHIFT(3),
1444 JCHTN);
1445
1446 jpu_set_qtbl(jpu, ctx->compr_quality);
1447 jpu_set_htbl(jpu);
1448 } else {
1449 unsigned long src_addr, dst_1_addr, dst_2_addr;
1450
1451 if (jpu_buf->subsampling != subsampling) {
1452 dev_err(ctx->jpu->dev,
1453 "src and dst formats do not match.\n");
1454 spin_unlock_irqrestore(&ctx->jpu->lock, flags);
1455 jpu_cleanup(ctx, false);
1456 return;
1457 }
1458
1459 src_addr = vb2_dma_contig_plane_dma_addr(&src_buf->vb2_buf, 0);
1460 dst_1_addr =
1461 vb2_dma_contig_plane_dma_addr(&dst_buf->vb2_buf, 0);
1462 if (q_data->fmtinfo->num_planes > 1)
1463 dst_2_addr = vb2_dma_contig_plane_dma_addr(
1464 &dst_buf->vb2_buf, 1);
1465 else
1466 dst_2_addr = dst_1_addr + w * h;
1467
1468 /* ...set up decoder operation */
1469 jpu_write(jpu, JCMOD_DSP_DEC | JCMOD_PCTR, JCMOD);
1470 jpu_write(jpu, JIFECNT_SWAP_WB, JIFECNT);
1471 jpu_write(jpu, JIFDCNT_SWAP_WB, JIFDCNT);
1472
1473 /* ...enable interrupts on transfer completion and d-g error */
1474 jpu_write(jpu, JINTE_TRANSF_COMPL | JINTE_ERR, JINTE);
1475
1476 /* ...set source/destination addresses of encoded data */
1477 jpu_write(jpu, src_addr, JIFDSA1);
1478 jpu_write(jpu, dst_1_addr, JIFDDYA1);
1479 jpu_write(jpu, dst_2_addr, JIFDDCA1);
1480
1481 jpu_write(jpu, bpl, JIFDDMW);
1482 }
1483
1484 /* ...start encoder/decoder operation */
1485 jpu_write(jpu, JCCMD_JSRT, JCCMD);
1486
1487 spin_unlock_irqrestore(&ctx->jpu->lock, flags);
1488 }
1489
1490 static const struct v4l2_m2m_ops jpu_m2m_ops = {
1491 .device_run = jpu_device_run,
1492 };
1493
1494 /*
1495 * ============================================================================
1496 * IRQ handler
1497 * ============================================================================
1498 */
1499 static irqreturn_t jpu_irq_handler(int irq, void *dev_id)
1500 {
1501 struct jpu *jpu = dev_id;
1502 struct jpu_ctx *curr_ctx;
1503 struct vb2_v4l2_buffer *src_buf, *dst_buf;
1504 unsigned int int_status;
1505
1506 int_status = jpu_read(jpu, JINTS);
1507
1508 /* ...spurious interrupt */
1509 if (!((JINTS_TRANSF_COMPL | JINTS_PROCESS_COMPL | JINTS_ERR) &
1510 int_status))
1511 return IRQ_NONE;
1512
1513 /* ...clear interrupts */
1514 jpu_write(jpu, ~(int_status & JINTS_MASK), JINTS);
1515 if (int_status & (JINTS_ERR | JINTS_PROCESS_COMPL))
1516 jpu_write(jpu, JCCMD_JEND, JCCMD);
1517
1518 spin_lock(&jpu->lock);
1519
1520 if ((int_status & JINTS_PROCESS_COMPL) &&
1521 !(int_status & JINTS_TRANSF_COMPL))
1522 goto handled;
1523
1524 curr_ctx = v4l2_m2m_get_curr_priv(jpu->m2m_dev);
1525 if (!curr_ctx) {
1526 /* ...instance is not running */
1527 dev_err(jpu->dev, "no active context for m2m\n");
1528 goto handled;
1529 }
1530
1531 src_buf = v4l2_m2m_src_buf_remove(curr_ctx->fh.m2m_ctx);
1532 dst_buf = v4l2_m2m_dst_buf_remove(curr_ctx->fh.m2m_ctx);
1533
1534 if (int_status & JINTS_TRANSF_COMPL) {
1535 if (curr_ctx->encoder) {
1536 unsigned long payload_size = jpu_read(jpu, JCDTCU) << 16
1537 | jpu_read(jpu, JCDTCM) << 8
1538 | jpu_read(jpu, JCDTCD);
1539 vb2_set_plane_payload(&dst_buf->vb2_buf, 0,
1540 payload_size + JPU_JPEG_HDR_SIZE);
1541 }
1542
1543 dst_buf->field = src_buf->field;
1544 dst_buf->vb2_buf.timestamp = src_buf->vb2_buf.timestamp;
1545 if (src_buf->flags & V4L2_BUF_FLAG_TIMECODE)
1546 dst_buf->timecode = src_buf->timecode;
1547 dst_buf->flags = src_buf->flags &
1548 (V4L2_BUF_FLAG_TIMECODE | V4L2_BUF_FLAG_KEYFRAME |
1549 V4L2_BUF_FLAG_PFRAME | V4L2_BUF_FLAG_BFRAME |
1550 V4L2_BUF_FLAG_TSTAMP_SRC_MASK);
1551
1552 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_DONE);
1553 v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_DONE);
1554 } else if (int_status & JINTS_ERR) {
1555 unsigned char error = jpu_read(jpu, JCDERR) & JCDERR_MASK;
1556
1557 dev_dbg(jpu->dev, "processing error: %#X: %s\n", error,
1558 error_to_text[error]);
1559
1560 v4l2_m2m_buf_done(src_buf, VB2_BUF_STATE_ERROR);
1561 v4l2_m2m_buf_done(dst_buf, VB2_BUF_STATE_ERROR);
1562 }
1563
1564 jpu->curr = NULL;
1565
1566 /* ...reset JPU after completion */
1567 jpu_write(jpu, JCCMD_SRST, JCCMD);
1568 spin_unlock(&jpu->lock);
1569
1570 v4l2_m2m_job_finish(jpu->m2m_dev, curr_ctx->fh.m2m_ctx);
1571
1572 return IRQ_HANDLED;
1573
1574 handled:
1575 spin_unlock(&jpu->lock);
1576 return IRQ_HANDLED;
1577 }
1578
1579 /*
1580 * ============================================================================
1581 * Driver basic infrastructure
1582 * ============================================================================
1583 */
1584 static const struct of_device_id jpu_dt_ids[] = {
1585 { .compatible = "renesas,jpu-r8a7790" }, /* H2 */
1586 { .compatible = "renesas,jpu-r8a7791" }, /* M2-W */
1587 { .compatible = "renesas,jpu-r8a7792" }, /* V2H */
1588 { .compatible = "renesas,jpu-r8a7793" }, /* M2-N */
1589 { .compatible = "renesas,rcar-gen2-jpu" },
1590 { },
1591 };
1592 MODULE_DEVICE_TABLE(of, jpu_dt_ids);
1593
1594 static int jpu_probe(struct platform_device *pdev)
1595 {
1596 struct jpu *jpu;
1597 struct resource *res;
1598 int ret;
1599 unsigned int i;
1600
1601 jpu = devm_kzalloc(&pdev->dev, sizeof(*jpu), GFP_KERNEL);
1602 if (!jpu)
1603 return -ENOMEM;
1604
1605 mutex_init(&jpu->mutex);
1606 spin_lock_init(&jpu->lock);
1607 jpu->dev = &pdev->dev;
1608
1609 /* memory-mapped registers */
1610 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1611 jpu->regs = devm_ioremap_resource(&pdev->dev, res);
1612 if (IS_ERR(jpu->regs))
1613 return PTR_ERR(jpu->regs);
1614
1615 /* interrupt service routine registration */
1616 jpu->irq = ret = platform_get_irq(pdev, 0);
1617 if (ret < 0) {
1618 dev_err(&pdev->dev, "cannot find IRQ\n");
1619 return ret;
1620 }
1621
1622 ret = devm_request_irq(&pdev->dev, jpu->irq, jpu_irq_handler, 0,
1623 dev_name(&pdev->dev), jpu);
1624 if (ret) {
1625 dev_err(&pdev->dev, "cannot claim IRQ %d\n", jpu->irq);
1626 return ret;
1627 }
1628
1629 /* clocks */
1630 jpu->clk = devm_clk_get(&pdev->dev, NULL);
1631 if (IS_ERR(jpu->clk)) {
1632 dev_err(&pdev->dev, "cannot get clock\n");
1633 return PTR_ERR(jpu->clk);
1634 }
1635
1636 /* v4l2 device */
1637 ret = v4l2_device_register(&pdev->dev, &jpu->v4l2_dev);
1638 if (ret) {
1639 dev_err(&pdev->dev, "Failed to register v4l2 device\n");
1640 return ret;
1641 }
1642
1643 /* mem2mem device */
1644 jpu->m2m_dev = v4l2_m2m_init(&jpu_m2m_ops);
1645 if (IS_ERR(jpu->m2m_dev)) {
1646 v4l2_err(&jpu->v4l2_dev, "Failed to init mem2mem device\n");
1647 ret = PTR_ERR(jpu->m2m_dev);
1648 goto device_register_rollback;
1649 }
1650
1651 /* fill in qantization and Huffman tables for encoder */
1652 for (i = 0; i < JPU_MAX_QUALITY; i++)
1653 jpu_generate_hdr(i, (unsigned char *)jpeg_hdrs[i]);
1654
1655 strscpy(jpu->vfd_encoder.name, DRV_NAME, sizeof(jpu->vfd_encoder.name));
1656 jpu->vfd_encoder.fops = &jpu_fops;
1657 jpu->vfd_encoder.ioctl_ops = &jpu_ioctl_ops;
1658 jpu->vfd_encoder.minor = -1;
1659 jpu->vfd_encoder.release = video_device_release_empty;
1660 jpu->vfd_encoder.lock = &jpu->mutex;
1661 jpu->vfd_encoder.v4l2_dev = &jpu->v4l2_dev;
1662 jpu->vfd_encoder.vfl_dir = VFL_DIR_M2M;
1663 jpu->vfd_encoder.device_caps = V4L2_CAP_STREAMING |
1664 V4L2_CAP_VIDEO_M2M_MPLANE;
1665
1666 ret = video_register_device(&jpu->vfd_encoder, VFL_TYPE_VIDEO, -1);
1667 if (ret) {
1668 v4l2_err(&jpu->v4l2_dev, "Failed to register video device\n");
1669 goto m2m_init_rollback;
1670 }
1671
1672 video_set_drvdata(&jpu->vfd_encoder, jpu);
1673
1674 strscpy(jpu->vfd_decoder.name, DRV_NAME, sizeof(jpu->vfd_decoder.name));
1675 jpu->vfd_decoder.fops = &jpu_fops;
1676 jpu->vfd_decoder.ioctl_ops = &jpu_ioctl_ops;
1677 jpu->vfd_decoder.minor = -1;
1678 jpu->vfd_decoder.release = video_device_release_empty;
1679 jpu->vfd_decoder.lock = &jpu->mutex;
1680 jpu->vfd_decoder.v4l2_dev = &jpu->v4l2_dev;
1681 jpu->vfd_decoder.vfl_dir = VFL_DIR_M2M;
1682 jpu->vfd_decoder.device_caps = V4L2_CAP_STREAMING |
1683 V4L2_CAP_VIDEO_M2M_MPLANE;
1684
1685 ret = video_register_device(&jpu->vfd_decoder, VFL_TYPE_VIDEO, -1);
1686 if (ret) {
1687 v4l2_err(&jpu->v4l2_dev, "Failed to register video device\n");
1688 goto enc_vdev_register_rollback;
1689 }
1690
1691 video_set_drvdata(&jpu->vfd_decoder, jpu);
1692 platform_set_drvdata(pdev, jpu);
1693
1694 v4l2_info(&jpu->v4l2_dev, "encoder device registered as /dev/video%d\n",
1695 jpu->vfd_encoder.num);
1696 v4l2_info(&jpu->v4l2_dev, "decoder device registered as /dev/video%d\n",
1697 jpu->vfd_decoder.num);
1698
1699 return 0;
1700
1701 enc_vdev_register_rollback:
1702 video_unregister_device(&jpu->vfd_encoder);
1703
1704 m2m_init_rollback:
1705 v4l2_m2m_release(jpu->m2m_dev);
1706
1707 device_register_rollback:
1708 v4l2_device_unregister(&jpu->v4l2_dev);
1709
1710 return ret;
1711 }
1712
1713 static int jpu_remove(struct platform_device *pdev)
1714 {
1715 struct jpu *jpu = platform_get_drvdata(pdev);
1716
1717 video_unregister_device(&jpu->vfd_decoder);
1718 video_unregister_device(&jpu->vfd_encoder);
1719 v4l2_m2m_release(jpu->m2m_dev);
1720 v4l2_device_unregister(&jpu->v4l2_dev);
1721
1722 return 0;
1723 }
1724
1725 #ifdef CONFIG_PM_SLEEP
1726 static int jpu_suspend(struct device *dev)
1727 {
1728 struct jpu *jpu = dev_get_drvdata(dev);
1729
1730 if (jpu->ref_count == 0)
1731 return 0;
1732
1733 clk_disable_unprepare(jpu->clk);
1734
1735 return 0;
1736 }
1737
1738 static int jpu_resume(struct device *dev)
1739 {
1740 struct jpu *jpu = dev_get_drvdata(dev);
1741
1742 if (jpu->ref_count == 0)
1743 return 0;
1744
1745 clk_prepare_enable(jpu->clk);
1746
1747 return 0;
1748 }
1749 #endif
1750
1751 static const struct dev_pm_ops jpu_pm_ops = {
1752 SET_SYSTEM_SLEEP_PM_OPS(jpu_suspend, jpu_resume)
1753 };
1754
1755 static struct platform_driver jpu_driver = {
1756 .probe = jpu_probe,
1757 .remove = jpu_remove,
1758 .driver = {
1759 .of_match_table = jpu_dt_ids,
1760 .name = DRV_NAME,
1761 .pm = &jpu_pm_ops,
1762 },
1763 };
1764
1765 module_platform_driver(jpu_driver);
1766
1767 MODULE_ALIAS("platform:" DRV_NAME);
1768 MODULE_AUTHOR("Mikhail Ulianov <mikhail.ulyanov@cogentembedded.com>");
1769 MODULE_DESCRIPTION("Renesas R-Car JPEG processing unit driver");
1770 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support