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