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