1
2
3
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
32static 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
45static 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
80static 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
99static 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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
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
176static 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
274static 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
283 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
284 V4L2_CAP_STREAMING;
285
286 if (go->board_info->num_aud_inputs)
287 cap->device_caps |= V4L2_CAP_AUDIO;
288 if (go->board_info->flags & GO7007_BOARD_HAS_TUNER)
289 cap->device_caps |= V4L2_CAP_TUNER;
290 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
291 return 0;
292}
293
294static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
295 struct v4l2_fmtdesc *fmt)
296{
297 char *desc = NULL;
298
299 switch (fmt->index) {
300 case 0:
301 fmt->pixelformat = V4L2_PIX_FMT_MJPEG;
302 desc = "Motion JPEG";
303 break;
304 case 1:
305 fmt->pixelformat = V4L2_PIX_FMT_MPEG1;
306 desc = "MPEG-1 ES";
307 break;
308 case 2:
309 fmt->pixelformat = V4L2_PIX_FMT_MPEG2;
310 desc = "MPEG-2 ES";
311 break;
312 case 3:
313 fmt->pixelformat = V4L2_PIX_FMT_MPEG4;
314 desc = "MPEG-4 ES";
315 break;
316 default:
317 return -EINVAL;
318 }
319 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
320 fmt->flags = V4L2_FMT_FLAG_COMPRESSED;
321
322 strscpy(fmt->description, desc, sizeof(fmt->description));
323
324 return 0;
325}
326
327static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
328 struct v4l2_format *fmt)
329{
330 struct go7007 *go = video_drvdata(file);
331
332 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
333 fmt->fmt.pix.width = go->width;
334 fmt->fmt.pix.height = go->height;
335 fmt->fmt.pix.pixelformat = go->format;
336 fmt->fmt.pix.field = V4L2_FIELD_NONE;
337 fmt->fmt.pix.bytesperline = 0;
338 fmt->fmt.pix.sizeimage = GO7007_BUF_SIZE;
339 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
340
341 return 0;
342}
343
344static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
345 struct v4l2_format *fmt)
346{
347 struct go7007 *go = video_drvdata(file);
348
349 return set_capture_size(go, fmt, 1);
350}
351
352static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
353 struct v4l2_format *fmt)
354{
355 struct go7007 *go = video_drvdata(file);
356
357 if (vb2_is_busy(&go->vidq))
358 return -EBUSY;
359
360 return set_capture_size(go, fmt, 0);
361}
362
363static int go7007_queue_setup(struct vb2_queue *q,
364 unsigned int *num_buffers, unsigned int *num_planes,
365 unsigned int sizes[], struct device *alloc_devs[])
366{
367 sizes[0] = GO7007_BUF_SIZE;
368 *num_planes = 1;
369
370 if (*num_buffers < 2)
371 *num_buffers = 2;
372
373 return 0;
374}
375
376static void go7007_buf_queue(struct vb2_buffer *vb)
377{
378 struct vb2_queue *vq = vb->vb2_queue;
379 struct go7007 *go = vb2_get_drv_priv(vq);
380 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
381 struct go7007_buffer *go7007_vb =
382 container_of(vbuf, struct go7007_buffer, vb);
383 unsigned long flags;
384
385 spin_lock_irqsave(&go->spinlock, flags);
386 list_add_tail(&go7007_vb->list, &go->vidq_active);
387 spin_unlock_irqrestore(&go->spinlock, flags);
388}
389
390static int go7007_buf_prepare(struct vb2_buffer *vb)
391{
392 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
393 struct go7007_buffer *go7007_vb =
394 container_of(vbuf, struct go7007_buffer, vb);
395
396 go7007_vb->modet_active = 0;
397 go7007_vb->frame_offset = 0;
398 vb->planes[0].bytesused = 0;
399 return 0;
400}
401
402static void go7007_buf_finish(struct vb2_buffer *vb)
403{
404 struct vb2_queue *vq = vb->vb2_queue;
405 struct go7007 *go = vb2_get_drv_priv(vq);
406 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
407 struct go7007_buffer *go7007_vb =
408 container_of(vbuf, struct go7007_buffer, vb);
409 u32 frame_type_flag = get_frame_type_flag(go7007_vb, go->format);
410
411 vbuf->flags &= ~(V4L2_BUF_FLAG_KEYFRAME | V4L2_BUF_FLAG_BFRAME |
412 V4L2_BUF_FLAG_PFRAME);
413 vbuf->flags |= frame_type_flag;
414 vbuf->field = V4L2_FIELD_NONE;
415}
416
417static int go7007_start_streaming(struct vb2_queue *q, unsigned int count)
418{
419 struct go7007 *go = vb2_get_drv_priv(q);
420 int ret;
421
422 set_formatting(go);
423 mutex_lock(&go->hw_lock);
424 go->next_seq = 0;
425 go->active_buf = NULL;
426 go->modet_event_status = 0;
427 q->streaming = 1;
428 if (go7007_start_encoder(go) < 0)
429 ret = -EIO;
430 else
431 ret = 0;
432 mutex_unlock(&go->hw_lock);
433 if (ret) {
434 q->streaming = 0;
435 return ret;
436 }
437 call_all(&go->v4l2_dev, video, s_stream, 1);
438 v4l2_ctrl_grab(go->mpeg_video_gop_size, true);
439 v4l2_ctrl_grab(go->mpeg_video_gop_closure, true);
440 v4l2_ctrl_grab(go->mpeg_video_bitrate, true);
441 v4l2_ctrl_grab(go->mpeg_video_aspect_ratio, true);
442
443 if (go->board_id == GO7007_BOARDID_ADS_USBAV_709)
444 go7007_write_addr(go, 0x3c82, 0x0005);
445 return ret;
446}
447
448static void go7007_stop_streaming(struct vb2_queue *q)
449{
450 struct go7007 *go = vb2_get_drv_priv(q);
451 unsigned long flags;
452
453 q->streaming = 0;
454 go7007_stream_stop(go);
455 mutex_lock(&go->hw_lock);
456 go7007_reset_encoder(go);
457 mutex_unlock(&go->hw_lock);
458 call_all(&go->v4l2_dev, video, s_stream, 0);
459
460 spin_lock_irqsave(&go->spinlock, flags);
461 INIT_LIST_HEAD(&go->vidq_active);
462 spin_unlock_irqrestore(&go->spinlock, flags);
463 v4l2_ctrl_grab(go->mpeg_video_gop_size, false);
464 v4l2_ctrl_grab(go->mpeg_video_gop_closure, false);
465 v4l2_ctrl_grab(go->mpeg_video_bitrate, false);
466 v4l2_ctrl_grab(go->mpeg_video_aspect_ratio, false);
467
468 if (go->board_id == GO7007_BOARDID_ADS_USBAV_709)
469 go7007_write_addr(go, 0x3c82, 0x000d);
470}
471
472static const struct vb2_ops go7007_video_qops = {
473 .queue_setup = go7007_queue_setup,
474 .buf_queue = go7007_buf_queue,
475 .buf_prepare = go7007_buf_prepare,
476 .buf_finish = go7007_buf_finish,
477 .start_streaming = go7007_start_streaming,
478 .stop_streaming = go7007_stop_streaming,
479 .wait_prepare = vb2_ops_wait_prepare,
480 .wait_finish = vb2_ops_wait_finish,
481};
482
483static int vidioc_g_parm(struct file *filp, void *priv,
484 struct v4l2_streamparm *parm)
485{
486 struct go7007 *go = video_drvdata(filp);
487 struct v4l2_fract timeperframe = {
488 .numerator = 1001 * go->fps_scale,
489 .denominator = go->sensor_framerate,
490 };
491
492 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
493 return -EINVAL;
494
495 parm->parm.capture.readbuffers = 2;
496 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
497 parm->parm.capture.timeperframe = timeperframe;
498
499 return 0;
500}
501
502static int vidioc_s_parm(struct file *filp, void *priv,
503 struct v4l2_streamparm *parm)
504{
505 struct go7007 *go = video_drvdata(filp);
506 unsigned int n, d;
507
508 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
509 return -EINVAL;
510
511 n = go->sensor_framerate *
512 parm->parm.capture.timeperframe.numerator;
513 d = 1001 * parm->parm.capture.timeperframe.denominator;
514 if (n != 0 && d != 0 && n > d)
515 go->fps_scale = (n + d/2) / d;
516 else
517 go->fps_scale = 1;
518
519 return vidioc_g_parm(filp, priv, parm);
520}
521
522
523
524
525
526
527
528
529
530
531
532static int vidioc_enum_framesizes(struct file *filp, void *priv,
533 struct v4l2_frmsizeenum *fsize)
534{
535 struct go7007 *go = video_drvdata(filp);
536 int width, height;
537
538 if (fsize->index > 2)
539 return -EINVAL;
540
541 if (!valid_pixelformat(fsize->pixel_format))
542 return -EINVAL;
543
544 get_resolution(go, &width, &height);
545 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
546 fsize->discrete.width = (width >> fsize->index) & ~0xf;
547 fsize->discrete.height = (height >> fsize->index) & ~0xf;
548 return 0;
549}
550
551static int vidioc_enum_frameintervals(struct file *filp, void *priv,
552 struct v4l2_frmivalenum *fival)
553{
554 struct go7007 *go = video_drvdata(filp);
555 int width, height;
556 int i;
557
558 if (fival->index > 4)
559 return -EINVAL;
560
561 if (!valid_pixelformat(fival->pixel_format))
562 return -EINVAL;
563
564 if (!(go->board_info->sensor_flags & GO7007_SENSOR_SCALING)) {
565 get_resolution(go, &width, &height);
566 for (i = 0; i <= 2; i++)
567 if (fival->width == ((width >> i) & ~0xf) &&
568 fival->height == ((height >> i) & ~0xf))
569 break;
570 if (i > 2)
571 return -EINVAL;
572 }
573 fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
574 fival->discrete.numerator = 1001 * (fival->index + 1);
575 fival->discrete.denominator = go->sensor_framerate;
576 return 0;
577}
578
579static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *std)
580{
581 struct go7007 *go = video_drvdata(file);
582
583 *std = go->std;
584 return 0;
585}
586
587static int go7007_s_std(struct go7007 *go)
588{
589 if (go->std & V4L2_STD_625_50) {
590 go->standard = GO7007_STD_PAL;
591 go->sensor_framerate = 25025;
592 } else {
593 go->standard = GO7007_STD_NTSC;
594 go->sensor_framerate = 30000;
595 }
596
597 call_all(&go->v4l2_dev, video, s_std, go->std);
598 set_capture_size(go, NULL, 0);
599 return 0;
600}
601
602static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id std)
603{
604 struct go7007 *go = video_drvdata(file);
605
606 if (vb2_is_busy(&go->vidq))
607 return -EBUSY;
608
609 go->std = std;
610
611 return go7007_s_std(go);
612}
613
614static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *std)
615{
616 struct go7007 *go = video_drvdata(file);
617
618 return call_all(&go->v4l2_dev, video, querystd, std);
619}
620
621static int vidioc_enum_input(struct file *file, void *priv,
622 struct v4l2_input *inp)
623{
624 struct go7007 *go = video_drvdata(file);
625
626 if (inp->index >= go->board_info->num_inputs)
627 return -EINVAL;
628
629 strscpy(inp->name, go->board_info->inputs[inp->index].name,
630 sizeof(inp->name));
631
632
633 if ((go->board_info->flags & GO7007_BOARD_HAS_TUNER) &&
634 inp->index == 0)
635 inp->type = V4L2_INPUT_TYPE_TUNER;
636 else
637 inp->type = V4L2_INPUT_TYPE_CAMERA;
638
639 if (go->board_info->num_aud_inputs)
640 inp->audioset = (1 << go->board_info->num_aud_inputs) - 1;
641 else
642 inp->audioset = 0;
643 inp->tuner = 0;
644 if (go->board_info->sensor_flags & GO7007_SENSOR_TV)
645 inp->std = video_devdata(file)->tvnorms;
646 else
647 inp->std = 0;
648
649 return 0;
650}
651
652
653static int vidioc_g_input(struct file *file, void *priv, unsigned int *input)
654{
655 struct go7007 *go = video_drvdata(file);
656
657 *input = go->input;
658
659 return 0;
660}
661
662static int vidioc_enumaudio(struct file *file, void *fh, struct v4l2_audio *a)
663{
664 struct go7007 *go = video_drvdata(file);
665
666 if (a->index >= go->board_info->num_aud_inputs)
667 return -EINVAL;
668 strscpy(a->name, go->board_info->aud_inputs[a->index].name,
669 sizeof(a->name));
670 a->capability = V4L2_AUDCAP_STEREO;
671 return 0;
672}
673
674static int vidioc_g_audio(struct file *file, void *fh, struct v4l2_audio *a)
675{
676 struct go7007 *go = video_drvdata(file);
677
678 a->index = go->aud_input;
679 strscpy(a->name, go->board_info->aud_inputs[go->aud_input].name,
680 sizeof(a->name));
681 a->capability = V4L2_AUDCAP_STEREO;
682 return 0;
683}
684
685static int vidioc_s_audio(struct file *file, void *fh,
686 const struct v4l2_audio *a)
687{
688 struct go7007 *go = video_drvdata(file);
689
690 if (a->index >= go->board_info->num_aud_inputs)
691 return -EINVAL;
692 go->aud_input = a->index;
693 v4l2_subdev_call(go->sd_audio, audio, s_routing,
694 go->board_info->aud_inputs[go->aud_input].audio_input, 0, 0);
695 return 0;
696}
697
698static void go7007_s_input(struct go7007 *go)
699{
700 unsigned int input = go->input;
701
702 v4l2_subdev_call(go->sd_video, video, s_routing,
703 go->board_info->inputs[input].video_input, 0,
704 go->board_info->video_config);
705 if (go->board_info->num_aud_inputs) {
706 int aud_input = go->board_info->inputs[input].audio_index;
707
708 v4l2_subdev_call(go->sd_audio, audio, s_routing,
709 go->board_info->aud_inputs[aud_input].audio_input, 0, 0);
710 go->aud_input = aud_input;
711 }
712}
713
714static int vidioc_s_input(struct file *file, void *priv, unsigned int input)
715{
716 struct go7007 *go = video_drvdata(file);
717
718 if (input >= go->board_info->num_inputs)
719 return -EINVAL;
720 if (vb2_is_busy(&go->vidq))
721 return -EBUSY;
722
723 go->input = input;
724 go7007_s_input(go);
725
726 return 0;
727}
728
729static int vidioc_g_tuner(struct file *file, void *priv,
730 struct v4l2_tuner *t)
731{
732 struct go7007 *go = video_drvdata(file);
733
734 if (t->index != 0)
735 return -EINVAL;
736
737 strscpy(t->name, "Tuner", sizeof(t->name));
738 return call_all(&go->v4l2_dev, tuner, g_tuner, t);
739}
740
741static int vidioc_s_tuner(struct file *file, void *priv,
742 const struct v4l2_tuner *t)
743{
744 struct go7007 *go = video_drvdata(file);
745
746 if (t->index != 0)
747 return -EINVAL;
748
749 return call_all(&go->v4l2_dev, tuner, s_tuner, t);
750}
751
752static int vidioc_g_frequency(struct file *file, void *priv,
753 struct v4l2_frequency *f)
754{
755 struct go7007 *go = video_drvdata(file);
756
757 if (f->tuner)
758 return -EINVAL;
759
760 return call_all(&go->v4l2_dev, tuner, g_frequency, f);
761}
762
763static int vidioc_s_frequency(struct file *file, void *priv,
764 const struct v4l2_frequency *f)
765{
766 struct go7007 *go = video_drvdata(file);
767
768 if (f->tuner)
769 return -EINVAL;
770
771 return call_all(&go->v4l2_dev, tuner, s_frequency, f);
772}
773
774static int vidioc_log_status(struct file *file, void *priv)
775{
776 struct go7007 *go = video_drvdata(file);
777
778 v4l2_ctrl_log_status(file, priv);
779 return call_all(&go->v4l2_dev, core, log_status);
780}
781
782static int vidioc_subscribe_event(struct v4l2_fh *fh,
783 const struct v4l2_event_subscription *sub)
784{
785
786 switch (sub->type) {
787 case V4L2_EVENT_MOTION_DET:
788
789
790 return v4l2_event_subscribe(fh, sub, 30, NULL);
791 default:
792 return v4l2_ctrl_subscribe_event(fh, sub);
793 }
794}
795
796
797static int go7007_s_ctrl(struct v4l2_ctrl *ctrl)
798{
799 struct go7007 *go =
800 container_of(ctrl->handler, struct go7007, hdl);
801 unsigned y;
802 u8 *mt;
803
804 switch (ctrl->id) {
805 case V4L2_CID_PIXEL_THRESHOLD0:
806 go->modet[0].pixel_threshold = ctrl->val;
807 break;
808 case V4L2_CID_MOTION_THRESHOLD0:
809 go->modet[0].motion_threshold = ctrl->val;
810 break;
811 case V4L2_CID_MB_THRESHOLD0:
812 go->modet[0].mb_threshold = ctrl->val;
813 break;
814 case V4L2_CID_PIXEL_THRESHOLD1:
815 go->modet[1].pixel_threshold = ctrl->val;
816 break;
817 case V4L2_CID_MOTION_THRESHOLD1:
818 go->modet[1].motion_threshold = ctrl->val;
819 break;
820 case V4L2_CID_MB_THRESHOLD1:
821 go->modet[1].mb_threshold = ctrl->val;
822 break;
823 case V4L2_CID_PIXEL_THRESHOLD2:
824 go->modet[2].pixel_threshold = ctrl->val;
825 break;
826 case V4L2_CID_MOTION_THRESHOLD2:
827 go->modet[2].motion_threshold = ctrl->val;
828 break;
829 case V4L2_CID_MB_THRESHOLD2:
830 go->modet[2].mb_threshold = ctrl->val;
831 break;
832 case V4L2_CID_PIXEL_THRESHOLD3:
833 go->modet[3].pixel_threshold = ctrl->val;
834 break;
835 case V4L2_CID_MOTION_THRESHOLD3:
836 go->modet[3].motion_threshold = ctrl->val;
837 break;
838 case V4L2_CID_MB_THRESHOLD3:
839 go->modet[3].mb_threshold = ctrl->val;
840 break;
841 case V4L2_CID_DETECT_MD_REGION_GRID:
842 mt = go->modet_map;
843 for (y = 0; y < go->height / 16; y++, mt += go->width / 16)
844 memcpy(mt, ctrl->p_new.p_u8 + y * (720 / 16), go->width / 16);
845 break;
846 default:
847 return -EINVAL;
848 }
849 return 0;
850}
851
852static const struct v4l2_file_operations go7007_fops = {
853 .owner = THIS_MODULE,
854 .open = v4l2_fh_open,
855 .release = vb2_fop_release,
856 .unlocked_ioctl = video_ioctl2,
857 .read = vb2_fop_read,
858 .mmap = vb2_fop_mmap,
859 .poll = vb2_fop_poll,
860};
861
862static const struct v4l2_ioctl_ops video_ioctl_ops = {
863 .vidioc_querycap = vidioc_querycap,
864 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
865 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
866 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
867 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
868 .vidioc_reqbufs = vb2_ioctl_reqbufs,
869 .vidioc_querybuf = vb2_ioctl_querybuf,
870 .vidioc_qbuf = vb2_ioctl_qbuf,
871 .vidioc_dqbuf = vb2_ioctl_dqbuf,
872 .vidioc_g_std = vidioc_g_std,
873 .vidioc_s_std = vidioc_s_std,
874 .vidioc_querystd = vidioc_querystd,
875 .vidioc_enum_input = vidioc_enum_input,
876 .vidioc_g_input = vidioc_g_input,
877 .vidioc_s_input = vidioc_s_input,
878 .vidioc_enumaudio = vidioc_enumaudio,
879 .vidioc_g_audio = vidioc_g_audio,
880 .vidioc_s_audio = vidioc_s_audio,
881 .vidioc_streamon = vb2_ioctl_streamon,
882 .vidioc_streamoff = vb2_ioctl_streamoff,
883 .vidioc_g_tuner = vidioc_g_tuner,
884 .vidioc_s_tuner = vidioc_s_tuner,
885 .vidioc_g_frequency = vidioc_g_frequency,
886 .vidioc_s_frequency = vidioc_s_frequency,
887 .vidioc_g_parm = vidioc_g_parm,
888 .vidioc_s_parm = vidioc_s_parm,
889 .vidioc_enum_framesizes = vidioc_enum_framesizes,
890 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
891 .vidioc_log_status = vidioc_log_status,
892 .vidioc_subscribe_event = vidioc_subscribe_event,
893 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
894};
895
896static const struct video_device go7007_template = {
897 .name = "go7007",
898 .fops = &go7007_fops,
899 .release = video_device_release_empty,
900 .ioctl_ops = &video_ioctl_ops,
901 .tvnorms = V4L2_STD_ALL,
902};
903
904static const struct v4l2_ctrl_ops go7007_ctrl_ops = {
905 .s_ctrl = go7007_s_ctrl,
906};
907
908static const struct v4l2_ctrl_config go7007_pixel_threshold0_ctrl = {
909 .ops = &go7007_ctrl_ops,
910 .id = V4L2_CID_PIXEL_THRESHOLD0,
911 .name = "Pixel Threshold Region 0",
912 .type = V4L2_CTRL_TYPE_INTEGER,
913 .def = 20,
914 .max = 32767,
915 .step = 1,
916};
917
918static const struct v4l2_ctrl_config go7007_motion_threshold0_ctrl = {
919 .ops = &go7007_ctrl_ops,
920 .id = V4L2_CID_MOTION_THRESHOLD0,
921 .name = "Motion Threshold Region 0",
922 .type = V4L2_CTRL_TYPE_INTEGER,
923 .def = 80,
924 .max = 32767,
925 .step = 1,
926};
927
928static const struct v4l2_ctrl_config go7007_mb_threshold0_ctrl = {
929 .ops = &go7007_ctrl_ops,
930 .id = V4L2_CID_MB_THRESHOLD0,
931 .name = "MB Threshold Region 0",
932 .type = V4L2_CTRL_TYPE_INTEGER,
933 .def = 200,
934 .max = 32767,
935 .step = 1,
936};
937
938static const struct v4l2_ctrl_config go7007_pixel_threshold1_ctrl = {
939 .ops = &go7007_ctrl_ops,
940 .id = V4L2_CID_PIXEL_THRESHOLD1,
941 .name = "Pixel Threshold Region 1",
942 .type = V4L2_CTRL_TYPE_INTEGER,
943 .def = 20,
944 .max = 32767,
945 .step = 1,
946};
947
948static const struct v4l2_ctrl_config go7007_motion_threshold1_ctrl = {
949 .ops = &go7007_ctrl_ops,
950 .id = V4L2_CID_MOTION_THRESHOLD1,
951 .name = "Motion Threshold Region 1",
952 .type = V4L2_CTRL_TYPE_INTEGER,
953 .def = 80,
954 .max = 32767,
955 .step = 1,
956};
957
958static const struct v4l2_ctrl_config go7007_mb_threshold1_ctrl = {
959 .ops = &go7007_ctrl_ops,
960 .id = V4L2_CID_MB_THRESHOLD1,
961 .name = "MB Threshold Region 1",
962 .type = V4L2_CTRL_TYPE_INTEGER,
963 .def = 200,
964 .max = 32767,
965 .step = 1,
966};
967
968static const struct v4l2_ctrl_config go7007_pixel_threshold2_ctrl = {
969 .ops = &go7007_ctrl_ops,
970 .id = V4L2_CID_PIXEL_THRESHOLD2,
971 .name = "Pixel Threshold Region 2",
972 .type = V4L2_CTRL_TYPE_INTEGER,
973 .def = 20,
974 .max = 32767,
975 .step = 1,
976};
977
978static const struct v4l2_ctrl_config go7007_motion_threshold2_ctrl = {
979 .ops = &go7007_ctrl_ops,
980 .id = V4L2_CID_MOTION_THRESHOLD2,
981 .name = "Motion Threshold Region 2",
982 .type = V4L2_CTRL_TYPE_INTEGER,
983 .def = 80,
984 .max = 32767,
985 .step = 1,
986};
987
988static const struct v4l2_ctrl_config go7007_mb_threshold2_ctrl = {
989 .ops = &go7007_ctrl_ops,
990 .id = V4L2_CID_MB_THRESHOLD2,
991 .name = "MB Threshold Region 2",
992 .type = V4L2_CTRL_TYPE_INTEGER,
993 .def = 200,
994 .max = 32767,
995 .step = 1,
996};
997
998static const struct v4l2_ctrl_config go7007_pixel_threshold3_ctrl = {
999 .ops = &go7007_ctrl_ops,
1000 .id = V4L2_CID_PIXEL_THRESHOLD3,
1001 .name = "Pixel Threshold Region 3",
1002 .type = V4L2_CTRL_TYPE_INTEGER,
1003 .def = 20,
1004 .max = 32767,
1005 .step = 1,
1006};
1007
1008static const struct v4l2_ctrl_config go7007_motion_threshold3_ctrl = {
1009 .ops = &go7007_ctrl_ops,
1010 .id = V4L2_CID_MOTION_THRESHOLD3,
1011 .name = "Motion Threshold Region 3",
1012 .type = V4L2_CTRL_TYPE_INTEGER,
1013 .def = 80,
1014 .max = 32767,
1015 .step = 1,
1016};
1017
1018static const struct v4l2_ctrl_config go7007_mb_threshold3_ctrl = {
1019 .ops = &go7007_ctrl_ops,
1020 .id = V4L2_CID_MB_THRESHOLD3,
1021 .name = "MB Threshold Region 3",
1022 .type = V4L2_CTRL_TYPE_INTEGER,
1023 .def = 200,
1024 .max = 32767,
1025 .step = 1,
1026};
1027
1028static const struct v4l2_ctrl_config go7007_mb_regions_ctrl = {
1029 .ops = &go7007_ctrl_ops,
1030 .id = V4L2_CID_DETECT_MD_REGION_GRID,
1031 .dims = { 576 / 16, 720 / 16 },
1032 .max = 3,
1033 .step = 1,
1034};
1035
1036int go7007_v4l2_ctrl_init(struct go7007 *go)
1037{
1038 struct v4l2_ctrl_handler *hdl = &go->hdl;
1039 struct v4l2_ctrl *ctrl;
1040
1041 v4l2_ctrl_handler_init(hdl, 22);
1042 go->mpeg_video_gop_size = v4l2_ctrl_new_std(hdl, NULL,
1043 V4L2_CID_MPEG_VIDEO_GOP_SIZE, 0, 34, 1, 15);
1044 go->mpeg_video_gop_closure = v4l2_ctrl_new_std(hdl, NULL,
1045 V4L2_CID_MPEG_VIDEO_GOP_CLOSURE, 0, 1, 1, 1);
1046 go->mpeg_video_bitrate = v4l2_ctrl_new_std(hdl, NULL,
1047 V4L2_CID_MPEG_VIDEO_BITRATE,
1048 64000, 10000000, 1, 9800000);
1049 go->mpeg_video_b_frames = v4l2_ctrl_new_std(hdl, NULL,
1050 V4L2_CID_MPEG_VIDEO_B_FRAMES, 0, 2, 2, 0);
1051 go->mpeg_video_rep_seqheader = v4l2_ctrl_new_std(hdl, NULL,
1052 V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER, 0, 1, 1, 1);
1053
1054 go->mpeg_video_aspect_ratio = v4l2_ctrl_new_std_menu(hdl, NULL,
1055 V4L2_CID_MPEG_VIDEO_ASPECT,
1056 V4L2_MPEG_VIDEO_ASPECT_16x9, 0,
1057 V4L2_MPEG_VIDEO_ASPECT_1x1);
1058 ctrl = v4l2_ctrl_new_std(hdl, NULL,
1059 V4L2_CID_JPEG_ACTIVE_MARKER, 0,
1060 V4L2_JPEG_ACTIVE_MARKER_DQT |
1061 V4L2_JPEG_ACTIVE_MARKER_DHT, 0,
1062 V4L2_JPEG_ACTIVE_MARKER_DQT |
1063 V4L2_JPEG_ACTIVE_MARKER_DHT);
1064 if (ctrl)
1065 ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1066 v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold0_ctrl, NULL);
1067 v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold0_ctrl, NULL);
1068 v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold0_ctrl, NULL);
1069 v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold1_ctrl, NULL);
1070 v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold1_ctrl, NULL);
1071 v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold1_ctrl, NULL);
1072 v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold2_ctrl, NULL);
1073 v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold2_ctrl, NULL);
1074 v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold2_ctrl, NULL);
1075 v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold3_ctrl, NULL);
1076 v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold3_ctrl, NULL);
1077 v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold3_ctrl, NULL);
1078 v4l2_ctrl_new_custom(hdl, &go7007_mb_regions_ctrl, NULL);
1079 go->modet_mode = v4l2_ctrl_new_std_menu(hdl, NULL,
1080 V4L2_CID_DETECT_MD_MODE,
1081 V4L2_DETECT_MD_MODE_REGION_GRID,
1082 1 << V4L2_DETECT_MD_MODE_THRESHOLD_GRID,
1083 V4L2_DETECT_MD_MODE_DISABLED);
1084 if (hdl->error) {
1085 int rv = hdl->error;
1086
1087 v4l2_err(&go->v4l2_dev, "Could not register controls\n");
1088 return rv;
1089 }
1090 go->v4l2_dev.ctrl_handler = hdl;
1091 return 0;
1092}
1093
1094int go7007_v4l2_init(struct go7007 *go)
1095{
1096 struct video_device *vdev = &go->vdev;
1097 int rv;
1098
1099 mutex_init(&go->serialize_lock);
1100 mutex_init(&go->queue_lock);
1101
1102 INIT_LIST_HEAD(&go->vidq_active);
1103 go->vidq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1104 go->vidq.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1105 go->vidq.ops = &go7007_video_qops;
1106 go->vidq.mem_ops = &vb2_vmalloc_memops;
1107 go->vidq.drv_priv = go;
1108 go->vidq.buf_struct_size = sizeof(struct go7007_buffer);
1109 go->vidq.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1110 go->vidq.lock = &go->queue_lock;
1111 rv = vb2_queue_init(&go->vidq);
1112 if (rv)
1113 return rv;
1114 *vdev = go7007_template;
1115 vdev->lock = &go->serialize_lock;
1116 vdev->queue = &go->vidq;
1117 vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
1118 V4L2_CAP_STREAMING;
1119 if (go->board_info->num_aud_inputs)
1120 vdev->device_caps |= V4L2_CAP_AUDIO;
1121 if (go->board_info->flags & GO7007_BOARD_HAS_TUNER)
1122 vdev->device_caps |= V4L2_CAP_TUNER;
1123 video_set_drvdata(vdev, go);
1124 vdev->v4l2_dev = &go->v4l2_dev;
1125 if (!v4l2_device_has_op(&go->v4l2_dev, 0, video, querystd))
1126 v4l2_disable_ioctl(vdev, VIDIOC_QUERYSTD);
1127 if (!(go->board_info->flags & GO7007_BOARD_HAS_TUNER)) {
1128 v4l2_disable_ioctl(vdev, VIDIOC_S_FREQUENCY);
1129 v4l2_disable_ioctl(vdev, VIDIOC_G_FREQUENCY);
1130 v4l2_disable_ioctl(vdev, VIDIOC_S_TUNER);
1131 v4l2_disable_ioctl(vdev, VIDIOC_G_TUNER);
1132 } else {
1133 struct v4l2_frequency f = {
1134 .type = V4L2_TUNER_ANALOG_TV,
1135 .frequency = 980,
1136 };
1137
1138 call_all(&go->v4l2_dev, tuner, s_frequency, &f);
1139 }
1140 if (!(go->board_info->sensor_flags & GO7007_SENSOR_TV)) {
1141 v4l2_disable_ioctl(vdev, VIDIOC_G_STD);
1142 v4l2_disable_ioctl(vdev, VIDIOC_S_STD);
1143 vdev->tvnorms = 0;
1144 }
1145 if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING)
1146 v4l2_disable_ioctl(vdev, VIDIOC_ENUM_FRAMESIZES);
1147 if (go->board_info->num_aud_inputs == 0) {
1148 v4l2_disable_ioctl(vdev, VIDIOC_G_AUDIO);
1149 v4l2_disable_ioctl(vdev, VIDIOC_S_AUDIO);
1150 v4l2_disable_ioctl(vdev, VIDIOC_ENUMAUDIO);
1151 }
1152
1153 if (go->board_info->sensor_flags & GO7007_SENSOR_SAA7115)
1154 v4l2_subdev_call(go->sd_video, video, s_crystal_freq,
1155 SAA7115_FREQ_24_576_MHZ,
1156 SAA7115_FREQ_FL_APLL | SAA7115_FREQ_FL_UCGC |
1157 SAA7115_FREQ_FL_DOUBLE_ASCLK);
1158 go7007_s_input(go);
1159 if (go->board_info->sensor_flags & GO7007_SENSOR_TV)
1160 go7007_s_std(go);
1161 rv = video_register_device(vdev, VFL_TYPE_VIDEO, -1);
1162 if (rv < 0)
1163 return rv;
1164 dev_info(go->dev, "registered device %s [v4l2]\n",
1165 video_device_node_name(vdev));
1166
1167 return 0;
1168}
1169
1170void go7007_v4l2_remove(struct go7007 *go)
1171{
1172 v4l2_ctrl_handler_free(&go->hdl);
1173}
1174
