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