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