?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/rockchip: Don't change hdmi reference clock rate
[drm/drm-misc.git] / drivers / media / usb / go7007 / go7007-v4l2.c
blob2087ffcb85a5a6d1f89b66a81d65f01772758c9f
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) 2005-2006 Micronas USA Inc.
4 */
5
6 #include <linux/module.h>
7 #include <linux/delay.h>
8 #include <linux/sched.h>
9 #include <linux/spinlock.h>
10 #include <linux/slab.h>
11 #include <linux/fs.h>
12 #include <linux/unistd.h>
13 #include <linux/time.h>
14 #include <linux/vmalloc.h>
15 #include <linux/pagemap.h>
16 #include <linux/i2c.h>
17 #include <linux/mutex.h>
18 #include <linux/uaccess.h>
19 #include <linux/videodev2.h>
20 #include <media/v4l2-common.h>
21 #include <media/v4l2-ioctl.h>
22 #include <media/v4l2-subdev.h>
23 #include <media/v4l2-event.h>
24 #include <media/videobuf2-vmalloc.h>
25 #include <media/i2c/saa7115.h>
26
27 #include "go7007-priv.h"
28
29 #define call_all(dev, o, f, args...) \
30 v4l2_device_call_until_err(dev, 0, o, f, ##args)
31
32 static bool valid_pixelformat(u32 pixelformat)
33 {
34 switch (pixelformat) {
35 case V4L2_PIX_FMT_MJPEG:
36 case V4L2_PIX_FMT_MPEG1:
37 case V4L2_PIX_FMT_MPEG2:
38 case V4L2_PIX_FMT_MPEG4:
39 return true;
40 default:
41 return false;
42 }
43 }
44
45 static u32 get_frame_type_flag(struct go7007_buffer *vb, int format)
46 {
47 u8 *ptr = vb2_plane_vaddr(&vb->vb.vb2_buf, 0);
48
49 switch (format) {
50 case V4L2_PIX_FMT_MJPEG:
51 return V4L2_BUF_FLAG_KEYFRAME;
52 case V4L2_PIX_FMT_MPEG4:
53 switch ((ptr[vb->frame_offset + 4] >> 6) & 0x3) {
54 case 0:
55 return V4L2_BUF_FLAG_KEYFRAME;
56 case 1:
57 return V4L2_BUF_FLAG_PFRAME;
58 case 2:
59 return V4L2_BUF_FLAG_BFRAME;
60 default:
61 return 0;
62 }
63 case V4L2_PIX_FMT_MPEG1:
64 case V4L2_PIX_FMT_MPEG2:
65 switch ((ptr[vb->frame_offset + 5] >> 3) & 0x7) {
66 case 1:
67 return V4L2_BUF_FLAG_KEYFRAME;
68 case 2:
69 return V4L2_BUF_FLAG_PFRAME;
70 case 3:
71 return V4L2_BUF_FLAG_BFRAME;
72 default:
73 return 0;
74 }
75 }
76
77 return 0;
78 }
79
80 static void get_resolution(struct go7007 *go, int *width, int *height)
81 {
82 switch (go->standard) {
83 case GO7007_STD_NTSC:
84 *width = 720;
85 *height = 480;
86 break;
87 case GO7007_STD_PAL:
88 *width = 720;
89 *height = 576;
90 break;
91 case GO7007_STD_OTHER:
92 default:
93 *width = go->board_info->sensor_width;
94 *height = go->board_info->sensor_height;
95 break;
96 }
97 }
98
99 static void set_formatting(struct go7007 *go)
100 {
101 if (go->format == V4L2_PIX_FMT_MJPEG) {
102 go->pali = 0;
103 go->aspect_ratio = GO7007_RATIO_1_1;
104 go->gop_size = 0;
105 go->ipb = 0;
106 go->closed_gop = 0;
107 go->repeat_seqhead = 0;
108 go->seq_header_enable = 0;
109 go->gop_header_enable = 0;
110 go->dvd_mode = 0;
111 return;
112 }
113
114 switch (go->format) {
115 case V4L2_PIX_FMT_MPEG1:
116 go->pali = 0;
117 break;
118 default:
119 case V4L2_PIX_FMT_MPEG2:
120 go->pali = 0x48;
121 break;
122 case V4L2_PIX_FMT_MPEG4:
123 /* For future reference: this is the list of MPEG4
124 * profiles that are available, although they are
125 * untested:
126 *
127 * Profile pali
128 * -------------- ----
129 * PROFILE_S_L0 0x08
130 * PROFILE_S_L1 0x01
131 * PROFILE_S_L2 0x02
132 * PROFILE_S_L3 0x03
133 * PROFILE_ARTS_L1 0x91
134 * PROFILE_ARTS_L2 0x92
135 * PROFILE_ARTS_L3 0x93
136 * PROFILE_ARTS_L4 0x94
137 * PROFILE_AS_L0 0xf0
138 * PROFILE_AS_L1 0xf1
139 * PROFILE_AS_L2 0xf2
140 * PROFILE_AS_L3 0xf3
141 * PROFILE_AS_L4 0xf4
142 * PROFILE_AS_L5 0xf5
143 */
144 go->pali = 0xf5;
145 break;
146 }
147 go->gop_size = v4l2_ctrl_g_ctrl(go->mpeg_video_gop_size);
148 go->closed_gop = v4l2_ctrl_g_ctrl(go->mpeg_video_gop_closure);
149 go->ipb = v4l2_ctrl_g_ctrl(go->mpeg_video_b_frames) != 0;
150 go->bitrate = v4l2_ctrl_g_ctrl(go->mpeg_video_bitrate);
151 go->repeat_seqhead = v4l2_ctrl_g_ctrl(go->mpeg_video_rep_seqheader);
152 go->gop_header_enable = 1;
153 go->dvd_mode = 0;
154 if (go->format == V4L2_PIX_FMT_MPEG2)
155 go->dvd_mode =
156 go->bitrate == 9800000 &&
157 go->gop_size == 15 &&
158 go->ipb == 0 &&
159 go->repeat_seqhead == 1 &&
160 go->closed_gop;
161
162 switch (v4l2_ctrl_g_ctrl(go->mpeg_video_aspect_ratio)) {
163 default:
164 case V4L2_MPEG_VIDEO_ASPECT_1x1:
165 go->aspect_ratio = GO7007_RATIO_1_1;
166 break;
167 case V4L2_MPEG_VIDEO_ASPECT_4x3:
168 go->aspect_ratio = GO7007_RATIO_4_3;
169 break;
170 case V4L2_MPEG_VIDEO_ASPECT_16x9:
171 go->aspect_ratio = GO7007_RATIO_16_9;
172 break;
173 }
174 }
175
176 static int set_capture_size(struct go7007 *go, struct v4l2_format *fmt, int try)
177 {
178 int sensor_height = 0, sensor_width = 0;
179 int width, height;
180
181 if (fmt != NULL && !valid_pixelformat(fmt->fmt.pix.pixelformat))
182 return -EINVAL;
183
184 get_resolution(go, &sensor_width, &sensor_height);
185
186 if (fmt == NULL) {
187 width = sensor_width;
188 height = sensor_height;
189 } else if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING) {
190 if (fmt->fmt.pix.width > sensor_width)
191 width = sensor_width;
192 else if (fmt->fmt.pix.width < 144)
193 width = 144;
194 else
195 width = fmt->fmt.pix.width & ~0x0f;
196
197 if (fmt->fmt.pix.height > sensor_height)
198 height = sensor_height;
199 else if (fmt->fmt.pix.height < 96)
200 height = 96;
201 else
202 height = fmt->fmt.pix.height & ~0x0f;
203 } else {
204 width = fmt->fmt.pix.width;
205
206 if (width <= sensor_width / 4) {
207 width = sensor_width / 4;
208 height = sensor_height / 4;
209 } else if (width <= sensor_width / 2) {
210 width = sensor_width / 2;
211 height = sensor_height / 2;
212 } else {
213 width = sensor_width;
214 height = sensor_height;
215 }
216 width &= ~0xf;
217 height &= ~0xf;
218 }
219
220 if (fmt != NULL) {
221 u32 pixelformat = fmt->fmt.pix.pixelformat;
222
223 memset(fmt, 0, sizeof(*fmt));
224 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
225 fmt->fmt.pix.width = width;
226 fmt->fmt.pix.height = height;
227 fmt->fmt.pix.pixelformat = pixelformat;
228 fmt->fmt.pix.field = V4L2_FIELD_NONE;
229 fmt->fmt.pix.bytesperline = 0;
230 fmt->fmt.pix.sizeimage = GO7007_BUF_SIZE;
231 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
232 }
233
234 if (try)
235 return 0;
236
237 if (fmt)
238 go->format = fmt->fmt.pix.pixelformat;
239 go->width = width;
240 go->height = height;
241 go->encoder_h_offset = go->board_info->sensor_h_offset;
242 go->encoder_v_offset = go->board_info->sensor_v_offset;
243
244 if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING) {
245 struct v4l2_subdev_format format = {
246 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
247 };
248
249 format.format.code = MEDIA_BUS_FMT_FIXED;
250 format.format.width = fmt ? fmt->fmt.pix.width : width;
251 format.format.height = height;
252 go->encoder_h_halve = 0;
253 go->encoder_v_halve = 0;
254 go->encoder_subsample = 0;
255 call_all(&go->v4l2_dev, pad, set_fmt, NULL, &format);
256 } else {
257 if (width <= sensor_width / 4) {
258 go->encoder_h_halve = 1;
259 go->encoder_v_halve = 1;
260 go->encoder_subsample = 1;
261 } else if (width <= sensor_width / 2) {
262 go->encoder_h_halve = 1;
263 go->encoder_v_halve = 1;
264 go->encoder_subsample = 0;
265 } else {
266 go->encoder_h_halve = 0;
267 go->encoder_v_halve = 0;
268 go->encoder_subsample = 0;
269 }
270 }
271 return 0;
272 }
273
274 static int vidioc_querycap(struct file *file, void *priv,
275 struct v4l2_capability *cap)
276 {
277 struct go7007 *go = video_drvdata(file);
278
279 strscpy(cap->driver, "go7007", sizeof(cap->driver));
280 strscpy(cap->card, go->name, sizeof(cap->card));
281 strscpy(cap->bus_info, go->bus_info, sizeof(cap->bus_info));
282 return 0;
283 }
284
285 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
286 struct v4l2_fmtdesc *fmt)
287 {
288 switch (fmt->index) {
289 case 0:
290 fmt->pixelformat = V4L2_PIX_FMT_MJPEG;
291 break;
292 case 1:
293 fmt->pixelformat = V4L2_PIX_FMT_MPEG1;
294 break;
295 case 2:
296 fmt->pixelformat = V4L2_PIX_FMT_MPEG2;
297 break;
298 case 3:
299 fmt->pixelformat = V4L2_PIX_FMT_MPEG4;
300 break;
301 default:
302 return -EINVAL;
303 }
304 return 0;
305 }
306
307 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
308 struct v4l2_format *fmt)
309 {
310 struct go7007 *go = video_drvdata(file);
311
312 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
313 fmt->fmt.pix.width = go->width;
314 fmt->fmt.pix.height = go->height;
315 fmt->fmt.pix.pixelformat = go->format;
316 fmt->fmt.pix.field = V4L2_FIELD_NONE;
317 fmt->fmt.pix.bytesperline = 0;
318 fmt->fmt.pix.sizeimage = GO7007_BUF_SIZE;
319 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
320
321 return 0;
322 }
323
324 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
325 struct v4l2_format *fmt)
326 {
327 struct go7007 *go = video_drvdata(file);
328
329 return set_capture_size(go, fmt, 1);
330 }
331
332 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
333 struct v4l2_format *fmt)
334 {
335 struct go7007 *go = video_drvdata(file);
336
337 if (vb2_is_busy(&go->vidq))
338 return -EBUSY;
339
340 return set_capture_size(go, fmt, 0);
341 }
342
343 static int go7007_queue_setup(struct vb2_queue *q,
344 unsigned int *num_buffers, unsigned int *num_planes,
345 unsigned int sizes[], struct device *alloc_devs[])
346 {
347 sizes[0] = GO7007_BUF_SIZE;
348 *num_planes = 1;
349
350 if (*num_buffers < 2)
351 *num_buffers = 2;
352
353 return 0;
354 }
355
356 static void go7007_buf_queue(struct vb2_buffer *vb)
357 {
358 struct vb2_queue *vq = vb->vb2_queue;
359 struct go7007 *go = vb2_get_drv_priv(vq);
360 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
361 struct go7007_buffer *go7007_vb =
362 container_of(vbuf, struct go7007_buffer, vb);
363 unsigned long flags;
364
365 spin_lock_irqsave(&go->spinlock, flags);
366 list_add_tail(&go7007_vb->list, &go->vidq_active);
367 spin_unlock_irqrestore(&go->spinlock, flags);
368 }
369
370 static int go7007_buf_prepare(struct vb2_buffer *vb)
371 {
372 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
373 struct go7007_buffer *go7007_vb =
374 container_of(vbuf, struct go7007_buffer, vb);
375
376 go7007_vb->modet_active = 0;
377 go7007_vb->frame_offset = 0;
378 vb->planes[0].bytesused = 0;
379 return 0;
380 }
381
382 static void go7007_buf_finish(struct vb2_buffer *vb)
383 {
384 struct vb2_queue *vq = vb->vb2_queue;
385 struct go7007 *go = vb2_get_drv_priv(vq);
386 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
387 struct go7007_buffer *go7007_vb =
388 container_of(vbuf, struct go7007_buffer, vb);
389 u32 frame_type_flag = get_frame_type_flag(go7007_vb, go->format);
390
391 vbuf->flags &= ~(V4L2_BUF_FLAG_KEYFRAME | V4L2_BUF_FLAG_BFRAME |
392 V4L2_BUF_FLAG_PFRAME);
393 vbuf->flags |= frame_type_flag;
394 vbuf->field = V4L2_FIELD_NONE;
395 }
396
397 static int go7007_start_streaming(struct vb2_queue *q, unsigned int count)
398 {
399 struct go7007 *go = vb2_get_drv_priv(q);
400 int ret;
401
402 set_formatting(go);
403 mutex_lock(&go->hw_lock);
404 go->next_seq = 0;
405 go->active_buf = NULL;
406 go->modet_event_status = 0;
407 if (go7007_start_encoder(go) < 0)
408 ret = -EIO;
409 else
410 ret = 0;
411 mutex_unlock(&go->hw_lock);
412 if (ret)
413 return ret;
414 call_all(&go->v4l2_dev, video, s_stream, 1);
415 v4l2_ctrl_grab(go->mpeg_video_gop_size, true);
416 v4l2_ctrl_grab(go->mpeg_video_gop_closure, true);
417 v4l2_ctrl_grab(go->mpeg_video_bitrate, true);
418 v4l2_ctrl_grab(go->mpeg_video_aspect_ratio, true);
419 /* Turn on Capture LED */
420 if (go->board_id == GO7007_BOARDID_ADS_USBAV_709)
421 go7007_write_addr(go, 0x3c82, 0x0005);
422 return ret;
423 }
424
425 static void go7007_stop_streaming(struct vb2_queue *q)
426 {
427 struct go7007 *go = vb2_get_drv_priv(q);
428 unsigned long flags;
429
430 go7007_stream_stop(go);
431 mutex_lock(&go->hw_lock);
432 go7007_reset_encoder(go);
433 mutex_unlock(&go->hw_lock);
434 call_all(&go->v4l2_dev, video, s_stream, 0);
435
436 spin_lock_irqsave(&go->spinlock, flags);
437 INIT_LIST_HEAD(&go->vidq_active);
438 spin_unlock_irqrestore(&go->spinlock, flags);
439 v4l2_ctrl_grab(go->mpeg_video_gop_size, false);
440 v4l2_ctrl_grab(go->mpeg_video_gop_closure, false);
441 v4l2_ctrl_grab(go->mpeg_video_bitrate, false);
442 v4l2_ctrl_grab(go->mpeg_video_aspect_ratio, false);
443 /* Turn on Capture LED */
444 if (go->board_id == GO7007_BOARDID_ADS_USBAV_709)
445 go7007_write_addr(go, 0x3c82, 0x000d);
446 }
447
448 static const struct vb2_ops go7007_video_qops = {
449 .queue_setup = go7007_queue_setup,
450 .buf_queue = go7007_buf_queue,
451 .buf_prepare = go7007_buf_prepare,
452 .buf_finish = go7007_buf_finish,
453 .start_streaming = go7007_start_streaming,
454 .stop_streaming = go7007_stop_streaming,
455 };
456
457 static int vidioc_g_parm(struct file *filp, void *priv,
458 struct v4l2_streamparm *parm)
459 {
460 struct go7007 *go = video_drvdata(filp);
461 struct v4l2_fract timeperframe = {
462 .numerator = 1001 * go->fps_scale,
463 .denominator = go->sensor_framerate,
464 };
465
466 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
467 return -EINVAL;
468
469 parm->parm.capture.readbuffers = 2;
470 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
471 parm->parm.capture.timeperframe = timeperframe;
472
473 return 0;
474 }
475
476 static int vidioc_s_parm(struct file *filp, void *priv,
477 struct v4l2_streamparm *parm)
478 {
479 struct go7007 *go = video_drvdata(filp);
480 unsigned int n, d;
481
482 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
483 return -EINVAL;
484
485 n = go->sensor_framerate *
486 parm->parm.capture.timeperframe.numerator;
487 d = 1001 * parm->parm.capture.timeperframe.denominator;
488 if (n != 0 && d != 0 && n > d)
489 go->fps_scale = (n + d/2) / d;
490 else
491 go->fps_scale = 1;
492
493 return vidioc_g_parm(filp, priv, parm);
494 }
495
496 /* VIDIOC_ENUMSTD on go7007 were used for enumerating the supported fps and
497 its resolution, when the device is not connected to TV.
498 This is were an API abuse, probably used by the lack of specific IOCTL's to
499 enumerate it, by the time the driver was written.
500
501 However, since kernel 2.6.19, two new ioctls (VIDIOC_ENUM_FRAMEINTERVALS
502 and VIDIOC_ENUM_FRAMESIZES) were added for this purpose.
503
504 The two functions below implement the newer ioctls
505 */
506 static int vidioc_enum_framesizes(struct file *filp, void *priv,
507 struct v4l2_frmsizeenum *fsize)
508 {
509 struct go7007 *go = video_drvdata(filp);
510 int width, height;
511
512 if (fsize->index > 2)
513 return -EINVAL;
514
515 if (!valid_pixelformat(fsize->pixel_format))
516 return -EINVAL;
517
518 get_resolution(go, &width, &height);
519 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
520 fsize->discrete.width = (width >> fsize->index) & ~0xf;
521 fsize->discrete.height = (height >> fsize->index) & ~0xf;
522 return 0;
523 }
524
525 static int vidioc_enum_frameintervals(struct file *filp, void *priv,
526 struct v4l2_frmivalenum *fival)
527 {
528 struct go7007 *go = video_drvdata(filp);
529 int width, height;
530 int i;
531
532 if (fival->index > 4)
533 return -EINVAL;
534
535 if (!valid_pixelformat(fival->pixel_format))
536 return -EINVAL;
537
538 if (!(go->board_info->sensor_flags & GO7007_SENSOR_SCALING)) {
539 get_resolution(go, &width, &height);
540 for (i = 0; i <= 2; i++)
541 if (fival->width == ((width >> i) & ~0xf) &&
542 fival->height == ((height >> i) & ~0xf))
543 break;
544 if (i > 2)
545 return -EINVAL;
546 }
547 fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
548 fival->discrete.numerator = 1001 * (fival->index + 1);
549 fival->discrete.denominator = go->sensor_framerate;
550 return 0;
551 }
552
553 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *std)
554 {
555 struct go7007 *go = video_drvdata(file);
556
557 *std = go->std;
558 return 0;
559 }
560
561 static int go7007_s_std(struct go7007 *go)
562 {
563 if (go->std & V4L2_STD_625_50) {
564 go->standard = GO7007_STD_PAL;
565 go->sensor_framerate = 25025;
566 } else {
567 go->standard = GO7007_STD_NTSC;
568 go->sensor_framerate = 30000;
569 }
570
571 call_all(&go->v4l2_dev, video, s_std, go->std);
572 set_capture_size(go, NULL, 0);
573 return 0;
574 }
575
576 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id std)
577 {
578 struct go7007 *go = video_drvdata(file);
579
580 if (vb2_is_busy(&go->vidq))
581 return -EBUSY;
582
583 go->std = std;
584
585 return go7007_s_std(go);
586 }
587
588 static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *std)
589 {
590 struct go7007 *go = video_drvdata(file);
591
592 return call_all(&go->v4l2_dev, video, querystd, std);
593 }
594
595 static int vidioc_enum_input(struct file *file, void *priv,
596 struct v4l2_input *inp)
597 {
598 struct go7007 *go = video_drvdata(file);
599
600 if (inp->index >= go->board_info->num_inputs)
601 return -EINVAL;
602
603 strscpy(inp->name, go->board_info->inputs[inp->index].name,
604 sizeof(inp->name));
605
606 /* If this board has a tuner, it will be the first input */
607 if ((go->board_info->flags & GO7007_BOARD_HAS_TUNER) &&
608 inp->index == 0)
609 inp->type = V4L2_INPUT_TYPE_TUNER;
610 else
611 inp->type = V4L2_INPUT_TYPE_CAMERA;
612
613 if (go->board_info->num_aud_inputs)
614 inp->audioset = (1 << go->board_info->num_aud_inputs) - 1;
615 else
616 inp->audioset = 0;
617 inp->tuner = 0;
618 if (go->board_info->sensor_flags & GO7007_SENSOR_TV)
619 inp->std = video_devdata(file)->tvnorms;
620 else
621 inp->std = 0;
622
623 return 0;
624 }
625
626
627 static int vidioc_g_input(struct file *file, void *priv, unsigned int *input)
628 {
629 struct go7007 *go = video_drvdata(file);
630
631 *input = go->input;
632
633 return 0;
634 }
635
636 static int vidioc_enumaudio(struct file *file, void *fh, struct v4l2_audio *a)
637 {
638 struct go7007 *go = video_drvdata(file);
639
640 if (a->index >= go->board_info->num_aud_inputs)
641 return -EINVAL;
642 strscpy(a->name, go->board_info->aud_inputs[a->index].name,
643 sizeof(a->name));
644 a->capability = V4L2_AUDCAP_STEREO;
645 return 0;
646 }
647
648 static int vidioc_g_audio(struct file *file, void *fh, struct v4l2_audio *a)
649 {
650 struct go7007 *go = video_drvdata(file);
651
652 a->index = go->aud_input;
653 strscpy(a->name, go->board_info->aud_inputs[go->aud_input].name,
654 sizeof(a->name));
655 a->capability = V4L2_AUDCAP_STEREO;
656 return 0;
657 }
658
659 static int vidioc_s_audio(struct file *file, void *fh,
660 const struct v4l2_audio *a)
661 {
662 struct go7007 *go = video_drvdata(file);
663
664 if (a->index >= go->board_info->num_aud_inputs)
665 return -EINVAL;
666 go->aud_input = a->index;
667 v4l2_subdev_call(go->sd_audio, audio, s_routing,
668 go->board_info->aud_inputs[go->aud_input].audio_input, 0, 0);
669 return 0;
670 }
671
672 static void go7007_s_input(struct go7007 *go)
673 {
674 unsigned int input = go->input;
675
676 v4l2_subdev_call(go->sd_video, video, s_routing,
677 go->board_info->inputs[input].video_input, 0,
678 go->board_info->video_config);
679 if (go->board_info->num_aud_inputs) {
680 int aud_input = go->board_info->inputs[input].audio_index;
681
682 v4l2_subdev_call(go->sd_audio, audio, s_routing,
683 go->board_info->aud_inputs[aud_input].audio_input, 0, 0);
684 go->aud_input = aud_input;
685 }
686 }
687
688 static int vidioc_s_input(struct file *file, void *priv, unsigned int input)
689 {
690 struct go7007 *go = video_drvdata(file);
691
692 if (input >= go->board_info->num_inputs)
693 return -EINVAL;
694 if (vb2_is_busy(&go->vidq))
695 return -EBUSY;
696
697 go->input = input;
698 go7007_s_input(go);
699
700 return 0;
701 }
702
703 static int vidioc_g_tuner(struct file *file, void *priv,
704 struct v4l2_tuner *t)
705 {
706 struct go7007 *go = video_drvdata(file);
707
708 if (t->index != 0)
709 return -EINVAL;
710
711 strscpy(t->name, "Tuner", sizeof(t->name));
712 return call_all(&go->v4l2_dev, tuner, g_tuner, t);
713 }
714
715 static int vidioc_s_tuner(struct file *file, void *priv,
716 const struct v4l2_tuner *t)
717 {
718 struct go7007 *go = video_drvdata(file);
719
720 if (t->index != 0)
721 return -EINVAL;
722
723 return call_all(&go->v4l2_dev, tuner, s_tuner, t);
724 }
725
726 static int vidioc_g_frequency(struct file *file, void *priv,
727 struct v4l2_frequency *f)
728 {
729 struct go7007 *go = video_drvdata(file);
730
731 if (f->tuner)
732 return -EINVAL;
733
734 return call_all(&go->v4l2_dev, tuner, g_frequency, f);
735 }
736
737 static int vidioc_s_frequency(struct file *file, void *priv,
738 const struct v4l2_frequency *f)
739 {
740 struct go7007 *go = video_drvdata(file);
741
742 if (f->tuner)
743 return -EINVAL;
744
745 return call_all(&go->v4l2_dev, tuner, s_frequency, f);
746 }
747
748 static int vidioc_log_status(struct file *file, void *priv)
749 {
750 struct go7007 *go = video_drvdata(file);
751
752 v4l2_ctrl_log_status(file, priv);
753 return call_all(&go->v4l2_dev, core, log_status);
754 }
755
756 static int vidioc_subscribe_event(struct v4l2_fh *fh,
757 const struct v4l2_event_subscription *sub)
758 {
759
760 switch (sub->type) {
761 case V4L2_EVENT_MOTION_DET:
762 /* Allow for up to 30 events (1 second for NTSC) to be
763 * stored. */
764 return v4l2_event_subscribe(fh, sub, 30, NULL);
765 default:
766 return v4l2_ctrl_subscribe_event(fh, sub);
767 }
768 }
769
770
771 static int go7007_s_ctrl(struct v4l2_ctrl *ctrl)
772 {
773 struct go7007 *go =
774 container_of(ctrl->handler, struct go7007, hdl);
775 unsigned y;
776 u8 *mt;
777
778 switch (ctrl->id) {
779 case V4L2_CID_PIXEL_THRESHOLD0:
780 go->modet[0].pixel_threshold = ctrl->val;
781 break;
782 case V4L2_CID_MOTION_THRESHOLD0:
783 go->modet[0].motion_threshold = ctrl->val;
784 break;
785 case V4L2_CID_MB_THRESHOLD0:
786 go->modet[0].mb_threshold = ctrl->val;
787 break;
788 case V4L2_CID_PIXEL_THRESHOLD1:
789 go->modet[1].pixel_threshold = ctrl->val;
790 break;
791 case V4L2_CID_MOTION_THRESHOLD1:
792 go->modet[1].motion_threshold = ctrl->val;
793 break;
794 case V4L2_CID_MB_THRESHOLD1:
795 go->modet[1].mb_threshold = ctrl->val;
796 break;
797 case V4L2_CID_PIXEL_THRESHOLD2:
798 go->modet[2].pixel_threshold = ctrl->val;
799 break;
800 case V4L2_CID_MOTION_THRESHOLD2:
801 go->modet[2].motion_threshold = ctrl->val;
802 break;
803 case V4L2_CID_MB_THRESHOLD2:
804 go->modet[2].mb_threshold = ctrl->val;
805 break;
806 case V4L2_CID_PIXEL_THRESHOLD3:
807 go->modet[3].pixel_threshold = ctrl->val;
808 break;
809 case V4L2_CID_MOTION_THRESHOLD3:
810 go->modet[3].motion_threshold = ctrl->val;
811 break;
812 case V4L2_CID_MB_THRESHOLD3:
813 go->modet[3].mb_threshold = ctrl->val;
814 break;
815 case V4L2_CID_DETECT_MD_REGION_GRID:
816 mt = go->modet_map;
817 for (y = 0; y < go->height / 16; y++, mt += go->width / 16)
818 memcpy(mt, ctrl->p_new.p_u8 + y * (720 / 16), go->width / 16);
819 break;
820 default:
821 return -EINVAL;
822 }
823 return 0;
824 }
825
826 static const struct v4l2_file_operations go7007_fops = {
827 .owner = THIS_MODULE,
828 .open = v4l2_fh_open,
829 .release = vb2_fop_release,
830 .unlocked_ioctl = video_ioctl2,
831 .read = vb2_fop_read,
832 .mmap = vb2_fop_mmap,
833 .poll = vb2_fop_poll,
834 };
835
836 static const struct v4l2_ioctl_ops video_ioctl_ops = {
837 .vidioc_querycap = vidioc_querycap,
838 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
839 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
840 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
841 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
842 .vidioc_reqbufs = vb2_ioctl_reqbufs,
843 .vidioc_querybuf = vb2_ioctl_querybuf,
844 .vidioc_qbuf = vb2_ioctl_qbuf,
845 .vidioc_dqbuf = vb2_ioctl_dqbuf,
846 .vidioc_g_std = vidioc_g_std,
847 .vidioc_s_std = vidioc_s_std,
848 .vidioc_querystd = vidioc_querystd,
849 .vidioc_enum_input = vidioc_enum_input,
850 .vidioc_g_input = vidioc_g_input,
851 .vidioc_s_input = vidioc_s_input,
852 .vidioc_enumaudio = vidioc_enumaudio,
853 .vidioc_g_audio = vidioc_g_audio,
854 .vidioc_s_audio = vidioc_s_audio,
855 .vidioc_streamon = vb2_ioctl_streamon,
856 .vidioc_streamoff = vb2_ioctl_streamoff,
857 .vidioc_g_tuner = vidioc_g_tuner,
858 .vidioc_s_tuner = vidioc_s_tuner,
859 .vidioc_g_frequency = vidioc_g_frequency,
860 .vidioc_s_frequency = vidioc_s_frequency,
861 .vidioc_g_parm = vidioc_g_parm,
862 .vidioc_s_parm = vidioc_s_parm,
863 .vidioc_enum_framesizes = vidioc_enum_framesizes,
864 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
865 .vidioc_log_status = vidioc_log_status,
866 .vidioc_subscribe_event = vidioc_subscribe_event,
867 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
868 };
869
870 static const struct video_device go7007_template = {
871 .name = "go7007",
872 .fops = &go7007_fops,
873 .release = video_device_release_empty,
874 .ioctl_ops = &video_ioctl_ops,
875 .tvnorms = V4L2_STD_ALL,
876 };
877
878 static const struct v4l2_ctrl_ops go7007_ctrl_ops = {
879 .s_ctrl = go7007_s_ctrl,
880 };
881
882 static const struct v4l2_ctrl_config go7007_pixel_threshold0_ctrl = {
883 .ops = &go7007_ctrl_ops,
884 .id = V4L2_CID_PIXEL_THRESHOLD0,
885 .name = "Pixel Threshold Region 0",
886 .type = V4L2_CTRL_TYPE_INTEGER,
887 .def = 20,
888 .max = 32767,
889 .step = 1,
890 };
891
892 static const struct v4l2_ctrl_config go7007_motion_threshold0_ctrl = {
893 .ops = &go7007_ctrl_ops,
894 .id = V4L2_CID_MOTION_THRESHOLD0,
895 .name = "Motion Threshold Region 0",
896 .type = V4L2_CTRL_TYPE_INTEGER,
897 .def = 80,
898 .max = 32767,
899 .step = 1,
900 };
901
902 static const struct v4l2_ctrl_config go7007_mb_threshold0_ctrl = {
903 .ops = &go7007_ctrl_ops,
904 .id = V4L2_CID_MB_THRESHOLD0,
905 .name = "MB Threshold Region 0",
906 .type = V4L2_CTRL_TYPE_INTEGER,
907 .def = 200,
908 .max = 32767,
909 .step = 1,
910 };
911
912 static const struct v4l2_ctrl_config go7007_pixel_threshold1_ctrl = {
913 .ops = &go7007_ctrl_ops,
914 .id = V4L2_CID_PIXEL_THRESHOLD1,
915 .name = "Pixel Threshold Region 1",
916 .type = V4L2_CTRL_TYPE_INTEGER,
917 .def = 20,
918 .max = 32767,
919 .step = 1,
920 };
921
922 static const struct v4l2_ctrl_config go7007_motion_threshold1_ctrl = {
923 .ops = &go7007_ctrl_ops,
924 .id = V4L2_CID_MOTION_THRESHOLD1,
925 .name = "Motion Threshold Region 1",
926 .type = V4L2_CTRL_TYPE_INTEGER,
927 .def = 80,
928 .max = 32767,
929 .step = 1,
930 };
931
932 static const struct v4l2_ctrl_config go7007_mb_threshold1_ctrl = {
933 .ops = &go7007_ctrl_ops,
934 .id = V4L2_CID_MB_THRESHOLD1,
935 .name = "MB Threshold Region 1",
936 .type = V4L2_CTRL_TYPE_INTEGER,
937 .def = 200,
938 .max = 32767,
939 .step = 1,
940 };
941
942 static const struct v4l2_ctrl_config go7007_pixel_threshold2_ctrl = {
943 .ops = &go7007_ctrl_ops,
944 .id = V4L2_CID_PIXEL_THRESHOLD2,
945 .name = "Pixel Threshold Region 2",
946 .type = V4L2_CTRL_TYPE_INTEGER,
947 .def = 20,
948 .max = 32767,
949 .step = 1,
950 };
951
952 static const struct v4l2_ctrl_config go7007_motion_threshold2_ctrl = {
953 .ops = &go7007_ctrl_ops,
954 .id = V4L2_CID_MOTION_THRESHOLD2,
955 .name = "Motion Threshold Region 2",
956 .type = V4L2_CTRL_TYPE_INTEGER,
957 .def = 80,
958 .max = 32767,
959 .step = 1,
960 };
961
962 static const struct v4l2_ctrl_config go7007_mb_threshold2_ctrl = {
963 .ops = &go7007_ctrl_ops,
964 .id = V4L2_CID_MB_THRESHOLD2,
965 .name = "MB Threshold Region 2",
966 .type = V4L2_CTRL_TYPE_INTEGER,
967 .def = 200,
968 .max = 32767,
969 .step = 1,
970 };
971
972 static const struct v4l2_ctrl_config go7007_pixel_threshold3_ctrl = {
973 .ops = &go7007_ctrl_ops,
974 .id = V4L2_CID_PIXEL_THRESHOLD3,
975 .name = "Pixel Threshold Region 3",
976 .type = V4L2_CTRL_TYPE_INTEGER,
977 .def = 20,
978 .max = 32767,
979 .step = 1,
980 };
981
982 static const struct v4l2_ctrl_config go7007_motion_threshold3_ctrl = {
983 .ops = &go7007_ctrl_ops,
984 .id = V4L2_CID_MOTION_THRESHOLD3,
985 .name = "Motion Threshold Region 3",
986 .type = V4L2_CTRL_TYPE_INTEGER,
987 .def = 80,
988 .max = 32767,
989 .step = 1,
990 };
991
992 static const struct v4l2_ctrl_config go7007_mb_threshold3_ctrl = {
993 .ops = &go7007_ctrl_ops,
994 .id = V4L2_CID_MB_THRESHOLD3,
995 .name = "MB Threshold Region 3",
996 .type = V4L2_CTRL_TYPE_INTEGER,
997 .def = 200,
998 .max = 32767,
999 .step = 1,
1000 };
1001
1002 static const struct v4l2_ctrl_config go7007_mb_regions_ctrl = {
1003 .ops = &go7007_ctrl_ops,
1004 .id = V4L2_CID_DETECT_MD_REGION_GRID,
1005 .dims = { 576 / 16, 720 / 16 },
1006 .max = 3,
1007 .step = 1,
1008 };
1009
1010 int go7007_v4l2_ctrl_init(struct go7007 *go)
1011 {
1012 struct v4l2_ctrl_handler *hdl = &go->hdl;
1013 struct v4l2_ctrl *ctrl;
1014
1015 v4l2_ctrl_handler_init(hdl, 22);
1016 go->mpeg_video_gop_size = v4l2_ctrl_new_std(hdl, NULL,
1017 V4L2_CID_MPEG_VIDEO_GOP_SIZE, 0, 34, 1, 15);
1018 go->mpeg_video_gop_closure = v4l2_ctrl_new_std(hdl, NULL,
1019 V4L2_CID_MPEG_VIDEO_GOP_CLOSURE, 0, 1, 1, 1);
1020 go->mpeg_video_bitrate = v4l2_ctrl_new_std(hdl, NULL,
1021 V4L2_CID_MPEG_VIDEO_BITRATE,
1022 64000, 10000000, 1, 9800000);
1023 go->mpeg_video_b_frames = v4l2_ctrl_new_std(hdl, NULL,
1024 V4L2_CID_MPEG_VIDEO_B_FRAMES, 0, 2, 2, 0);
1025 go->mpeg_video_rep_seqheader = v4l2_ctrl_new_std(hdl, NULL,
1026 V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER, 0, 1, 1, 1);
1027
1028 go->mpeg_video_aspect_ratio = v4l2_ctrl_new_std_menu(hdl, NULL,
1029 V4L2_CID_MPEG_VIDEO_ASPECT,
1030 V4L2_MPEG_VIDEO_ASPECT_16x9, 0,
1031 V4L2_MPEG_VIDEO_ASPECT_1x1);
1032 ctrl = v4l2_ctrl_new_std(hdl, NULL,
1033 V4L2_CID_JPEG_ACTIVE_MARKER, 0,
1034 V4L2_JPEG_ACTIVE_MARKER_DQT |
1035 V4L2_JPEG_ACTIVE_MARKER_DHT, 0,
1036 V4L2_JPEG_ACTIVE_MARKER_DQT |
1037 V4L2_JPEG_ACTIVE_MARKER_DHT);
1038 if (ctrl)
1039 ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1040 v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold0_ctrl, NULL);
1041 v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold0_ctrl, NULL);
1042 v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold0_ctrl, NULL);
1043 v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold1_ctrl, NULL);
1044 v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold1_ctrl, NULL);
1045 v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold1_ctrl, NULL);
1046 v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold2_ctrl, NULL);
1047 v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold2_ctrl, NULL);
1048 v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold2_ctrl, NULL);
1049 v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold3_ctrl, NULL);
1050 v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold3_ctrl, NULL);
1051 v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold3_ctrl, NULL);
1052 v4l2_ctrl_new_custom(hdl, &go7007_mb_regions_ctrl, NULL);
1053 go->modet_mode = v4l2_ctrl_new_std_menu(hdl, NULL,
1054 V4L2_CID_DETECT_MD_MODE,
1055 V4L2_DETECT_MD_MODE_REGION_GRID,
1056 1 << V4L2_DETECT_MD_MODE_THRESHOLD_GRID,
1057 V4L2_DETECT_MD_MODE_DISABLED);
1058 if (hdl->error) {
1059 int rv = hdl->error;
1060
1061 v4l2_err(&go->v4l2_dev, "Could not register controls\n");
1062 return rv;
1063 }
1064 go->v4l2_dev.ctrl_handler = hdl;
1065 return 0;
1066 }
1067
1068 int go7007_v4l2_init(struct go7007 *go)
1069 {
1070 struct video_device *vdev = &go->vdev;
1071 int rv;
1072
1073 mutex_init(&go->serialize_lock);
1074 mutex_init(&go->queue_lock);
1075
1076 INIT_LIST_HEAD(&go->vidq_active);
1077 go->vidq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1078 go->vidq.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1079 go->vidq.ops = &go7007_video_qops;
1080 go->vidq.mem_ops = &vb2_vmalloc_memops;
1081 go->vidq.drv_priv = go;
1082 go->vidq.buf_struct_size = sizeof(struct go7007_buffer);
1083 go->vidq.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1084 go->vidq.lock = &go->queue_lock;
1085 rv = vb2_queue_init(&go->vidq);
1086 if (rv)
1087 return rv;
1088 *vdev = go7007_template;
1089 vdev->lock = &go->serialize_lock;
1090 vdev->queue = &go->vidq;
1091 vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
1092 V4L2_CAP_STREAMING;
1093 if (go->board_info->num_aud_inputs)
1094 vdev->device_caps |= V4L2_CAP_AUDIO;
1095 if (go->board_info->flags & GO7007_BOARD_HAS_TUNER)
1096 vdev->device_caps |= V4L2_CAP_TUNER;
1097 video_set_drvdata(vdev, go);
1098 vdev->v4l2_dev = &go->v4l2_dev;
1099 if (!v4l2_device_has_op(&go->v4l2_dev, 0, video, querystd))
1100 v4l2_disable_ioctl(vdev, VIDIOC_QUERYSTD);
1101 if (!(go->board_info->flags & GO7007_BOARD_HAS_TUNER)) {
1102 v4l2_disable_ioctl(vdev, VIDIOC_S_FREQUENCY);
1103 v4l2_disable_ioctl(vdev, VIDIOC_G_FREQUENCY);
1104 v4l2_disable_ioctl(vdev, VIDIOC_S_TUNER);
1105 v4l2_disable_ioctl(vdev, VIDIOC_G_TUNER);
1106 } else {
1107 struct v4l2_frequency f = {
1108 .type = V4L2_TUNER_ANALOG_TV,
1109 .frequency = 980,
1110 };
1111
1112 call_all(&go->v4l2_dev, tuner, s_frequency, &f);
1113 }
1114 if (!(go->board_info->sensor_flags & GO7007_SENSOR_TV)) {
1115 v4l2_disable_ioctl(vdev, VIDIOC_G_STD);
1116 v4l2_disable_ioctl(vdev, VIDIOC_S_STD);
1117 vdev->tvnorms = 0;
1118 }
1119 if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING)
1120 v4l2_disable_ioctl(vdev, VIDIOC_ENUM_FRAMESIZES);
1121 if (go->board_info->num_aud_inputs == 0) {
1122 v4l2_disable_ioctl(vdev, VIDIOC_G_AUDIO);
1123 v4l2_disable_ioctl(vdev, VIDIOC_S_AUDIO);
1124 v4l2_disable_ioctl(vdev, VIDIOC_ENUMAUDIO);
1125 }
1126 /* Setup correct crystal frequency on this board */
1127 if (go->board_info->sensor_flags & GO7007_SENSOR_SAA7115)
1128 v4l2_subdev_call(go->sd_video, video, s_crystal_freq,
1129 SAA7115_FREQ_24_576_MHZ,
1130 SAA7115_FREQ_FL_APLL | SAA7115_FREQ_FL_UCGC |
1131 SAA7115_FREQ_FL_DOUBLE_ASCLK);
1132 go7007_s_input(go);
1133 if (go->board_info->sensor_flags & GO7007_SENSOR_TV)
1134 go7007_s_std(go);
1135 rv = video_register_device(vdev, VFL_TYPE_VIDEO, -1);
1136 if (rv < 0)
1137 return rv;
1138 dev_info(go->dev, "registered device %s [v4l2]\n",
1139 video_device_node_name(vdev));
1140
1141 return 0;
1142 }
1143
1144 void go7007_v4l2_remove(struct go7007 *go)
1145 {
1146 v4l2_ctrl_handler_free(&go->hdl);
1147 }
Kernel DRM miscellaneous fixes and cross-tree changes