2 * Copyright (C) 2005-2006 Micronas USA Inc.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License (Version 2) as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
14 #include <linux/module.h>
15 #include <linux/delay.h>
16 #include <linux/sched.h>
17 #include <linux/spinlock.h>
18 #include <linux/slab.h>
20 #include <linux/unistd.h>
21 #include <linux/time.h>
22 #include <linux/vmalloc.h>
23 #include <linux/pagemap.h>
24 #include <linux/i2c.h>
25 #include <linux/mutex.h>
26 #include <linux/uaccess.h>
27 #include <linux/videodev2.h>
28 #include <media/v4l2-common.h>
29 #include <media/v4l2-ioctl.h>
30 #include <media/v4l2-subdev.h>
31 #include <media/v4l2-event.h>
32 #include <media/videobuf2-vmalloc.h>
33 #include <media/saa7115.h>
35 #include "go7007-priv.h"
37 #define call_all(dev, o, f, args...) \
38 v4l2_device_call_until_err(dev, 0, o, f, ##args)
40 static bool valid_pixelformat(u32 pixelformat)
42 switch (pixelformat) {
43 case V4L2_PIX_FMT_MJPEG:
44 case V4L2_PIX_FMT_MPEG1:
45 case V4L2_PIX_FMT_MPEG2:
46 case V4L2_PIX_FMT_MPEG4:
53 static u32 get_frame_type_flag(struct go7007_buffer *vb, int format)
55 u8 *ptr = vb2_plane_vaddr(&vb->vb, 0);
58 case V4L2_PIX_FMT_MJPEG:
59 return V4L2_BUF_FLAG_KEYFRAME;
60 case V4L2_PIX_FMT_MPEG4:
61 switch ((ptr[vb->frame_offset + 4] >> 6) & 0x3) {
63 return V4L2_BUF_FLAG_KEYFRAME;
65 return V4L2_BUF_FLAG_PFRAME;
67 return V4L2_BUF_FLAG_BFRAME;
71 case V4L2_PIX_FMT_MPEG1:
72 case V4L2_PIX_FMT_MPEG2:
73 switch ((ptr[vb->frame_offset + 5] >> 3) & 0x7) {
75 return V4L2_BUF_FLAG_KEYFRAME;
77 return V4L2_BUF_FLAG_PFRAME;
79 return V4L2_BUF_FLAG_BFRAME;
88 static void get_resolution(struct go7007 *go, int *width, int *height)
90 switch (go->standard) {
99 case GO7007_STD_OTHER:
101 *width = go->board_info->sensor_width;
102 *height = go->board_info->sensor_height;
107 static void set_formatting(struct go7007 *go)
109 if (go->format == V4L2_PIX_FMT_MJPEG) {
111 go->aspect_ratio = GO7007_RATIO_1_1;
115 go->repeat_seqhead = 0;
116 go->seq_header_enable = 0;
117 go->gop_header_enable = 0;
122 switch (go->format) {
123 case V4L2_PIX_FMT_MPEG1:
127 case V4L2_PIX_FMT_MPEG2:
130 case V4L2_PIX_FMT_MPEG4:
131 /* For future reference: this is the list of MPEG4
132 * profiles that are available, although they are
136 * -------------- ----
141 * PROFILE_ARTS_L1 0x91
142 * PROFILE_ARTS_L2 0x92
143 * PROFILE_ARTS_L3 0x93
144 * PROFILE_ARTS_L4 0x94
155 go->gop_size = v4l2_ctrl_g_ctrl(go->mpeg_video_gop_size);
156 go->closed_gop = v4l2_ctrl_g_ctrl(go->mpeg_video_gop_closure);
157 go->ipb = v4l2_ctrl_g_ctrl(go->mpeg_video_b_frames) != 0;
158 go->bitrate = v4l2_ctrl_g_ctrl(go->mpeg_video_bitrate);
159 go->repeat_seqhead = v4l2_ctrl_g_ctrl(go->mpeg_video_rep_seqheader);
160 go->gop_header_enable = 1;
162 if (go->format == V4L2_PIX_FMT_MPEG2)
164 go->bitrate == 9800000 &&
165 go->gop_size == 15 &&
167 go->repeat_seqhead == 1 &&
170 switch (v4l2_ctrl_g_ctrl(go->mpeg_video_aspect_ratio)) {
172 case V4L2_MPEG_VIDEO_ASPECT_1x1:
173 go->aspect_ratio = GO7007_RATIO_1_1;
175 case V4L2_MPEG_VIDEO_ASPECT_4x3:
176 go->aspect_ratio = GO7007_RATIO_4_3;
178 case V4L2_MPEG_VIDEO_ASPECT_16x9:
179 go->aspect_ratio = GO7007_RATIO_16_9;
184 static int set_capture_size(struct go7007 *go, struct v4l2_format *fmt, int try)
186 int sensor_height = 0, sensor_width = 0;
189 if (fmt != NULL && !valid_pixelformat(fmt->fmt.pix.pixelformat))
192 get_resolution(go, &sensor_width, &sensor_height);
195 width = sensor_width;
196 height = sensor_height;
197 } else if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING) {
198 if (fmt->fmt.pix.width > sensor_width)
199 width = sensor_width;
200 else if (fmt->fmt.pix.width < 144)
203 width = fmt->fmt.pix.width & ~0x0f;
205 if (fmt->fmt.pix.height > sensor_height)
206 height = sensor_height;
207 else if (fmt->fmt.pix.height < 96)
210 height = fmt->fmt.pix.height & ~0x0f;
212 width = fmt->fmt.pix.width;
214 if (width <= sensor_width / 4) {
215 width = sensor_width / 4;
216 height = sensor_height / 4;
217 } else if (width <= sensor_width / 2) {
218 width = sensor_width / 2;
219 height = sensor_height / 2;
221 width = sensor_width;
222 height = sensor_height;
229 u32 pixelformat = fmt->fmt.pix.pixelformat;
231 memset(fmt, 0, sizeof(*fmt));
232 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
233 fmt->fmt.pix.width = width;
234 fmt->fmt.pix.height = height;
235 fmt->fmt.pix.pixelformat = pixelformat;
236 fmt->fmt.pix.field = V4L2_FIELD_NONE;
237 fmt->fmt.pix.bytesperline = 0;
238 fmt->fmt.pix.sizeimage = GO7007_BUF_SIZE;
239 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
246 go->format = fmt->fmt.pix.pixelformat;
249 go->encoder_h_offset = go->board_info->sensor_h_offset;
250 go->encoder_v_offset = go->board_info->sensor_v_offset;
252 if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING) {
253 struct v4l2_subdev_format format = {
254 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
257 format.format.code = MEDIA_BUS_FMT_FIXED;
258 format.format.width = fmt ? fmt->fmt.pix.width : width;
259 format.format.height = height;
260 go->encoder_h_halve = 0;
261 go->encoder_v_halve = 0;
262 go->encoder_subsample = 0;
263 call_all(&go->v4l2_dev, pad, set_fmt, NULL, &format);
265 if (width <= sensor_width / 4) {
266 go->encoder_h_halve = 1;
267 go->encoder_v_halve = 1;
268 go->encoder_subsample = 1;
269 } else if (width <= sensor_width / 2) {
270 go->encoder_h_halve = 1;
271 go->encoder_v_halve = 1;
272 go->encoder_subsample = 0;
274 go->encoder_h_halve = 0;
275 go->encoder_v_halve = 0;
276 go->encoder_subsample = 0;
282 static int vidioc_querycap(struct file *file, void *priv,
283 struct v4l2_capability *cap)
285 struct go7007 *go = video_drvdata(file);
287 strlcpy(cap->driver, "go7007", sizeof(cap->driver));
288 strlcpy(cap->card, go->name, sizeof(cap->card));
289 strlcpy(cap->bus_info, go->bus_info, sizeof(cap->bus_info));
291 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
294 if (go->board_info->num_aud_inputs)
295 cap->device_caps |= V4L2_CAP_AUDIO;
296 if (go->board_info->flags & GO7007_BOARD_HAS_TUNER)
297 cap->device_caps |= V4L2_CAP_TUNER;
298 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
302 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
303 struct v4l2_fmtdesc *fmt)
307 switch (fmt->index) {
309 fmt->pixelformat = V4L2_PIX_FMT_MJPEG;
310 desc = "Motion JPEG";
313 fmt->pixelformat = V4L2_PIX_FMT_MPEG1;
317 fmt->pixelformat = V4L2_PIX_FMT_MPEG2;
321 fmt->pixelformat = V4L2_PIX_FMT_MPEG4;
327 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
328 fmt->flags = V4L2_FMT_FLAG_COMPRESSED;
330 strncpy(fmt->description, desc, sizeof(fmt->description));
335 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
336 struct v4l2_format *fmt)
338 struct go7007 *go = video_drvdata(file);
340 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
341 fmt->fmt.pix.width = go->width;
342 fmt->fmt.pix.height = go->height;
343 fmt->fmt.pix.pixelformat = go->format;
344 fmt->fmt.pix.field = V4L2_FIELD_NONE;
345 fmt->fmt.pix.bytesperline = 0;
346 fmt->fmt.pix.sizeimage = GO7007_BUF_SIZE;
347 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
352 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
353 struct v4l2_format *fmt)
355 struct go7007 *go = video_drvdata(file);
357 return set_capture_size(go, fmt, 1);
360 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
361 struct v4l2_format *fmt)
363 struct go7007 *go = video_drvdata(file);
365 if (vb2_is_busy(&go->vidq))
368 return set_capture_size(go, fmt, 0);
371 static int go7007_queue_setup(struct vb2_queue *q,
372 const struct v4l2_format *fmt,
373 unsigned int *num_buffers, unsigned int *num_planes,
374 unsigned int sizes[], void *alloc_ctxs[])
376 sizes[0] = GO7007_BUF_SIZE;
379 if (*num_buffers < 2)
385 static void go7007_buf_queue(struct vb2_buffer *vb)
387 struct vb2_queue *vq = vb->vb2_queue;
388 struct go7007 *go = vb2_get_drv_priv(vq);
389 struct go7007_buffer *go7007_vb =
390 container_of(vb, struct go7007_buffer, vb);
393 spin_lock_irqsave(&go->spinlock, flags);
394 list_add_tail(&go7007_vb->list, &go->vidq_active);
395 spin_unlock_irqrestore(&go->spinlock, flags);
398 static int go7007_buf_prepare(struct vb2_buffer *vb)
400 struct go7007_buffer *go7007_vb =
401 container_of(vb, struct go7007_buffer, vb);
403 go7007_vb->modet_active = 0;
404 go7007_vb->frame_offset = 0;
405 vb->v4l2_planes[0].bytesused = 0;
409 static void go7007_buf_finish(struct vb2_buffer *vb)
411 struct vb2_queue *vq = vb->vb2_queue;
412 struct go7007 *go = vb2_get_drv_priv(vq);
413 struct go7007_buffer *go7007_vb =
414 container_of(vb, struct go7007_buffer, vb);
415 u32 frame_type_flag = get_frame_type_flag(go7007_vb, go->format);
416 struct v4l2_buffer *buf = &vb->v4l2_buf;
418 buf->flags &= ~(V4L2_BUF_FLAG_KEYFRAME | V4L2_BUF_FLAG_BFRAME |
419 V4L2_BUF_FLAG_PFRAME);
420 buf->flags |= frame_type_flag;
421 buf->field = V4L2_FIELD_NONE;
424 static int go7007_start_streaming(struct vb2_queue *q, unsigned int count)
426 struct go7007 *go = vb2_get_drv_priv(q);
430 mutex_lock(&go->hw_lock);
432 go->active_buf = NULL;
433 go->modet_event_status = 0;
435 if (go7007_start_encoder(go) < 0)
439 mutex_unlock(&go->hw_lock);
444 call_all(&go->v4l2_dev, video, s_stream, 1);
445 v4l2_ctrl_grab(go->mpeg_video_gop_size, true);
446 v4l2_ctrl_grab(go->mpeg_video_gop_closure, true);
447 v4l2_ctrl_grab(go->mpeg_video_bitrate, true);
448 v4l2_ctrl_grab(go->mpeg_video_aspect_ratio, true);
449 /* Turn on Capture LED */
450 if (go->board_id == GO7007_BOARDID_ADS_USBAV_709)
451 go7007_write_addr(go, 0x3c82, 0x0005);
455 static void go7007_stop_streaming(struct vb2_queue *q)
457 struct go7007 *go = vb2_get_drv_priv(q);
461 go7007_stream_stop(go);
462 mutex_lock(&go->hw_lock);
463 go7007_reset_encoder(go);
464 mutex_unlock(&go->hw_lock);
465 call_all(&go->v4l2_dev, video, s_stream, 0);
467 spin_lock_irqsave(&go->spinlock, flags);
468 INIT_LIST_HEAD(&go->vidq_active);
469 spin_unlock_irqrestore(&go->spinlock, flags);
470 v4l2_ctrl_grab(go->mpeg_video_gop_size, false);
471 v4l2_ctrl_grab(go->mpeg_video_gop_closure, false);
472 v4l2_ctrl_grab(go->mpeg_video_bitrate, false);
473 v4l2_ctrl_grab(go->mpeg_video_aspect_ratio, false);
474 /* Turn on Capture LED */
475 if (go->board_id == GO7007_BOARDID_ADS_USBAV_709)
476 go7007_write_addr(go, 0x3c82, 0x000d);
479 static struct vb2_ops go7007_video_qops = {
480 .queue_setup = go7007_queue_setup,
481 .buf_queue = go7007_buf_queue,
482 .buf_prepare = go7007_buf_prepare,
483 .buf_finish = go7007_buf_finish,
484 .start_streaming = go7007_start_streaming,
485 .stop_streaming = go7007_stop_streaming,
486 .wait_prepare = vb2_ops_wait_prepare,
487 .wait_finish = vb2_ops_wait_finish,
490 static int vidioc_g_parm(struct file *filp, void *priv,
491 struct v4l2_streamparm *parm)
493 struct go7007 *go = video_drvdata(filp);
494 struct v4l2_fract timeperframe = {
495 .numerator = 1001 * go->fps_scale,
496 .denominator = go->sensor_framerate,
499 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
502 parm->parm.capture.readbuffers = 2;
503 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
504 parm->parm.capture.timeperframe = timeperframe;
509 static int vidioc_s_parm(struct file *filp, void *priv,
510 struct v4l2_streamparm *parm)
512 struct go7007 *go = video_drvdata(filp);
515 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
518 n = go->sensor_framerate *
519 parm->parm.capture.timeperframe.numerator;
520 d = 1001 * parm->parm.capture.timeperframe.denominator;
521 if (n != 0 && d != 0 && n > d)
522 go->fps_scale = (n + d/2) / d;
526 return vidioc_g_parm(filp, priv, parm);
529 /* VIDIOC_ENUMSTD on go7007 were used for enumerating the supported fps and
530 its resolution, when the device is not connected to TV.
531 This is were an API abuse, probably used by the lack of specific IOCTL's to
532 enumerate it, by the time the driver was written.
534 However, since kernel 2.6.19, two new ioctls (VIDIOC_ENUM_FRAMEINTERVALS
535 and VIDIOC_ENUM_FRAMESIZES) were added for this purpose.
537 The two functions below implement the newer ioctls
539 static int vidioc_enum_framesizes(struct file *filp, void *priv,
540 struct v4l2_frmsizeenum *fsize)
542 struct go7007 *go = video_drvdata(filp);
545 if (fsize->index > 2)
548 if (!valid_pixelformat(fsize->pixel_format))
551 get_resolution(go, &width, &height);
552 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
553 fsize->discrete.width = (width >> fsize->index) & ~0xf;
554 fsize->discrete.height = (height >> fsize->index) & ~0xf;
558 static int vidioc_enum_frameintervals(struct file *filp, void *priv,
559 struct v4l2_frmivalenum *fival)
561 struct go7007 *go = video_drvdata(filp);
565 if (fival->index > 4)
568 if (!valid_pixelformat(fival->pixel_format))
571 if (!(go->board_info->sensor_flags & GO7007_SENSOR_SCALING)) {
572 get_resolution(go, &width, &height);
573 for (i = 0; i <= 2; i++)
574 if (fival->width == ((width >> i) & ~0xf) &&
575 fival->height == ((height >> i) & ~0xf))
580 fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
581 fival->discrete.numerator = 1001 * (fival->index + 1);
582 fival->discrete.denominator = go->sensor_framerate;
586 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *std)
588 struct go7007 *go = video_drvdata(file);
594 static int go7007_s_std(struct go7007 *go)
596 if (go->std & V4L2_STD_625_50) {
597 go->standard = GO7007_STD_PAL;
598 go->sensor_framerate = 25025;
600 go->standard = GO7007_STD_NTSC;
601 go->sensor_framerate = 30000;
604 call_all(&go->v4l2_dev, video, s_std, go->std);
605 set_capture_size(go, NULL, 0);
609 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id std)
611 struct go7007 *go = video_drvdata(file);
613 if (vb2_is_busy(&go->vidq))
618 return go7007_s_std(go);
621 static int vidioc_querystd(struct file *file, void *priv, v4l2_std_id *std)
623 struct go7007 *go = video_drvdata(file);
625 return call_all(&go->v4l2_dev, video, querystd, std);
628 static int vidioc_enum_input(struct file *file, void *priv,
629 struct v4l2_input *inp)
631 struct go7007 *go = video_drvdata(file);
633 if (inp->index >= go->board_info->num_inputs)
636 strncpy(inp->name, go->board_info->inputs[inp->index].name,
639 /* If this board has a tuner, it will be the first input */
640 if ((go->board_info->flags & GO7007_BOARD_HAS_TUNER) &&
642 inp->type = V4L2_INPUT_TYPE_TUNER;
644 inp->type = V4L2_INPUT_TYPE_CAMERA;
646 if (go->board_info->num_aud_inputs)
647 inp->audioset = (1 << go->board_info->num_aud_inputs) - 1;
651 if (go->board_info->sensor_flags & GO7007_SENSOR_TV)
652 inp->std = video_devdata(file)->tvnorms;
660 static int vidioc_g_input(struct file *file, void *priv, unsigned int *input)
662 struct go7007 *go = video_drvdata(file);
669 static int vidioc_enumaudio(struct file *file, void *fh, struct v4l2_audio *a)
671 struct go7007 *go = video_drvdata(file);
673 if (a->index >= go->board_info->num_aud_inputs)
675 strlcpy(a->name, go->board_info->aud_inputs[a->index].name,
677 a->capability = V4L2_AUDCAP_STEREO;
681 static int vidioc_g_audio(struct file *file, void *fh, struct v4l2_audio *a)
683 struct go7007 *go = video_drvdata(file);
685 a->index = go->aud_input;
686 strlcpy(a->name, go->board_info->aud_inputs[go->aud_input].name,
688 a->capability = V4L2_AUDCAP_STEREO;
692 static int vidioc_s_audio(struct file *file, void *fh,
693 const struct v4l2_audio *a)
695 struct go7007 *go = video_drvdata(file);
697 if (a->index >= go->board_info->num_aud_inputs)
699 go->aud_input = a->index;
700 v4l2_subdev_call(go->sd_audio, audio, s_routing,
701 go->board_info->aud_inputs[go->aud_input].audio_input, 0, 0);
705 static void go7007_s_input(struct go7007 *go)
707 unsigned int input = go->input;
709 v4l2_subdev_call(go->sd_video, video, s_routing,
710 go->board_info->inputs[input].video_input, 0,
711 go->board_info->video_config);
712 if (go->board_info->num_aud_inputs) {
713 int aud_input = go->board_info->inputs[input].audio_index;
715 v4l2_subdev_call(go->sd_audio, audio, s_routing,
716 go->board_info->aud_inputs[aud_input].audio_input, 0, 0);
717 go->aud_input = aud_input;
721 static int vidioc_s_input(struct file *file, void *priv, unsigned int input)
723 struct go7007 *go = video_drvdata(file);
725 if (input >= go->board_info->num_inputs)
727 if (vb2_is_busy(&go->vidq))
736 static int vidioc_g_tuner(struct file *file, void *priv,
737 struct v4l2_tuner *t)
739 struct go7007 *go = video_drvdata(file);
744 strlcpy(t->name, "Tuner", sizeof(t->name));
745 return call_all(&go->v4l2_dev, tuner, g_tuner, t);
748 static int vidioc_s_tuner(struct file *file, void *priv,
749 const struct v4l2_tuner *t)
751 struct go7007 *go = video_drvdata(file);
756 return call_all(&go->v4l2_dev, tuner, s_tuner, t);
759 static int vidioc_g_frequency(struct file *file, void *priv,
760 struct v4l2_frequency *f)
762 struct go7007 *go = video_drvdata(file);
767 return call_all(&go->v4l2_dev, tuner, g_frequency, f);
770 static int vidioc_s_frequency(struct file *file, void *priv,
771 const struct v4l2_frequency *f)
773 struct go7007 *go = video_drvdata(file);
778 return call_all(&go->v4l2_dev, tuner, s_frequency, f);
781 static int vidioc_log_status(struct file *file, void *priv)
783 struct go7007 *go = video_drvdata(file);
785 v4l2_ctrl_log_status(file, priv);
786 return call_all(&go->v4l2_dev, core, log_status);
789 static int vidioc_subscribe_event(struct v4l2_fh *fh,
790 const struct v4l2_event_subscription *sub)
794 case V4L2_EVENT_CTRL:
795 return v4l2_ctrl_subscribe_event(fh, sub);
796 case V4L2_EVENT_MOTION_DET:
797 /* Allow for up to 30 events (1 second for NTSC) to be
799 return v4l2_event_subscribe(fh, sub, 30, NULL);
805 static int go7007_s_ctrl(struct v4l2_ctrl *ctrl)
808 container_of(ctrl->handler, struct go7007, hdl);
813 case V4L2_CID_PIXEL_THRESHOLD0:
814 go->modet[0].pixel_threshold = ctrl->val;
816 case V4L2_CID_MOTION_THRESHOLD0:
817 go->modet[0].motion_threshold = ctrl->val;
819 case V4L2_CID_MB_THRESHOLD0:
820 go->modet[0].mb_threshold = ctrl->val;
822 case V4L2_CID_PIXEL_THRESHOLD1:
823 go->modet[1].pixel_threshold = ctrl->val;
825 case V4L2_CID_MOTION_THRESHOLD1:
826 go->modet[1].motion_threshold = ctrl->val;
828 case V4L2_CID_MB_THRESHOLD1:
829 go->modet[1].mb_threshold = ctrl->val;
831 case V4L2_CID_PIXEL_THRESHOLD2:
832 go->modet[2].pixel_threshold = ctrl->val;
834 case V4L2_CID_MOTION_THRESHOLD2:
835 go->modet[2].motion_threshold = ctrl->val;
837 case V4L2_CID_MB_THRESHOLD2:
838 go->modet[2].mb_threshold = ctrl->val;
840 case V4L2_CID_PIXEL_THRESHOLD3:
841 go->modet[3].pixel_threshold = ctrl->val;
843 case V4L2_CID_MOTION_THRESHOLD3:
844 go->modet[3].motion_threshold = ctrl->val;
846 case V4L2_CID_MB_THRESHOLD3:
847 go->modet[3].mb_threshold = ctrl->val;
849 case V4L2_CID_DETECT_MD_REGION_GRID:
851 for (y = 0; y < go->height / 16; y++, mt += go->width / 16)
852 memcpy(mt, ctrl->p_new.p_u8 + y * (720 / 16), go->width / 16);
860 static struct v4l2_file_operations go7007_fops = {
861 .owner = THIS_MODULE,
862 .open = v4l2_fh_open,
863 .release = vb2_fop_release,
864 .unlocked_ioctl = video_ioctl2,
865 .read = vb2_fop_read,
866 .mmap = vb2_fop_mmap,
867 .poll = vb2_fop_poll,
870 static const struct v4l2_ioctl_ops video_ioctl_ops = {
871 .vidioc_querycap = vidioc_querycap,
872 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
873 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
874 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
875 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
876 .vidioc_reqbufs = vb2_ioctl_reqbufs,
877 .vidioc_querybuf = vb2_ioctl_querybuf,
878 .vidioc_qbuf = vb2_ioctl_qbuf,
879 .vidioc_dqbuf = vb2_ioctl_dqbuf,
880 .vidioc_g_std = vidioc_g_std,
881 .vidioc_s_std = vidioc_s_std,
882 .vidioc_querystd = vidioc_querystd,
883 .vidioc_enum_input = vidioc_enum_input,
884 .vidioc_g_input = vidioc_g_input,
885 .vidioc_s_input = vidioc_s_input,
886 .vidioc_enumaudio = vidioc_enumaudio,
887 .vidioc_g_audio = vidioc_g_audio,
888 .vidioc_s_audio = vidioc_s_audio,
889 .vidioc_streamon = vb2_ioctl_streamon,
890 .vidioc_streamoff = vb2_ioctl_streamoff,
891 .vidioc_g_tuner = vidioc_g_tuner,
892 .vidioc_s_tuner = vidioc_s_tuner,
893 .vidioc_g_frequency = vidioc_g_frequency,
894 .vidioc_s_frequency = vidioc_s_frequency,
895 .vidioc_g_parm = vidioc_g_parm,
896 .vidioc_s_parm = vidioc_s_parm,
897 .vidioc_enum_framesizes = vidioc_enum_framesizes,
898 .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
899 .vidioc_log_status = vidioc_log_status,
900 .vidioc_subscribe_event = vidioc_subscribe_event,
901 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
904 static struct video_device go7007_template = {
906 .fops = &go7007_fops,
907 .release = video_device_release_empty,
908 .ioctl_ops = &video_ioctl_ops,
909 .tvnorms = V4L2_STD_ALL,
912 static const struct v4l2_ctrl_ops go7007_ctrl_ops = {
913 .s_ctrl = go7007_s_ctrl,
916 static const struct v4l2_ctrl_config go7007_pixel_threshold0_ctrl = {
917 .ops = &go7007_ctrl_ops,
918 .id = V4L2_CID_PIXEL_THRESHOLD0,
919 .name = "Pixel Threshold Region 0",
920 .type = V4L2_CTRL_TYPE_INTEGER,
926 static const struct v4l2_ctrl_config go7007_motion_threshold0_ctrl = {
927 .ops = &go7007_ctrl_ops,
928 .id = V4L2_CID_MOTION_THRESHOLD0,
929 .name = "Motion Threshold Region 0",
930 .type = V4L2_CTRL_TYPE_INTEGER,
936 static const struct v4l2_ctrl_config go7007_mb_threshold0_ctrl = {
937 .ops = &go7007_ctrl_ops,
938 .id = V4L2_CID_MB_THRESHOLD0,
939 .name = "MB Threshold Region 0",
940 .type = V4L2_CTRL_TYPE_INTEGER,
946 static const struct v4l2_ctrl_config go7007_pixel_threshold1_ctrl = {
947 .ops = &go7007_ctrl_ops,
948 .id = V4L2_CID_PIXEL_THRESHOLD1,
949 .name = "Pixel Threshold Region 1",
950 .type = V4L2_CTRL_TYPE_INTEGER,
956 static const struct v4l2_ctrl_config go7007_motion_threshold1_ctrl = {
957 .ops = &go7007_ctrl_ops,
958 .id = V4L2_CID_MOTION_THRESHOLD1,
959 .name = "Motion Threshold Region 1",
960 .type = V4L2_CTRL_TYPE_INTEGER,
966 static const struct v4l2_ctrl_config go7007_mb_threshold1_ctrl = {
967 .ops = &go7007_ctrl_ops,
968 .id = V4L2_CID_MB_THRESHOLD1,
969 .name = "MB Threshold Region 1",
970 .type = V4L2_CTRL_TYPE_INTEGER,
976 static const struct v4l2_ctrl_config go7007_pixel_threshold2_ctrl = {
977 .ops = &go7007_ctrl_ops,
978 .id = V4L2_CID_PIXEL_THRESHOLD2,
979 .name = "Pixel Threshold Region 2",
980 .type = V4L2_CTRL_TYPE_INTEGER,
986 static const struct v4l2_ctrl_config go7007_motion_threshold2_ctrl = {
987 .ops = &go7007_ctrl_ops,
988 .id = V4L2_CID_MOTION_THRESHOLD2,
989 .name = "Motion Threshold Region 2",
990 .type = V4L2_CTRL_TYPE_INTEGER,
996 static const struct v4l2_ctrl_config go7007_mb_threshold2_ctrl = {
997 .ops = &go7007_ctrl_ops,
998 .id = V4L2_CID_MB_THRESHOLD2,
999 .name = "MB Threshold Region 2",
1000 .type = V4L2_CTRL_TYPE_INTEGER,
1006 static const struct v4l2_ctrl_config go7007_pixel_threshold3_ctrl = {
1007 .ops = &go7007_ctrl_ops,
1008 .id = V4L2_CID_PIXEL_THRESHOLD3,
1009 .name = "Pixel Threshold Region 3",
1010 .type = V4L2_CTRL_TYPE_INTEGER,
1016 static const struct v4l2_ctrl_config go7007_motion_threshold3_ctrl = {
1017 .ops = &go7007_ctrl_ops,
1018 .id = V4L2_CID_MOTION_THRESHOLD3,
1019 .name = "Motion Threshold Region 3",
1020 .type = V4L2_CTRL_TYPE_INTEGER,
1026 static const struct v4l2_ctrl_config go7007_mb_threshold3_ctrl = {
1027 .ops = &go7007_ctrl_ops,
1028 .id = V4L2_CID_MB_THRESHOLD3,
1029 .name = "MB Threshold Region 3",
1030 .type = V4L2_CTRL_TYPE_INTEGER,
1036 static const struct v4l2_ctrl_config go7007_mb_regions_ctrl = {
1037 .ops = &go7007_ctrl_ops,
1038 .id = V4L2_CID_DETECT_MD_REGION_GRID,
1039 .dims = { 576 / 16, 720 / 16 },
1044 int go7007_v4l2_ctrl_init(struct go7007 *go)
1046 struct v4l2_ctrl_handler *hdl = &go->hdl;
1047 struct v4l2_ctrl *ctrl;
1049 v4l2_ctrl_handler_init(hdl, 22);
1050 go->mpeg_video_gop_size = v4l2_ctrl_new_std(hdl, NULL,
1051 V4L2_CID_MPEG_VIDEO_GOP_SIZE, 0, 34, 1, 15);
1052 go->mpeg_video_gop_closure = v4l2_ctrl_new_std(hdl, NULL,
1053 V4L2_CID_MPEG_VIDEO_GOP_CLOSURE, 0, 1, 1, 1);
1054 go->mpeg_video_bitrate = v4l2_ctrl_new_std(hdl, NULL,
1055 V4L2_CID_MPEG_VIDEO_BITRATE,
1056 64000, 10000000, 1, 9800000);
1057 go->mpeg_video_b_frames = v4l2_ctrl_new_std(hdl, NULL,
1058 V4L2_CID_MPEG_VIDEO_B_FRAMES, 0, 2, 2, 0);
1059 go->mpeg_video_rep_seqheader = v4l2_ctrl_new_std(hdl, NULL,
1060 V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER, 0, 1, 1, 1);
1062 go->mpeg_video_aspect_ratio = v4l2_ctrl_new_std_menu(hdl, NULL,
1063 V4L2_CID_MPEG_VIDEO_ASPECT,
1064 V4L2_MPEG_VIDEO_ASPECT_16x9, 0,
1065 V4L2_MPEG_VIDEO_ASPECT_1x1);
1066 ctrl = v4l2_ctrl_new_std(hdl, NULL,
1067 V4L2_CID_JPEG_ACTIVE_MARKER, 0,
1068 V4L2_JPEG_ACTIVE_MARKER_DQT |
1069 V4L2_JPEG_ACTIVE_MARKER_DHT, 0,
1070 V4L2_JPEG_ACTIVE_MARKER_DQT |
1071 V4L2_JPEG_ACTIVE_MARKER_DHT);
1073 ctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1074 v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold0_ctrl, NULL);
1075 v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold0_ctrl, NULL);
1076 v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold0_ctrl, NULL);
1077 v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold1_ctrl, NULL);
1078 v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold1_ctrl, NULL);
1079 v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold1_ctrl, NULL);
1080 v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold2_ctrl, NULL);
1081 v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold2_ctrl, NULL);
1082 v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold2_ctrl, NULL);
1083 v4l2_ctrl_new_custom(hdl, &go7007_pixel_threshold3_ctrl, NULL);
1084 v4l2_ctrl_new_custom(hdl, &go7007_motion_threshold3_ctrl, NULL);
1085 v4l2_ctrl_new_custom(hdl, &go7007_mb_threshold3_ctrl, NULL);
1086 v4l2_ctrl_new_custom(hdl, &go7007_mb_regions_ctrl, NULL);
1087 go->modet_mode = v4l2_ctrl_new_std_menu(hdl, NULL,
1088 V4L2_CID_DETECT_MD_MODE,
1089 V4L2_DETECT_MD_MODE_REGION_GRID,
1090 1 << V4L2_DETECT_MD_MODE_THRESHOLD_GRID,
1091 V4L2_DETECT_MD_MODE_DISABLED);
1093 int rv = hdl->error;
1095 v4l2_err(&go->v4l2_dev, "Could not register controls\n");
1098 go->v4l2_dev.ctrl_handler = hdl;
1102 int go7007_v4l2_init(struct go7007 *go)
1104 struct video_device *vdev = &go->vdev;
1107 mutex_init(&go->serialize_lock);
1108 mutex_init(&go->queue_lock);
1110 INIT_LIST_HEAD(&go->vidq_active);
1111 go->vidq.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1112 go->vidq.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
1113 go->vidq.ops = &go7007_video_qops;
1114 go->vidq.mem_ops = &vb2_vmalloc_memops;
1115 go->vidq.drv_priv = go;
1116 go->vidq.buf_struct_size = sizeof(struct go7007_buffer);
1117 go->vidq.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1118 go->vidq.lock = &go->queue_lock;
1119 rv = vb2_queue_init(&go->vidq);
1122 *vdev = go7007_template;
1123 vdev->lock = &go->serialize_lock;
1124 vdev->queue = &go->vidq;
1125 video_set_drvdata(vdev, go);
1126 vdev->v4l2_dev = &go->v4l2_dev;
1127 if (!v4l2_device_has_op(&go->v4l2_dev, video, querystd))
1128 v4l2_disable_ioctl(vdev, VIDIOC_QUERYSTD);
1129 if (!(go->board_info->flags & GO7007_BOARD_HAS_TUNER)) {
1130 v4l2_disable_ioctl(vdev, VIDIOC_S_FREQUENCY);
1131 v4l2_disable_ioctl(vdev, VIDIOC_G_FREQUENCY);
1132 v4l2_disable_ioctl(vdev, VIDIOC_S_TUNER);
1133 v4l2_disable_ioctl(vdev, VIDIOC_G_TUNER);
1135 struct v4l2_frequency f = {
1136 .type = V4L2_TUNER_ANALOG_TV,
1140 call_all(&go->v4l2_dev, tuner, s_frequency, &f);
1142 if (!(go->board_info->sensor_flags & GO7007_SENSOR_TV)) {
1143 v4l2_disable_ioctl(vdev, VIDIOC_G_STD);
1144 v4l2_disable_ioctl(vdev, VIDIOC_S_STD);
1147 if (go->board_info->sensor_flags & GO7007_SENSOR_SCALING)
1148 v4l2_disable_ioctl(vdev, VIDIOC_ENUM_FRAMESIZES);
1149 if (go->board_info->num_aud_inputs == 0) {
1150 v4l2_disable_ioctl(vdev, VIDIOC_G_AUDIO);
1151 v4l2_disable_ioctl(vdev, VIDIOC_S_AUDIO);
1152 v4l2_disable_ioctl(vdev, VIDIOC_ENUMAUDIO);
1154 /* Setup correct crystal frequency on this board */
1155 if (go->board_info->sensor_flags & GO7007_SENSOR_SAA7115)
1156 v4l2_subdev_call(go->sd_video, video, s_crystal_freq,
1157 SAA7115_FREQ_24_576_MHZ,
1158 SAA7115_FREQ_FL_APLL | SAA7115_FREQ_FL_UCGC |
1159 SAA7115_FREQ_FL_DOUBLE_ASCLK);
1161 if (go->board_info->sensor_flags & GO7007_SENSOR_TV)
1163 rv = video_register_device(vdev, VFL_TYPE_GRABBER, -1);
1166 dev_info(go->dev, "registered device %s [v4l2]\n",
1167 video_device_node_name(vdev));
1172 void go7007_v4l2_remove(struct go7007 *go)
1174 v4l2_ctrl_handler_free(&go->hdl);