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