]> git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blob - drivers/media/platform/rcar_fdp1.c
projects / mirror_ubuntu-focal-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge remote-tracking branch 'asoc/topic/pcm512x' into asoc-next
[mirror_ubuntu-focal-kernel.git] / drivers / media / platform / rcar_fdp1.c
1 /*
2 * Renesas R-Car Fine Display Processor
3 *
4 * Video format converter and frame deinterlacer device.
5 *
6 * Author: Kieran Bingham, <kieran@bingham.xyz>
7 * Copyright (c) 2016 Renesas Electronics Corporation.
8 *
9 * This code is developed and inspired from the vim2m, rcar_jpu,
10 * m2m-deinterlace, and vsp1 drivers.
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2 of the
15 * License, or (at your option) any later version
16 */
17
18 #include <linux/clk.h>
19 #include <linux/delay.h>
20 #include <linux/dma-mapping.h>
21 #include <linux/fs.h>
22 #include <linux/interrupt.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/pm_runtime.h>
28 #include <linux/sched.h>
29 #include <linux/slab.h>
30 #include <linux/timer.h>
31 #include <media/rcar-fcp.h>
32 #include <media/v4l2-ctrls.h>
33 #include <media/v4l2-device.h>
34 #include <media/v4l2-event.h>
35 #include <media/v4l2-ioctl.h>
36 #include <media/v4l2-mem2mem.h>
37 #include <media/videobuf2-dma-contig.h>
38
39 static unsigned int debug;
40 module_param(debug, uint, 0644);
41 MODULE_PARM_DESC(debug, "activate debug info");
42
43 /* Minimum and maximum frame width/height */
44 #define FDP1_MIN_W 80U
45 #define FDP1_MIN_H 80U
46
47 #define FDP1_MAX_W 3840U
48 #define FDP1_MAX_H 2160U
49
50 #define FDP1_MAX_PLANES 3U
51 #define FDP1_MAX_STRIDE 8190U
52
53 /* Flags that indicate a format can be used for capture/output */
54 #define FDP1_CAPTURE BIT(0)
55 #define FDP1_OUTPUT BIT(1)
56
57 #define DRIVER_NAME "rcar_fdp1"
58
59 /* Number of Job's to have available on the processing queue */
60 #define FDP1_NUMBER_JOBS 8
61
62 #define dprintk(fdp1, fmt, arg...) \
63 v4l2_dbg(1, debug, &fdp1->v4l2_dev, "%s: " fmt, __func__, ## arg)
64
65 /*
66 * FDP1 registers and bits
67 */
68
69 /* FDP1 start register - Imm */
70 #define FD1_CTL_CMD 0x0000
71 #define FD1_CTL_CMD_STRCMD BIT(0)
72
73 /* Sync generator register - Imm */
74 #define FD1_CTL_SGCMD 0x0004
75 #define FD1_CTL_SGCMD_SGEN BIT(0)
76
77 /* Register set end register - Imm */
78 #define FD1_CTL_REGEND 0x0008
79 #define FD1_CTL_REGEND_REGEND BIT(0)
80
81 /* Channel activation register - Vupdt */
82 #define FD1_CTL_CHACT 0x000c
83 #define FD1_CTL_CHACT_SMW BIT(9)
84 #define FD1_CTL_CHACT_WR BIT(8)
85 #define FD1_CTL_CHACT_SMR BIT(3)
86 #define FD1_CTL_CHACT_RD2 BIT(2)
87 #define FD1_CTL_CHACT_RD1 BIT(1)
88 #define FD1_CTL_CHACT_RD0 BIT(0)
89
90 /* Operation Mode Register - Vupdt */
91 #define FD1_CTL_OPMODE 0x0010
92 #define FD1_CTL_OPMODE_PRG BIT(4)
93 #define FD1_CTL_OPMODE_VIMD_INTERRUPT (0 << 0)
94 #define FD1_CTL_OPMODE_VIMD_BESTEFFORT (1 << 0)
95 #define FD1_CTL_OPMODE_VIMD_NOINTERRUPT (2 << 0)
96
97 #define FD1_CTL_VPERIOD 0x0014
98 #define FD1_CTL_CLKCTRL 0x0018
99 #define FD1_CTL_CLKCTRL_CSTP_N BIT(0)
100
101 /* Software reset register */
102 #define FD1_CTL_SRESET 0x001c
103 #define FD1_CTL_SRESET_SRST BIT(0)
104
105 /* Control status register (V-update-status) */
106 #define FD1_CTL_STATUS 0x0024
107 #define FD1_CTL_STATUS_VINT_CNT_MASK GENMASK(31, 16)
108 #define FD1_CTL_STATUS_VINT_CNT_SHIFT 16
109 #define FD1_CTL_STATUS_SGREGSET BIT(10)
110 #define FD1_CTL_STATUS_SGVERR BIT(9)
111 #define FD1_CTL_STATUS_SGFREND BIT(8)
112 #define FD1_CTL_STATUS_BSY BIT(0)
113
114 #define FD1_CTL_VCYCLE_STAT 0x0028
115
116 /* Interrupt enable register */
117 #define FD1_CTL_IRQENB 0x0038
118 /* Interrupt status register */
119 #define FD1_CTL_IRQSTA 0x003c
120 /* Interrupt control register */
121 #define FD1_CTL_IRQFSET 0x0040
122
123 /* Common IRQ Bit settings */
124 #define FD1_CTL_IRQ_VERE BIT(16)
125 #define FD1_CTL_IRQ_VINTE BIT(4)
126 #define FD1_CTL_IRQ_FREE BIT(0)
127 #define FD1_CTL_IRQ_MASK (FD1_CTL_IRQ_VERE | \
128 FD1_CTL_IRQ_VINTE | \
129 FD1_CTL_IRQ_FREE)
130
131 /* RPF */
132 #define FD1_RPF_SIZE 0x0060
133 #define FD1_RPF_SIZE_MASK GENMASK(12, 0)
134 #define FD1_RPF_SIZE_H_SHIFT 16
135 #define FD1_RPF_SIZE_V_SHIFT 0
136
137 #define FD1_RPF_FORMAT 0x0064
138 #define FD1_RPF_FORMAT_CIPM BIT(16)
139 #define FD1_RPF_FORMAT_RSPYCS BIT(13)
140 #define FD1_RPF_FORMAT_RSPUVS BIT(12)
141 #define FD1_RPF_FORMAT_CF BIT(8)
142
143 #define FD1_RPF_PSTRIDE 0x0068
144 #define FD1_RPF_PSTRIDE_Y_SHIFT 16
145 #define FD1_RPF_PSTRIDE_C_SHIFT 0
146
147 /* RPF0 Source Component Y Address register */
148 #define FD1_RPF0_ADDR_Y 0x006c
149
150 /* RPF1 Current Picture Registers */
151 #define FD1_RPF1_ADDR_Y 0x0078
152 #define FD1_RPF1_ADDR_C0 0x007c
153 #define FD1_RPF1_ADDR_C1 0x0080
154
155 /* RPF2 next picture register */
156 #define FD1_RPF2_ADDR_Y 0x0084
157
158 #define FD1_RPF_SMSK_ADDR 0x0090
159 #define FD1_RPF_SWAP 0x0094
160
161 /* WPF */
162 #define FD1_WPF_FORMAT 0x00c0
163 #define FD1_WPF_FORMAT_PDV_SHIFT 24
164 #define FD1_WPF_FORMAT_FCNL BIT(20)
165 #define FD1_WPF_FORMAT_WSPYCS BIT(15)
166 #define FD1_WPF_FORMAT_WSPUVS BIT(14)
167 #define FD1_WPF_FORMAT_WRTM_601_16 (0 << 9)
168 #define FD1_WPF_FORMAT_WRTM_601_0 (1 << 9)
169 #define FD1_WPF_FORMAT_WRTM_709_16 (2 << 9)
170 #define FD1_WPF_FORMAT_CSC BIT(8)
171
172 #define FD1_WPF_RNDCTL 0x00c4
173 #define FD1_WPF_RNDCTL_CBRM BIT(28)
174 #define FD1_WPF_RNDCTL_CLMD_NOCLIP (0 << 12)
175 #define FD1_WPF_RNDCTL_CLMD_CLIP_16_235 (1 << 12)
176 #define FD1_WPF_RNDCTL_CLMD_CLIP_1_254 (2 << 12)
177
178 #define FD1_WPF_PSTRIDE 0x00c8
179 #define FD1_WPF_PSTRIDE_Y_SHIFT 16
180 #define FD1_WPF_PSTRIDE_C_SHIFT 0
181
182 /* WPF Destination picture */
183 #define FD1_WPF_ADDR_Y 0x00cc
184 #define FD1_WPF_ADDR_C0 0x00d0
185 #define FD1_WPF_ADDR_C1 0x00d4
186 #define FD1_WPF_SWAP 0x00d8
187 #define FD1_WPF_SWAP_OSWAP_SHIFT 0
188 #define FD1_WPF_SWAP_SSWAP_SHIFT 4
189
190 /* WPF/RPF Common */
191 #define FD1_RWPF_SWAP_BYTE BIT(0)
192 #define FD1_RWPF_SWAP_WORD BIT(1)
193 #define FD1_RWPF_SWAP_LWRD BIT(2)
194 #define FD1_RWPF_SWAP_LLWD BIT(3)
195
196 /* IPC */
197 #define FD1_IPC_MODE 0x0100
198 #define FD1_IPC_MODE_DLI BIT(8)
199 #define FD1_IPC_MODE_DIM_ADAPT2D3D (0 << 0)
200 #define FD1_IPC_MODE_DIM_FIXED2D (1 << 0)
201 #define FD1_IPC_MODE_DIM_FIXED3D (2 << 0)
202 #define FD1_IPC_MODE_DIM_PREVFIELD (3 << 0)
203 #define FD1_IPC_MODE_DIM_NEXTFIELD (4 << 0)
204
205 #define FD1_IPC_SMSK_THRESH 0x0104
206 #define FD1_IPC_SMSK_THRESH_CONST 0x00010002
207
208 #define FD1_IPC_COMB_DET 0x0108
209 #define FD1_IPC_COMB_DET_CONST 0x00200040
210
211 #define FD1_IPC_MOTDEC 0x010c
212 #define FD1_IPC_MOTDEC_CONST 0x00008020
213
214 /* DLI registers */
215 #define FD1_IPC_DLI_BLEND 0x0120
216 #define FD1_IPC_DLI_BLEND_CONST 0x0080ff02
217
218 #define FD1_IPC_DLI_HGAIN 0x0124
219 #define FD1_IPC_DLI_HGAIN_CONST 0x001000ff
220
221 #define FD1_IPC_DLI_SPRS 0x0128
222 #define FD1_IPC_DLI_SPRS_CONST 0x009004ff
223
224 #define FD1_IPC_DLI_ANGLE 0x012c
225 #define FD1_IPC_DLI_ANGLE_CONST 0x0004080c
226
227 #define FD1_IPC_DLI_ISOPIX0 0x0130
228 #define FD1_IPC_DLI_ISOPIX0_CONST 0xff10ff10
229
230 #define FD1_IPC_DLI_ISOPIX1 0x0134
231 #define FD1_IPC_DLI_ISOPIX1_CONST 0x0000ff10
232
233 /* Sensor registers */
234 #define FD1_IPC_SENSOR_TH0 0x0140
235 #define FD1_IPC_SENSOR_TH0_CONST 0x20208080
236
237 #define FD1_IPC_SENSOR_TH1 0x0144
238 #define FD1_IPC_SENSOR_TH1_CONST 0
239
240 #define FD1_IPC_SENSOR_CTL0 0x0170
241 #define FD1_IPC_SENSOR_CTL0_CONST 0x00002201
242
243 #define FD1_IPC_SENSOR_CTL1 0x0174
244 #define FD1_IPC_SENSOR_CTL1_CONST 0
245
246 #define FD1_IPC_SENSOR_CTL2 0x0178
247 #define FD1_IPC_SENSOR_CTL2_X_SHIFT 16
248 #define FD1_IPC_SENSOR_CTL2_Y_SHIFT 0
249
250 #define FD1_IPC_SENSOR_CTL3 0x017c
251 #define FD1_IPC_SENSOR_CTL3_0_SHIFT 16
252 #define FD1_IPC_SENSOR_CTL3_1_SHIFT 0
253
254 /* Line memory pixel number register */
255 #define FD1_IPC_LMEM 0x01e0
256 #define FD1_IPC_LMEM_LINEAR 1024
257 #define FD1_IPC_LMEM_TILE 960
258
259 /* Internal Data (HW Version) */
260 #define FD1_IP_INTDATA 0x0800
261 #define FD1_IP_H3_ES1 0x02010101
262 #define FD1_IP_M3W 0x02010202
263 #define FD1_IP_H3 0x02010203
264
265 /* LUTs */
266 #define FD1_LUT_DIF_ADJ 0x1000
267 #define FD1_LUT_SAD_ADJ 0x1400
268 #define FD1_LUT_BLD_GAIN 0x1800
269 #define FD1_LUT_DIF_GAIN 0x1c00
270 #define FD1_LUT_MDET 0x2000
271
272 /**
273 * struct fdp1_fmt - The FDP1 internal format data
274 * @fourcc: the fourcc code, to match the V4L2 API
275 * @bpp: bits per pixel per plane
276 * @num_planes: number of planes
277 * @hsub: horizontal subsampling factor
278 * @vsub: vertical subsampling factor
279 * @fmt: 7-bit format code for the fdp1 hardware
280 * @swap_yc: the Y and C components are swapped (Y comes before C)
281 * @swap_uv: the U and V components are swapped (V comes before U)
282 * @swap: swap register control
283 * @types: types of queue this format is applicable to
284 */
285 struct fdp1_fmt {
286 u32 fourcc;
287 u8 bpp[3];
288 u8 num_planes;
289 u8 hsub;
290 u8 vsub;
291 u8 fmt;
292 bool swap_yc;
293 bool swap_uv;
294 u8 swap;
295 u8 types;
296 };
297
298 static const struct fdp1_fmt fdp1_formats[] = {
299 /* RGB formats are only supported by the Write Pixel Formatter */
300
301 { V4L2_PIX_FMT_RGB332, { 8, 0, 0 }, 1, 1, 1, 0x00, false, false,
302 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
303 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
304 FDP1_CAPTURE },
305 { V4L2_PIX_FMT_XRGB444, { 16, 0, 0 }, 1, 1, 1, 0x01, false, false,
306 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
307 FD1_RWPF_SWAP_WORD,
308 FDP1_CAPTURE },
309 { V4L2_PIX_FMT_XRGB555, { 16, 0, 0 }, 1, 1, 1, 0x04, false, false,
310 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
311 FD1_RWPF_SWAP_WORD,
312 FDP1_CAPTURE },
313 { V4L2_PIX_FMT_RGB565, { 16, 0, 0 }, 1, 1, 1, 0x06, false, false,
314 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
315 FD1_RWPF_SWAP_WORD,
316 FDP1_CAPTURE },
317 { V4L2_PIX_FMT_ABGR32, { 32, 0, 0 }, 1, 1, 1, 0x13, false, false,
318 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD,
319 FDP1_CAPTURE },
320 { V4L2_PIX_FMT_XBGR32, { 32, 0, 0 }, 1, 1, 1, 0x13, false, false,
321 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD,
322 FDP1_CAPTURE },
323 { V4L2_PIX_FMT_ARGB32, { 32, 0, 0 }, 1, 1, 1, 0x13, false, false,
324 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
325 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
326 FDP1_CAPTURE },
327 { V4L2_PIX_FMT_XRGB32, { 32, 0, 0 }, 1, 1, 1, 0x13, false, false,
328 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
329 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
330 FDP1_CAPTURE },
331 { V4L2_PIX_FMT_RGB24, { 24, 0, 0 }, 1, 1, 1, 0x15, false, false,
332 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
333 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
334 FDP1_CAPTURE },
335 { V4L2_PIX_FMT_BGR24, { 24, 0, 0 }, 1, 1, 1, 0x18, false, false,
336 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
337 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
338 FDP1_CAPTURE },
339 { V4L2_PIX_FMT_ARGB444, { 16, 0, 0 }, 1, 1, 1, 0x19, false, false,
340 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
341 FD1_RWPF_SWAP_WORD,
342 FDP1_CAPTURE },
343 { V4L2_PIX_FMT_ARGB555, { 16, 0, 0 }, 1, 1, 1, 0x1b, false, false,
344 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
345 FD1_RWPF_SWAP_WORD,
346 FDP1_CAPTURE },
347
348 /* YUV Formats are supported by Read and Write Pixel Formatters */
349
350 { V4L2_PIX_FMT_NV16M, { 8, 16, 0 }, 2, 2, 1, 0x41, false, false,
351 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
352 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
353 FDP1_CAPTURE | FDP1_OUTPUT },
354 { V4L2_PIX_FMT_NV61M, { 8, 16, 0 }, 2, 2, 1, 0x41, false, true,
355 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
356 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
357 FDP1_CAPTURE | FDP1_OUTPUT },
358 { V4L2_PIX_FMT_NV12M, { 8, 16, 0 }, 2, 2, 2, 0x42, false, false,
359 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
360 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
361 FDP1_CAPTURE | FDP1_OUTPUT },
362 { V4L2_PIX_FMT_NV21M, { 8, 16, 0 }, 2, 2, 2, 0x42, false, true,
363 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
364 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
365 FDP1_CAPTURE | FDP1_OUTPUT },
366 { V4L2_PIX_FMT_UYVY, { 16, 0, 0 }, 1, 2, 1, 0x47, false, false,
367 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
368 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
369 FDP1_CAPTURE | FDP1_OUTPUT },
370 { V4L2_PIX_FMT_VYUY, { 16, 0, 0 }, 1, 2, 1, 0x47, false, true,
371 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
372 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
373 FDP1_CAPTURE | FDP1_OUTPUT },
374 { V4L2_PIX_FMT_YUYV, { 16, 0, 0 }, 1, 2, 1, 0x47, true, false,
375 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
376 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
377 FDP1_CAPTURE | FDP1_OUTPUT },
378 { V4L2_PIX_FMT_YVYU, { 16, 0, 0 }, 1, 2, 1, 0x47, true, true,
379 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
380 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
381 FDP1_CAPTURE | FDP1_OUTPUT },
382 { V4L2_PIX_FMT_YUV444M, { 8, 8, 8 }, 3, 1, 1, 0x4a, false, false,
383 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
384 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
385 FDP1_CAPTURE | FDP1_OUTPUT },
386 { V4L2_PIX_FMT_YVU444M, { 8, 8, 8 }, 3, 1, 1, 0x4a, false, true,
387 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
388 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
389 FDP1_CAPTURE | FDP1_OUTPUT },
390 { V4L2_PIX_FMT_YUV422M, { 8, 8, 8 }, 3, 2, 1, 0x4b, false, false,
391 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
392 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
393 FDP1_CAPTURE | FDP1_OUTPUT },
394 { V4L2_PIX_FMT_YVU422M, { 8, 8, 8 }, 3, 2, 1, 0x4b, false, true,
395 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
396 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
397 FDP1_CAPTURE | FDP1_OUTPUT },
398 { V4L2_PIX_FMT_YUV420M, { 8, 8, 8 }, 3, 2, 2, 0x4c, false, false,
399 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
400 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
401 FDP1_CAPTURE | FDP1_OUTPUT },
402 { V4L2_PIX_FMT_YVU420M, { 8, 8, 8 }, 3, 2, 2, 0x4c, false, true,
403 FD1_RWPF_SWAP_LLWD | FD1_RWPF_SWAP_LWRD |
404 FD1_RWPF_SWAP_WORD | FD1_RWPF_SWAP_BYTE,
405 FDP1_CAPTURE | FDP1_OUTPUT },
406 };
407
408 static int fdp1_fmt_is_rgb(const struct fdp1_fmt *fmt)
409 {
410 return fmt->fmt <= 0x1b; /* Last RGB code */
411 }
412
413 /*
414 * FDP1 Lookup tables range from 0...255 only
415 *
416 * Each table must be less than 256 entries, and all tables
417 * are padded out to 256 entries by duplicating the last value.
418 */
419 static const u8 fdp1_diff_adj[] = {
420 0x00, 0x24, 0x43, 0x5e, 0x76, 0x8c, 0x9e, 0xaf,
421 0xbd, 0xc9, 0xd4, 0xdd, 0xe4, 0xea, 0xef, 0xf3,
422 0xf6, 0xf9, 0xfb, 0xfc, 0xfd, 0xfe, 0xfe, 0xff,
423 };
424
425 static const u8 fdp1_sad_adj[] = {
426 0x00, 0x24, 0x43, 0x5e, 0x76, 0x8c, 0x9e, 0xaf,
427 0xbd, 0xc9, 0xd4, 0xdd, 0xe4, 0xea, 0xef, 0xf3,
428 0xf6, 0xf9, 0xfb, 0xfc, 0xfd, 0xfe, 0xfe, 0xff,
429 };
430
431 static const u8 fdp1_bld_gain[] = {
432 0x80,
433 };
434
435 static const u8 fdp1_dif_gain[] = {
436 0x80,
437 };
438
439 static const u8 fdp1_mdet[] = {
440 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
441 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
442 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
443 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
444 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
445 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
446 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
447 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
448 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
449 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
450 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
451 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
452 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
453 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
454 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
455 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
456 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
457 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
458 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
459 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
460 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
461 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
462 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
463 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
464 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
465 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
466 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
467 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
468 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
469 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
470 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
471 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
472 };
473
474 /* Per-queue, driver-specific private data */
475 struct fdp1_q_data {
476 const struct fdp1_fmt *fmt;
477 struct v4l2_pix_format_mplane format;
478
479 unsigned int vsize;
480 unsigned int stride_y;
481 unsigned int stride_c;
482 };
483
484 static const struct fdp1_fmt *fdp1_find_format(u32 pixelformat)
485 {
486 const struct fdp1_fmt *fmt;
487 unsigned int i;
488
489 for (i = 0; i < ARRAY_SIZE(fdp1_formats); i++) {
490 fmt = &fdp1_formats[i];
491 if (fmt->fourcc == pixelformat)
492 return fmt;
493 }
494
495 return NULL;
496 }
497
498 enum fdp1_deint_mode {
499 FDP1_PROGRESSIVE = 0, /* Must be zero when !deinterlacing */
500 FDP1_ADAPT2D3D,
501 FDP1_FIXED2D,
502 FDP1_FIXED3D,
503 FDP1_PREVFIELD,
504 FDP1_NEXTFIELD,
505 };
506
507 #define FDP1_DEINT_MODE_USES_NEXT(mode) \
508 (mode == FDP1_ADAPT2D3D || \
509 mode == FDP1_FIXED3D || \
510 mode == FDP1_NEXTFIELD)
511
512 #define FDP1_DEINT_MODE_USES_PREV(mode) \
513 (mode == FDP1_ADAPT2D3D || \
514 mode == FDP1_FIXED3D || \
515 mode == FDP1_PREVFIELD)
516
517 /*
518 * FDP1 operates on potentially 3 fields, which are tracked
519 * from the VB buffers using this context structure.
520 * Will always be a field or a full frame, never two fields.
521 */
522 struct fdp1_field_buffer {
523 struct vb2_v4l2_buffer *vb;
524 dma_addr_t addrs[3];
525
526 /* Should be NONE:TOP:BOTTOM only */
527 enum v4l2_field field;
528
529 /* Flag to indicate this is the last field in the vb */
530 bool last_field;
531
532 /* Buffer queue lists */
533 struct list_head list;
534 };
535
536 struct fdp1_buffer {
537 struct v4l2_m2m_buffer m2m_buf;
538 struct fdp1_field_buffer fields[2];
539 unsigned int num_fields;
540 };
541
542 static inline struct fdp1_buffer *to_fdp1_buffer(struct vb2_v4l2_buffer *vb)
543 {
544 return container_of(vb, struct fdp1_buffer, m2m_buf.vb);
545 }
546
547 struct fdp1_job {
548 struct fdp1_field_buffer *previous;
549 struct fdp1_field_buffer *active;
550 struct fdp1_field_buffer *next;
551 struct fdp1_field_buffer *dst;
552
553 /* A job can only be on one list at a time */
554 struct list_head list;
555 };
556
557 struct fdp1_dev {
558 struct v4l2_device v4l2_dev;
559 struct video_device vfd;
560
561 struct mutex dev_mutex;
562 spinlock_t irqlock;
563 spinlock_t device_process_lock;
564
565 void __iomem *regs;
566 unsigned int irq;
567 struct device *dev;
568
569 /* Job Queues */
570 struct fdp1_job jobs[FDP1_NUMBER_JOBS];
571 struct list_head free_job_list;
572 struct list_head queued_job_list;
573 struct list_head hw_job_list;
574
575 unsigned int clk_rate;
576
577 struct rcar_fcp_device *fcp;
578 struct v4l2_m2m_dev *m2m_dev;
579 };
580
581 struct fdp1_ctx {
582 struct v4l2_fh fh;
583 struct fdp1_dev *fdp1;
584
585 struct v4l2_ctrl_handler hdl;
586 unsigned int sequence;
587
588 /* Processed buffers in this transaction */
589 u8 num_processed;
590
591 /* Transaction length (i.e. how many buffers per transaction) */
592 u32 translen;
593
594 /* Abort requested by m2m */
595 int aborting;
596
597 /* Deinterlace processing mode */
598 enum fdp1_deint_mode deint_mode;
599
600 /*
601 * Adaptive 2D/3D mode uses a shared mask
602 * This is allocated at streamon, if the ADAPT2D3D mode
603 * is requested
604 */
605 unsigned int smsk_size;
606 dma_addr_t smsk_addr[2];
607 void *smsk_cpu;
608
609 /* Capture pipeline, can specify an alpha value
610 * for supported formats. 0-255 only
611 */
612 unsigned char alpha;
613
614 /* Source and destination queue data */
615 struct fdp1_q_data out_q; /* HW Source */
616 struct fdp1_q_data cap_q; /* HW Destination */
617
618 /*
619 * Field Queues
620 * Interlaced fields are used on 3 occasions, and tracked in this list.
621 *
622 * V4L2 Buffers are tracked inside the fdp1_buffer
623 * and released when the last 'field' completes
624 */
625 struct list_head fields_queue;
626 unsigned int buffers_queued;
627
628 /*
629 * For de-interlacing we need to track our previous buffer
630 * while preparing our job lists.
631 */
632 struct fdp1_field_buffer *previous;
633 };
634
635 static inline struct fdp1_ctx *fh_to_ctx(struct v4l2_fh *fh)
636 {
637 return container_of(fh, struct fdp1_ctx, fh);
638 }
639
640 static struct fdp1_q_data *get_q_data(struct fdp1_ctx *ctx,
641 enum v4l2_buf_type type)
642 {
643 if (V4L2_TYPE_IS_OUTPUT(type))
644 return &ctx->out_q;
645 else
646 return &ctx->cap_q;
647 }
648
649 /*
650 * list_remove_job: Take the first item off the specified job list
651 *
652 * Returns: pointer to a job, or NULL if the list is empty.
653 */
654 static struct fdp1_job *list_remove_job(struct fdp1_dev *fdp1,
655 struct list_head *list)
656 {
657 struct fdp1_job *job;
658 unsigned long flags;
659
660 spin_lock_irqsave(&fdp1->irqlock, flags);
661 job = list_first_entry_or_null(list, struct fdp1_job, list);
662 if (job)
663 list_del(&job->list);
664 spin_unlock_irqrestore(&fdp1->irqlock, flags);
665
666 return job;
667 }
668
669 /*
670 * list_add_job: Add a job to the specified job list
671 *
672 * Returns: void - always succeeds
673 */
674 static void list_add_job(struct fdp1_dev *fdp1,
675 struct list_head *list,
676 struct fdp1_job *job)
677 {
678 unsigned long flags;
679
680 spin_lock_irqsave(&fdp1->irqlock, flags);
681 list_add_tail(&job->list, list);
682 spin_unlock_irqrestore(&fdp1->irqlock, flags);
683 }
684
685 static struct fdp1_job *fdp1_job_alloc(struct fdp1_dev *fdp1)
686 {
687 return list_remove_job(fdp1, &fdp1->free_job_list);
688 }
689
690 static void fdp1_job_free(struct fdp1_dev *fdp1, struct fdp1_job *job)
691 {
692 /* Ensure that all residue from previous jobs is gone */
693 memset(job, 0, sizeof(struct fdp1_job));
694
695 list_add_job(fdp1, &fdp1->free_job_list, job);
696 }
697
698 static void queue_job(struct fdp1_dev *fdp1, struct fdp1_job *job)
699 {
700 list_add_job(fdp1, &fdp1->queued_job_list, job);
701 }
702
703 static struct fdp1_job *get_queued_job(struct fdp1_dev *fdp1)
704 {
705 return list_remove_job(fdp1, &fdp1->queued_job_list);
706 }
707
708 static void queue_hw_job(struct fdp1_dev *fdp1, struct fdp1_job *job)
709 {
710 list_add_job(fdp1, &fdp1->hw_job_list, job);
711 }
712
713 static struct fdp1_job *get_hw_queued_job(struct fdp1_dev *fdp1)
714 {
715 return list_remove_job(fdp1, &fdp1->hw_job_list);
716 }
717
718 /*
719 * Buffer lists handling
720 */
721 static void fdp1_field_complete(struct fdp1_ctx *ctx,
722 struct fdp1_field_buffer *fbuf)
723 {
724 /* job->previous may be on the first field */
725 if (!fbuf)
726 return;
727
728 if (fbuf->last_field)
729 v4l2_m2m_buf_done(fbuf->vb, VB2_BUF_STATE_DONE);
730 }
731
732 static void fdp1_queue_field(struct fdp1_ctx *ctx,
733 struct fdp1_field_buffer *fbuf)
734 {
735 unsigned long flags;
736
737 spin_lock_irqsave(&ctx->fdp1->irqlock, flags);
738 list_add_tail(&fbuf->list, &ctx->fields_queue);
739 spin_unlock_irqrestore(&ctx->fdp1->irqlock, flags);
740
741 ctx->buffers_queued++;
742 }
743
744 static struct fdp1_field_buffer *fdp1_dequeue_field(struct fdp1_ctx *ctx)
745 {
746 struct fdp1_field_buffer *fbuf;
747 unsigned long flags;
748
749 ctx->buffers_queued--;
750
751 spin_lock_irqsave(&ctx->fdp1->irqlock, flags);
752 fbuf = list_first_entry_or_null(&ctx->fields_queue,
753 struct fdp1_field_buffer, list);
754 if (fbuf)
755 list_del(&fbuf->list);
756 spin_unlock_irqrestore(&ctx->fdp1->irqlock, flags);
757
758 return fbuf;
759 }
760
761 /*
762 * Return the next field in the queue - or NULL,
763 * without removing the item from the list
764 */
765 static struct fdp1_field_buffer *fdp1_peek_queued_field(struct fdp1_ctx *ctx)
766 {
767 struct fdp1_field_buffer *fbuf;
768 unsigned long flags;
769
770 spin_lock_irqsave(&ctx->fdp1->irqlock, flags);
771 fbuf = list_first_entry_or_null(&ctx->fields_queue,
772 struct fdp1_field_buffer, list);
773 spin_unlock_irqrestore(&ctx->fdp1->irqlock, flags);
774
775 return fbuf;
776 }
777
778 static u32 fdp1_read(struct fdp1_dev *fdp1, unsigned int reg)
779 {
780 u32 value = ioread32(fdp1->regs + reg);
781
782 if (debug >= 2)
783 dprintk(fdp1, "Read 0x%08x from 0x%04x\n", value, reg);
784
785 return value;
786 }
787
788 static void fdp1_write(struct fdp1_dev *fdp1, u32 val, unsigned int reg)
789 {
790 if (debug >= 2)
791 dprintk(fdp1, "Write 0x%08x to 0x%04x\n", val, reg);
792
793 iowrite32(val, fdp1->regs + reg);
794 }
795
796 /* IPC registers are to be programmed with constant values */
797 static void fdp1_set_ipc_dli(struct fdp1_ctx *ctx)
798 {
799 struct fdp1_dev *fdp1 = ctx->fdp1;
800
801 fdp1_write(fdp1, FD1_IPC_SMSK_THRESH_CONST, FD1_IPC_SMSK_THRESH);
802 fdp1_write(fdp1, FD1_IPC_COMB_DET_CONST, FD1_IPC_COMB_DET);
803 fdp1_write(fdp1, FD1_IPC_MOTDEC_CONST, FD1_IPC_MOTDEC);
804
805 fdp1_write(fdp1, FD1_IPC_DLI_BLEND_CONST, FD1_IPC_DLI_BLEND);
806 fdp1_write(fdp1, FD1_IPC_DLI_HGAIN_CONST, FD1_IPC_DLI_HGAIN);
807 fdp1_write(fdp1, FD1_IPC_DLI_SPRS_CONST, FD1_IPC_DLI_SPRS);
808 fdp1_write(fdp1, FD1_IPC_DLI_ANGLE_CONST, FD1_IPC_DLI_ANGLE);
809 fdp1_write(fdp1, FD1_IPC_DLI_ISOPIX0_CONST, FD1_IPC_DLI_ISOPIX0);
810 fdp1_write(fdp1, FD1_IPC_DLI_ISOPIX1_CONST, FD1_IPC_DLI_ISOPIX1);
811 }
812
813
814 static void fdp1_set_ipc_sensor(struct fdp1_ctx *ctx)
815 {
816 struct fdp1_dev *fdp1 = ctx->fdp1;
817 struct fdp1_q_data *src_q_data = &ctx->out_q;
818 unsigned int x0, x1;
819 unsigned int hsize = src_q_data->format.width;
820 unsigned int vsize = src_q_data->format.height;
821
822 x0 = hsize / 3;
823 x1 = 2 * hsize / 3;
824
825 fdp1_write(fdp1, FD1_IPC_SENSOR_TH0_CONST, FD1_IPC_SENSOR_TH0);
826 fdp1_write(fdp1, FD1_IPC_SENSOR_TH1_CONST, FD1_IPC_SENSOR_TH1);
827 fdp1_write(fdp1, FD1_IPC_SENSOR_CTL0_CONST, FD1_IPC_SENSOR_CTL0);
828 fdp1_write(fdp1, FD1_IPC_SENSOR_CTL1_CONST, FD1_IPC_SENSOR_CTL1);
829
830 fdp1_write(fdp1, ((hsize - 1) << FD1_IPC_SENSOR_CTL2_X_SHIFT) |
831 ((vsize - 1) << FD1_IPC_SENSOR_CTL2_Y_SHIFT),
832 FD1_IPC_SENSOR_CTL2);
833
834 fdp1_write(fdp1, (x0 << FD1_IPC_SENSOR_CTL3_0_SHIFT) |
835 (x1 << FD1_IPC_SENSOR_CTL3_1_SHIFT),
836 FD1_IPC_SENSOR_CTL3);
837 }
838
839 /*
840 * fdp1_write_lut: Write a padded LUT to the hw
841 *
842 * FDP1 uses constant data for de-interlacing processing,
843 * with large tables. These hardware tables are all 256 bytes
844 * long, however they often contain repeated data at the end.
845 *
846 * The last byte of the table is written to all remaining entries.
847 */
848 static void fdp1_write_lut(struct fdp1_dev *fdp1, const u8 *lut,
849 unsigned int len, unsigned int base)
850 {
851 unsigned int i;
852 u8 pad;
853
854 /* Tables larger than the hw are clipped */
855 len = min(len, 256u);
856
857 for (i = 0; i < len; i++)
858 fdp1_write(fdp1, lut[i], base + (i*4));
859
860 /* Tables are padded with the last entry */
861 pad = lut[i-1];
862
863 for (; i < 256; i++)
864 fdp1_write(fdp1, pad, base + (i*4));
865 }
866
867 static void fdp1_set_lut(struct fdp1_dev *fdp1)
868 {
869 fdp1_write_lut(fdp1, fdp1_diff_adj, ARRAY_SIZE(fdp1_diff_adj),
870 FD1_LUT_DIF_ADJ);
871 fdp1_write_lut(fdp1, fdp1_sad_adj, ARRAY_SIZE(fdp1_sad_adj),
872 FD1_LUT_SAD_ADJ);
873 fdp1_write_lut(fdp1, fdp1_bld_gain, ARRAY_SIZE(fdp1_bld_gain),
874 FD1_LUT_BLD_GAIN);
875 fdp1_write_lut(fdp1, fdp1_dif_gain, ARRAY_SIZE(fdp1_dif_gain),
876 FD1_LUT_DIF_GAIN);
877 fdp1_write_lut(fdp1, fdp1_mdet, ARRAY_SIZE(fdp1_mdet),
878 FD1_LUT_MDET);
879 }
880
881 static void fdp1_configure_rpf(struct fdp1_ctx *ctx,
882 struct fdp1_job *job)
883 {
884 struct fdp1_dev *fdp1 = ctx->fdp1;
885 u32 picture_size;
886 u32 pstride;
887 u32 format;
888 u32 smsk_addr;
889
890 struct fdp1_q_data *q_data = &ctx->out_q;
891
892 /* Picture size is common to Source and Destination frames */
893 picture_size = (q_data->format.width << FD1_RPF_SIZE_H_SHIFT)
894 | (q_data->vsize << FD1_RPF_SIZE_V_SHIFT);
895
896 /* Strides */
897 pstride = q_data->stride_y << FD1_RPF_PSTRIDE_Y_SHIFT;
898 if (q_data->format.num_planes > 1)
899 pstride |= q_data->stride_c << FD1_RPF_PSTRIDE_C_SHIFT;
900
901 /* Format control */
902 format = q_data->fmt->fmt;
903 if (q_data->fmt->swap_yc)
904 format |= FD1_RPF_FORMAT_RSPYCS;
905
906 if (q_data->fmt->swap_uv)
907 format |= FD1_RPF_FORMAT_RSPUVS;
908
909 if (job->active->field == V4L2_FIELD_BOTTOM) {
910 format |= FD1_RPF_FORMAT_CF; /* Set for Bottom field */
911 smsk_addr = ctx->smsk_addr[0];
912 } else {
913 smsk_addr = ctx->smsk_addr[1];
914 }
915
916 /* Deint mode is non-zero when deinterlacing */
917 if (ctx->deint_mode)
918 format |= FD1_RPF_FORMAT_CIPM;
919
920 fdp1_write(fdp1, format, FD1_RPF_FORMAT);
921 fdp1_write(fdp1, q_data->fmt->swap, FD1_RPF_SWAP);
922 fdp1_write(fdp1, picture_size, FD1_RPF_SIZE);
923 fdp1_write(fdp1, pstride, FD1_RPF_PSTRIDE);
924 fdp1_write(fdp1, smsk_addr, FD1_RPF_SMSK_ADDR);
925
926 /* Previous Field Channel (CH0) */
927 if (job->previous)
928 fdp1_write(fdp1, job->previous->addrs[0], FD1_RPF0_ADDR_Y);
929
930 /* Current Field Channel (CH1) */
931 fdp1_write(fdp1, job->active->addrs[0], FD1_RPF1_ADDR_Y);
932 fdp1_write(fdp1, job->active->addrs[1], FD1_RPF1_ADDR_C0);
933 fdp1_write(fdp1, job->active->addrs[2], FD1_RPF1_ADDR_C1);
934
935 /* Next Field Channel (CH2) */
936 if (job->next)
937 fdp1_write(fdp1, job->next->addrs[0], FD1_RPF2_ADDR_Y);
938 }
939
940 static void fdp1_configure_wpf(struct fdp1_ctx *ctx,
941 struct fdp1_job *job)
942 {
943 struct fdp1_dev *fdp1 = ctx->fdp1;
944 struct fdp1_q_data *src_q_data = &ctx->out_q;
945 struct fdp1_q_data *q_data = &ctx->cap_q;
946 u32 pstride;
947 u32 format;
948 u32 swap;
949 u32 rndctl;
950
951 pstride = q_data->format.plane_fmt[0].bytesperline
952 << FD1_WPF_PSTRIDE_Y_SHIFT;
953
954 if (q_data->format.num_planes > 1)
955 pstride |= q_data->format.plane_fmt[1].bytesperline
956 << FD1_WPF_PSTRIDE_C_SHIFT;
957
958 format = q_data->fmt->fmt; /* Output Format Code */
959
960 if (q_data->fmt->swap_yc)
961 format |= FD1_WPF_FORMAT_WSPYCS;
962
963 if (q_data->fmt->swap_uv)
964 format |= FD1_WPF_FORMAT_WSPUVS;
965
966 if (fdp1_fmt_is_rgb(q_data->fmt)) {
967 /* Enable Colour Space conversion */
968 format |= FD1_WPF_FORMAT_CSC;
969
970 /* Set WRTM */
971 if (src_q_data->format.ycbcr_enc == V4L2_YCBCR_ENC_709)
972 format |= FD1_WPF_FORMAT_WRTM_709_16;
973 else if (src_q_data->format.quantization ==
974 V4L2_QUANTIZATION_FULL_RANGE)
975 format |= FD1_WPF_FORMAT_WRTM_601_0;
976 else
977 format |= FD1_WPF_FORMAT_WRTM_601_16;
978 }
979
980 /* Set an alpha value into the Pad Value */
981 format |= ctx->alpha << FD1_WPF_FORMAT_PDV_SHIFT;
982
983 /* Determine picture rounding and clipping */
984 rndctl = FD1_WPF_RNDCTL_CBRM; /* Rounding Off */
985 rndctl |= FD1_WPF_RNDCTL_CLMD_NOCLIP;
986
987 /* WPF Swap needs both ISWAP and OSWAP setting */
988 swap = q_data->fmt->swap << FD1_WPF_SWAP_OSWAP_SHIFT;
989 swap |= src_q_data->fmt->swap << FD1_WPF_SWAP_SSWAP_SHIFT;
990
991 fdp1_write(fdp1, format, FD1_WPF_FORMAT);
992 fdp1_write(fdp1, rndctl, FD1_WPF_RNDCTL);
993 fdp1_write(fdp1, swap, FD1_WPF_SWAP);
994 fdp1_write(fdp1, pstride, FD1_WPF_PSTRIDE);
995
996 fdp1_write(fdp1, job->dst->addrs[0], FD1_WPF_ADDR_Y);
997 fdp1_write(fdp1, job->dst->addrs[1], FD1_WPF_ADDR_C0);
998 fdp1_write(fdp1, job->dst->addrs[2], FD1_WPF_ADDR_C1);
999 }
1000
1001 static void fdp1_configure_deint_mode(struct fdp1_ctx *ctx,
1002 struct fdp1_job *job)
1003 {
1004 struct fdp1_dev *fdp1 = ctx->fdp1;
1005 u32 opmode = FD1_CTL_OPMODE_VIMD_NOINTERRUPT;
1006 u32 ipcmode = FD1_IPC_MODE_DLI; /* Always set */
1007 u32 channels = FD1_CTL_CHACT_WR | FD1_CTL_CHACT_RD1; /* Always on */
1008
1009 /* De-interlacing Mode */
1010 switch (ctx->deint_mode) {
1011 default:
1012 case FDP1_PROGRESSIVE:
1013 dprintk(fdp1, "Progressive Mode\n");
1014 opmode |= FD1_CTL_OPMODE_PRG;
1015 ipcmode |= FD1_IPC_MODE_DIM_FIXED2D;
1016 break;
1017 case FDP1_ADAPT2D3D:
1018 dprintk(fdp1, "Adapt2D3D Mode\n");
1019 if (ctx->sequence == 0 || ctx->aborting)
1020 ipcmode |= FD1_IPC_MODE_DIM_FIXED2D;
1021 else
1022 ipcmode |= FD1_IPC_MODE_DIM_ADAPT2D3D;
1023
1024 if (ctx->sequence > 1) {
1025 channels |= FD1_CTL_CHACT_SMW;
1026 channels |= FD1_CTL_CHACT_RD0 | FD1_CTL_CHACT_RD2;
1027 }
1028
1029 if (ctx->sequence > 2)
1030 channels |= FD1_CTL_CHACT_SMR;
1031
1032 break;
1033 case FDP1_FIXED3D:
1034 dprintk(fdp1, "Fixed 3D Mode\n");
1035 ipcmode |= FD1_IPC_MODE_DIM_FIXED3D;
1036 /* Except for first and last frame, enable all channels */
1037 if (!(ctx->sequence == 0 || ctx->aborting))
1038 channels |= FD1_CTL_CHACT_RD0 | FD1_CTL_CHACT_RD2;
1039 break;
1040 case FDP1_FIXED2D:
1041 dprintk(fdp1, "Fixed 2D Mode\n");
1042 ipcmode |= FD1_IPC_MODE_DIM_FIXED2D;
1043 /* No extra channels enabled */
1044 break;
1045 case FDP1_PREVFIELD:
1046 dprintk(fdp1, "Previous Field Mode\n");
1047 ipcmode |= FD1_IPC_MODE_DIM_PREVFIELD;
1048 channels |= FD1_CTL_CHACT_RD0; /* Previous */
1049 break;
1050 case FDP1_NEXTFIELD:
1051 dprintk(fdp1, "Next Field Mode\n");
1052 ipcmode |= FD1_IPC_MODE_DIM_NEXTFIELD;
1053 channels |= FD1_CTL_CHACT_RD2; /* Next */
1054 break;
1055 }
1056
1057 fdp1_write(fdp1, channels, FD1_CTL_CHACT);
1058 fdp1_write(fdp1, opmode, FD1_CTL_OPMODE);
1059 fdp1_write(fdp1, ipcmode, FD1_IPC_MODE);
1060 }
1061
1062 /*
1063 * fdp1_device_process() - Run the hardware
1064 *
1065 * Configure and start the hardware to generate a single frame
1066 * of output given our input parameters.
1067 */
1068 static int fdp1_device_process(struct fdp1_ctx *ctx)
1069
1070 {
1071 struct fdp1_dev *fdp1 = ctx->fdp1;
1072 struct fdp1_job *job;
1073 unsigned long flags;
1074
1075 spin_lock_irqsave(&fdp1->device_process_lock, flags);
1076
1077 /* Get a job to process */
1078 job = get_queued_job(fdp1);
1079 if (!job) {
1080 /*
1081 * VINT can call us to see if we can queue another job.
1082 * If we have no work to do, we simply return.
1083 */
1084 spin_unlock_irqrestore(&fdp1->device_process_lock, flags);
1085 return 0;
1086 }
1087
1088 /* First Frame only? ... */
1089 fdp1_write(fdp1, FD1_CTL_CLKCTRL_CSTP_N, FD1_CTL_CLKCTRL);
1090
1091 /* Set the mode, and configuration */
1092 fdp1_configure_deint_mode(ctx, job);
1093
1094 /* DLI Static Configuration */
1095 fdp1_set_ipc_dli(ctx);
1096
1097 /* Sensor Configuration */
1098 fdp1_set_ipc_sensor(ctx);
1099
1100 /* Setup the source picture */
1101 fdp1_configure_rpf(ctx, job);
1102
1103 /* Setup the destination picture */
1104 fdp1_configure_wpf(ctx, job);
1105
1106 /* Line Memory Pixel Number Register for linear access */
1107 fdp1_write(fdp1, FD1_IPC_LMEM_LINEAR, FD1_IPC_LMEM);
1108
1109 /* Enable Interrupts */
1110 fdp1_write(fdp1, FD1_CTL_IRQ_MASK, FD1_CTL_IRQENB);
1111
1112 /* Finally, the Immediate Registers */
1113
1114 /* This job is now in the HW queue */
1115 queue_hw_job(fdp1, job);
1116
1117 /* Start the command */
1118 fdp1_write(fdp1, FD1_CTL_CMD_STRCMD, FD1_CTL_CMD);
1119
1120 /* Registers will update to HW at next VINT */
1121 fdp1_write(fdp1, FD1_CTL_REGEND_REGEND, FD1_CTL_REGEND);
1122
1123 /* Enable VINT Generator */
1124 fdp1_write(fdp1, FD1_CTL_SGCMD_SGEN, FD1_CTL_SGCMD);
1125
1126 spin_unlock_irqrestore(&fdp1->device_process_lock, flags);
1127
1128 return 0;
1129 }
1130
1131 /*
1132 * mem2mem callbacks
1133 */
1134
1135 /*
1136 * job_ready() - check whether an instance is ready to be scheduled to run
1137 */
1138 static int fdp1_m2m_job_ready(void *priv)
1139 {
1140 struct fdp1_ctx *ctx = priv;
1141 struct fdp1_q_data *src_q_data = &ctx->out_q;
1142 int srcbufs = 1;
1143 int dstbufs = 1;
1144
1145 dprintk(ctx->fdp1, "+ Src: %d : Dst: %d\n",
1146 v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx),
1147 v4l2_m2m_num_dst_bufs_ready(ctx->fh.m2m_ctx));
1148
1149 /* One output buffer is required for each field */
1150 if (V4L2_FIELD_HAS_BOTH(src_q_data->format.field))
1151 dstbufs = 2;
1152
1153 if (v4l2_m2m_num_src_bufs_ready(ctx->fh.m2m_ctx) < srcbufs
1154 || v4l2_m2m_num_dst_bufs_ready(ctx->fh.m2m_ctx) < dstbufs) {
1155 dprintk(ctx->fdp1, "Not enough buffers available\n");
1156 return 0;
1157 }
1158
1159 return 1;
1160 }
1161
1162 static void fdp1_m2m_job_abort(void *priv)
1163 {
1164 struct fdp1_ctx *ctx = priv;
1165
1166 dprintk(ctx->fdp1, "+\n");
1167
1168 /* Will cancel the transaction in the next interrupt handler */
1169 ctx->aborting = 1;
1170
1171 /* Immediate abort sequence */
1172 fdp1_write(ctx->fdp1, 0, FD1_CTL_SGCMD);
1173 fdp1_write(ctx->fdp1, FD1_CTL_SRESET_SRST, FD1_CTL_SRESET);
1174 }
1175
1176 /*
1177 * fdp1_prepare_job: Prepare and queue a new job for a single action of work
1178 *
1179 * Prepare the next field, (or frame in progressive) and an output
1180 * buffer for the hardware to perform a single operation.
1181 */
1182 static struct fdp1_job *fdp1_prepare_job(struct fdp1_ctx *ctx)
1183 {
1184 struct vb2_v4l2_buffer *vbuf;
1185 struct fdp1_buffer *fbuf;
1186 struct fdp1_dev *fdp1 = ctx->fdp1;
1187 struct fdp1_job *job;
1188 unsigned int buffers_required = 1;
1189
1190 dprintk(fdp1, "+\n");
1191
1192 if (FDP1_DEINT_MODE_USES_NEXT(ctx->deint_mode))
1193 buffers_required = 2;
1194
1195 if (ctx->buffers_queued < buffers_required)
1196 return NULL;
1197
1198 job = fdp1_job_alloc(fdp1);
1199 if (!job) {
1200 dprintk(fdp1, "No free jobs currently available\n");
1201 return NULL;
1202 }
1203
1204 job->active = fdp1_dequeue_field(ctx);
1205 if (!job->active) {
1206 /* Buffer check should prevent this ever happening */
1207 dprintk(fdp1, "No input buffers currently available\n");
1208
1209 fdp1_job_free(fdp1, job);
1210 return NULL;
1211 }
1212
1213 dprintk(fdp1, "+ Buffer en-route...\n");
1214
1215 /* Source buffers have been prepared on our buffer_queue
1216 * Prepare our Output buffer
1217 */
1218 vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
1219 fbuf = to_fdp1_buffer(vbuf);
1220 job->dst = &fbuf->fields[0];
1221
1222 job->active->vb->sequence = ctx->sequence;
1223 job->dst->vb->sequence = ctx->sequence;
1224 ctx->sequence++;
1225
1226 if (FDP1_DEINT_MODE_USES_PREV(ctx->deint_mode)) {
1227 job->previous = ctx->previous;
1228
1229 /* Active buffer becomes the next job's previous buffer */
1230 ctx->previous = job->active;
1231 }
1232
1233 if (FDP1_DEINT_MODE_USES_NEXT(ctx->deint_mode)) {
1234 /* Must be called after 'active' is dequeued */
1235 job->next = fdp1_peek_queued_field(ctx);
1236 }
1237
1238 /* Transfer timestamps and flags from src->dst */
1239
1240 job->dst->vb->vb2_buf.timestamp = job->active->vb->vb2_buf.timestamp;
1241
1242 job->dst->vb->flags = job->active->vb->flags &
1243 V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
1244
1245 /* Ideally, the frame-end function will just 'check' to see
1246 * if there are more jobs instead
1247 */
1248 ctx->translen++;
1249
1250 /* Finally, Put this job on the processing queue */
1251 queue_job(fdp1, job);
1252
1253 dprintk(fdp1, "Job Queued translen = %d\n", ctx->translen);
1254
1255 return job;
1256 }
1257
1258 /* fdp1_m2m_device_run() - prepares and starts the device for an M2M task
1259 *
1260 * A single input buffer is taken and serialised into our fdp1_buffer
1261 * queue. The queue is then processed to create as many jobs as possible
1262 * from our available input.
1263 */
1264 static void fdp1_m2m_device_run(void *priv)
1265 {
1266 struct fdp1_ctx *ctx = priv;
1267 struct fdp1_dev *fdp1 = ctx->fdp1;
1268 struct vb2_v4l2_buffer *src_vb;
1269 struct fdp1_buffer *buf;
1270 unsigned int i;
1271
1272 dprintk(fdp1, "+\n");
1273
1274 ctx->translen = 0;
1275
1276 /* Get our incoming buffer of either one or two fields, or one frame */
1277 src_vb = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
1278 buf = to_fdp1_buffer(src_vb);
1279
1280 for (i = 0; i < buf->num_fields; i++) {
1281 struct fdp1_field_buffer *fbuf = &buf->fields[i];
1282
1283 fdp1_queue_field(ctx, fbuf);
1284 dprintk(fdp1, "Queued Buffer [%d] last_field:%d\n",
1285 i, fbuf->last_field);
1286 }
1287
1288 /* Queue as many jobs as our data provides for */
1289 while (fdp1_prepare_job(ctx))
1290 ;
1291
1292 if (ctx->translen == 0) {
1293 dprintk(fdp1, "No jobs were processed. M2M action complete\n");
1294 v4l2_m2m_job_finish(fdp1->m2m_dev, ctx->fh.m2m_ctx);
1295 return;
1296 }
1297
1298 /* Kick the job processing action */
1299 fdp1_device_process(ctx);
1300 }
1301
1302 /*
1303 * device_frame_end:
1304 *
1305 * Handles the M2M level after a buffer completion event.
1306 */
1307 static void device_frame_end(struct fdp1_dev *fdp1,
1308 enum vb2_buffer_state state)
1309 {
1310 struct fdp1_ctx *ctx;
1311 unsigned long flags;
1312 struct fdp1_job *job = get_hw_queued_job(fdp1);
1313
1314 dprintk(fdp1, "+\n");
1315
1316 ctx = v4l2_m2m_get_curr_priv(fdp1->m2m_dev);
1317
1318 if (ctx == NULL) {
1319 v4l2_err(&fdp1->v4l2_dev,
1320 "Instance released before the end of transaction\n");
1321 return;
1322 }
1323
1324 ctx->num_processed++;
1325
1326 /*
1327 * fdp1_field_complete will call buf_done only when the last vb2_buffer
1328 * reference is complete
1329 */
1330 if (FDP1_DEINT_MODE_USES_PREV(ctx->deint_mode))
1331 fdp1_field_complete(ctx, job->previous);
1332 else
1333 fdp1_field_complete(ctx, job->active);
1334
1335 spin_lock_irqsave(&fdp1->irqlock, flags);
1336 v4l2_m2m_buf_done(job->dst->vb, state);
1337 job->dst = NULL;
1338 spin_unlock_irqrestore(&fdp1->irqlock, flags);
1339
1340 /* Move this job back to the free job list */
1341 fdp1_job_free(fdp1, job);
1342
1343 dprintk(fdp1, "curr_ctx->num_processed %d curr_ctx->translen %d\n",
1344 ctx->num_processed, ctx->translen);
1345
1346 if (ctx->num_processed == ctx->translen ||
1347 ctx->aborting) {
1348 dprintk(ctx->fdp1, "Finishing transaction\n");
1349 ctx->num_processed = 0;
1350 v4l2_m2m_job_finish(fdp1->m2m_dev, ctx->fh.m2m_ctx);
1351 } else {
1352 /*
1353 * For pipelined performance support, this would
1354 * be called from a VINT handler
1355 */
1356 fdp1_device_process(ctx);
1357 }
1358 }
1359
1360 /*
1361 * video ioctls
1362 */
1363 static int fdp1_vidioc_querycap(struct file *file, void *priv,
1364 struct v4l2_capability *cap)
1365 {
1366 strlcpy(cap->driver, DRIVER_NAME, sizeof(cap->driver));
1367 strlcpy(cap->card, DRIVER_NAME, sizeof(cap->card));
1368 snprintf(cap->bus_info, sizeof(cap->bus_info),
1369 "platform:%s", DRIVER_NAME);
1370 return 0;
1371 }
1372
1373 static int fdp1_enum_fmt(struct v4l2_fmtdesc *f, u32 type)
1374 {
1375 unsigned int i, num;
1376
1377 num = 0;
1378
1379 for (i = 0; i < ARRAY_SIZE(fdp1_formats); ++i) {
1380 if (fdp1_formats[i].types & type) {
1381 if (num == f->index)
1382 break;
1383 ++num;
1384 }
1385 }
1386
1387 /* Format not found */
1388 if (i >= ARRAY_SIZE(fdp1_formats))
1389 return -EINVAL;
1390
1391 /* Format found */
1392 f->pixelformat = fdp1_formats[i].fourcc;
1393
1394 return 0;
1395 }
1396
1397 static int fdp1_enum_fmt_vid_cap(struct file *file, void *priv,
1398 struct v4l2_fmtdesc *f)
1399 {
1400 return fdp1_enum_fmt(f, FDP1_CAPTURE);
1401 }
1402
1403 static int fdp1_enum_fmt_vid_out(struct file *file, void *priv,
1404 struct v4l2_fmtdesc *f)
1405 {
1406 return fdp1_enum_fmt(f, FDP1_OUTPUT);
1407 }
1408
1409 static int fdp1_g_fmt(struct file *file, void *priv, struct v4l2_format *f)
1410 {
1411 struct fdp1_q_data *q_data;
1412 struct fdp1_ctx *ctx = fh_to_ctx(priv);
1413
1414 if (!v4l2_m2m_get_vq(ctx->fh.m2m_ctx, f->type))
1415 return -EINVAL;
1416
1417 q_data = get_q_data(ctx, f->type);
1418 f->fmt.pix_mp = q_data->format;
1419
1420 return 0;
1421 }
1422
1423 static void fdp1_compute_stride(struct v4l2_pix_format_mplane *pix,
1424 const struct fdp1_fmt *fmt)
1425 {
1426 unsigned int i;
1427
1428 /* Compute and clamp the stride and image size. */
1429 for (i = 0; i < min_t(unsigned int, fmt->num_planes, 2U); ++i) {
1430 unsigned int hsub = i > 0 ? fmt->hsub : 1;
1431 unsigned int vsub = i > 0 ? fmt->vsub : 1;
1432 /* From VSP : TODO: Confirm alignment limits for FDP1 */
1433 unsigned int align = 128;
1434 unsigned int bpl;
1435
1436 bpl = clamp_t(unsigned int, pix->plane_fmt[i].bytesperline,
1437 pix->width / hsub * fmt->bpp[i] / 8,
1438 round_down(FDP1_MAX_STRIDE, align));
1439
1440 pix->plane_fmt[i].bytesperline = round_up(bpl, align);
1441 pix->plane_fmt[i].sizeimage = pix->plane_fmt[i].bytesperline
1442 * pix->height / vsub;
1443
1444 memset(pix->plane_fmt[i].reserved, 0,
1445 sizeof(pix->plane_fmt[i].reserved));
1446 }
1447
1448 if (fmt->num_planes == 3) {
1449 /* The two chroma planes must have the same stride. */
1450 pix->plane_fmt[2].bytesperline = pix->plane_fmt[1].bytesperline;
1451 pix->plane_fmt[2].sizeimage = pix->plane_fmt[1].sizeimage;
1452
1453 memset(pix->plane_fmt[2].reserved, 0,
1454 sizeof(pix->plane_fmt[2].reserved));
1455 }
1456 }
1457
1458 static void fdp1_try_fmt_output(struct fdp1_ctx *ctx,
1459 const struct fdp1_fmt **fmtinfo,
1460 struct v4l2_pix_format_mplane *pix)
1461 {
1462 const struct fdp1_fmt *fmt;
1463 unsigned int width;
1464 unsigned int height;
1465
1466 /* Validate the pixel format to ensure the output queue supports it. */
1467 fmt = fdp1_find_format(pix->pixelformat);
1468 if (!fmt || !(fmt->types & FDP1_OUTPUT))
1469 fmt = fdp1_find_format(V4L2_PIX_FMT_YUYV);
1470
1471 if (fmtinfo)
1472 *fmtinfo = fmt;
1473
1474 pix->pixelformat = fmt->fourcc;
1475 pix->num_planes = fmt->num_planes;
1476
1477 /*
1478 * Progressive video and all interlaced field orders are acceptable.
1479 * Default to V4L2_FIELD_INTERLACED.
1480 */
1481 if (pix->field != V4L2_FIELD_NONE &&
1482 pix->field != V4L2_FIELD_ALTERNATE &&
1483 !V4L2_FIELD_HAS_BOTH(pix->field))
1484 pix->field = V4L2_FIELD_INTERLACED;
1485
1486 /*
1487 * The deinterlacer doesn't care about the colorspace, accept all values
1488 * and default to V4L2_COLORSPACE_SMPTE170M. The YUV to RGB conversion
1489 * at the output of the deinterlacer supports a subset of encodings and
1490 * quantization methods and will only be available when the colorspace
1491 * allows it.
1492 */
1493 if (pix->colorspace == V4L2_COLORSPACE_DEFAULT)
1494 pix->colorspace = V4L2_COLORSPACE_SMPTE170M;
1495
1496 /*
1497 * Align the width and height for YUV 4:2:2 and 4:2:0 formats and clamp
1498 * them to the supported frame size range. The height boundary are
1499 * related to the full frame, divide them by two when the format passes
1500 * fields in separate buffers.
1501 */
1502 width = round_down(pix->width, fmt->hsub);
1503 pix->width = clamp(width, FDP1_MIN_W, FDP1_MAX_W);
1504
1505 height = round_down(pix->height, fmt->vsub);
1506 if (pix->field == V4L2_FIELD_ALTERNATE)
1507 pix->height = clamp(height, FDP1_MIN_H / 2, FDP1_MAX_H / 2);
1508 else
1509 pix->height = clamp(height, FDP1_MIN_H, FDP1_MAX_H);
1510
1511 fdp1_compute_stride(pix, fmt);
1512 }
1513
1514 static void fdp1_try_fmt_capture(struct fdp1_ctx *ctx,
1515 const struct fdp1_fmt **fmtinfo,
1516 struct v4l2_pix_format_mplane *pix)
1517 {
1518 struct fdp1_q_data *src_data = &ctx->out_q;
1519 enum v4l2_colorspace colorspace;
1520 enum v4l2_ycbcr_encoding ycbcr_enc;
1521 enum v4l2_quantization quantization;
1522 const struct fdp1_fmt *fmt;
1523 bool allow_rgb;
1524
1525 /*
1526 * Validate the pixel format. We can only accept RGB output formats if
1527 * the input encoding and quantization are compatible with the format
1528 * conversions supported by the hardware. The supported combinations are
1529 *
1530 * V4L2_YCBCR_ENC_601 + V4L2_QUANTIZATION_LIM_RANGE
1531 * V4L2_YCBCR_ENC_601 + V4L2_QUANTIZATION_FULL_RANGE
1532 * V4L2_YCBCR_ENC_709 + V4L2_QUANTIZATION_LIM_RANGE
1533 */
1534 colorspace = src_data->format.colorspace;
1535
1536 ycbcr_enc = src_data->format.ycbcr_enc;
1537 if (ycbcr_enc == V4L2_YCBCR_ENC_DEFAULT)
1538 ycbcr_enc = V4L2_MAP_YCBCR_ENC_DEFAULT(colorspace);
1539
1540 quantization = src_data->format.quantization;
1541 if (quantization == V4L2_QUANTIZATION_DEFAULT)
1542 quantization = V4L2_MAP_QUANTIZATION_DEFAULT(false, colorspace,
1543 ycbcr_enc);
1544
1545 allow_rgb = ycbcr_enc == V4L2_YCBCR_ENC_601 ||
1546 (ycbcr_enc == V4L2_YCBCR_ENC_709 &&
1547 quantization == V4L2_QUANTIZATION_LIM_RANGE);
1548
1549 fmt = fdp1_find_format(pix->pixelformat);
1550 if (!fmt || (!allow_rgb && fdp1_fmt_is_rgb(fmt)))
1551 fmt = fdp1_find_format(V4L2_PIX_FMT_YUYV);
1552
1553 if (fmtinfo)
1554 *fmtinfo = fmt;
1555
1556 pix->pixelformat = fmt->fourcc;
1557 pix->num_planes = fmt->num_planes;
1558 pix->field = V4L2_FIELD_NONE;
1559
1560 /*
1561 * The colorspace on the capture queue is copied from the output queue
1562 * as the hardware can't change the colorspace. It can convert YCbCr to
1563 * RGB though, in which case the encoding and quantization are set to
1564 * default values as anything else wouldn't make sense.
1565 */
1566 pix->colorspace = src_data->format.colorspace;
1567 pix->xfer_func = src_data->format.xfer_func;
1568
1569 if (fdp1_fmt_is_rgb(fmt)) {
1570 pix->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
1571 pix->quantization = V4L2_QUANTIZATION_DEFAULT;
1572 } else {
1573 pix->ycbcr_enc = src_data->format.ycbcr_enc;
1574 pix->quantization = src_data->format.quantization;
1575 }
1576
1577 /*
1578 * The frame width is identical to the output queue, and the height is
1579 * either doubled or identical depending on whether the output queue
1580 * field order contains one or two fields per frame.
1581 */
1582 pix->width = src_data->format.width;
1583 if (src_data->format.field == V4L2_FIELD_ALTERNATE)
1584 pix->height = 2 * src_data->format.height;
1585 else
1586 pix->height = src_data->format.height;
1587
1588 fdp1_compute_stride(pix, fmt);
1589 }
1590
1591 static int fdp1_try_fmt(struct file *file, void *priv, struct v4l2_format *f)
1592 {
1593 struct fdp1_ctx *ctx = fh_to_ctx(priv);
1594
1595 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1596 fdp1_try_fmt_output(ctx, NULL, &f->fmt.pix_mp);
1597 else
1598 fdp1_try_fmt_capture(ctx, NULL, &f->fmt.pix_mp);
1599
1600 dprintk(ctx->fdp1, "Try %s format: %4.4s (0x%08x) %ux%u field %u\n",
1601 V4L2_TYPE_IS_OUTPUT(f->type) ? "output" : "capture",
1602 (char *)&f->fmt.pix_mp.pixelformat, f->fmt.pix_mp.pixelformat,
1603 f->fmt.pix_mp.width, f->fmt.pix_mp.height, f->fmt.pix_mp.field);
1604
1605 return 0;
1606 }
1607
1608 static void fdp1_set_format(struct fdp1_ctx *ctx,
1609 struct v4l2_pix_format_mplane *pix,
1610 enum v4l2_buf_type type)
1611 {
1612 struct fdp1_q_data *q_data = get_q_data(ctx, type);
1613 const struct fdp1_fmt *fmtinfo;
1614
1615 if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1616 fdp1_try_fmt_output(ctx, &fmtinfo, pix);
1617 else
1618 fdp1_try_fmt_capture(ctx, &fmtinfo, pix);
1619
1620 q_data->fmt = fmtinfo;
1621 q_data->format = *pix;
1622
1623 q_data->vsize = pix->height;
1624 if (pix->field != V4L2_FIELD_NONE)
1625 q_data->vsize /= 2;
1626
1627 q_data->stride_y = pix->plane_fmt[0].bytesperline;
1628 q_data->stride_c = pix->plane_fmt[1].bytesperline;
1629
1630 /* Adjust strides for interleaved buffers */
1631 if (pix->field == V4L2_FIELD_INTERLACED ||
1632 pix->field == V4L2_FIELD_INTERLACED_TB ||
1633 pix->field == V4L2_FIELD_INTERLACED_BT) {
1634 q_data->stride_y *= 2;
1635 q_data->stride_c *= 2;
1636 }
1637
1638 /* Propagate the format from the output node to the capture node. */
1639 if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1640 struct fdp1_q_data *dst_data = &ctx->cap_q;
1641
1642 /*
1643 * Copy the format, clear the per-plane bytes per line and image
1644 * size, override the field and double the height if needed.
1645 */
1646 dst_data->format = q_data->format;
1647 memset(dst_data->format.plane_fmt, 0,
1648 sizeof(dst_data->format.plane_fmt));
1649
1650 dst_data->format.field = V4L2_FIELD_NONE;
1651 if (pix->field == V4L2_FIELD_ALTERNATE)
1652 dst_data->format.height *= 2;
1653
1654 fdp1_try_fmt_capture(ctx, &dst_data->fmt, &dst_data->format);
1655
1656 dst_data->vsize = dst_data->format.height;
1657 dst_data->stride_y = dst_data->format.plane_fmt[0].bytesperline;
1658 dst_data->stride_c = dst_data->format.plane_fmt[1].bytesperline;
1659 }
1660 }
1661
1662 static int fdp1_s_fmt(struct file *file, void *priv, struct v4l2_format *f)
1663 {
1664 struct fdp1_ctx *ctx = fh_to_ctx(priv);
1665 struct v4l2_m2m_ctx *m2m_ctx = ctx->fh.m2m_ctx;
1666 struct vb2_queue *vq = v4l2_m2m_get_vq(m2m_ctx, f->type);
1667
1668 if (vb2_is_busy(vq)) {
1669 v4l2_err(&ctx->fdp1->v4l2_dev, "%s queue busy\n", __func__);
1670 return -EBUSY;
1671 }
1672
1673 fdp1_set_format(ctx, &f->fmt.pix_mp, f->type);
1674
1675 dprintk(ctx->fdp1, "Set %s format: %4.4s (0x%08x) %ux%u field %u\n",
1676 V4L2_TYPE_IS_OUTPUT(f->type) ? "output" : "capture",
1677 (char *)&f->fmt.pix_mp.pixelformat, f->fmt.pix_mp.pixelformat,
1678 f->fmt.pix_mp.width, f->fmt.pix_mp.height, f->fmt.pix_mp.field);
1679
1680 return 0;
1681 }
1682
1683 static int fdp1_g_ctrl(struct v4l2_ctrl *ctrl)
1684 {
1685 struct fdp1_ctx *ctx =
1686 container_of(ctrl->handler, struct fdp1_ctx, hdl);
1687 struct fdp1_q_data *src_q_data = &ctx->out_q;
1688
1689 switch (ctrl->id) {
1690 case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE:
1691 if (V4L2_FIELD_HAS_BOTH(src_q_data->format.field))
1692 ctrl->val = 2;
1693 else
1694 ctrl->val = 1;
1695 return 0;
1696 }
1697
1698 return 1;
1699 }
1700
1701 static int fdp1_s_ctrl(struct v4l2_ctrl *ctrl)
1702 {
1703 struct fdp1_ctx *ctx =
1704 container_of(ctrl->handler, struct fdp1_ctx, hdl);
1705
1706 switch (ctrl->id) {
1707 case V4L2_CID_ALPHA_COMPONENT:
1708 ctx->alpha = ctrl->val;
1709 break;
1710
1711 case V4L2_CID_DEINTERLACING_MODE:
1712 ctx->deint_mode = ctrl->val;
1713 break;
1714 }
1715
1716 return 0;
1717 }
1718
1719 static const struct v4l2_ctrl_ops fdp1_ctrl_ops = {
1720 .s_ctrl = fdp1_s_ctrl,
1721 .g_volatile_ctrl = fdp1_g_ctrl,
1722 };
1723
1724 static const char * const fdp1_ctrl_deint_menu[] = {
1725 "Progressive",
1726 "Adaptive 2D/3D",
1727 "Fixed 2D",
1728 "Fixed 3D",
1729 "Previous field",
1730 "Next field",
1731 NULL
1732 };
1733
1734 static const struct v4l2_ioctl_ops fdp1_ioctl_ops = {
1735 .vidioc_querycap = fdp1_vidioc_querycap,
1736
1737 .vidioc_enum_fmt_vid_cap_mplane = fdp1_enum_fmt_vid_cap,
1738 .vidioc_enum_fmt_vid_out_mplane = fdp1_enum_fmt_vid_out,
1739 .vidioc_g_fmt_vid_cap_mplane = fdp1_g_fmt,
1740 .vidioc_g_fmt_vid_out_mplane = fdp1_g_fmt,
1741 .vidioc_try_fmt_vid_cap_mplane = fdp1_try_fmt,
1742 .vidioc_try_fmt_vid_out_mplane = fdp1_try_fmt,
1743 .vidioc_s_fmt_vid_cap_mplane = fdp1_s_fmt,
1744 .vidioc_s_fmt_vid_out_mplane = fdp1_s_fmt,
1745
1746 .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
1747 .vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
1748 .vidioc_qbuf = v4l2_m2m_ioctl_qbuf,
1749 .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,
1750 .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf,
1751 .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
1752 .vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
1753
1754 .vidioc_streamon = v4l2_m2m_ioctl_streamon,
1755 .vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
1756
1757 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1758 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1759 };
1760
1761 /*
1762 * Queue operations
1763 */
1764
1765 static int fdp1_queue_setup(struct vb2_queue *vq,
1766 unsigned int *nbuffers, unsigned int *nplanes,
1767 unsigned int sizes[],
1768 struct device *alloc_ctxs[])
1769 {
1770 struct fdp1_ctx *ctx = vb2_get_drv_priv(vq);
1771 struct fdp1_q_data *q_data;
1772 unsigned int i;
1773
1774 q_data = get_q_data(ctx, vq->type);
1775
1776 if (*nplanes) {
1777 if (*nplanes > FDP1_MAX_PLANES)
1778 return -EINVAL;
1779
1780 return 0;
1781 }
1782
1783 *nplanes = q_data->format.num_planes;
1784
1785 for (i = 0; i < *nplanes; i++)
1786 sizes[i] = q_data->format.plane_fmt[i].sizeimage;
1787
1788 return 0;
1789 }
1790
1791 static void fdp1_buf_prepare_field(struct fdp1_q_data *q_data,
1792 struct vb2_v4l2_buffer *vbuf,
1793 unsigned int field_num)
1794 {
1795 struct fdp1_buffer *buf = to_fdp1_buffer(vbuf);
1796 struct fdp1_field_buffer *fbuf = &buf->fields[field_num];
1797 unsigned int num_fields;
1798 unsigned int i;
1799
1800 num_fields = V4L2_FIELD_HAS_BOTH(vbuf->field) ? 2 : 1;
1801
1802 fbuf->vb = vbuf;
1803 fbuf->last_field = (field_num + 1) == num_fields;
1804
1805 for (i = 0; i < vbuf->vb2_buf.num_planes; ++i)
1806 fbuf->addrs[i] = vb2_dma_contig_plane_dma_addr(&vbuf->vb2_buf, i);
1807
1808 switch (vbuf->field) {
1809 case V4L2_FIELD_INTERLACED:
1810 /*
1811 * Interlaced means bottom-top for 60Hz TV standards (NTSC) and
1812 * top-bottom for 50Hz. As TV standards are not applicable to
1813 * the mem-to-mem API, use the height as a heuristic.
1814 */
1815 fbuf->field = (q_data->format.height < 576) == field_num
1816 ? V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM;
1817 break;
1818 case V4L2_FIELD_INTERLACED_TB:
1819 case V4L2_FIELD_SEQ_TB:
1820 fbuf->field = field_num ? V4L2_FIELD_BOTTOM : V4L2_FIELD_TOP;
1821 break;
1822 case V4L2_FIELD_INTERLACED_BT:
1823 case V4L2_FIELD_SEQ_BT:
1824 fbuf->field = field_num ? V4L2_FIELD_TOP : V4L2_FIELD_BOTTOM;
1825 break;
1826 default:
1827 fbuf->field = vbuf->field;
1828 break;
1829 }
1830
1831 /* Buffer is completed */
1832 if (!field_num)
1833 return;
1834
1835 /* Adjust buffer addresses for second field */
1836 switch (vbuf->field) {
1837 case V4L2_FIELD_INTERLACED:
1838 case V4L2_FIELD_INTERLACED_TB:
1839 case V4L2_FIELD_INTERLACED_BT:
1840 for (i = 0; i < vbuf->vb2_buf.num_planes; i++)
1841 fbuf->addrs[i] +=
1842 (i == 0 ? q_data->stride_y : q_data->stride_c);
1843 break;
1844 case V4L2_FIELD_SEQ_TB:
1845 case V4L2_FIELD_SEQ_BT:
1846 for (i = 0; i < vbuf->vb2_buf.num_planes; i++)
1847 fbuf->addrs[i] += q_data->vsize *
1848 (i == 0 ? q_data->stride_y : q_data->stride_c);
1849 break;
1850 }
1851 }
1852
1853 static int fdp1_buf_prepare(struct vb2_buffer *vb)
1854 {
1855 struct fdp1_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
1856 struct fdp1_q_data *q_data = get_q_data(ctx, vb->vb2_queue->type);
1857 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1858 struct fdp1_buffer *buf = to_fdp1_buffer(vbuf);
1859 unsigned int i;
1860
1861 if (V4L2_TYPE_IS_OUTPUT(vb->vb2_queue->type)) {
1862 bool field_valid = true;
1863
1864 /* Validate the buffer field. */
1865 switch (q_data->format.field) {
1866 case V4L2_FIELD_NONE:
1867 if (vbuf->field != V4L2_FIELD_NONE)
1868 field_valid = false;
1869 break;
1870
1871 case V4L2_FIELD_ALTERNATE:
1872 if (vbuf->field != V4L2_FIELD_TOP &&
1873 vbuf->field != V4L2_FIELD_BOTTOM)
1874 field_valid = false;
1875 break;
1876
1877 case V4L2_FIELD_INTERLACED:
1878 case V4L2_FIELD_SEQ_TB:
1879 case V4L2_FIELD_SEQ_BT:
1880 case V4L2_FIELD_INTERLACED_TB:
1881 case V4L2_FIELD_INTERLACED_BT:
1882 if (vbuf->field != q_data->format.field)
1883 field_valid = false;
1884 break;
1885 }
1886
1887 if (!field_valid) {
1888 dprintk(ctx->fdp1,
1889 "buffer field %u invalid for format field %u\n",
1890 vbuf->field, q_data->format.field);
1891 return -EINVAL;
1892 }
1893 } else {
1894 vbuf->field = V4L2_FIELD_NONE;
1895 }
1896
1897 /* Validate the planes sizes. */
1898 for (i = 0; i < q_data->format.num_planes; i++) {
1899 unsigned long size = q_data->format.plane_fmt[i].sizeimage;
1900
1901 if (vb2_plane_size(vb, i) < size) {
1902 dprintk(ctx->fdp1,
1903 "data will not fit into plane [%u/%u] (%lu < %lu)\n",
1904 i, q_data->format.num_planes,
1905 vb2_plane_size(vb, i), size);
1906 return -EINVAL;
1907 }
1908
1909 /* We have known size formats all around */
1910 vb2_set_plane_payload(vb, i, size);
1911 }
1912
1913 buf->num_fields = V4L2_FIELD_HAS_BOTH(vbuf->field) ? 2 : 1;
1914 for (i = 0; i < buf->num_fields; ++i)
1915 fdp1_buf_prepare_field(q_data, vbuf, i);
1916
1917 return 0;
1918 }
1919
1920 static void fdp1_buf_queue(struct vb2_buffer *vb)
1921 {
1922 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1923 struct fdp1_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
1924
1925 v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
1926 }
1927
1928 static int fdp1_start_streaming(struct vb2_queue *q, unsigned int count)
1929 {
1930 struct fdp1_ctx *ctx = vb2_get_drv_priv(q);
1931 struct fdp1_q_data *q_data = get_q_data(ctx, q->type);
1932
1933 if (V4L2_TYPE_IS_OUTPUT(q->type)) {
1934 /*
1935 * Force our deint_mode when we are progressive,
1936 * ignoring any setting on the device from the user,
1937 * Otherwise, lock in the requested de-interlace mode.
1938 */
1939 if (q_data->format.field == V4L2_FIELD_NONE)
1940 ctx->deint_mode = FDP1_PROGRESSIVE;
1941
1942 if (ctx->deint_mode == FDP1_ADAPT2D3D) {
1943 u32 stride;
1944 dma_addr_t smsk_base;
1945 const u32 bpp = 2; /* bytes per pixel */
1946
1947 stride = round_up(q_data->format.width, 8);
1948
1949 ctx->smsk_size = bpp * stride * q_data->vsize;
1950
1951 ctx->smsk_cpu = dma_alloc_coherent(ctx->fdp1->dev,
1952 ctx->smsk_size, &smsk_base, GFP_KERNEL);
1953
1954 if (ctx->smsk_cpu == NULL) {
1955 dprintk(ctx->fdp1, "Failed to alloc smsk\n");
1956 return -ENOMEM;
1957 }
1958
1959 ctx->smsk_addr[0] = smsk_base;
1960 ctx->smsk_addr[1] = smsk_base + (ctx->smsk_size/2);
1961 }
1962 }
1963
1964 return 0;
1965 }
1966
1967 static void fdp1_stop_streaming(struct vb2_queue *q)
1968 {
1969 struct fdp1_ctx *ctx = vb2_get_drv_priv(q);
1970 struct vb2_v4l2_buffer *vbuf;
1971 unsigned long flags;
1972
1973 while (1) {
1974 if (V4L2_TYPE_IS_OUTPUT(q->type))
1975 vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
1976 else
1977 vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
1978 if (vbuf == NULL)
1979 break;
1980 spin_lock_irqsave(&ctx->fdp1->irqlock, flags);
1981 v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
1982 spin_unlock_irqrestore(&ctx->fdp1->irqlock, flags);
1983 }
1984
1985 /* Empty Output queues */
1986 if (V4L2_TYPE_IS_OUTPUT(q->type)) {
1987 /* Empty our internal queues */
1988 struct fdp1_field_buffer *fbuf;
1989
1990 /* Free any queued buffers */
1991 fbuf = fdp1_dequeue_field(ctx);
1992 while (fbuf != NULL) {
1993 fdp1_field_complete(ctx, fbuf);
1994 fbuf = fdp1_dequeue_field(ctx);
1995 }
1996
1997 /* Free smsk_data */
1998 if (ctx->smsk_cpu) {
1999 dma_free_coherent(ctx->fdp1->dev, ctx->smsk_size,
2000 ctx->smsk_cpu, ctx->smsk_addr[0]);
2001 ctx->smsk_addr[0] = ctx->smsk_addr[1] = 0;
2002 ctx->smsk_cpu = NULL;
2003 }
2004
2005 WARN(!list_empty(&ctx->fields_queue),
2006 "Buffer queue not empty");
2007 } else {
2008 /* Empty Capture queues (Jobs) */
2009 struct fdp1_job *job;
2010
2011 job = get_queued_job(ctx->fdp1);
2012 while (job) {
2013 if (FDP1_DEINT_MODE_USES_PREV(ctx->deint_mode))
2014 fdp1_field_complete(ctx, job->previous);
2015 else
2016 fdp1_field_complete(ctx, job->active);
2017
2018 v4l2_m2m_buf_done(job->dst->vb, VB2_BUF_STATE_ERROR);
2019 job->dst = NULL;
2020
2021 job = get_queued_job(ctx->fdp1);
2022 }
2023
2024 /* Free any held buffer in the ctx */
2025 fdp1_field_complete(ctx, ctx->previous);
2026
2027 WARN(!list_empty(&ctx->fdp1->queued_job_list),
2028 "Queued Job List not empty");
2029
2030 WARN(!list_empty(&ctx->fdp1->hw_job_list),
2031 "HW Job list not empty");
2032 }
2033 }
2034
2035 static const struct vb2_ops fdp1_qops = {
2036 .queue_setup = fdp1_queue_setup,
2037 .buf_prepare = fdp1_buf_prepare,
2038 .buf_queue = fdp1_buf_queue,
2039 .start_streaming = fdp1_start_streaming,
2040 .stop_streaming = fdp1_stop_streaming,
2041 .wait_prepare = vb2_ops_wait_prepare,
2042 .wait_finish = vb2_ops_wait_finish,
2043 };
2044
2045 static int queue_init(void *priv, struct vb2_queue *src_vq,
2046 struct vb2_queue *dst_vq)
2047 {
2048 struct fdp1_ctx *ctx = priv;
2049 int ret;
2050
2051 src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
2052 src_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
2053 src_vq->drv_priv = ctx;
2054 src_vq->buf_struct_size = sizeof(struct fdp1_buffer);
2055 src_vq->ops = &fdp1_qops;
2056 src_vq->mem_ops = &vb2_dma_contig_memops;
2057 src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
2058 src_vq->lock = &ctx->fdp1->dev_mutex;
2059 src_vq->dev = ctx->fdp1->dev;
2060
2061 ret = vb2_queue_init(src_vq);
2062 if (ret)
2063 return ret;
2064
2065 dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
2066 dst_vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
2067 dst_vq->drv_priv = ctx;
2068 dst_vq->buf_struct_size = sizeof(struct fdp1_buffer);
2069 dst_vq->ops = &fdp1_qops;
2070 dst_vq->mem_ops = &vb2_dma_contig_memops;
2071 dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
2072 dst_vq->lock = &ctx->fdp1->dev_mutex;
2073 dst_vq->dev = ctx->fdp1->dev;
2074
2075 return vb2_queue_init(dst_vq);
2076 }
2077
2078 /*
2079 * File operations
2080 */
2081 static int fdp1_open(struct file *file)
2082 {
2083 struct fdp1_dev *fdp1 = video_drvdata(file);
2084 struct v4l2_pix_format_mplane format;
2085 struct fdp1_ctx *ctx = NULL;
2086 struct v4l2_ctrl *ctrl;
2087 int ret = 0;
2088
2089 if (mutex_lock_interruptible(&fdp1->dev_mutex))
2090 return -ERESTARTSYS;
2091
2092 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
2093 if (!ctx) {
2094 ret = -ENOMEM;
2095 goto done;
2096 }
2097
2098 v4l2_fh_init(&ctx->fh, video_devdata(file));
2099 file->private_data = &ctx->fh;
2100 ctx->fdp1 = fdp1;
2101
2102 /* Initialise Queues */
2103 INIT_LIST_HEAD(&ctx->fields_queue);
2104
2105 ctx->translen = 1;
2106 ctx->sequence = 0;
2107
2108 /* Initialise controls */
2109
2110 v4l2_ctrl_handler_init(&ctx->hdl, 3);
2111 v4l2_ctrl_new_std_menu_items(&ctx->hdl, &fdp1_ctrl_ops,
2112 V4L2_CID_DEINTERLACING_MODE,
2113 FDP1_NEXTFIELD, BIT(0), FDP1_FIXED3D,
2114 fdp1_ctrl_deint_menu);
2115
2116 ctrl = v4l2_ctrl_new_std(&ctx->hdl, &fdp1_ctrl_ops,
2117 V4L2_CID_MIN_BUFFERS_FOR_CAPTURE, 1, 2, 1, 1);
2118 if (ctrl)
2119 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
2120
2121 v4l2_ctrl_new_std(&ctx->hdl, &fdp1_ctrl_ops,
2122 V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 255);
2123
2124 if (ctx->hdl.error) {
2125 ret = ctx->hdl.error;
2126 v4l2_ctrl_handler_free(&ctx->hdl);
2127 goto done;
2128 }
2129
2130 ctx->fh.ctrl_handler = &ctx->hdl;
2131 v4l2_ctrl_handler_setup(&ctx->hdl);
2132
2133 /* Configure default parameters. */
2134 memset(&format, 0, sizeof(format));
2135 fdp1_set_format(ctx, &format, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
2136
2137 ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(fdp1->m2m_dev, ctx, &queue_init);
2138
2139 if (IS_ERR(ctx->fh.m2m_ctx)) {
2140 ret = PTR_ERR(ctx->fh.m2m_ctx);
2141
2142 v4l2_ctrl_handler_free(&ctx->hdl);
2143 kfree(ctx);
2144 goto done;
2145 }
2146
2147 /* Perform any power management required */
2148 pm_runtime_get_sync(fdp1->dev);
2149
2150 v4l2_fh_add(&ctx->fh);
2151
2152 dprintk(fdp1, "Created instance: %p, m2m_ctx: %p\n",
2153 ctx, ctx->fh.m2m_ctx);
2154
2155 done:
2156 mutex_unlock(&fdp1->dev_mutex);
2157 return ret;
2158 }
2159
2160 static int fdp1_release(struct file *file)
2161 {
2162 struct fdp1_dev *fdp1 = video_drvdata(file);
2163 struct fdp1_ctx *ctx = fh_to_ctx(file->private_data);
2164
2165 dprintk(fdp1, "Releasing instance %p\n", ctx);
2166
2167 v4l2_fh_del(&ctx->fh);
2168 v4l2_fh_exit(&ctx->fh);
2169 v4l2_ctrl_handler_free(&ctx->hdl);
2170 mutex_lock(&fdp1->dev_mutex);
2171 v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
2172 mutex_unlock(&fdp1->dev_mutex);
2173 kfree(ctx);
2174
2175 pm_runtime_put(fdp1->dev);
2176
2177 return 0;
2178 }
2179
2180 static const struct v4l2_file_operations fdp1_fops = {
2181 .owner = THIS_MODULE,
2182 .open = fdp1_open,
2183 .release = fdp1_release,
2184 .poll = v4l2_m2m_fop_poll,
2185 .unlocked_ioctl = video_ioctl2,
2186 .mmap = v4l2_m2m_fop_mmap,
2187 };
2188
2189 static const struct video_device fdp1_videodev = {
2190 .name = DRIVER_NAME,
2191 .vfl_dir = VFL_DIR_M2M,
2192 .fops = &fdp1_fops,
2193 .device_caps = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING,
2194 .ioctl_ops = &fdp1_ioctl_ops,
2195 .minor = -1,
2196 .release = video_device_release_empty,
2197 };
2198
2199 static const struct v4l2_m2m_ops m2m_ops = {
2200 .device_run = fdp1_m2m_device_run,
2201 .job_ready = fdp1_m2m_job_ready,
2202 .job_abort = fdp1_m2m_job_abort,
2203 };
2204
2205 static irqreturn_t fdp1_irq_handler(int irq, void *dev_id)
2206 {
2207 struct fdp1_dev *fdp1 = dev_id;
2208 u32 int_status;
2209 u32 ctl_status;
2210 u32 vint_cnt;
2211 u32 cycles;
2212
2213 int_status = fdp1_read(fdp1, FD1_CTL_IRQSTA);
2214 cycles = fdp1_read(fdp1, FD1_CTL_VCYCLE_STAT);
2215 ctl_status = fdp1_read(fdp1, FD1_CTL_STATUS);
2216 vint_cnt = (ctl_status & FD1_CTL_STATUS_VINT_CNT_MASK) >>
2217 FD1_CTL_STATUS_VINT_CNT_SHIFT;
2218
2219 /* Clear interrupts */
2220 fdp1_write(fdp1, ~(int_status) & FD1_CTL_IRQ_MASK, FD1_CTL_IRQSTA);
2221
2222 if (debug >= 2) {
2223 dprintk(fdp1, "IRQ: 0x%x %s%s%s\n", int_status,
2224 int_status & FD1_CTL_IRQ_VERE ? "[Error]" : "[!E]",
2225 int_status & FD1_CTL_IRQ_VINTE ? "[VSync]" : "[!V]",
2226 int_status & FD1_CTL_IRQ_FREE ? "[FrameEnd]" : "[!F]");
2227
2228 dprintk(fdp1, "CycleStatus = %d (%dms)\n",
2229 cycles, cycles/(fdp1->clk_rate/1000));
2230
2231 dprintk(fdp1,
2232 "Control Status = 0x%08x : VINT_CNT = %d %s:%s:%s:%s\n",
2233 ctl_status, vint_cnt,
2234 ctl_status & FD1_CTL_STATUS_SGREGSET ? "RegSet" : "",
2235 ctl_status & FD1_CTL_STATUS_SGVERR ? "Vsync Error" : "",
2236 ctl_status & FD1_CTL_STATUS_SGFREND ? "FrameEnd" : "",
2237 ctl_status & FD1_CTL_STATUS_BSY ? "Busy" : "");
2238 dprintk(fdp1, "***********************************\n");
2239 }
2240
2241 /* Spurious interrupt */
2242 if (!(FD1_CTL_IRQ_MASK & int_status))
2243 return IRQ_NONE;
2244
2245 /* Work completed, release the frame */
2246 if (FD1_CTL_IRQ_VERE & int_status)
2247 device_frame_end(fdp1, VB2_BUF_STATE_ERROR);
2248 else if (FD1_CTL_IRQ_FREE & int_status)
2249 device_frame_end(fdp1, VB2_BUF_STATE_DONE);
2250
2251 return IRQ_HANDLED;
2252 }
2253
2254 static int fdp1_probe(struct platform_device *pdev)
2255 {
2256 struct fdp1_dev *fdp1;
2257 struct video_device *vfd;
2258 struct device_node *fcp_node;
2259 struct resource *res;
2260 struct clk *clk;
2261 unsigned int i;
2262
2263 int ret;
2264 int hw_version;
2265
2266 fdp1 = devm_kzalloc(&pdev->dev, sizeof(*fdp1), GFP_KERNEL);
2267 if (!fdp1)
2268 return -ENOMEM;
2269
2270 INIT_LIST_HEAD(&fdp1->free_job_list);
2271 INIT_LIST_HEAD(&fdp1->queued_job_list);
2272 INIT_LIST_HEAD(&fdp1->hw_job_list);
2273
2274 /* Initialise the jobs on the free list */
2275 for (i = 0; i < ARRAY_SIZE(fdp1->jobs); i++)
2276 list_add(&fdp1->jobs[i].list, &fdp1->free_job_list);
2277
2278 mutex_init(&fdp1->dev_mutex);
2279
2280 spin_lock_init(&fdp1->irqlock);
2281 spin_lock_init(&fdp1->device_process_lock);
2282 fdp1->dev = &pdev->dev;
2283 platform_set_drvdata(pdev, fdp1);
2284
2285 /* Memory-mapped registers */
2286 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2287 fdp1->regs = devm_ioremap_resource(&pdev->dev, res);
2288 if (IS_ERR(fdp1->regs))
2289 return PTR_ERR(fdp1->regs);
2290
2291 /* Interrupt service routine registration */
2292 fdp1->irq = ret = platform_get_irq(pdev, 0);
2293 if (ret < 0) {
2294 dev_err(&pdev->dev, "cannot find IRQ\n");
2295 return ret;
2296 }
2297
2298 ret = devm_request_irq(&pdev->dev, fdp1->irq, fdp1_irq_handler, 0,
2299 dev_name(&pdev->dev), fdp1);
2300 if (ret) {
2301 dev_err(&pdev->dev, "cannot claim IRQ %d\n", fdp1->irq);
2302 return ret;
2303 }
2304
2305 /* FCP */
2306 fcp_node = of_parse_phandle(pdev->dev.of_node, "renesas,fcp", 0);
2307 if (fcp_node) {
2308 fdp1->fcp = rcar_fcp_get(fcp_node);
2309 of_node_put(fcp_node);
2310 if (IS_ERR(fdp1->fcp)) {
2311 dev_err(&pdev->dev, "FCP not found (%ld)\n",
2312 PTR_ERR(fdp1->fcp));
2313 return PTR_ERR(fdp1->fcp);
2314 }
2315 }
2316
2317 /* Determine our clock rate */
2318 clk = clk_get(&pdev->dev, NULL);
2319 if (IS_ERR(clk))
2320 return PTR_ERR(clk);
2321
2322 fdp1->clk_rate = clk_get_rate(clk);
2323 clk_put(clk);
2324
2325 /* V4L2 device registration */
2326 ret = v4l2_device_register(&pdev->dev, &fdp1->v4l2_dev);
2327 if (ret) {
2328 v4l2_err(&fdp1->v4l2_dev, "Failed to register video device\n");
2329 return ret;
2330 }
2331
2332 /* M2M registration */
2333 fdp1->m2m_dev = v4l2_m2m_init(&m2m_ops);
2334 if (IS_ERR(fdp1->m2m_dev)) {
2335 v4l2_err(&fdp1->v4l2_dev, "Failed to init mem2mem device\n");
2336 ret = PTR_ERR(fdp1->m2m_dev);
2337 goto unreg_dev;
2338 }
2339
2340 /* Video registration */
2341 fdp1->vfd = fdp1_videodev;
2342 vfd = &fdp1->vfd;
2343 vfd->lock = &fdp1->dev_mutex;
2344 vfd->v4l2_dev = &fdp1->v4l2_dev;
2345 video_set_drvdata(vfd, fdp1);
2346 strlcpy(vfd->name, fdp1_videodev.name, sizeof(vfd->name));
2347
2348 ret = video_register_device(vfd, VFL_TYPE_GRABBER, 0);
2349 if (ret) {
2350 v4l2_err(&fdp1->v4l2_dev, "Failed to register video device\n");
2351 goto release_m2m;
2352 }
2353
2354 v4l2_info(&fdp1->v4l2_dev,
2355 "Device registered as /dev/video%d\n", vfd->num);
2356
2357 /* Power up the cells to read HW */
2358 pm_runtime_enable(&pdev->dev);
2359 pm_runtime_get_sync(fdp1->dev);
2360
2361 hw_version = fdp1_read(fdp1, FD1_IP_INTDATA);
2362 switch (hw_version) {
2363 case FD1_IP_H3_ES1:
2364 dprintk(fdp1, "FDP1 Version R-Car H3 ES1\n");
2365 break;
2366 case FD1_IP_M3W:
2367 dprintk(fdp1, "FDP1 Version R-Car M3-W\n");
2368 break;
2369 case FD1_IP_H3:
2370 dprintk(fdp1, "FDP1 Version R-Car H3\n");
2371 break;
2372 default:
2373 dev_err(fdp1->dev, "FDP1 Unidentifiable (0x%08x)\n",
2374 hw_version);
2375 }
2376
2377 /* Allow the hw to sleep until an open call puts it to use */
2378 pm_runtime_put(fdp1->dev);
2379
2380 return 0;
2381
2382 release_m2m:
2383 v4l2_m2m_release(fdp1->m2m_dev);
2384
2385 unreg_dev:
2386 v4l2_device_unregister(&fdp1->v4l2_dev);
2387
2388 return ret;
2389 }
2390
2391 static int fdp1_remove(struct platform_device *pdev)
2392 {
2393 struct fdp1_dev *fdp1 = platform_get_drvdata(pdev);
2394
2395 v4l2_m2m_release(fdp1->m2m_dev);
2396 video_unregister_device(&fdp1->vfd);
2397 v4l2_device_unregister(&fdp1->v4l2_dev);
2398 pm_runtime_disable(&pdev->dev);
2399
2400 return 0;
2401 }
2402
2403 static int __maybe_unused fdp1_pm_runtime_suspend(struct device *dev)
2404 {
2405 struct fdp1_dev *fdp1 = dev_get_drvdata(dev);
2406
2407 rcar_fcp_disable(fdp1->fcp);
2408
2409 return 0;
2410 }
2411
2412 static int __maybe_unused fdp1_pm_runtime_resume(struct device *dev)
2413 {
2414 struct fdp1_dev *fdp1 = dev_get_drvdata(dev);
2415
2416 /* Program in the static LUTs */
2417 fdp1_set_lut(fdp1);
2418
2419 return rcar_fcp_enable(fdp1->fcp);
2420 }
2421
2422 static const struct dev_pm_ops fdp1_pm_ops = {
2423 SET_RUNTIME_PM_OPS(fdp1_pm_runtime_suspend,
2424 fdp1_pm_runtime_resume,
2425 NULL)
2426 };
2427
2428 static const struct of_device_id fdp1_dt_ids[] = {
2429 { .compatible = "renesas,fdp1" },
2430 { },
2431 };
2432 MODULE_DEVICE_TABLE(of, fdp1_dt_ids);
2433
2434 static struct platform_driver fdp1_pdrv = {
2435 .probe = fdp1_probe,
2436 .remove = fdp1_remove,
2437 .driver = {
2438 .name = DRIVER_NAME,
2439 .of_match_table = fdp1_dt_ids,
2440 .pm = &fdp1_pm_ops,
2441 },
2442 };
2443
2444 module_platform_driver(fdp1_pdrv);
2445
2446 MODULE_DESCRIPTION("Renesas R-Car Fine Display Processor Driver");
2447 MODULE_AUTHOR("Kieran Bingham <kieran@bingham.xyz>");
2448 MODULE_LICENSE("GPL");
2449 MODULE_ALIAS("platform:" DRIVER_NAME);
Ubuntu Focal Linux kernel mirror