drivers/media/usb/go7007/go7007-v4l2.c

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