xref: /linux/drivers/media/platform/renesas/rcar-vin/rcar-v4l2.c (revision 6fd600d742744dc7ef7fc65ca26daa2b1163158a)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Driver for Renesas R-Car VIN
4  *
5  * Copyright (C) 2016 Renesas Electronics Corp.
6  * Copyright (C) 2011-2013 Renesas Solutions Corp.
7  * Copyright (C) 2013 Cogent Embedded, Inc., <source@cogentembedded.com>
8  * Copyright (C) 2008 Magnus Damm
9  *
10  * Based on the soc-camera rcar_vin driver
11  */
12 
13 #include <linux/pm_runtime.h>
14 
15 #include <media/v4l2-event.h>
16 #include <media/v4l2-ioctl.h>
17 #include <media/v4l2-mc.h>
18 #include <media/v4l2-rect.h>
19 
20 #include "rcar-vin.h"
21 
22 #define RVIN_DEFAULT_FORMAT	V4L2_PIX_FMT_YUYV
23 #define RVIN_DEFAULT_WIDTH	800
24 #define RVIN_DEFAULT_HEIGHT	600
25 #define RVIN_DEFAULT_FIELD	V4L2_FIELD_NONE
26 #define RVIN_DEFAULT_COLORSPACE	V4L2_COLORSPACE_SRGB
27 
28 /* -----------------------------------------------------------------------------
29  * Format Conversions
30  */
31 
32 static const struct rvin_video_format rvin_formats[] = {
33 	{
34 		.fourcc			= V4L2_PIX_FMT_NV12,
35 		.bpp			= 1,
36 	},
37 	{
38 		.fourcc			= V4L2_PIX_FMT_NV16,
39 		.bpp			= 1,
40 	},
41 	{
42 		.fourcc			= V4L2_PIX_FMT_YUYV,
43 		.bpp			= 2,
44 	},
45 	{
46 		.fourcc			= V4L2_PIX_FMT_UYVY,
47 		.bpp			= 2,
48 	},
49 	{
50 		.fourcc			= V4L2_PIX_FMT_RGB565,
51 		.bpp			= 2,
52 	},
53 	{
54 		.fourcc			= V4L2_PIX_FMT_XRGB555,
55 		.bpp			= 2,
56 	},
57 	{
58 		.fourcc			= V4L2_PIX_FMT_XBGR32,
59 		.bpp			= 4,
60 	},
61 	{
62 		.fourcc			= V4L2_PIX_FMT_ARGB555,
63 		.bpp			= 2,
64 	},
65 	{
66 		.fourcc			= V4L2_PIX_FMT_ABGR32,
67 		.bpp			= 4,
68 	},
69 	{
70 		.fourcc			= V4L2_PIX_FMT_SBGGR8,
71 		.bpp			= 1,
72 	},
73 	{
74 		.fourcc			= V4L2_PIX_FMT_SGBRG8,
75 		.bpp			= 1,
76 	},
77 	{
78 		.fourcc			= V4L2_PIX_FMT_SGRBG8,
79 		.bpp			= 1,
80 	},
81 	{
82 		.fourcc			= V4L2_PIX_FMT_SRGGB8,
83 		.bpp			= 1,
84 	},
85 	{
86 		.fourcc			= V4L2_PIX_FMT_GREY,
87 		.bpp			= 1,
88 	},
89 };
90 
rvin_format_from_pixel(struct rvin_dev * vin,u32 pixelformat)91 const struct rvin_video_format *rvin_format_from_pixel(struct rvin_dev *vin,
92 						       u32 pixelformat)
93 {
94 	int i;
95 
96 	switch (pixelformat) {
97 	case V4L2_PIX_FMT_XBGR32:
98 		if (vin->info->model == RCAR_M1)
99 			return NULL;
100 		break;
101 	case V4L2_PIX_FMT_NV12:
102 		/*
103 		 * If NV12 is supported it's only supported on channels 0, 1, 4,
104 		 * 5, 8, 9, 12 and 13.
105 		 */
106 		if (!vin->info->nv12 || !(BIT(vin->id) & 0x3333))
107 			return NULL;
108 		break;
109 	default:
110 		break;
111 	}
112 
113 	for (i = 0; i < ARRAY_SIZE(rvin_formats); i++)
114 		if (rvin_formats[i].fourcc == pixelformat)
115 			return rvin_formats + i;
116 
117 	return NULL;
118 }
119 
rvin_format_bytesperline(struct rvin_dev * vin,struct v4l2_pix_format * pix)120 static u32 rvin_format_bytesperline(struct rvin_dev *vin,
121 				    struct v4l2_pix_format *pix)
122 {
123 	const struct rvin_video_format *fmt;
124 	u32 align;
125 
126 	fmt = rvin_format_from_pixel(vin, pix->pixelformat);
127 
128 	if (WARN_ON(!fmt))
129 		return -EINVAL;
130 
131 	switch (pix->pixelformat) {
132 	case V4L2_PIX_FMT_NV12:
133 	case V4L2_PIX_FMT_NV16:
134 		align = 0x20;
135 		break;
136 	default:
137 		align = 0x10;
138 		break;
139 	}
140 
141 	if (V4L2_FIELD_IS_SEQUENTIAL(pix->field))
142 		align = 0x80;
143 
144 	return ALIGN(pix->width, align) * fmt->bpp;
145 }
146 
rvin_format_sizeimage(struct v4l2_pix_format * pix)147 static u32 rvin_format_sizeimage(struct v4l2_pix_format *pix)
148 {
149 	switch (pix->pixelformat) {
150 	case V4L2_PIX_FMT_NV12:
151 		return pix->bytesperline * pix->height * 3 / 2;
152 	case V4L2_PIX_FMT_NV16:
153 		return pix->bytesperline * pix->height * 2;
154 	default:
155 		return pix->bytesperline * pix->height;
156 	}
157 }
158 
rvin_format_align(struct rvin_dev * vin,struct v4l2_pix_format * pix)159 static void rvin_format_align(struct rvin_dev *vin, struct v4l2_pix_format *pix)
160 {
161 	u32 walign;
162 
163 	if (!rvin_format_from_pixel(vin, pix->pixelformat))
164 		pix->pixelformat = RVIN_DEFAULT_FORMAT;
165 
166 	switch (pix->field) {
167 	case V4L2_FIELD_TOP:
168 	case V4L2_FIELD_BOTTOM:
169 	case V4L2_FIELD_NONE:
170 	case V4L2_FIELD_INTERLACED_TB:
171 	case V4L2_FIELD_INTERLACED_BT:
172 	case V4L2_FIELD_INTERLACED:
173 	case V4L2_FIELD_ALTERNATE:
174 	case V4L2_FIELD_SEQ_TB:
175 	case V4L2_FIELD_SEQ_BT:
176 		break;
177 	default:
178 		pix->field = RVIN_DEFAULT_FIELD;
179 		break;
180 	}
181 
182 	/* Hardware limits width alignment based on format. */
183 	switch (pix->pixelformat) {
184 	/* Multiple of 32 (2^5) for NV12/16. */
185 	case V4L2_PIX_FMT_NV12:
186 	case V4L2_PIX_FMT_NV16:
187 		walign = 5;
188 		break;
189 	/* Multiple of 2 (2^1) for YUV. */
190 	case V4L2_PIX_FMT_YUYV:
191 	case V4L2_PIX_FMT_UYVY:
192 		walign = 1;
193 		break;
194 	/* No multiple for RGB. */
195 	default:
196 		walign = 0;
197 		break;
198 	}
199 
200 	/* Limit to VIN capabilities */
201 	v4l_bound_align_image(&pix->width, 5, vin->info->max_width, walign,
202 			      &pix->height, 2, vin->info->max_height, 0, 0);
203 
204 	pix->bytesperline = rvin_format_bytesperline(vin, pix);
205 	pix->sizeimage = rvin_format_sizeimage(pix);
206 
207 	vin_dbg(vin, "Format %ux%u bpl: %u size: %u\n",
208 		pix->width, pix->height, pix->bytesperline, pix->sizeimage);
209 }
210 
211 /* -----------------------------------------------------------------------------
212  * V4L2
213  */
214 
rvin_reset_format(struct rvin_dev * vin)215 static int rvin_reset_format(struct rvin_dev *vin)
216 {
217 	struct v4l2_subdev_format fmt = {
218 		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
219 		.pad = vin->parallel.source_pad,
220 	};
221 	int ret;
222 
223 	ret = v4l2_subdev_call(vin_to_source(vin), pad, get_fmt, NULL, &fmt);
224 	if (ret)
225 		return ret;
226 
227 	v4l2_fill_pix_format(&vin->format, &fmt.format);
228 
229 	vin->crop.top = 0;
230 	vin->crop.left = 0;
231 	vin->crop.width = vin->format.width;
232 	vin->crop.height = vin->format.height;
233 
234 	/*  Make use of the hardware interlacer by default. */
235 	if (vin->format.field == V4L2_FIELD_ALTERNATE) {
236 		vin->format.field = V4L2_FIELD_INTERLACED;
237 		vin->format.height *= 2;
238 	}
239 
240 	rvin_format_align(vin, &vin->format);
241 
242 	vin->compose.top = 0;
243 	vin->compose.left = 0;
244 	vin->compose.width = vin->format.width;
245 	vin->compose.height = vin->format.height;
246 
247 	return 0;
248 }
249 
rvin_try_format(struct rvin_dev * vin,u32 which,struct v4l2_pix_format * pix,struct v4l2_rect * src_rect)250 static int rvin_try_format(struct rvin_dev *vin, u32 which,
251 			   struct v4l2_pix_format *pix,
252 			   struct v4l2_rect *src_rect)
253 {
254 	struct v4l2_subdev *sd = vin_to_source(vin);
255 	struct v4l2_subdev_state *sd_state;
256 	static struct lock_class_key key;
257 	struct v4l2_subdev_format format = {
258 		.which = which,
259 		.pad = vin->parallel.source_pad,
260 	};
261 	enum v4l2_field field;
262 	u32 width, height;
263 	int ret;
264 
265 	/*
266 	 * FIXME: Drop this call, drivers are not supposed to use
267 	 * __v4l2_subdev_state_alloc().
268 	 */
269 	sd_state = __v4l2_subdev_state_alloc(sd, "rvin:state->lock", &key);
270 	if (IS_ERR(sd_state))
271 		return PTR_ERR(sd_state);
272 
273 	if (!rvin_format_from_pixel(vin, pix->pixelformat))
274 		pix->pixelformat = RVIN_DEFAULT_FORMAT;
275 
276 	v4l2_fill_mbus_format(&format.format, pix, vin->mbus_code);
277 
278 	/* Allow the video device to override field and to scale */
279 	field = pix->field;
280 	width = pix->width;
281 	height = pix->height;
282 
283 	ret = v4l2_subdev_call(sd, pad, set_fmt, sd_state, &format);
284 	if (ret < 0 && ret != -ENOIOCTLCMD)
285 		goto done;
286 	ret = 0;
287 
288 	v4l2_fill_pix_format(pix, &format.format);
289 
290 	if (src_rect) {
291 		src_rect->top = 0;
292 		src_rect->left = 0;
293 		src_rect->width = pix->width;
294 		src_rect->height = pix->height;
295 	}
296 
297 	if (field != V4L2_FIELD_ANY)
298 		pix->field = field;
299 
300 	pix->width = width;
301 	pix->height = height;
302 
303 	rvin_format_align(vin, pix);
304 done:
305 	__v4l2_subdev_state_free(sd_state);
306 
307 	return ret;
308 }
309 
rvin_querycap(struct file * file,void * priv,struct v4l2_capability * cap)310 static int rvin_querycap(struct file *file, void *priv,
311 			 struct v4l2_capability *cap)
312 {
313 	strscpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
314 	strscpy(cap->card, "R_Car_VIN", sizeof(cap->card));
315 	return 0;
316 }
317 
rvin_try_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)318 static int rvin_try_fmt_vid_cap(struct file *file, void *priv,
319 				struct v4l2_format *f)
320 {
321 	struct rvin_dev *vin = video_drvdata(file);
322 
323 	return rvin_try_format(vin, V4L2_SUBDEV_FORMAT_TRY, &f->fmt.pix, NULL);
324 }
325 
rvin_s_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)326 static int rvin_s_fmt_vid_cap(struct file *file, void *priv,
327 			      struct v4l2_format *f)
328 {
329 	struct rvin_dev *vin = video_drvdata(file);
330 	struct v4l2_rect fmt_rect, src_rect;
331 	int ret;
332 
333 	if (vb2_is_busy(&vin->queue))
334 		return -EBUSY;
335 
336 	ret = rvin_try_format(vin, V4L2_SUBDEV_FORMAT_ACTIVE, &f->fmt.pix,
337 			      &src_rect);
338 	if (ret)
339 		return ret;
340 
341 	vin->format = f->fmt.pix;
342 
343 	fmt_rect.top = 0;
344 	fmt_rect.left = 0;
345 	fmt_rect.width = vin->format.width;
346 	fmt_rect.height = vin->format.height;
347 
348 	v4l2_rect_map_inside(&vin->crop, &src_rect);
349 	v4l2_rect_map_inside(&vin->compose, &fmt_rect);
350 
351 	return 0;
352 }
353 
rvin_g_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)354 static int rvin_g_fmt_vid_cap(struct file *file, void *priv,
355 			      struct v4l2_format *f)
356 {
357 	struct rvin_dev *vin = video_drvdata(file);
358 
359 	f->fmt.pix = vin->format;
360 
361 	return 0;
362 }
363 
rvin_enum_fmt_vid_cap(struct file * file,void * priv,struct v4l2_fmtdesc * f)364 static int rvin_enum_fmt_vid_cap(struct file *file, void *priv,
365 				 struct v4l2_fmtdesc *f)
366 {
367 	struct rvin_dev *vin = video_drvdata(file);
368 	unsigned int i;
369 	int matched;
370 
371 	/*
372 	 * If mbus_code is set only enumerate supported pixel formats for that
373 	 * bus code. Converting from YCbCr to RGB and RGB to YCbCr is possible
374 	 * with VIN, so all supported YCbCr and RGB media bus codes can produce
375 	 * all of the related pixel formats. If mbus_code is not set enumerate
376 	 * all possible pixelformats.
377 	 *
378 	 * TODO: Once raw MEDIA_BUS_FMT_SRGGB12_1X12 format is added to the
379 	 * driver this needs to be extended so raw media bus code only result in
380 	 * raw pixel format.
381 	 */
382 	switch (f->mbus_code) {
383 	case 0:
384 	case MEDIA_BUS_FMT_YUYV8_1X16:
385 	case MEDIA_BUS_FMT_UYVY8_1X16:
386 	case MEDIA_BUS_FMT_UYVY8_2X8:
387 	case MEDIA_BUS_FMT_UYVY10_2X10:
388 	case MEDIA_BUS_FMT_RGB888_1X24:
389 		break;
390 	case MEDIA_BUS_FMT_SBGGR8_1X8:
391 		if (f->index)
392 			return -EINVAL;
393 		f->pixelformat = V4L2_PIX_FMT_SBGGR8;
394 		return 0;
395 	case MEDIA_BUS_FMT_SGBRG8_1X8:
396 		if (f->index)
397 			return -EINVAL;
398 		f->pixelformat = V4L2_PIX_FMT_SGBRG8;
399 		return 0;
400 	case MEDIA_BUS_FMT_SGRBG8_1X8:
401 		if (f->index)
402 			return -EINVAL;
403 		f->pixelformat = V4L2_PIX_FMT_SGRBG8;
404 		return 0;
405 	case MEDIA_BUS_FMT_SRGGB8_1X8:
406 		if (f->index)
407 			return -EINVAL;
408 		f->pixelformat = V4L2_PIX_FMT_SRGGB8;
409 		return 0;
410 	default:
411 		return -EINVAL;
412 	}
413 
414 	matched = -1;
415 	for (i = 0; i < ARRAY_SIZE(rvin_formats); i++) {
416 		if (rvin_format_from_pixel(vin, rvin_formats[i].fourcc))
417 			matched++;
418 
419 		if (matched == f->index) {
420 			f->pixelformat = rvin_formats[i].fourcc;
421 			return 0;
422 		}
423 	}
424 
425 	return -EINVAL;
426 }
427 
rvin_remote_rectangle(struct rvin_dev * vin,struct v4l2_rect * rect)428 static int rvin_remote_rectangle(struct rvin_dev *vin, struct v4l2_rect *rect)
429 {
430 	struct v4l2_subdev_format fmt = {
431 		.which = V4L2_SUBDEV_FORMAT_ACTIVE,
432 	};
433 	struct v4l2_subdev *sd;
434 	unsigned int index;
435 	int ret;
436 
437 	if (vin->info->use_mc) {
438 		struct media_pad *pad = media_pad_remote_pad_first(&vin->pad);
439 
440 		if (!pad)
441 			return -EINVAL;
442 
443 		sd = media_entity_to_v4l2_subdev(pad->entity);
444 		index = pad->index;
445 	} else {
446 		sd = vin_to_source(vin);
447 		index = vin->parallel.source_pad;
448 	}
449 
450 	fmt.pad = index;
451 	ret = v4l2_subdev_call(sd, pad, get_fmt, NULL, &fmt);
452 	if (ret)
453 		return ret;
454 
455 	rect->left = rect->top = 0;
456 	rect->width = fmt.format.width;
457 	rect->height = fmt.format.height;
458 
459 	if (fmt.format.field == V4L2_FIELD_ALTERNATE) {
460 		switch (vin->format.field) {
461 		case V4L2_FIELD_INTERLACED_TB:
462 		case V4L2_FIELD_INTERLACED_BT:
463 		case V4L2_FIELD_INTERLACED:
464 		case V4L2_FIELD_SEQ_TB:
465 		case V4L2_FIELD_SEQ_BT:
466 			rect->height *= 2;
467 			break;
468 		}
469 	}
470 
471 	return 0;
472 }
473 
rvin_g_selection(struct file * file,void * fh,struct v4l2_selection * s)474 static int rvin_g_selection(struct file *file, void *fh,
475 			    struct v4l2_selection *s)
476 {
477 	struct rvin_dev *vin = video_drvdata(file);
478 	int ret;
479 
480 	if (!vin->scaler)
481 		return -ENOIOCTLCMD;
482 
483 	if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
484 		return -EINVAL;
485 
486 	switch (s->target) {
487 	case V4L2_SEL_TGT_CROP_BOUNDS:
488 	case V4L2_SEL_TGT_CROP_DEFAULT:
489 		ret = rvin_remote_rectangle(vin, &s->r);
490 		if (ret)
491 			return ret;
492 
493 		break;
494 	case V4L2_SEL_TGT_CROP:
495 		s->r = vin->crop;
496 		break;
497 	case V4L2_SEL_TGT_COMPOSE_BOUNDS:
498 	case V4L2_SEL_TGT_COMPOSE_DEFAULT:
499 		s->r.left = s->r.top = 0;
500 		s->r.width = vin->format.width;
501 		s->r.height = vin->format.height;
502 		break;
503 	case V4L2_SEL_TGT_COMPOSE:
504 		s->r = vin->compose;
505 		break;
506 	default:
507 		return -EINVAL;
508 	}
509 
510 	return 0;
511 }
512 
rvin_s_selection(struct file * file,void * fh,struct v4l2_selection * s)513 static int rvin_s_selection(struct file *file, void *fh,
514 			    struct v4l2_selection *s)
515 {
516 	struct rvin_dev *vin = video_drvdata(file);
517 	const struct rvin_video_format *fmt;
518 	struct v4l2_rect r = s->r;
519 	struct v4l2_rect max_rect;
520 	struct v4l2_rect min_rect = {
521 		.width = 6,
522 		.height = 2,
523 	};
524 	int ret;
525 
526 	if (!vin->scaler)
527 		return -ENOIOCTLCMD;
528 
529 	if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
530 		return -EINVAL;
531 
532 	v4l2_rect_set_min_size(&r, &min_rect);
533 
534 	switch (s->target) {
535 	case V4L2_SEL_TGT_CROP:
536 		/* Can't crop outside of source input */
537 		ret = rvin_remote_rectangle(vin, &max_rect);
538 		if (ret)
539 			return ret;
540 
541 		v4l2_rect_map_inside(&r, &max_rect);
542 
543 		v4l_bound_align_image(&r.width, 6, max_rect.width, 0,
544 				      &r.height, 2, max_rect.height, 0, 0);
545 
546 		r.top  = clamp_t(s32, r.top, 0, max_rect.height - r.height);
547 		r.left = clamp_t(s32, r.left, 0, max_rect.width - r.width);
548 
549 		vin->crop = s->r = r;
550 
551 		vin_dbg(vin, "Cropped %dx%d@%d:%d of %dx%d\n",
552 			r.width, r.height, r.left, r.top,
553 			max_rect.width, max_rect.height);
554 		break;
555 	case V4L2_SEL_TGT_COMPOSE:
556 		/* Make sure compose rect fits inside output format */
557 		max_rect.top = max_rect.left = 0;
558 		max_rect.width = vin->format.width;
559 		max_rect.height = vin->format.height;
560 		v4l2_rect_map_inside(&r, &max_rect);
561 
562 		/*
563 		 * Composing is done by adding a offset to the buffer address,
564 		 * the HW wants this address to be aligned to HW_BUFFER_MASK.
565 		 * Make sure the top and left values meets this requirement.
566 		 */
567 		while ((r.top * vin->format.bytesperline) & HW_BUFFER_MASK)
568 			r.top--;
569 
570 		fmt = rvin_format_from_pixel(vin, vin->format.pixelformat);
571 		while ((r.left * fmt->bpp) & HW_BUFFER_MASK)
572 			r.left--;
573 
574 		vin->compose = s->r = r;
575 
576 		vin_dbg(vin, "Compose %dx%d@%d:%d in %dx%d\n",
577 			r.width, r.height, r.left, r.top,
578 			vin->format.width, vin->format.height);
579 		break;
580 	default:
581 		return -EINVAL;
582 	}
583 
584 	/* HW supports modifying configuration while running */
585 	rvin_crop_scale_comp(vin);
586 
587 	return 0;
588 }
589 
rvin_g_parm(struct file * file,void * priv,struct v4l2_streamparm * parm)590 static int rvin_g_parm(struct file *file, void *priv,
591 		       struct v4l2_streamparm *parm)
592 {
593 	struct rvin_dev *vin = video_drvdata(file);
594 	struct v4l2_subdev *sd = vin_to_source(vin);
595 
596 	return v4l2_g_parm_cap(&vin->vdev, sd, parm);
597 }
598 
rvin_s_parm(struct file * file,void * priv,struct v4l2_streamparm * parm)599 static int rvin_s_parm(struct file *file, void *priv,
600 		       struct v4l2_streamparm *parm)
601 {
602 	struct rvin_dev *vin = video_drvdata(file);
603 	struct v4l2_subdev *sd = vin_to_source(vin);
604 
605 	return v4l2_s_parm_cap(&vin->vdev, sd, parm);
606 }
607 
rvin_g_pixelaspect(struct file * file,void * priv,int type,struct v4l2_fract * f)608 static int rvin_g_pixelaspect(struct file *file, void *priv,
609 			      int type, struct v4l2_fract *f)
610 {
611 	struct rvin_dev *vin = video_drvdata(file);
612 	struct v4l2_subdev *sd = vin_to_source(vin);
613 
614 	if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
615 		return -EINVAL;
616 
617 	return v4l2_subdev_call(sd, video, g_pixelaspect, f);
618 }
619 
rvin_enum_input(struct file * file,void * priv,struct v4l2_input * i)620 static int rvin_enum_input(struct file *file, void *priv,
621 			   struct v4l2_input *i)
622 {
623 	struct rvin_dev *vin = video_drvdata(file);
624 	struct v4l2_subdev *sd = vin_to_source(vin);
625 	int ret;
626 
627 	if (i->index != 0)
628 		return -EINVAL;
629 
630 	ret = v4l2_subdev_call(sd, video, g_input_status, &i->status);
631 	if (ret < 0 && ret != -ENOIOCTLCMD && ret != -ENODEV)
632 		return ret;
633 
634 	i->type = V4L2_INPUT_TYPE_CAMERA;
635 
636 	if (v4l2_subdev_has_op(sd, pad, dv_timings_cap)) {
637 		i->capabilities = V4L2_IN_CAP_DV_TIMINGS;
638 		i->std = 0;
639 	} else {
640 		i->capabilities = V4L2_IN_CAP_STD;
641 		i->std = vin->vdev.tvnorms;
642 	}
643 
644 	strscpy(i->name, "Camera", sizeof(i->name));
645 
646 	return 0;
647 }
648 
rvin_g_input(struct file * file,void * priv,unsigned int * i)649 static int rvin_g_input(struct file *file, void *priv, unsigned int *i)
650 {
651 	*i = 0;
652 	return 0;
653 }
654 
rvin_s_input(struct file * file,void * priv,unsigned int i)655 static int rvin_s_input(struct file *file, void *priv, unsigned int i)
656 {
657 	if (i > 0)
658 		return -EINVAL;
659 	return 0;
660 }
661 
rvin_querystd(struct file * file,void * priv,v4l2_std_id * a)662 static int rvin_querystd(struct file *file, void *priv, v4l2_std_id *a)
663 {
664 	struct rvin_dev *vin = video_drvdata(file);
665 	struct v4l2_subdev *sd = vin_to_source(vin);
666 
667 	return v4l2_subdev_call(sd, video, querystd, a);
668 }
669 
rvin_s_std(struct file * file,void * priv,v4l2_std_id a)670 static int rvin_s_std(struct file *file, void *priv, v4l2_std_id a)
671 {
672 	struct rvin_dev *vin = video_drvdata(file);
673 	int ret;
674 
675 	ret = v4l2_subdev_call(vin_to_source(vin), video, s_std, a);
676 	if (ret < 0)
677 		return ret;
678 
679 	vin->std = a;
680 
681 	/* Changing the standard will change the width/height */
682 	return rvin_reset_format(vin);
683 }
684 
rvin_g_std(struct file * file,void * priv,v4l2_std_id * a)685 static int rvin_g_std(struct file *file, void *priv, v4l2_std_id *a)
686 {
687 	struct rvin_dev *vin = video_drvdata(file);
688 
689 	if (v4l2_subdev_has_op(vin_to_source(vin), pad, dv_timings_cap))
690 		return -ENOIOCTLCMD;
691 
692 	*a = vin->std;
693 
694 	return 0;
695 }
696 
rvin_subscribe_event(struct v4l2_fh * fh,const struct v4l2_event_subscription * sub)697 static int rvin_subscribe_event(struct v4l2_fh *fh,
698 				const struct v4l2_event_subscription *sub)
699 {
700 	switch (sub->type) {
701 	case V4L2_EVENT_SOURCE_CHANGE:
702 		return v4l2_event_subscribe(fh, sub, 4, NULL);
703 	}
704 	return v4l2_ctrl_subscribe_event(fh, sub);
705 }
706 
rvin_enum_dv_timings(struct file * file,void * priv_fh,struct v4l2_enum_dv_timings * timings)707 static int rvin_enum_dv_timings(struct file *file, void *priv_fh,
708 				struct v4l2_enum_dv_timings *timings)
709 {
710 	struct rvin_dev *vin = video_drvdata(file);
711 	struct v4l2_subdev *sd = vin_to_source(vin);
712 	int ret;
713 
714 	if (timings->pad)
715 		return -EINVAL;
716 
717 	timings->pad = vin->parallel.sink_pad;
718 
719 	ret = v4l2_subdev_call(sd, pad, enum_dv_timings, timings);
720 
721 	timings->pad = 0;
722 
723 	return ret;
724 }
725 
rvin_s_dv_timings(struct file * file,void * priv_fh,struct v4l2_dv_timings * timings)726 static int rvin_s_dv_timings(struct file *file, void *priv_fh,
727 			     struct v4l2_dv_timings *timings)
728 {
729 	struct rvin_dev *vin = video_drvdata(file);
730 	struct v4l2_subdev *sd = vin_to_source(vin);
731 	int ret;
732 
733 	ret = v4l2_subdev_call(sd, pad, s_dv_timings,
734 			       vin->parallel.sink_pad, timings);
735 	if (ret)
736 		return ret;
737 
738 	/* Changing the timings will change the width/height */
739 	return rvin_reset_format(vin);
740 }
741 
rvin_g_dv_timings(struct file * file,void * priv_fh,struct v4l2_dv_timings * timings)742 static int rvin_g_dv_timings(struct file *file, void *priv_fh,
743 			     struct v4l2_dv_timings *timings)
744 {
745 	struct rvin_dev *vin = video_drvdata(file);
746 	struct v4l2_subdev *sd = vin_to_source(vin);
747 
748 	return v4l2_subdev_call(sd, pad, g_dv_timings,
749 				vin->parallel.sink_pad, timings);
750 }
751 
rvin_query_dv_timings(struct file * file,void * priv_fh,struct v4l2_dv_timings * timings)752 static int rvin_query_dv_timings(struct file *file, void *priv_fh,
753 				 struct v4l2_dv_timings *timings)
754 {
755 	struct rvin_dev *vin = video_drvdata(file);
756 	struct v4l2_subdev *sd = vin_to_source(vin);
757 
758 	return v4l2_subdev_call(sd, pad, query_dv_timings,
759 				vin->parallel.sink_pad, timings);
760 }
761 
rvin_dv_timings_cap(struct file * file,void * priv_fh,struct v4l2_dv_timings_cap * cap)762 static int rvin_dv_timings_cap(struct file *file, void *priv_fh,
763 			       struct v4l2_dv_timings_cap *cap)
764 {
765 	struct rvin_dev *vin = video_drvdata(file);
766 	struct v4l2_subdev *sd = vin_to_source(vin);
767 	int ret;
768 
769 	if (cap->pad)
770 		return -EINVAL;
771 
772 	cap->pad = vin->parallel.sink_pad;
773 
774 	ret = v4l2_subdev_call(sd, pad, dv_timings_cap, cap);
775 
776 	cap->pad = 0;
777 
778 	return ret;
779 }
780 
rvin_g_edid(struct file * file,void * fh,struct v4l2_edid * edid)781 static int rvin_g_edid(struct file *file, void *fh, struct v4l2_edid *edid)
782 {
783 	struct rvin_dev *vin = video_drvdata(file);
784 	struct v4l2_subdev *sd = vin_to_source(vin);
785 	int ret;
786 
787 	if (edid->pad)
788 		return -EINVAL;
789 
790 	edid->pad = vin->parallel.sink_pad;
791 
792 	ret = v4l2_subdev_call(sd, pad, get_edid, edid);
793 
794 	edid->pad = 0;
795 
796 	return ret;
797 }
798 
rvin_s_edid(struct file * file,void * fh,struct v4l2_edid * edid)799 static int rvin_s_edid(struct file *file, void *fh, struct v4l2_edid *edid)
800 {
801 	struct rvin_dev *vin = video_drvdata(file);
802 	struct v4l2_subdev *sd = vin_to_source(vin);
803 	int ret;
804 
805 	if (edid->pad)
806 		return -EINVAL;
807 
808 	edid->pad = vin->parallel.sink_pad;
809 
810 	ret = v4l2_subdev_call(sd, pad, set_edid, edid);
811 
812 	edid->pad = 0;
813 
814 	return ret;
815 }
816 
817 static const struct v4l2_ioctl_ops rvin_ioctl_ops = {
818 	.vidioc_querycap		= rvin_querycap,
819 	.vidioc_try_fmt_vid_cap		= rvin_try_fmt_vid_cap,
820 	.vidioc_g_fmt_vid_cap		= rvin_g_fmt_vid_cap,
821 	.vidioc_s_fmt_vid_cap		= rvin_s_fmt_vid_cap,
822 	.vidioc_enum_fmt_vid_cap	= rvin_enum_fmt_vid_cap,
823 
824 	.vidioc_g_selection		= rvin_g_selection,
825 	.vidioc_s_selection		= rvin_s_selection,
826 
827 	.vidioc_g_parm			= rvin_g_parm,
828 	.vidioc_s_parm			= rvin_s_parm,
829 
830 	.vidioc_g_pixelaspect		= rvin_g_pixelaspect,
831 
832 	.vidioc_enum_input		= rvin_enum_input,
833 	.vidioc_g_input			= rvin_g_input,
834 	.vidioc_s_input			= rvin_s_input,
835 
836 	.vidioc_dv_timings_cap		= rvin_dv_timings_cap,
837 	.vidioc_enum_dv_timings		= rvin_enum_dv_timings,
838 	.vidioc_g_dv_timings		= rvin_g_dv_timings,
839 	.vidioc_s_dv_timings		= rvin_s_dv_timings,
840 	.vidioc_query_dv_timings	= rvin_query_dv_timings,
841 
842 	.vidioc_g_edid			= rvin_g_edid,
843 	.vidioc_s_edid			= rvin_s_edid,
844 
845 	.vidioc_querystd		= rvin_querystd,
846 	.vidioc_g_std			= rvin_g_std,
847 	.vidioc_s_std			= rvin_s_std,
848 
849 	.vidioc_reqbufs			= vb2_ioctl_reqbufs,
850 	.vidioc_create_bufs		= vb2_ioctl_create_bufs,
851 	.vidioc_querybuf		= vb2_ioctl_querybuf,
852 	.vidioc_qbuf			= vb2_ioctl_qbuf,
853 	.vidioc_dqbuf			= vb2_ioctl_dqbuf,
854 	.vidioc_expbuf			= vb2_ioctl_expbuf,
855 	.vidioc_prepare_buf		= vb2_ioctl_prepare_buf,
856 	.vidioc_streamon		= vb2_ioctl_streamon,
857 	.vidioc_streamoff		= vb2_ioctl_streamoff,
858 
859 	.vidioc_log_status		= v4l2_ctrl_log_status,
860 	.vidioc_subscribe_event		= rvin_subscribe_event,
861 	.vidioc_unsubscribe_event	= v4l2_event_unsubscribe,
862 };
863 
864 /* -----------------------------------------------------------------------------
865  * V4L2 Media Controller
866  */
867 
rvin_mc_try_format(struct rvin_dev * vin,struct v4l2_pix_format * pix)868 static void rvin_mc_try_format(struct rvin_dev *vin,
869 			       struct v4l2_pix_format *pix)
870 {
871 	/*
872 	 * The V4L2 specification clearly documents the colorspace fields
873 	 * as being set by drivers for capture devices. Using the values
874 	 * supplied by userspace thus wouldn't comply with the API. Until
875 	 * the API is updated force fixed values.
876 	 */
877 	pix->colorspace = RVIN_DEFAULT_COLORSPACE;
878 	pix->xfer_func = V4L2_MAP_XFER_FUNC_DEFAULT(pix->colorspace);
879 	pix->ycbcr_enc = V4L2_MAP_YCBCR_ENC_DEFAULT(pix->colorspace);
880 	pix->quantization = V4L2_MAP_QUANTIZATION_DEFAULT(true, pix->colorspace,
881 							  pix->ycbcr_enc);
882 
883 	rvin_format_align(vin, pix);
884 }
885 
rvin_mc_try_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)886 static int rvin_mc_try_fmt_vid_cap(struct file *file, void *priv,
887 				   struct v4l2_format *f)
888 {
889 	struct rvin_dev *vin = video_drvdata(file);
890 
891 	rvin_mc_try_format(vin, &f->fmt.pix);
892 
893 	return 0;
894 }
895 
rvin_mc_s_fmt_vid_cap(struct file * file,void * priv,struct v4l2_format * f)896 static int rvin_mc_s_fmt_vid_cap(struct file *file, void *priv,
897 				 struct v4l2_format *f)
898 {
899 	struct rvin_dev *vin = video_drvdata(file);
900 
901 	if (vb2_is_busy(&vin->queue))
902 		return -EBUSY;
903 
904 	rvin_mc_try_format(vin, &f->fmt.pix);
905 
906 	vin->format = f->fmt.pix;
907 
908 	vin->crop.top = 0;
909 	vin->crop.left = 0;
910 	vin->crop.width = vin->format.width;
911 	vin->crop.height = vin->format.height;
912 	vin->compose = vin->crop;
913 
914 	return 0;
915 }
916 
917 static const struct v4l2_ioctl_ops rvin_mc_ioctl_ops = {
918 	.vidioc_querycap		= rvin_querycap,
919 	.vidioc_try_fmt_vid_cap		= rvin_mc_try_fmt_vid_cap,
920 	.vidioc_g_fmt_vid_cap		= rvin_g_fmt_vid_cap,
921 	.vidioc_s_fmt_vid_cap		= rvin_mc_s_fmt_vid_cap,
922 	.vidioc_enum_fmt_vid_cap	= rvin_enum_fmt_vid_cap,
923 
924 	.vidioc_g_selection		= rvin_g_selection,
925 	.vidioc_s_selection		= rvin_s_selection,
926 
927 	.vidioc_reqbufs			= vb2_ioctl_reqbufs,
928 	.vidioc_create_bufs		= vb2_ioctl_create_bufs,
929 	.vidioc_querybuf		= vb2_ioctl_querybuf,
930 	.vidioc_qbuf			= vb2_ioctl_qbuf,
931 	.vidioc_dqbuf			= vb2_ioctl_dqbuf,
932 	.vidioc_expbuf			= vb2_ioctl_expbuf,
933 	.vidioc_prepare_buf		= vb2_ioctl_prepare_buf,
934 	.vidioc_streamon		= vb2_ioctl_streamon,
935 	.vidioc_streamoff		= vb2_ioctl_streamoff,
936 
937 	.vidioc_log_status		= v4l2_ctrl_log_status,
938 	.vidioc_subscribe_event		= rvin_subscribe_event,
939 	.vidioc_unsubscribe_event	= v4l2_event_unsubscribe,
940 };
941 
942 /* -----------------------------------------------------------------------------
943  * File Operations
944  */
945 
rvin_power_parallel(struct rvin_dev * vin,bool on)946 static int rvin_power_parallel(struct rvin_dev *vin, bool on)
947 {
948 	struct v4l2_subdev *sd = vin_to_source(vin);
949 	int power = on ? 1 : 0;
950 	int ret;
951 
952 	ret = v4l2_subdev_call(sd, core, s_power, power);
953 	if (ret < 0 && ret != -ENOIOCTLCMD && ret != -ENODEV)
954 		return ret;
955 
956 	return 0;
957 }
958 
rvin_open(struct file * file)959 static int rvin_open(struct file *file)
960 {
961 	struct rvin_dev *vin = video_drvdata(file);
962 	int ret;
963 
964 	ret = pm_runtime_resume_and_get(vin->dev);
965 	if (ret < 0)
966 		return ret;
967 
968 	ret = mutex_lock_interruptible(&vin->lock);
969 	if (ret)
970 		goto err_pm;
971 
972 	file->private_data = vin;
973 
974 	ret = v4l2_fh_open(file);
975 	if (ret)
976 		goto err_unlock;
977 
978 	if (vin->info->use_mc)
979 		ret = v4l2_pipeline_pm_get(&vin->vdev.entity);
980 	else if (v4l2_fh_is_singular_file(file))
981 		ret = rvin_power_parallel(vin, true);
982 
983 	if (ret < 0)
984 		goto err_open;
985 
986 	ret = v4l2_ctrl_handler_setup(&vin->ctrl_handler);
987 	if (ret)
988 		goto err_power;
989 
990 	mutex_unlock(&vin->lock);
991 
992 	return 0;
993 err_power:
994 	if (vin->info->use_mc)
995 		v4l2_pipeline_pm_put(&vin->vdev.entity);
996 	else if (v4l2_fh_is_singular_file(file))
997 		rvin_power_parallel(vin, false);
998 err_open:
999 	v4l2_fh_release(file);
1000 err_unlock:
1001 	mutex_unlock(&vin->lock);
1002 err_pm:
1003 	pm_runtime_put(vin->dev);
1004 
1005 	return ret;
1006 }
1007 
rvin_release(struct file * file)1008 static int rvin_release(struct file *file)
1009 {
1010 	struct rvin_dev *vin = video_drvdata(file);
1011 	bool fh_singular;
1012 	int ret;
1013 
1014 	mutex_lock(&vin->lock);
1015 
1016 	/* Save the singular status before we call the clean-up helper */
1017 	fh_singular = v4l2_fh_is_singular_file(file);
1018 
1019 	/* the release helper will cleanup any on-going streaming */
1020 	ret = _vb2_fop_release(file, NULL);
1021 
1022 	if (vin->info->use_mc) {
1023 		v4l2_pipeline_pm_put(&vin->vdev.entity);
1024 	} else {
1025 		if (fh_singular)
1026 			rvin_power_parallel(vin, false);
1027 	}
1028 
1029 	mutex_unlock(&vin->lock);
1030 
1031 	pm_runtime_put(vin->dev);
1032 
1033 	return ret;
1034 }
1035 
1036 static const struct v4l2_file_operations rvin_fops = {
1037 	.owner		= THIS_MODULE,
1038 	.unlocked_ioctl	= video_ioctl2,
1039 	.open		= rvin_open,
1040 	.release	= rvin_release,
1041 	.poll		= vb2_fop_poll,
1042 	.mmap		= vb2_fop_mmap,
1043 	.read		= vb2_fop_read,
1044 };
1045 
rvin_v4l2_unregister(struct rvin_dev * vin)1046 void rvin_v4l2_unregister(struct rvin_dev *vin)
1047 {
1048 	if (!video_is_registered(&vin->vdev))
1049 		return;
1050 
1051 	v4l2_info(&vin->v4l2_dev, "Removing %s\n",
1052 		  video_device_node_name(&vin->vdev));
1053 
1054 	/* Checks internally if vdev have been init or not */
1055 	video_unregister_device(&vin->vdev);
1056 }
1057 
rvin_notify_video_device(struct rvin_dev * vin,unsigned int notification,void * arg)1058 static void rvin_notify_video_device(struct rvin_dev *vin,
1059 				     unsigned int notification, void *arg)
1060 {
1061 	switch (notification) {
1062 	case V4L2_DEVICE_NOTIFY_EVENT:
1063 		v4l2_event_queue(&vin->vdev, arg);
1064 		break;
1065 	default:
1066 		break;
1067 	}
1068 }
1069 
rvin_notify(struct v4l2_subdev * sd,unsigned int notification,void * arg)1070 static void rvin_notify(struct v4l2_subdev *sd,
1071 			unsigned int notification, void *arg)
1072 {
1073 	struct v4l2_subdev *remote;
1074 	struct rvin_group *group;
1075 	struct media_pad *pad;
1076 	struct rvin_dev *vin =
1077 		container_of(sd->v4l2_dev, struct rvin_dev, v4l2_dev);
1078 	unsigned int i;
1079 
1080 	/* If no media controller, no need to route the event. */
1081 	if (!vin->info->use_mc) {
1082 		rvin_notify_video_device(vin, notification, arg);
1083 		return;
1084 	}
1085 
1086 	group = vin->group;
1087 
1088 	for (i = 0; i < RCAR_VIN_NUM; i++) {
1089 		vin = group->vin[i];
1090 		if (!vin)
1091 			continue;
1092 
1093 		pad = media_pad_remote_pad_first(&vin->pad);
1094 		if (!pad)
1095 			continue;
1096 
1097 		remote = media_entity_to_v4l2_subdev(pad->entity);
1098 		if (remote != sd)
1099 			continue;
1100 
1101 		rvin_notify_video_device(vin, notification, arg);
1102 	}
1103 }
1104 
rvin_v4l2_register(struct rvin_dev * vin)1105 int rvin_v4l2_register(struct rvin_dev *vin)
1106 {
1107 	struct video_device *vdev = &vin->vdev;
1108 	int ret;
1109 
1110 	vin->v4l2_dev.notify = rvin_notify;
1111 
1112 	/* video node */
1113 	vdev->v4l2_dev = &vin->v4l2_dev;
1114 	vdev->queue = &vin->queue;
1115 	snprintf(vdev->name, sizeof(vdev->name), "VIN%u output", vin->id);
1116 	vdev->release = video_device_release_empty;
1117 	vdev->lock = &vin->lock;
1118 	vdev->fops = &rvin_fops;
1119 	vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
1120 		V4L2_CAP_READWRITE;
1121 
1122 	/* Set a default format */
1123 	vin->format.pixelformat	= RVIN_DEFAULT_FORMAT;
1124 	vin->format.width = RVIN_DEFAULT_WIDTH;
1125 	vin->format.height = RVIN_DEFAULT_HEIGHT;
1126 	vin->format.field = RVIN_DEFAULT_FIELD;
1127 	vin->format.colorspace = RVIN_DEFAULT_COLORSPACE;
1128 
1129 	if (vin->info->use_mc) {
1130 		vdev->device_caps |= V4L2_CAP_IO_MC;
1131 		vdev->ioctl_ops = &rvin_mc_ioctl_ops;
1132 	} else {
1133 		vdev->ioctl_ops = &rvin_ioctl_ops;
1134 		rvin_reset_format(vin);
1135 	}
1136 
1137 	rvin_format_align(vin, &vin->format);
1138 
1139 	ret = video_register_device(&vin->vdev, VFL_TYPE_VIDEO, -1);
1140 	if (ret) {
1141 		vin_err(vin, "Failed to register video device\n");
1142 		return ret;
1143 	}
1144 
1145 	video_set_drvdata(&vin->vdev, vin);
1146 
1147 	v4l2_info(&vin->v4l2_dev, "Device registered as %s\n",
1148 		  video_device_node_name(&vin->vdev));
1149 
1150 	return ret;
1151 }
1152