1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Copyright (c) 2011-2018 Magewell Electronics Co., Ltd. (Nanjing)
4  * Author: Yong Deng <yong.deng@magewell.com>
5  * Copyright 2021-2022 Bootlin
6  * Author: Paul Kocialkowski <paul.kocialkowski@bootlin.com>
7  */
8 
9 #include <linux/of.h>
10 #include <linux/regmap.h>
11 #include <media/v4l2-device.h>
12 #include <media/v4l2-event.h>
13 #include <media/v4l2-ioctl.h>
14 #include <media/v4l2-mc.h>
15 #include <media/videobuf2-dma-contig.h>
16 #include <media/videobuf2-v4l2.h>
17 
18 #include "sun6i_csi.h"
19 #include "sun6i_csi_bridge.h"
20 #include "sun6i_csi_capture.h"
21 #include "sun6i_csi_reg.h"
22 
23 /* Helpers */
24 
25 void sun6i_csi_capture_dimensions(struct sun6i_csi_device *csi_dev,
26 				  unsigned int *width, unsigned int *height)
27 {
28 	if (width)
29 		*width = csi_dev->capture.format.fmt.pix.width;
30 	if (height)
31 		*height = csi_dev->capture.format.fmt.pix.height;
32 }
33 
34 void sun6i_csi_capture_format(struct sun6i_csi_device *csi_dev,
35 			      u32 *pixelformat, u32 *field)
36 {
37 	if (pixelformat)
38 		*pixelformat = csi_dev->capture.format.fmt.pix.pixelformat;
39 
40 	if (field)
41 		*field = csi_dev->capture.format.fmt.pix.field;
42 }
43 
44 /* Format */
45 
46 static const struct sun6i_csi_capture_format sun6i_csi_capture_formats[] = {
47 	/* Bayer */
48 	{
49 		.pixelformat		= V4L2_PIX_FMT_SBGGR8,
50 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_8,
51 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_8,
52 	},
53 	{
54 		.pixelformat		= V4L2_PIX_FMT_SGBRG8,
55 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_8,
56 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_8,
57 	},
58 	{
59 		.pixelformat		= V4L2_PIX_FMT_SGRBG8,
60 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_8,
61 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_8,
62 	},
63 	{
64 		.pixelformat		= V4L2_PIX_FMT_SRGGB8,
65 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_8,
66 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_8,
67 	},
68 	{
69 		.pixelformat		= V4L2_PIX_FMT_SBGGR10,
70 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_10,
71 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_10,
72 	},
73 	{
74 		.pixelformat		= V4L2_PIX_FMT_SGBRG10,
75 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_10,
76 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_10,
77 	},
78 	{
79 		.pixelformat		= V4L2_PIX_FMT_SGRBG10,
80 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_10,
81 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_10,
82 	},
83 	{
84 		.pixelformat		= V4L2_PIX_FMT_SRGGB10,
85 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_10,
86 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_10,
87 	},
88 	{
89 		.pixelformat		= V4L2_PIX_FMT_SBGGR12,
90 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_12,
91 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_12,
92 	},
93 	{
94 		.pixelformat		= V4L2_PIX_FMT_SGBRG12,
95 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_12,
96 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_12,
97 	},
98 	{
99 		.pixelformat		= V4L2_PIX_FMT_SGRBG12,
100 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_12,
101 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_12,
102 	},
103 	{
104 		.pixelformat		= V4L2_PIX_FMT_SRGGB12,
105 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_12,
106 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_12,
107 	},
108 	/* RGB */
109 	{
110 		.pixelformat		= V4L2_PIX_FMT_RGB565,
111 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RGB565,
112 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RGB565,
113 	},
114 	{
115 		.pixelformat		= V4L2_PIX_FMT_RGB565X,
116 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RGB565,
117 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RGB565,
118 	},
119 	/* YUV422 */
120 	{
121 		.pixelformat		= V4L2_PIX_FMT_YUYV,
122 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_8,
123 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_8,
124 		.input_format_raw	= true,
125 		.hsize_len_factor	= 2,
126 	},
127 	{
128 		.pixelformat		= V4L2_PIX_FMT_YVYU,
129 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_8,
130 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_8,
131 		.input_format_raw	= true,
132 		.hsize_len_factor	= 2,
133 	},
134 	{
135 		.pixelformat		= V4L2_PIX_FMT_UYVY,
136 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_8,
137 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_8,
138 		.input_format_raw	= true,
139 		.hsize_len_factor	= 2,
140 	},
141 	{
142 		.pixelformat		= V4L2_PIX_FMT_VYUY,
143 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_8,
144 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_8,
145 		.input_format_raw	= true,
146 		.hsize_len_factor	= 2,
147 	},
148 	{
149 		.pixelformat		= V4L2_PIX_FMT_NV16,
150 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_YUV422SP,
151 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_YUV422SP,
152 	},
153 	{
154 		.pixelformat		= V4L2_PIX_FMT_NV61,
155 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_YUV422SP,
156 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_YUV422SP,
157 		.input_yuv_seq_invert	= true,
158 	},
159 	{
160 		.pixelformat		= V4L2_PIX_FMT_YUV422P,
161 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_YUV422P,
162 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_YUV422P,
163 	},
164 	/* YUV420 */
165 	{
166 		.pixelformat		= V4L2_PIX_FMT_NV12_16L16,
167 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_YUV420MB,
168 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_YUV420MB,
169 	},
170 	{
171 		.pixelformat		= V4L2_PIX_FMT_NV12,
172 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_YUV420SP,
173 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_YUV420SP,
174 	},
175 	{
176 		.pixelformat		= V4L2_PIX_FMT_NV21,
177 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_YUV420SP,
178 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_YUV420SP,
179 		.input_yuv_seq_invert	= true,
180 	},
181 
182 	{
183 		.pixelformat		= V4L2_PIX_FMT_YUV420,
184 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_YUV420P,
185 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_YUV420P,
186 	},
187 	{
188 		.pixelformat		= V4L2_PIX_FMT_YVU420,
189 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_YUV420P,
190 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_YUV420P,
191 		.input_yuv_seq_invert	= true,
192 	},
193 	/* Compressed */
194 	{
195 		.pixelformat		= V4L2_PIX_FMT_JPEG,
196 		.output_format_frame	= SUN6I_CSI_OUTPUT_FMT_FRAME_RAW_8,
197 		.output_format_field	= SUN6I_CSI_OUTPUT_FMT_FIELD_RAW_8,
198 	},
199 };
200 
201 const
202 struct sun6i_csi_capture_format *sun6i_csi_capture_format_find(u32 pixelformat)
203 {
204 	unsigned int i;
205 
206 	for (i = 0; i < ARRAY_SIZE(sun6i_csi_capture_formats); i++)
207 		if (sun6i_csi_capture_formats[i].pixelformat == pixelformat)
208 			return &sun6i_csi_capture_formats[i];
209 
210 	return NULL;
211 }
212 
213 /* RAW formats need an exact match between pixel and mbus formats. */
214 static const
215 struct sun6i_csi_capture_format_match sun6i_csi_capture_format_matches[] = {
216 	/* YUV420 */
217 	{
218 		.pixelformat	= V4L2_PIX_FMT_YUYV,
219 		.mbus_code	= MEDIA_BUS_FMT_YUYV8_2X8,
220 	},
221 	{
222 		.pixelformat	= V4L2_PIX_FMT_YUYV,
223 		.mbus_code	= MEDIA_BUS_FMT_YUYV8_1X16,
224 	},
225 	{
226 		.pixelformat	= V4L2_PIX_FMT_YVYU,
227 		.mbus_code	= MEDIA_BUS_FMT_YVYU8_2X8,
228 	},
229 	{
230 		.pixelformat	= V4L2_PIX_FMT_YVYU,
231 		.mbus_code	= MEDIA_BUS_FMT_YVYU8_1X16,
232 	},
233 	{
234 		.pixelformat	= V4L2_PIX_FMT_UYVY,
235 		.mbus_code	= MEDIA_BUS_FMT_UYVY8_2X8,
236 	},
237 	{
238 		.pixelformat	= V4L2_PIX_FMT_UYVY,
239 		.mbus_code	= MEDIA_BUS_FMT_UYVY8_1X16,
240 	},
241 	{
242 		.pixelformat	= V4L2_PIX_FMT_VYUY,
243 		.mbus_code	= MEDIA_BUS_FMT_VYUY8_2X8,
244 	},
245 	{
246 		.pixelformat	= V4L2_PIX_FMT_VYUY,
247 		.mbus_code	= MEDIA_BUS_FMT_VYUY8_1X16,
248 	},
249 	/* RGB */
250 	{
251 		.pixelformat	= V4L2_PIX_FMT_RGB565,
252 		.mbus_code	= MEDIA_BUS_FMT_RGB565_2X8_LE,
253 	},
254 	{
255 		.pixelformat	= V4L2_PIX_FMT_RGB565X,
256 		.mbus_code	= MEDIA_BUS_FMT_RGB565_2X8_BE,
257 	},
258 	/* Bayer */
259 	{
260 		.pixelformat	= V4L2_PIX_FMT_SBGGR8,
261 		.mbus_code	= MEDIA_BUS_FMT_SBGGR8_1X8,
262 	},
263 	{
264 		.pixelformat	= V4L2_PIX_FMT_SGBRG8,
265 		.mbus_code	= MEDIA_BUS_FMT_SGBRG8_1X8,
266 	},
267 	{
268 		.pixelformat	= V4L2_PIX_FMT_SGRBG8,
269 		.mbus_code	= MEDIA_BUS_FMT_SGRBG8_1X8,
270 	},
271 	{
272 		.pixelformat	= V4L2_PIX_FMT_SRGGB8,
273 		.mbus_code	= MEDIA_BUS_FMT_SRGGB8_1X8,
274 	},
275 	{
276 		.pixelformat	= V4L2_PIX_FMT_SBGGR10,
277 		.mbus_code	= MEDIA_BUS_FMT_SBGGR10_1X10,
278 	},
279 	{
280 		.pixelformat	= V4L2_PIX_FMT_SGBRG10,
281 		.mbus_code	= MEDIA_BUS_FMT_SGBRG10_1X10,
282 	},
283 	{
284 		.pixelformat	= V4L2_PIX_FMT_SGRBG10,
285 		.mbus_code	= MEDIA_BUS_FMT_SGRBG10_1X10,
286 	},
287 	{
288 		.pixelformat	= V4L2_PIX_FMT_SRGGB10,
289 		.mbus_code	= MEDIA_BUS_FMT_SRGGB10_1X10,
290 	},
291 	{
292 		.pixelformat	= V4L2_PIX_FMT_SBGGR12,
293 		.mbus_code	= MEDIA_BUS_FMT_SBGGR12_1X12,
294 	},
295 	{
296 		.pixelformat	= V4L2_PIX_FMT_SGBRG12,
297 		.mbus_code	= MEDIA_BUS_FMT_SGBRG12_1X12,
298 	},
299 	{
300 		.pixelformat	= V4L2_PIX_FMT_SGRBG12,
301 		.mbus_code	= MEDIA_BUS_FMT_SGRBG12_1X12,
302 	},
303 	{
304 		.pixelformat	= V4L2_PIX_FMT_SRGGB12,
305 		.mbus_code	= MEDIA_BUS_FMT_SRGGB12_1X12,
306 	},
307 	/* Compressed */
308 	{
309 		.pixelformat	= V4L2_PIX_FMT_JPEG,
310 		.mbus_code	= MEDIA_BUS_FMT_JPEG_1X8,
311 	},
312 };
313 
314 static bool sun6i_csi_capture_format_match(u32 pixelformat, u32 mbus_code)
315 {
316 	unsigned int i;
317 
318 	for (i = 0; i < ARRAY_SIZE(sun6i_csi_capture_format_matches); i++) {
319 		const struct sun6i_csi_capture_format_match *match =
320 			&sun6i_csi_capture_format_matches[i];
321 
322 		if (match->pixelformat == pixelformat &&
323 		    match->mbus_code == mbus_code)
324 			return true;
325 	}
326 
327 	return false;
328 }
329 
330 /* Capture */
331 
332 static void
333 sun6i_csi_capture_buffer_configure(struct sun6i_csi_device *csi_dev,
334 				   struct sun6i_csi_buffer *csi_buffer)
335 {
336 	struct regmap *regmap = csi_dev->regmap;
337 	const struct v4l2_format_info *info;
338 	struct vb2_buffer *vb2_buffer;
339 	unsigned int width, height;
340 	dma_addr_t address;
341 	u32 pixelformat;
342 
343 	vb2_buffer = &csi_buffer->v4l2_buffer.vb2_buf;
344 	address = vb2_dma_contig_plane_dma_addr(vb2_buffer, 0);
345 
346 	regmap_write(regmap, SUN6I_CSI_CH_FIFO0_ADDR_REG,
347 		     SUN6I_CSI_ADDR_VALUE(address));
348 
349 	sun6i_csi_capture_dimensions(csi_dev, &width, &height);
350 	sun6i_csi_capture_format(csi_dev, &pixelformat, NULL);
351 
352 	info = v4l2_format_info(pixelformat);
353 	/* Unsupported formats are single-plane, so we can stop here. */
354 	if (!info)
355 		return;
356 
357 	if (info->comp_planes > 1) {
358 		address += info->bpp[0] * width * height;
359 
360 		regmap_write(regmap, SUN6I_CSI_CH_FIFO1_ADDR_REG,
361 			     SUN6I_CSI_ADDR_VALUE(address));
362 	}
363 
364 	if (info->comp_planes > 2) {
365 		address += info->bpp[1] * DIV_ROUND_UP(width, info->hdiv) *
366 			   DIV_ROUND_UP(height, info->vdiv);
367 
368 		regmap_write(regmap, SUN6I_CSI_CH_FIFO2_ADDR_REG,
369 			     SUN6I_CSI_ADDR_VALUE(address));
370 	}
371 }
372 
373 void sun6i_csi_capture_configure(struct sun6i_csi_device *csi_dev)
374 {
375 	struct regmap *regmap = csi_dev->regmap;
376 	const struct sun6i_csi_capture_format *format;
377 	const struct v4l2_format_info *info;
378 	u32 hsize_len, vsize_len;
379 	u32 luma_line, chroma_line = 0;
380 	u32 pixelformat, field;
381 	u32 width, height;
382 
383 	sun6i_csi_capture_dimensions(csi_dev, &width, &height);
384 	sun6i_csi_capture_format(csi_dev, &pixelformat, &field);
385 
386 	format = sun6i_csi_capture_format_find(pixelformat);
387 	if (WARN_ON(!format))
388 		return;
389 
390 	hsize_len = width;
391 	vsize_len = height;
392 
393 	/*
394 	 * When using 8-bit raw input/output (for packed YUV), we need to adapt
395 	 * the width to account for the difference in bpp when it's not 8-bit.
396 	 */
397 	if (format->hsize_len_factor)
398 		hsize_len *= format->hsize_len_factor;
399 
400 	regmap_write(regmap, SUN6I_CSI_CH_HSIZE_REG,
401 		     SUN6I_CSI_CH_HSIZE_LEN(hsize_len) |
402 		     SUN6I_CSI_CH_HSIZE_START(0));
403 
404 	regmap_write(regmap, SUN6I_CSI_CH_VSIZE_REG,
405 		     SUN6I_CSI_CH_VSIZE_LEN(vsize_len) |
406 		     SUN6I_CSI_CH_VSIZE_START(0));
407 
408 	switch (pixelformat) {
409 	case V4L2_PIX_FMT_RGB565X:
410 		luma_line = width * 2;
411 		break;
412 	case V4L2_PIX_FMT_NV12_16L16:
413 		luma_line = width;
414 		chroma_line = width;
415 		break;
416 	case V4L2_PIX_FMT_JPEG:
417 		luma_line = width;
418 		break;
419 	default:
420 		info = v4l2_format_info(pixelformat);
421 		if (WARN_ON(!info))
422 			return;
423 
424 		luma_line = width * info->bpp[0];
425 
426 		if (info->comp_planes > 1)
427 			chroma_line = width * info->bpp[1] / info->hdiv;
428 		break;
429 	}
430 
431 	regmap_write(regmap, SUN6I_CSI_CH_BUF_LEN_REG,
432 		     SUN6I_CSI_CH_BUF_LEN_CHROMA_LINE(chroma_line) |
433 		     SUN6I_CSI_CH_BUF_LEN_LUMA_LINE(luma_line));
434 }
435 
436 /* State */
437 
438 static void sun6i_csi_capture_state_cleanup(struct sun6i_csi_device *csi_dev,
439 					    bool error)
440 {
441 	struct sun6i_csi_capture_state *state = &csi_dev->capture.state;
442 	struct sun6i_csi_buffer **csi_buffer_states[] = {
443 		&state->pending, &state->current, &state->complete,
444 	};
445 	struct sun6i_csi_buffer *csi_buffer;
446 	struct vb2_buffer *vb2_buffer;
447 	unsigned long flags;
448 	unsigned int i;
449 
450 	spin_lock_irqsave(&state->lock, flags);
451 
452 	for (i = 0; i < ARRAY_SIZE(csi_buffer_states); i++) {
453 		csi_buffer = *csi_buffer_states[i];
454 		if (!csi_buffer)
455 			continue;
456 
457 		vb2_buffer = &csi_buffer->v4l2_buffer.vb2_buf;
458 		vb2_buffer_done(vb2_buffer, error ? VB2_BUF_STATE_ERROR :
459 				VB2_BUF_STATE_QUEUED);
460 
461 		*csi_buffer_states[i] = NULL;
462 	}
463 
464 	list_for_each_entry(csi_buffer, &state->queue, list) {
465 		vb2_buffer = &csi_buffer->v4l2_buffer.vb2_buf;
466 		vb2_buffer_done(vb2_buffer, error ? VB2_BUF_STATE_ERROR :
467 				VB2_BUF_STATE_QUEUED);
468 	}
469 
470 	INIT_LIST_HEAD(&state->queue);
471 
472 	spin_unlock_irqrestore(&state->lock, flags);
473 }
474 
475 void sun6i_csi_capture_state_update(struct sun6i_csi_device *csi_dev)
476 {
477 	struct sun6i_csi_capture_state *state = &csi_dev->capture.state;
478 	struct sun6i_csi_buffer *csi_buffer;
479 	unsigned long flags;
480 
481 	spin_lock_irqsave(&state->lock, flags);
482 
483 	if (list_empty(&state->queue))
484 		goto complete;
485 
486 	if (state->pending)
487 		goto complete;
488 
489 	csi_buffer = list_first_entry(&state->queue, struct sun6i_csi_buffer,
490 				      list);
491 
492 	sun6i_csi_capture_buffer_configure(csi_dev, csi_buffer);
493 
494 	list_del(&csi_buffer->list);
495 
496 	state->pending = csi_buffer;
497 
498 complete:
499 	spin_unlock_irqrestore(&state->lock, flags);
500 }
501 
502 static void sun6i_csi_capture_state_complete(struct sun6i_csi_device *csi_dev)
503 {
504 	struct sun6i_csi_capture_state *state = &csi_dev->capture.state;
505 	unsigned long flags;
506 
507 	spin_lock_irqsave(&state->lock, flags);
508 
509 	if (!state->pending)
510 		goto complete;
511 
512 	state->complete = state->current;
513 	state->current = state->pending;
514 	state->pending = NULL;
515 
516 	if (state->complete) {
517 		struct sun6i_csi_buffer *csi_buffer = state->complete;
518 		struct vb2_buffer *vb2_buffer =
519 			&csi_buffer->v4l2_buffer.vb2_buf;
520 
521 		vb2_buffer->timestamp = ktime_get_ns();
522 		csi_buffer->v4l2_buffer.sequence = state->sequence;
523 
524 		vb2_buffer_done(vb2_buffer, VB2_BUF_STATE_DONE);
525 
526 		state->complete = NULL;
527 	}
528 
529 complete:
530 	spin_unlock_irqrestore(&state->lock, flags);
531 }
532 
533 void sun6i_csi_capture_frame_done(struct sun6i_csi_device *csi_dev)
534 {
535 	struct sun6i_csi_capture_state *state = &csi_dev->capture.state;
536 	unsigned long flags;
537 
538 	spin_lock_irqsave(&state->lock, flags);
539 	state->sequence++;
540 	spin_unlock_irqrestore(&state->lock, flags);
541 }
542 
543 void sun6i_csi_capture_sync(struct sun6i_csi_device *csi_dev)
544 {
545 	sun6i_csi_capture_state_complete(csi_dev);
546 	sun6i_csi_capture_state_update(csi_dev);
547 }
548 
549 /* Queue */
550 
551 static int sun6i_csi_capture_queue_setup(struct vb2_queue *queue,
552 					 unsigned int *buffers_count,
553 					 unsigned int *planes_count,
554 					 unsigned int sizes[],
555 					 struct device *alloc_devs[])
556 {
557 	struct sun6i_csi_device *csi_dev = vb2_get_drv_priv(queue);
558 	unsigned int size = csi_dev->capture.format.fmt.pix.sizeimage;
559 
560 	if (*planes_count)
561 		return sizes[0] < size ? -EINVAL : 0;
562 
563 	*planes_count = 1;
564 	sizes[0] = size;
565 
566 	return 0;
567 }
568 
569 static int sun6i_csi_capture_buffer_prepare(struct vb2_buffer *buffer)
570 {
571 	struct sun6i_csi_device *csi_dev = vb2_get_drv_priv(buffer->vb2_queue);
572 	struct sun6i_csi_capture *capture = &csi_dev->capture;
573 	struct v4l2_device *v4l2_dev = csi_dev->v4l2_dev;
574 	struct vb2_v4l2_buffer *v4l2_buffer = to_vb2_v4l2_buffer(buffer);
575 	unsigned long size = capture->format.fmt.pix.sizeimage;
576 
577 	if (vb2_plane_size(buffer, 0) < size) {
578 		v4l2_err(v4l2_dev, "buffer too small (%lu < %lu)\n",
579 			 vb2_plane_size(buffer, 0), size);
580 		return -EINVAL;
581 	}
582 
583 	vb2_set_plane_payload(buffer, 0, size);
584 
585 	v4l2_buffer->field = capture->format.fmt.pix.field;
586 
587 	return 0;
588 }
589 
590 static void sun6i_csi_capture_buffer_queue(struct vb2_buffer *buffer)
591 {
592 	struct sun6i_csi_device *csi_dev = vb2_get_drv_priv(buffer->vb2_queue);
593 	struct sun6i_csi_capture_state *state = &csi_dev->capture.state;
594 	struct vb2_v4l2_buffer *v4l2_buffer = to_vb2_v4l2_buffer(buffer);
595 	struct sun6i_csi_buffer *csi_buffer =
596 		container_of(v4l2_buffer, struct sun6i_csi_buffer, v4l2_buffer);
597 	unsigned long flags;
598 
599 	spin_lock_irqsave(&state->lock, flags);
600 	list_add_tail(&csi_buffer->list, &state->queue);
601 	spin_unlock_irqrestore(&state->lock, flags);
602 }
603 
604 static int sun6i_csi_capture_start_streaming(struct vb2_queue *queue,
605 					     unsigned int count)
606 {
607 	struct sun6i_csi_device *csi_dev = vb2_get_drv_priv(queue);
608 	struct sun6i_csi_capture_state *state = &csi_dev->capture.state;
609 	struct video_device *video_dev = &csi_dev->capture.video_dev;
610 	struct v4l2_subdev *subdev = &csi_dev->bridge.subdev;
611 	int ret;
612 
613 	state->sequence = 0;
614 
615 	ret = video_device_pipeline_alloc_start(video_dev);
616 	if (ret < 0)
617 		goto error_state;
618 
619 	state->streaming = true;
620 
621 	ret = v4l2_subdev_call(subdev, video, s_stream, 1);
622 	if (ret && ret != -ENOIOCTLCMD)
623 		goto error_streaming;
624 
625 	return 0;
626 
627 error_streaming:
628 	state->streaming = false;
629 
630 	video_device_pipeline_stop(video_dev);
631 
632 error_state:
633 	sun6i_csi_capture_state_cleanup(csi_dev, false);
634 
635 	return ret;
636 }
637 
638 static void sun6i_csi_capture_stop_streaming(struct vb2_queue *queue)
639 {
640 	struct sun6i_csi_device *csi_dev = vb2_get_drv_priv(queue);
641 	struct sun6i_csi_capture_state *state = &csi_dev->capture.state;
642 	struct video_device *video_dev = &csi_dev->capture.video_dev;
643 	struct v4l2_subdev *subdev = &csi_dev->bridge.subdev;
644 
645 	v4l2_subdev_call(subdev, video, s_stream, 0);
646 
647 	state->streaming = false;
648 
649 	video_device_pipeline_stop(video_dev);
650 
651 	sun6i_csi_capture_state_cleanup(csi_dev, true);
652 }
653 
654 static const struct vb2_ops sun6i_csi_capture_queue_ops = {
655 	.queue_setup		= sun6i_csi_capture_queue_setup,
656 	.buf_prepare		= sun6i_csi_capture_buffer_prepare,
657 	.buf_queue		= sun6i_csi_capture_buffer_queue,
658 	.start_streaming	= sun6i_csi_capture_start_streaming,
659 	.stop_streaming		= sun6i_csi_capture_stop_streaming,
660 	.wait_prepare		= vb2_ops_wait_prepare,
661 	.wait_finish		= vb2_ops_wait_finish,
662 };
663 
664 /* V4L2 Device */
665 
666 static void sun6i_csi_capture_format_prepare(struct v4l2_format *format)
667 {
668 	struct v4l2_pix_format *pix_format = &format->fmt.pix;
669 	const struct v4l2_format_info *info;
670 	unsigned int width, height;
671 
672 	v4l_bound_align_image(&pix_format->width, SUN6I_CSI_CAPTURE_WIDTH_MIN,
673 			      SUN6I_CSI_CAPTURE_WIDTH_MAX, 1,
674 			      &pix_format->height, SUN6I_CSI_CAPTURE_HEIGHT_MIN,
675 			      SUN6I_CSI_CAPTURE_HEIGHT_MAX, 1, 0);
676 
677 	if (!sun6i_csi_capture_format_find(pix_format->pixelformat))
678 		pix_format->pixelformat =
679 			sun6i_csi_capture_formats[0].pixelformat;
680 
681 	width = pix_format->width;
682 	height = pix_format->height;
683 
684 	info = v4l2_format_info(pix_format->pixelformat);
685 
686 	switch (pix_format->pixelformat) {
687 	case V4L2_PIX_FMT_NV12_16L16:
688 		pix_format->bytesperline = width * 12 / 8;
689 		pix_format->sizeimage = pix_format->bytesperline * height;
690 		break;
691 	case V4L2_PIX_FMT_JPEG:
692 		pix_format->bytesperline = width;
693 		pix_format->sizeimage = pix_format->bytesperline * height;
694 		break;
695 	default:
696 		v4l2_fill_pixfmt(pix_format, pix_format->pixelformat,
697 				 width, height);
698 		break;
699 	}
700 
701 	if (pix_format->field == V4L2_FIELD_ANY)
702 		pix_format->field = V4L2_FIELD_NONE;
703 
704 	if (pix_format->pixelformat == V4L2_PIX_FMT_JPEG)
705 		pix_format->colorspace = V4L2_COLORSPACE_JPEG;
706 	else if (info && info->pixel_enc == V4L2_PIXEL_ENC_BAYER)
707 		pix_format->colorspace = V4L2_COLORSPACE_RAW;
708 	else
709 		pix_format->colorspace = V4L2_COLORSPACE_SRGB;
710 
711 	pix_format->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
712 	pix_format->quantization = V4L2_QUANTIZATION_DEFAULT;
713 	pix_format->xfer_func = V4L2_XFER_FUNC_DEFAULT;
714 }
715 
716 static int sun6i_csi_capture_querycap(struct file *file, void *private,
717 				      struct v4l2_capability *capability)
718 {
719 	struct sun6i_csi_device *csi_dev = video_drvdata(file);
720 	struct video_device *video_dev = &csi_dev->capture.video_dev;
721 
722 	strscpy(capability->driver, SUN6I_CSI_NAME, sizeof(capability->driver));
723 	strscpy(capability->card, video_dev->name, sizeof(capability->card));
724 	snprintf(capability->bus_info, sizeof(capability->bus_info),
725 		 "platform:%s", dev_name(csi_dev->dev));
726 
727 	return 0;
728 }
729 
730 static int sun6i_csi_capture_enum_fmt(struct file *file, void *private,
731 				      struct v4l2_fmtdesc *fmtdesc)
732 {
733 	u32 index = fmtdesc->index;
734 
735 	if (index >= ARRAY_SIZE(sun6i_csi_capture_formats))
736 		return -EINVAL;
737 
738 	fmtdesc->pixelformat = sun6i_csi_capture_formats[index].pixelformat;
739 
740 	return 0;
741 }
742 
743 static int sun6i_csi_capture_g_fmt(struct file *file, void *private,
744 				   struct v4l2_format *format)
745 {
746 	struct sun6i_csi_device *csi_dev = video_drvdata(file);
747 
748 	*format = csi_dev->capture.format;
749 
750 	return 0;
751 }
752 
753 static int sun6i_csi_capture_s_fmt(struct file *file, void *private,
754 				   struct v4l2_format *format)
755 {
756 	struct sun6i_csi_device *csi_dev = video_drvdata(file);
757 	struct sun6i_csi_capture *capture = &csi_dev->capture;
758 
759 	if (vb2_is_busy(&capture->queue))
760 		return -EBUSY;
761 
762 	sun6i_csi_capture_format_prepare(format);
763 
764 	csi_dev->capture.format = *format;
765 
766 	return 0;
767 }
768 
769 static int sun6i_csi_capture_try_fmt(struct file *file, void *private,
770 				     struct v4l2_format *format)
771 {
772 	sun6i_csi_capture_format_prepare(format);
773 
774 	return 0;
775 }
776 
777 static int sun6i_csi_capture_enum_input(struct file *file, void *private,
778 					struct v4l2_input *input)
779 {
780 	if (input->index != 0)
781 		return -EINVAL;
782 
783 	input->type = V4L2_INPUT_TYPE_CAMERA;
784 	strscpy(input->name, "Camera", sizeof(input->name));
785 
786 	return 0;
787 }
788 
789 static int sun6i_csi_capture_g_input(struct file *file, void *private,
790 				     unsigned int *index)
791 {
792 	*index = 0;
793 
794 	return 0;
795 }
796 
797 static int sun6i_csi_capture_s_input(struct file *file, void *private,
798 				     unsigned int index)
799 {
800 	if (index != 0)
801 		return -EINVAL;
802 
803 	return 0;
804 }
805 
806 static const struct v4l2_ioctl_ops sun6i_csi_capture_ioctl_ops = {
807 	.vidioc_querycap		= sun6i_csi_capture_querycap,
808 
809 	.vidioc_enum_fmt_vid_cap	= sun6i_csi_capture_enum_fmt,
810 	.vidioc_g_fmt_vid_cap		= sun6i_csi_capture_g_fmt,
811 	.vidioc_s_fmt_vid_cap		= sun6i_csi_capture_s_fmt,
812 	.vidioc_try_fmt_vid_cap		= sun6i_csi_capture_try_fmt,
813 
814 	.vidioc_enum_input		= sun6i_csi_capture_enum_input,
815 	.vidioc_g_input			= sun6i_csi_capture_g_input,
816 	.vidioc_s_input			= sun6i_csi_capture_s_input,
817 
818 	.vidioc_create_bufs		= vb2_ioctl_create_bufs,
819 	.vidioc_prepare_buf		= vb2_ioctl_prepare_buf,
820 	.vidioc_reqbufs			= vb2_ioctl_reqbufs,
821 	.vidioc_querybuf		= vb2_ioctl_querybuf,
822 	.vidioc_expbuf			= vb2_ioctl_expbuf,
823 	.vidioc_qbuf			= vb2_ioctl_qbuf,
824 	.vidioc_dqbuf			= vb2_ioctl_dqbuf,
825 	.vidioc_streamon		= vb2_ioctl_streamon,
826 	.vidioc_streamoff		= vb2_ioctl_streamoff,
827 };
828 
829 /* V4L2 File */
830 
831 static int sun6i_csi_capture_open(struct file *file)
832 {
833 	struct sun6i_csi_device *csi_dev = video_drvdata(file);
834 	struct sun6i_csi_capture *capture = &csi_dev->capture;
835 	int ret;
836 
837 	if (mutex_lock_interruptible(&capture->lock))
838 		return -ERESTARTSYS;
839 
840 	ret = v4l2_pipeline_pm_get(&capture->video_dev.entity);
841 	if (ret < 0)
842 		goto error_lock;
843 
844 	ret = v4l2_fh_open(file);
845 	if (ret < 0)
846 		goto error_pipeline;
847 
848 	mutex_unlock(&capture->lock);
849 
850 	return 0;
851 
852 error_pipeline:
853 	v4l2_pipeline_pm_put(&capture->video_dev.entity);
854 
855 error_lock:
856 	mutex_unlock(&capture->lock);
857 
858 	return ret;
859 }
860 
861 static int sun6i_csi_capture_close(struct file *file)
862 {
863 	struct sun6i_csi_device *csi_dev = video_drvdata(file);
864 	struct sun6i_csi_capture *capture = &csi_dev->capture;
865 
866 	mutex_lock(&capture->lock);
867 
868 	_vb2_fop_release(file, NULL);
869 	v4l2_pipeline_pm_put(&capture->video_dev.entity);
870 
871 	mutex_unlock(&capture->lock);
872 
873 	return 0;
874 }
875 
876 static const struct v4l2_file_operations sun6i_csi_capture_fops = {
877 	.owner		= THIS_MODULE,
878 	.open		= sun6i_csi_capture_open,
879 	.release	= sun6i_csi_capture_close,
880 	.unlocked_ioctl	= video_ioctl2,
881 	.mmap		= vb2_fop_mmap,
882 	.poll		= vb2_fop_poll
883 };
884 
885 /* Media Entity */
886 
887 static int sun6i_csi_capture_link_validate(struct media_link *link)
888 {
889 	struct video_device *video_dev =
890 		media_entity_to_video_device(link->sink->entity);
891 	struct sun6i_csi_device *csi_dev = video_get_drvdata(video_dev);
892 	struct v4l2_device *v4l2_dev = csi_dev->v4l2_dev;
893 	const struct sun6i_csi_capture_format *capture_format;
894 	const struct sun6i_csi_bridge_format *bridge_format;
895 	unsigned int capture_width, capture_height;
896 	unsigned int bridge_width, bridge_height;
897 	const struct v4l2_format_info *format_info;
898 	u32 pixelformat, capture_field;
899 	u32 mbus_code, bridge_field;
900 	bool match;
901 
902 	sun6i_csi_capture_dimensions(csi_dev, &capture_width, &capture_height);
903 
904 	sun6i_csi_capture_format(csi_dev, &pixelformat, &capture_field);
905 	capture_format = sun6i_csi_capture_format_find(pixelformat);
906 	if (WARN_ON(!capture_format))
907 		return -EINVAL;
908 
909 	sun6i_csi_bridge_dimensions(csi_dev, &bridge_width, &bridge_height);
910 
911 	sun6i_csi_bridge_format(csi_dev, &mbus_code, &bridge_field);
912 	bridge_format = sun6i_csi_bridge_format_find(mbus_code);
913 	if (WARN_ON(!bridge_format))
914 		return -EINVAL;
915 
916 	/* No cropping/scaling is supported. */
917 	if (capture_width != bridge_width || capture_height != bridge_height) {
918 		v4l2_err(v4l2_dev,
919 			 "invalid input/output dimensions: %ux%u/%ux%u\n",
920 			 bridge_width, bridge_height, capture_width,
921 			 capture_height);
922 		return -EINVAL;
923 	}
924 
925 	format_info = v4l2_format_info(pixelformat);
926 	/* Some formats are not listed. */
927 	if (!format_info)
928 		return 0;
929 
930 	if (format_info->pixel_enc == V4L2_PIXEL_ENC_BAYER &&
931 	    bridge_format->input_format != SUN6I_CSI_INPUT_FMT_RAW)
932 		goto invalid;
933 
934 	if (format_info->pixel_enc == V4L2_PIXEL_ENC_RGB &&
935 	    bridge_format->input_format != SUN6I_CSI_INPUT_FMT_RAW)
936 		goto invalid;
937 
938 	if (format_info->pixel_enc == V4L2_PIXEL_ENC_YUV) {
939 		if (bridge_format->input_format != SUN6I_CSI_INPUT_FMT_YUV420 &&
940 		    bridge_format->input_format != SUN6I_CSI_INPUT_FMT_YUV422)
941 			goto invalid;
942 
943 		/* YUV420 input can't produce YUV422 output. */
944 		if (bridge_format->input_format == SUN6I_CSI_INPUT_FMT_YUV420 &&
945 		    format_info->vdiv == 1)
946 			goto invalid;
947 	}
948 
949 	/* With raw input mode, we need a 1:1 match between input and output. */
950 	if (bridge_format->input_format == SUN6I_CSI_INPUT_FMT_RAW ||
951 	    capture_format->input_format_raw) {
952 		match = sun6i_csi_capture_format_match(pixelformat, mbus_code);
953 		if (!match)
954 			goto invalid;
955 	}
956 
957 	return 0;
958 
959 invalid:
960 	v4l2_err(v4l2_dev, "invalid input/output format combination\n");
961 	return -EINVAL;
962 }
963 
964 static const struct media_entity_operations sun6i_csi_capture_media_ops = {
965 	.link_validate = sun6i_csi_capture_link_validate
966 };
967 
968 /* Capture */
969 
970 int sun6i_csi_capture_setup(struct sun6i_csi_device *csi_dev)
971 {
972 	struct sun6i_csi_capture *capture = &csi_dev->capture;
973 	struct sun6i_csi_capture_state *state = &capture->state;
974 	struct v4l2_device *v4l2_dev = csi_dev->v4l2_dev;
975 	struct v4l2_subdev *bridge_subdev = &csi_dev->bridge.subdev;
976 	struct video_device *video_dev = &capture->video_dev;
977 	struct vb2_queue *queue = &capture->queue;
978 	struct media_pad *pad = &capture->pad;
979 	struct v4l2_format *format = &csi_dev->capture.format;
980 	struct v4l2_pix_format *pix_format = &format->fmt.pix;
981 	int ret;
982 
983 	/* This may happen with multiple bridge notifier bound calls. */
984 	if (state->setup)
985 		return 0;
986 
987 	/* State */
988 
989 	INIT_LIST_HEAD(&state->queue);
990 	spin_lock_init(&state->lock);
991 
992 	/* Media Entity */
993 
994 	video_dev->entity.ops = &sun6i_csi_capture_media_ops;
995 
996 	/* Media Pad */
997 
998 	pad->flags = MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_MUST_CONNECT;
999 
1000 	ret = media_entity_pads_init(&video_dev->entity, 1, pad);
1001 	if (ret < 0)
1002 		return ret;
1003 
1004 	/* Queue */
1005 
1006 	mutex_init(&capture->lock);
1007 
1008 	queue->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1009 	queue->io_modes = VB2_MMAP | VB2_DMABUF;
1010 	queue->buf_struct_size = sizeof(struct sun6i_csi_buffer);
1011 	queue->ops = &sun6i_csi_capture_queue_ops;
1012 	queue->mem_ops = &vb2_dma_contig_memops;
1013 	queue->min_buffers_needed = 2;
1014 	queue->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1015 	queue->lock = &capture->lock;
1016 	queue->dev = csi_dev->dev;
1017 	queue->drv_priv = csi_dev;
1018 
1019 	ret = vb2_queue_init(queue);
1020 	if (ret) {
1021 		v4l2_err(v4l2_dev, "failed to initialize vb2 queue: %d\n", ret);
1022 		goto error_media_entity;
1023 	}
1024 
1025 	/* V4L2 Format */
1026 
1027 	format->type = queue->type;
1028 	pix_format->pixelformat = sun6i_csi_capture_formats[0].pixelformat;
1029 	pix_format->width = 1280;
1030 	pix_format->height = 720;
1031 	pix_format->field = V4L2_FIELD_NONE;
1032 
1033 	sun6i_csi_capture_format_prepare(format);
1034 
1035 	/* Video Device */
1036 
1037 	strscpy(video_dev->name, SUN6I_CSI_CAPTURE_NAME,
1038 		sizeof(video_dev->name));
1039 	video_dev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
1040 	video_dev->vfl_dir = VFL_DIR_RX;
1041 	video_dev->release = video_device_release_empty;
1042 	video_dev->fops = &sun6i_csi_capture_fops;
1043 	video_dev->ioctl_ops = &sun6i_csi_capture_ioctl_ops;
1044 	video_dev->v4l2_dev = v4l2_dev;
1045 	video_dev->queue = queue;
1046 	video_dev->lock = &capture->lock;
1047 
1048 	video_set_drvdata(video_dev, csi_dev);
1049 
1050 	ret = video_register_device(video_dev, VFL_TYPE_VIDEO, -1);
1051 	if (ret < 0) {
1052 		v4l2_err(v4l2_dev, "failed to register video device: %d\n",
1053 			 ret);
1054 		goto error_media_entity;
1055 	}
1056 
1057 	/* Media Pad Link */
1058 
1059 	ret = media_create_pad_link(&bridge_subdev->entity,
1060 				    SUN6I_CSI_BRIDGE_PAD_SOURCE,
1061 				    &video_dev->entity, 0,
1062 				    csi_dev->isp_available ? 0 :
1063 				    MEDIA_LNK_FL_ENABLED |
1064 				    MEDIA_LNK_FL_IMMUTABLE);
1065 	if (ret < 0) {
1066 		v4l2_err(v4l2_dev, "failed to create %s:%u -> %s:%u link\n",
1067 			 bridge_subdev->entity.name,
1068 			 SUN6I_CSI_BRIDGE_PAD_SOURCE,
1069 			 video_dev->entity.name, 0);
1070 		goto error_video_device;
1071 	}
1072 
1073 	state->setup = true;
1074 
1075 	return 0;
1076 
1077 error_video_device:
1078 	vb2_video_unregister_device(video_dev);
1079 
1080 error_media_entity:
1081 	media_entity_cleanup(&video_dev->entity);
1082 
1083 	mutex_destroy(&capture->lock);
1084 
1085 	return ret;
1086 }
1087 
1088 void sun6i_csi_capture_cleanup(struct sun6i_csi_device *csi_dev)
1089 {
1090 	struct sun6i_csi_capture *capture = &csi_dev->capture;
1091 	struct video_device *video_dev = &capture->video_dev;
1092 
1093 	/* This may happen if async registration failed to complete. */
1094 	if (!capture->state.setup)
1095 		return;
1096 
1097 	vb2_video_unregister_device(video_dev);
1098 	media_entity_cleanup(&video_dev->entity);
1099 	mutex_destroy(&capture->lock);
1100 
1101 	capture->state.setup = false;
1102 }
1103