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