drivers/media/common/saa7146_video.c

   1 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   2
   3 #include <media/saa7146_vv.h>
   4 #include <media/v4l2-chip-ident.h>
   5 #include <linux/module.h>
   6
   7 static int max_memory = 32;
   8
   9 module_param(max_memory, int, 0644);
  10 MODULE_PARM_DESC(max_memory, "maximum memory usage for capture buffers (default: 32Mb)");
  11
  12 #define IS_CAPTURE_ACTIVE(fh) \
  13         (((vv->video_status & STATUS_CAPTURE) != 0) && (vv->video_fh == fh))
  14
  15 #define IS_OVERLAY_ACTIVE(fh) \
  16         (((vv->video_status & STATUS_OVERLAY) != 0) && (vv->video_fh == fh))
  17
  18 /* format descriptions for capture and preview */
  19 static struct saa7146_format formats[] = {
  20         {
  21                 .name           = "RGB-8 (3-3-2)",
  22                 .pixelformat    = V4L2_PIX_FMT_RGB332,
  23                 .trans          = RGB08_COMPOSED,
  24                 .depth          = 8,
  25                 .flags          = 0,
  26         }, {
  27                 .name           = "RGB-16 (5/B-6/G-5/R)",
  28                 .pixelformat    = V4L2_PIX_FMT_RGB565,
  29                 .trans          = RGB16_COMPOSED,
  30                 .depth          = 16,
  31                 .flags          = 0,
  32         }, {
  33                 .name           = "RGB-24 (B-G-R)",
  34                 .pixelformat    = V4L2_PIX_FMT_BGR24,
  35                 .trans          = RGB24_COMPOSED,
  36                 .depth          = 24,
  37                 .flags          = 0,
  38         }, {
  39                 .name           = "RGB-32 (B-G-R)",
  40                 .pixelformat    = V4L2_PIX_FMT_BGR32,
  41                 .trans          = RGB32_COMPOSED,
  42                 .depth          = 32,
  43                 .flags          = 0,
  44         }, {
  45                 .name           = "RGB-32 (R-G-B)",
  46                 .pixelformat    = V4L2_PIX_FMT_RGB32,
  47                 .trans          = RGB32_COMPOSED,
  48                 .depth          = 32,
  49                 .flags          = 0,
  50                 .swap           = 0x2,
  51         }, {
  52                 .name           = "Greyscale-8",
  53                 .pixelformat    = V4L2_PIX_FMT_GREY,
  54                 .trans          = Y8,
  55                 .depth          = 8,
  56                 .flags          = 0,
  57         }, {
  58                 .name           = "YUV 4:2:2 planar (Y-Cb-Cr)",
  59                 .pixelformat    = V4L2_PIX_FMT_YUV422P,
  60                 .trans          = YUV422_DECOMPOSED,
  61                 .depth          = 16,
  62                 .flags          = FORMAT_BYTE_SWAP|FORMAT_IS_PLANAR,
  63         }, {
  64                 .name           = "YVU 4:2:0 planar (Y-Cb-Cr)",
  65                 .pixelformat    = V4L2_PIX_FMT_YVU420,
  66                 .trans          = YUV420_DECOMPOSED,
  67                 .depth          = 12,
  68                 .flags          = FORMAT_BYTE_SWAP|FORMAT_IS_PLANAR,
  69         }, {
  70                 .name           = "YUV 4:2:0 planar (Y-Cb-Cr)",
  71                 .pixelformat    = V4L2_PIX_FMT_YUV420,
  72                 .trans          = YUV420_DECOMPOSED,
  73                 .depth          = 12,
  74                 .flags          = FORMAT_IS_PLANAR,
  75         }, {
  76                 .name           = "YUV 4:2:2 (U-Y-V-Y)",
  77                 .pixelformat    = V4L2_PIX_FMT_UYVY,
  78                 .trans          = YUV422_COMPOSED,
  79                 .depth          = 16,
  80                 .flags          = 0,
  81         }
  82 };
  83
  84 /* unfortunately, the saa7146 contains a bug which prevents it from doing on-the-fly byte swaps.
  85    due to this, it's impossible to provide additional *packed* formats, which are simply byte swapped
  86    (like V4L2_PIX_FMT_YUYV) ... 8-( */
  87
  88 static int NUM_FORMATS = sizeof(formats)/sizeof(struct saa7146_format);
  89
  90 struct saa7146_format* saa7146_format_by_fourcc(struct saa7146_dev *dev, int fourcc)
  91 {
  92         int i, j = NUM_FORMATS;
  93
  94         for (i = 0; i < j; i++) {
  95                 if (formats[i].pixelformat == fourcc) {
  96                         return formats+i;
  97                 }
  98         }
  99
 100         DEB_D("unknown pixelformat:'%4.4s'\n", (char *)&fourcc);
 101         return NULL;
 102 }
 103
 104 static int vidioc_try_fmt_vid_overlay(struct file *file, void *fh, struct v4l2_format *f);
 105
 106 int saa7146_start_preview(struct saa7146_fh *fh)
 107 {
 108         struct saa7146_dev *dev = fh->dev;
 109         struct saa7146_vv *vv = dev->vv_data;
 110         struct v4l2_format fmt;
 111         int ret = 0, err = 0;
 112
 113         DEB_EE("dev:%p, fh:%p\n", dev, fh);
 114
 115         /* check if we have overlay information */
 116         if (vv->ov.fh == NULL) {
 117                 DEB_D("no overlay data available. try S_FMT first.\n");
 118                 return -EAGAIN;
 119         }
 120
 121         /* check if streaming capture is running */
 122         if (IS_CAPTURE_ACTIVE(fh) != 0) {
 123                 DEB_D("streaming capture is active\n");
 124                 return -EBUSY;
 125         }
 126
 127         /* check if overlay is running */
 128         if (IS_OVERLAY_ACTIVE(fh) != 0) {
 129                 if (vv->video_fh == fh) {
 130                         DEB_D("overlay is already active\n");
 131                         return 0;
 132                 }
 133                 DEB_D("overlay is already active in another open\n");
 134                 return -EBUSY;
 135         }
 136
 137         if (0 == saa7146_res_get(fh, RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP)) {
 138                 DEB_D("cannot get necessary overlay resources\n");
 139                 return -EBUSY;
 140         }
 141
 142         fmt.fmt.win = vv->ov.win;
 143         err = vidioc_try_fmt_vid_overlay(NULL, fh, &fmt);
 144         if (0 != err) {
 145                 saa7146_res_free(vv->video_fh, RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP);
 146                 return -EBUSY;
 147         }
 148         vv->ov.win = fmt.fmt.win;
 149
 150         DEB_D("%dx%d+%d+%d %s field=%s\n",
 151               vv->ov.win.w.width, vv->ov.win.w.height,
 152               vv->ov.win.w.left, vv->ov.win.w.top,
 153               vv->ov_fmt->name, v4l2_field_names[vv->ov.win.field]);
 154
 155         if (0 != (ret = saa7146_enable_overlay(fh))) {
 156                 DEB_D("enabling overlay failed: %d\n", ret);
 157                 saa7146_res_free(vv->video_fh, RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP);
 158                 return ret;
 159         }
 160
 161         vv->video_status = STATUS_OVERLAY;
 162         vv->video_fh = fh;
 163
 164         return 0;
 165 }
 166 EXPORT_SYMBOL_GPL(saa7146_start_preview);
 167
 168 int saa7146_stop_preview(struct saa7146_fh *fh)
 169 {
 170         struct saa7146_dev *dev = fh->dev;
 171         struct saa7146_vv *vv = dev->vv_data;
 172
 173         DEB_EE("dev:%p, fh:%p\n", dev, fh);
 174
 175         /* check if streaming capture is running */
 176         if (IS_CAPTURE_ACTIVE(fh) != 0) {
 177                 DEB_D("streaming capture is active\n");
 178                 return -EBUSY;
 179         }
 180
 181         /* check if overlay is running at all */
 182         if ((vv->video_status & STATUS_OVERLAY) == 0) {
 183                 DEB_D("no active overlay\n");
 184                 return 0;
 185         }
 186
 187         if (vv->video_fh != fh) {
 188                 DEB_D("overlay is active, but in another open\n");
 189                 return -EBUSY;
 190         }
 191
 192         vv->video_status = 0;
 193         vv->video_fh = NULL;
 194
 195         saa7146_disable_overlay(fh);
 196
 197         saa7146_res_free(fh, RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP);
 198
 199         return 0;
 200 }
 201 EXPORT_SYMBOL_GPL(saa7146_stop_preview);
 202
 203 /********************************************************************************/
 204 /* common pagetable functions */
 205
 206 static int saa7146_pgtable_build(struct saa7146_dev *dev, struct saa7146_buf *buf)
 207 {
 208         struct pci_dev *pci = dev->pci;
 209         struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
 210         struct scatterlist *list = dma->sglist;
 211         int length = dma->sglen;
 212         struct saa7146_format *sfmt = saa7146_format_by_fourcc(dev,buf->fmt->pixelformat);
 213
 214         DEB_EE("dev:%p, buf:%p, sg_len:%d\n", dev, buf, length);
 215
 216         if( 0 != IS_PLANAR(sfmt->trans)) {
 217                 struct saa7146_pgtable *pt1 = &buf->pt[0];
 218                 struct saa7146_pgtable *pt2 = &buf->pt[1];
 219                 struct saa7146_pgtable *pt3 = &buf->pt[2];
 220                 __le32  *ptr1, *ptr2, *ptr3;
 221                 __le32 fill;
 222
 223                 int size = buf->fmt->width*buf->fmt->height;
 224                 int i,p,m1,m2,m3,o1,o2;
 225
 226                 switch( sfmt->depth ) {
 227                         case 12: {
 228                                 /* create some offsets inside the page table */
 229                                 m1 = ((size+PAGE_SIZE)/PAGE_SIZE)-1;
 230                                 m2 = ((size+(size/4)+PAGE_SIZE)/PAGE_SIZE)-1;
 231                                 m3 = ((size+(size/2)+PAGE_SIZE)/PAGE_SIZE)-1;
 232                                 o1 = size%PAGE_SIZE;
 233                                 o2 = (size+(size/4))%PAGE_SIZE;
 234                                 DEB_CAP("size:%d, m1:%d, m2:%d, m3:%d, o1:%d, o2:%d\n",
 235                                         size, m1, m2, m3, o1, o2);
 236                                 break;
 237                         }
 238                         case 16: {
 239                                 /* create some offsets inside the page table */
 240                                 m1 = ((size+PAGE_SIZE)/PAGE_SIZE)-1;
 241                                 m2 = ((size+(size/2)+PAGE_SIZE)/PAGE_SIZE)-1;
 242                                 m3 = ((2*size+PAGE_SIZE)/PAGE_SIZE)-1;
 243                                 o1 = size%PAGE_SIZE;
 244                                 o2 = (size+(size/2))%PAGE_SIZE;
 245                                 DEB_CAP("size:%d, m1:%d, m2:%d, m3:%d, o1:%d, o2:%d\n",
 246                                         size, m1, m2, m3, o1, o2);
 247                                 break;
 248                         }
 249                         default: {
 250                                 return -1;
 251                         }
 252                 }
 253
 254                 ptr1 = pt1->cpu;
 255                 ptr2 = pt2->cpu;
 256                 ptr3 = pt3->cpu;
 257
 258                 /* walk all pages, copy all page addresses to ptr1 */
 259                 for (i = 0; i < length; i++, list++) {
 260                         for (p = 0; p * 4096 < list->length; p++, ptr1++) {
 261                                 *ptr1 = cpu_to_le32(sg_dma_address(list) - list->offset);
 262                         }
 263                 }
 264 /*
 265                 ptr1 = pt1->cpu;
 266                 for(j=0;j<40;j++) {
 267                         printk("ptr1 %d: 0x%08x\n",j,ptr1[j]);
 268                 }
 269 */
 270
 271                 /* if we have a user buffer, the first page may not be
 272                    aligned to a page boundary. */
 273                 pt1->offset = dma->sglist->offset;
 274                 pt2->offset = pt1->offset+o1;
 275                 pt3->offset = pt1->offset+o2;
 276
 277                 /* create video-dma2 page table */
 278                 ptr1 = pt1->cpu;
 279                 for(i = m1; i <= m2 ; i++, ptr2++) {
 280                         *ptr2 = ptr1[i];
 281                 }
 282                 fill = *(ptr2-1);
 283                 for(;i<1024;i++,ptr2++) {
 284                         *ptr2 = fill;
 285                 }
 286                 /* create video-dma3 page table */
 287                 ptr1 = pt1->cpu;
 288                 for(i = m2; i <= m3; i++,ptr3++) {
 289                         *ptr3 = ptr1[i];
 290                 }
 291                 fill = *(ptr3-1);
 292                 for(;i<1024;i++,ptr3++) {
 293                         *ptr3 = fill;
 294                 }
 295                 /* finally: finish up video-dma1 page table */
 296                 ptr1 = pt1->cpu+m1;
 297                 fill = pt1->cpu[m1];
 298                 for(i=m1;i<1024;i++,ptr1++) {
 299                         *ptr1 = fill;
 300                 }
 301 /*
 302                 ptr1 = pt1->cpu;
 303                 ptr2 = pt2->cpu;
 304                 ptr3 = pt3->cpu;
 305                 for(j=0;j<40;j++) {
 306                         printk("ptr1 %d: 0x%08x\n",j,ptr1[j]);
 307                 }
 308                 for(j=0;j<40;j++) {
 309                         printk("ptr2 %d: 0x%08x\n",j,ptr2[j]);
 310                 }
 311                 for(j=0;j<40;j++) {
 312                         printk("ptr3 %d: 0x%08x\n",j,ptr3[j]);
 313                 }
 314 */
 315         } else {
 316                 struct saa7146_pgtable *pt = &buf->pt[0];
 317                 return saa7146_pgtable_build_single(pci, pt, list, length);
 318         }
 319
 320         return 0;
 321 }
 322
 323
 324 /********************************************************************************/
 325 /* file operations */
 326
 327 static int video_begin(struct saa7146_fh *fh)
 328 {
 329         struct saa7146_dev *dev = fh->dev;
 330         struct saa7146_vv *vv = dev->vv_data;
 331         struct saa7146_format *fmt = NULL;
 332         unsigned int resource;
 333         int ret = 0, err = 0;
 334
 335         DEB_EE("dev:%p, fh:%p\n", dev, fh);
 336
 337         if ((vv->video_status & STATUS_CAPTURE) != 0) {
 338                 if (vv->video_fh == fh) {
 339                         DEB_S("already capturing\n");
 340                         return 0;
 341                 }
 342                 DEB_S("already capturing in another open\n");
 343                 return -EBUSY;
 344         }
 345
 346         if ((vv->video_status & STATUS_OVERLAY) != 0) {
 347                 DEB_S("warning: suspending overlay video for streaming capture\n");
 348                 vv->ov_suspend = vv->video_fh;
 349                 err = saa7146_stop_preview(vv->video_fh); /* side effect: video_status is now 0, video_fh is NULL */
 350                 if (0 != err) {
 351                         DEB_D("suspending video failed. aborting\n");
 352                         return err;
 353                 }
 354         }
 355
 356         fmt = saa7146_format_by_fourcc(dev, vv->video_fmt.pixelformat);
 357         /* we need to have a valid format set here */
 358         BUG_ON(NULL == fmt);
 359
 360         if (0 != (fmt->flags & FORMAT_IS_PLANAR)) {
 361                 resource = RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP|RESOURCE_DMA3_BRS;
 362         } else {
 363                 resource = RESOURCE_DMA1_HPS;
 364         }
 365
 366         ret = saa7146_res_get(fh, resource);
 367         if (0 == ret) {
 368                 DEB_S("cannot get capture resource %d\n", resource);
 369                 if (vv->ov_suspend != NULL) {
 370                         saa7146_start_preview(vv->ov_suspend);
 371                         vv->ov_suspend = NULL;
 372                 }
 373                 return -EBUSY;
 374         }
 375
 376         /* clear out beginning of streaming bit (rps register 0)*/
 377         saa7146_write(dev, MC2, MASK_27 );
 378
 379         /* enable rps0 irqs */
 380         SAA7146_IER_ENABLE(dev, MASK_27);
 381
 382         vv->video_fh = fh;
 383         vv->video_status = STATUS_CAPTURE;
 384
 385         return 0;
 386 }
 387
 388 static int video_end(struct saa7146_fh *fh, struct file *file)
 389 {
 390         struct saa7146_dev *dev = fh->dev;
 391         struct saa7146_vv *vv = dev->vv_data;
 392         struct saa7146_format *fmt = NULL;
 393         unsigned long flags;
 394         unsigned int resource;
 395         u32 dmas = 0;
 396         DEB_EE("dev:%p, fh:%p\n", dev, fh);
 397
 398         if ((vv->video_status & STATUS_CAPTURE) != STATUS_CAPTURE) {
 399                 DEB_S("not capturing\n");
 400                 return 0;
 401         }
 402
 403         if (vv->video_fh != fh) {
 404                 DEB_S("capturing, but in another open\n");
 405                 return -EBUSY;
 406         }
 407
 408         fmt = saa7146_format_by_fourcc(dev, vv->video_fmt.pixelformat);
 409         /* we need to have a valid format set here */
 410         BUG_ON(NULL == fmt);
 411
 412         if (0 != (fmt->flags & FORMAT_IS_PLANAR)) {
 413                 resource = RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP|RESOURCE_DMA3_BRS;
 414                 dmas = MASK_22 | MASK_21 | MASK_20;
 415         } else {
 416                 resource = RESOURCE_DMA1_HPS;
 417                 dmas = MASK_22;
 418         }
 419         spin_lock_irqsave(&dev->slock,flags);
 420
 421         /* disable rps0  */
 422         saa7146_write(dev, MC1, MASK_28);
 423
 424         /* disable rps0 irqs */
 425         SAA7146_IER_DISABLE(dev, MASK_27);
 426
 427         /* shut down all used video dma transfers */
 428         saa7146_write(dev, MC1, dmas);
 429
 430         spin_unlock_irqrestore(&dev->slock, flags);
 431
 432         vv->video_fh = NULL;
 433         vv->video_status = 0;
 434
 435         saa7146_res_free(fh, resource);
 436
 437         if (vv->ov_suspend != NULL) {
 438                 saa7146_start_preview(vv->ov_suspend);
 439                 vv->ov_suspend = NULL;
 440         }
 441
 442         return 0;
 443 }
 444
 445 static int vidioc_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
 446 {
 447         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 448
 449         strcpy((char *)cap->driver, "saa7146 v4l2");
 450         strlcpy((char *)cap->card, dev->ext->name, sizeof(cap->card));
 451         sprintf((char *)cap->bus_info, "PCI:%s", pci_name(dev->pci));
 452         cap->version = SAA7146_VERSION_CODE;
 453         cap->device_caps =
 454                 V4L2_CAP_VIDEO_CAPTURE |
 455                 V4L2_CAP_VIDEO_OVERLAY |
 456                 V4L2_CAP_READWRITE |
 457                 V4L2_CAP_STREAMING;
 458         cap->device_caps |= dev->ext_vv_data->capabilities;
 459         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 460         return 0;
 461 }
 462
 463 static int vidioc_g_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
 464 {
 465         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 466         struct saa7146_vv *vv = dev->vv_data;
 467
 468         *fb = vv->ov_fb;
 469         fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
 470         fb->flags = V4L2_FBUF_FLAG_PRIMARY;
 471         return 0;
 472 }
 473
 474 static int vidioc_s_fbuf(struct file *file, void *fh, struct v4l2_framebuffer *fb)
 475 {
 476         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 477         struct saa7146_vv *vv = dev->vv_data;
 478         struct saa7146_format *fmt;
 479
 480         DEB_EE("VIDIOC_S_FBUF\n");
 481
 482         if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO))
 483                 return -EPERM;
 484
 485         /* check args */
 486         fmt = saa7146_format_by_fourcc(dev, fb->fmt.pixelformat);
 487         if (NULL == fmt)
 488                 return -EINVAL;
 489
 490         /* planar formats are not allowed for overlay video, clipping and video dma would clash */
 491         if (fmt->flags & FORMAT_IS_PLANAR)
 492                 DEB_S("planar pixelformat '%4.4s' not allowed for overlay\n",
 493                       (char *)&fmt->pixelformat);
 494
 495         /* check if overlay is running */
 496         if (IS_OVERLAY_ACTIVE(fh) != 0) {
 497                 if (vv->video_fh != fh) {
 498                         DEB_D("refusing to change framebuffer informations while overlay is active in another open\n");
 499                         return -EBUSY;
 500                 }
 501         }
 502
 503         /* ok, accept it */
 504         vv->ov_fb = *fb;
 505         vv->ov_fmt = fmt;
 506
 507         if (vv->ov_fb.fmt.bytesperline < vv->ov_fb.fmt.width) {
 508                 vv->ov_fb.fmt.bytesperline = vv->ov_fb.fmt.width * fmt->depth / 8;
 509                 DEB_D("setting bytesperline to %d\n", vv->ov_fb.fmt.bytesperline);
 510         }
 511         return 0;
 512 }
 513
 514 static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *f)
 515 {
 516         if (f->index >= NUM_FORMATS)
 517                 return -EINVAL;
 518         strlcpy((char *)f->description, formats[f->index].name,
 519                         sizeof(f->description));
 520         f->pixelformat = formats[f->index].pixelformat;
 521         return 0;
 522 }
 523
 524 int saa7146_s_ctrl(struct v4l2_ctrl *ctrl)
 525 {
 526         struct saa7146_dev *dev = container_of(ctrl->handler,
 527                                 struct saa7146_dev, ctrl_handler);
 528         struct saa7146_vv *vv = dev->vv_data;
 529         u32 val;
 530
 531         switch (ctrl->id) {
 532         case V4L2_CID_BRIGHTNESS:
 533                 val = saa7146_read(dev, BCS_CTRL);
 534                 val &= 0x00ffffff;
 535                 val |= (ctrl->val << 24);
 536                 saa7146_write(dev, BCS_CTRL, val);
 537                 saa7146_write(dev, MC2, MASK_22 | MASK_06);
 538                 break;
 539
 540         case V4L2_CID_CONTRAST:
 541                 val = saa7146_read(dev, BCS_CTRL);
 542                 val &= 0xff00ffff;
 543                 val |= (ctrl->val << 16);
 544                 saa7146_write(dev, BCS_CTRL, val);
 545                 saa7146_write(dev, MC2, MASK_22 | MASK_06);
 546                 break;
 547
 548         case V4L2_CID_SATURATION:
 549                 val = saa7146_read(dev, BCS_CTRL);
 550                 val &= 0xffffff00;
 551                 val |= (ctrl->val << 0);
 552                 saa7146_write(dev, BCS_CTRL, val);
 553                 saa7146_write(dev, MC2, MASK_22 | MASK_06);
 554                 break;
 555
 556         case V4L2_CID_HFLIP:
 557                 /* fixme: we can support changing VFLIP and HFLIP here... */
 558                 if ((vv->video_status & STATUS_CAPTURE))
 559                         return -EBUSY;
 560                 vv->hflip = ctrl->val;
 561                 break;
 562
 563         case V4L2_CID_VFLIP:
 564                 if ((vv->video_status & STATUS_CAPTURE))
 565                         return -EBUSY;
 566                 vv->vflip = ctrl->val;
 567                 break;
 568
 569         default:
 570                 return -EINVAL;
 571         }
 572
 573         if ((vv->video_status & STATUS_OVERLAY) != 0) { /* CHECK: && (vv->video_fh == fh)) */
 574                 struct saa7146_fh *fh = vv->video_fh;
 575
 576                 saa7146_stop_preview(fh);
 577                 saa7146_start_preview(fh);
 578         }
 579         return 0;
 580 }
 581
 582 static int vidioc_g_parm(struct file *file, void *fh,
 583                 struct v4l2_streamparm *parm)
 584 {
 585         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 586         struct saa7146_vv *vv = dev->vv_data;
 587
 588         if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 589                 return -EINVAL;
 590         parm->parm.capture.readbuffers = 1;
 591         v4l2_video_std_frame_period(vv->standard->id,
 592                                     &parm->parm.capture.timeperframe);
 593         return 0;
 594 }
 595
 596 static int vidioc_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *f)
 597 {
 598         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 599         struct saa7146_vv *vv = dev->vv_data;
 600
 601         f->fmt.pix = vv->video_fmt;
 602         return 0;
 603 }
 604
 605 static int vidioc_g_fmt_vid_overlay(struct file *file, void *fh, struct v4l2_format *f)
 606 {
 607         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 608         struct saa7146_vv *vv = dev->vv_data;
 609
 610         f->fmt.win = vv->ov.win;
 611         return 0;
 612 }
 613
 614 static int vidioc_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *f)
 615 {
 616         f->fmt.vbi = ((struct saa7146_fh *)fh)->vbi_fmt;
 617         return 0;
 618 }
 619
 620 static int vidioc_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *f)
 621 {
 622         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 623         struct saa7146_vv *vv = dev->vv_data;
 624         struct saa7146_format *fmt;
 625         enum v4l2_field field;
 626         int maxw, maxh;
 627         int calc_bpl;
 628
 629         DEB_EE("V4L2_BUF_TYPE_VIDEO_CAPTURE: dev:%p, fh:%p\n", dev, fh);
 630
 631         fmt = saa7146_format_by_fourcc(dev, f->fmt.pix.pixelformat);
 632         if (NULL == fmt)
 633                 return -EINVAL;
 634
 635         field = f->fmt.pix.field;
 636         maxw  = vv->standard->h_max_out;
 637         maxh  = vv->standard->v_max_out;
 638
 639         if (V4L2_FIELD_ANY == field) {
 640                 field = (f->fmt.pix.height > maxh / 2)
 641                         ? V4L2_FIELD_INTERLACED
 642                         : V4L2_FIELD_BOTTOM;
 643         }
 644         switch (field) {
 645         case V4L2_FIELD_ALTERNATE:
 646                 vv->last_field = V4L2_FIELD_TOP;
 647                 maxh = maxh / 2;
 648                 break;
 649         case V4L2_FIELD_TOP:
 650         case V4L2_FIELD_BOTTOM:
 651                 vv->last_field = V4L2_FIELD_INTERLACED;
 652                 maxh = maxh / 2;
 653                 break;
 654         case V4L2_FIELD_INTERLACED:
 655                 vv->last_field = V4L2_FIELD_INTERLACED;
 656                 break;
 657         default:
 658                 DEB_D("no known field mode '%d'\n", field);
 659                 return -EINVAL;
 660         }
 661
 662         f->fmt.pix.field = field;
 663         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 664         if (f->fmt.pix.width > maxw)
 665                 f->fmt.pix.width = maxw;
 666         if (f->fmt.pix.height > maxh)
 667                 f->fmt.pix.height = maxh;
 668
 669         calc_bpl = (f->fmt.pix.width * fmt->depth) / 8;
 670
 671         if (f->fmt.pix.bytesperline < calc_bpl)
 672                 f->fmt.pix.bytesperline = calc_bpl;
 673
 674         if (f->fmt.pix.bytesperline > (2 * PAGE_SIZE * fmt->depth) / 8) /* arbitrary constraint */
 675                 f->fmt.pix.bytesperline = calc_bpl;
 676
 677         f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * f->fmt.pix.height;
 678         DEB_D("w:%d, h:%d, bytesperline:%d, sizeimage:%d\n",
 679               f->fmt.pix.width, f->fmt.pix.height,
 680               f->fmt.pix.bytesperline, f->fmt.pix.sizeimage);
 681
 682         return 0;
 683 }
 684
 685
 686 static int vidioc_try_fmt_vid_overlay(struct file *file, void *fh, struct v4l2_format *f)
 687 {
 688         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 689         struct saa7146_vv *vv = dev->vv_data;
 690         struct v4l2_window *win = &f->fmt.win;
 691         enum v4l2_field field;
 692         int maxw, maxh;
 693
 694         DEB_EE("dev:%p\n", dev);
 695
 696         if (NULL == vv->ov_fb.base) {
 697                 DEB_D("no fb base set\n");
 698                 return -EINVAL;
 699         }
 700         if (NULL == vv->ov_fmt) {
 701                 DEB_D("no fb fmt set\n");
 702                 return -EINVAL;
 703         }
 704         if (win->w.width < 48 || win->w.height < 32) {
 705                 DEB_D("min width/height. (%d,%d)\n",
 706                       win->w.width, win->w.height);
 707                 return -EINVAL;
 708         }
 709         if (win->clipcount > 16) {
 710                 DEB_D("clipcount too big\n");
 711                 return -EINVAL;
 712         }
 713
 714         field = win->field;
 715         maxw  = vv->standard->h_max_out;
 716         maxh  = vv->standard->v_max_out;
 717
 718         if (V4L2_FIELD_ANY == field) {
 719                 field = (win->w.height > maxh / 2)
 720                         ? V4L2_FIELD_INTERLACED
 721                         : V4L2_FIELD_TOP;
 722                 }
 723         switch (field) {
 724         case V4L2_FIELD_TOP:
 725         case V4L2_FIELD_BOTTOM:
 726         case V4L2_FIELD_ALTERNATE:
 727                 maxh = maxh / 2;
 728                 break;
 729         case V4L2_FIELD_INTERLACED:
 730                 break;
 731         default:
 732                 DEB_D("no known field mode '%d'\n", field);
 733                 return -EINVAL;
 734         }
 735
 736         win->field = field;
 737         if (win->w.width > maxw)
 738                 win->w.width = maxw;
 739         if (win->w.height > maxh)
 740                 win->w.height = maxh;
 741
 742         return 0;
 743 }
 744
 745 static int vidioc_s_fmt_vid_cap(struct file *file, void *__fh, struct v4l2_format *f)
 746 {
 747         struct saa7146_fh *fh = __fh;
 748         struct saa7146_dev *dev = fh->dev;
 749         struct saa7146_vv *vv = dev->vv_data;
 750         int err;
 751
 752         DEB_EE("V4L2_BUF_TYPE_VIDEO_CAPTURE: dev:%p, fh:%p\n", dev, fh);
 753         if (IS_CAPTURE_ACTIVE(fh) != 0) {
 754                 DEB_EE("streaming capture is active\n");
 755                 return -EBUSY;
 756         }
 757         err = vidioc_try_fmt_vid_cap(file, fh, f);
 758         if (0 != err)
 759                 return err;
 760         vv->video_fmt = f->fmt.pix;
 761         DEB_EE("set to pixelformat '%4.4s'\n",
 762                (char *)&vv->video_fmt.pixelformat);
 763         return 0;
 764 }
 765
 766 static int vidioc_s_fmt_vid_overlay(struct file *file, void *__fh, struct v4l2_format *f)
 767 {
 768         struct saa7146_fh *fh = __fh;
 769         struct saa7146_dev *dev = fh->dev;
 770         struct saa7146_vv *vv = dev->vv_data;
 771         int err;
 772
 773         DEB_EE("V4L2_BUF_TYPE_VIDEO_OVERLAY: dev:%p, fh:%p\n", dev, fh);
 774         err = vidioc_try_fmt_vid_overlay(file, fh, f);
 775         if (0 != err)
 776                 return err;
 777         vv->ov.win    = f->fmt.win;
 778         vv->ov.nclips = f->fmt.win.clipcount;
 779         if (vv->ov.nclips > 16)
 780                 vv->ov.nclips = 16;
 781         if (copy_from_user(vv->ov.clips, f->fmt.win.clips,
 782                                 sizeof(struct v4l2_clip) * vv->ov.nclips)) {
 783                 return -EFAULT;
 784         }
 785
 786         /* vv->ov.fh is used to indicate that we have valid overlay informations, too */
 787         vv->ov.fh = fh;
 788
 789         /* check if our current overlay is active */
 790         if (IS_OVERLAY_ACTIVE(fh) != 0) {
 791                 saa7146_stop_preview(fh);
 792                 saa7146_start_preview(fh);
 793         }
 794         return 0;
 795 }
 796
 797 static int vidioc_g_std(struct file *file, void *fh, v4l2_std_id *norm)
 798 {
 799         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 800         struct saa7146_vv *vv = dev->vv_data;
 801
 802         *norm = vv->standard->id;
 803         return 0;
 804 }
 805
 806         /* the saa7146 supfhrts (used in conjunction with the saa7111a for example)
 807            PAL / NTSC / SECAM. if your hardware does not (or does more)
 808            -- override this function in your extension */
 809 /*
 810         case VIDIOC_ENUMSTD:
 811         {
 812                 struct v4l2_standard *e = arg;
 813                 if (e->index < 0 )
 814                         return -EINVAL;
 815                 if( e->index < dev->ext_vv_data->num_stds ) {
 816                         DEB_EE("VIDIOC_ENUMSTD: index:%d\n", e->index);
 817                         v4l2_video_std_construct(e, dev->ext_vv_data->stds[e->index].id, dev->ext_vv_data->stds[e->index].name);
 818                         return 0;
 819                 }
 820                 return -EINVAL;
 821         }
 822         */
 823
 824 static int vidioc_s_std(struct file *file, void *fh, v4l2_std_id *id)
 825 {
 826         struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
 827         struct saa7146_vv *vv = dev->vv_data;
 828         int found = 0;
 829         int err, i;
 830
 831         DEB_EE("VIDIOC_S_STD\n");
 832
 833         if ((vv->video_status & STATUS_CAPTURE) == STATUS_CAPTURE) {
 834                 DEB_D("cannot change video standard while streaming capture is active\n");
 835                 return -EBUSY;
 836         }
 837
 838         if ((vv->video_status & STATUS_OVERLAY) != 0) {
 839                 vv->ov_suspend = vv->video_fh;
 840                 err = saa7146_stop_preview(vv->video_fh); /* side effect: video_status is now 0, video_fh is NULL */
 841                 if (0 != err) {
 842                         DEB_D("suspending video failed. aborting\n");
 843                         return err;
 844                 }
 845         }
 846
 847         for (i = 0; i < dev->ext_vv_data->num_stds; i++)
 848                 if (*id & dev->ext_vv_data->stds[i].id)
 849                         break;
 850         if (i != dev->ext_vv_data->num_stds) {
 851                 vv->standard = &dev->ext_vv_data->stds[i];
 852                 if (NULL != dev->ext_vv_data->std_callback)
 853                         dev->ext_vv_data->std_callback(dev, vv->standard);
 854                 found = 1;
 855         }
 856
 857         if (vv->ov_suspend != NULL) {
 858                 saa7146_start_preview(vv->ov_suspend);
 859                 vv->ov_suspend = NULL;
 860         }
 861
 862         if (!found) {
 863                 DEB_EE("VIDIOC_S_STD: standard not found\n");
 864                 return -EINVAL;
 865         }
 866
 867         DEB_EE("VIDIOC_S_STD: set to standard to '%s'\n", vv->standard->name);
 868         return 0;
 869 }
 870
 871 static int vidioc_overlay(struct file *file, void *fh, unsigned int on)
 872 {
 873         int err;
 874
 875         DEB_D("VIDIOC_OVERLAY on:%d\n", on);
 876         if (on)
 877                 err = saa7146_start_preview(fh);
 878         else
 879                 err = saa7146_stop_preview(fh);
 880         return err;
 881 }
 882
 883 static int vidioc_reqbufs(struct file *file, void *__fh, struct v4l2_requestbuffers *b)
 884 {
 885         struct saa7146_fh *fh = __fh;
 886
 887         if (b->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
 888                 return videobuf_reqbufs(&fh->video_q, b);
 889         if (b->type == V4L2_BUF_TYPE_VBI_CAPTURE)
 890                 return videobuf_reqbufs(&fh->vbi_q, b);
 891         return -EINVAL;
 892 }
 893
 894 static int vidioc_querybuf(struct file *file, void *__fh, struct v4l2_buffer *buf)
 895 {
 896         struct saa7146_fh *fh = __fh;
 897
 898         if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
 899                 return videobuf_querybuf(&fh->video_q, buf);
 900         if (buf->type == V4L2_BUF_TYPE_VBI_CAPTURE)
 901                 return videobuf_querybuf(&fh->vbi_q, buf);
 902         return -EINVAL;
 903 }
 904
 905 static int vidioc_qbuf(struct file *file, void *__fh, struct v4l2_buffer *buf)
 906 {
 907         struct saa7146_fh *fh = __fh;
 908
 909         if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
 910                 return videobuf_qbuf(&fh->video_q, buf);
 911         if (buf->type == V4L2_BUF_TYPE_VBI_CAPTURE)
 912                 return videobuf_qbuf(&fh->vbi_q, buf);
 913         return -EINVAL;
 914 }
 915
 916 static int vidioc_dqbuf(struct file *file, void *__fh, struct v4l2_buffer *buf)
 917 {
 918         struct saa7146_fh *fh = __fh;
 919
 920         if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
 921                 return videobuf_dqbuf(&fh->video_q, buf, file->f_flags & O_NONBLOCK);
 922         if (buf->type == V4L2_BUF_TYPE_VBI_CAPTURE)
 923                 return videobuf_dqbuf(&fh->vbi_q, buf, file->f_flags & O_NONBLOCK);
 924         return -EINVAL;
 925 }
 926
 927 static int vidioc_streamon(struct file *file, void *__fh, enum v4l2_buf_type type)
 928 {
 929         struct saa7146_fh *fh = __fh;
 930         int err;
 931
 932         DEB_D("VIDIOC_STREAMON, type:%d\n", type);
 933
 934         err = video_begin(fh);
 935         if (err)
 936                 return err;
 937         if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
 938                 return videobuf_streamon(&fh->video_q);
 939         if (type == V4L2_BUF_TYPE_VBI_CAPTURE)
 940                 return videobuf_streamon(&fh->vbi_q);
 941         return -EINVAL;
 942 }
 943
 944 static int vidioc_streamoff(struct file *file, void *__fh, enum v4l2_buf_type type)
 945 {
 946         struct saa7146_fh *fh = __fh;
 947         struct saa7146_dev *dev = fh->dev;
 948         struct saa7146_vv *vv = dev->vv_data;
 949         int err;
 950
 951         DEB_D("VIDIOC_STREAMOFF, type:%d\n", type);
 952
 953         /* ugly: we need to copy some checks from video_end(),
 954            because videobuf_streamoff() relies on the capture running.
 955            check and fix this */
 956         if ((vv->video_status & STATUS_CAPTURE) != STATUS_CAPTURE) {
 957                 DEB_S("not capturing\n");
 958                 return 0;
 959         }
 960
 961         if (vv->video_fh != fh) {
 962                 DEB_S("capturing, but in another open\n");
 963                 return -EBUSY;
 964         }
 965
 966         err = -EINVAL;
 967         if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
 968                 err = videobuf_streamoff(&fh->video_q);
 969         else if (type == V4L2_BUF_TYPE_VBI_CAPTURE)
 970                 err = videobuf_streamoff(&fh->vbi_q);
 971         if (0 != err) {
 972                 DEB_D("warning: videobuf_streamoff() failed\n");
 973                 video_end(fh, file);
 974         } else {
 975                 err = video_end(fh, file);
 976         }
 977         return err;
 978 }
 979
 980 static int vidioc_g_chip_ident(struct file *file, void *__fh,
 981                 struct v4l2_dbg_chip_ident *chip)
 982 {
 983         struct saa7146_fh *fh = __fh;
 984         struct saa7146_dev *dev = fh->dev;
 985
 986         chip->ident = V4L2_IDENT_NONE;
 987         chip->revision = 0;
 988         if (chip->match.type == V4L2_CHIP_MATCH_HOST && !chip->match.addr) {
 989                 chip->ident = V4L2_IDENT_SAA7146;
 990                 return 0;
 991         }
 992         return v4l2_device_call_until_err(&dev->v4l2_dev, 0,
 993                         core, g_chip_ident, chip);
 994 }
 995
 996 const struct v4l2_ioctl_ops saa7146_video_ioctl_ops = {
 997         .vidioc_querycap             = vidioc_querycap,
 998         .vidioc_enum_fmt_vid_cap     = vidioc_enum_fmt_vid_cap,
 999         .vidioc_enum_fmt_vid_overlay = vidioc_enum_fmt_vid_cap,
1000         .vidioc_g_fmt_vid_cap        = vidioc_g_fmt_vid_cap,
1001         .vidioc_try_fmt_vid_cap      = vidioc_try_fmt_vid_cap,
1002         .vidioc_s_fmt_vid_cap        = vidioc_s_fmt_vid_cap,
1003         .vidioc_g_fmt_vid_overlay    = vidioc_g_fmt_vid_overlay,
1004         .vidioc_try_fmt_vid_overlay  = vidioc_try_fmt_vid_overlay,
1005         .vidioc_s_fmt_vid_overlay    = vidioc_s_fmt_vid_overlay,
1006         .vidioc_g_fmt_vbi_cap        = vidioc_g_fmt_vbi_cap,
1007         .vidioc_g_chip_ident         = vidioc_g_chip_ident,
1008
1009         .vidioc_overlay              = vidioc_overlay,
1010         .vidioc_g_fbuf               = vidioc_g_fbuf,
1011         .vidioc_s_fbuf               = vidioc_s_fbuf,
1012         .vidioc_reqbufs              = vidioc_reqbufs,
1013         .vidioc_querybuf             = vidioc_querybuf,
1014         .vidioc_qbuf                 = vidioc_qbuf,
1015         .vidioc_dqbuf                = vidioc_dqbuf,
1016         .vidioc_g_std                = vidioc_g_std,
1017         .vidioc_s_std                = vidioc_s_std,
1018         .vidioc_streamon             = vidioc_streamon,
1019         .vidioc_streamoff            = vidioc_streamoff,
1020         .vidioc_g_parm               = vidioc_g_parm,
1021 };
1022
1023 /*********************************************************************************/
1024 /* buffer handling functions                                                  */
1025
1026 static int buffer_activate (struct saa7146_dev *dev,
1027                      struct saa7146_buf *buf,
1028                      struct saa7146_buf *next)
1029 {
1030         struct saa7146_vv *vv = dev->vv_data;
1031
1032         buf->vb.state = VIDEOBUF_ACTIVE;
1033         saa7146_set_capture(dev,buf,next);
1034
1035         mod_timer(&vv->video_q.timeout, jiffies+BUFFER_TIMEOUT);
1036         return 0;
1037 }
1038
1039 static void release_all_pagetables(struct saa7146_dev *dev, struct saa7146_buf *buf)
1040 {
1041         saa7146_pgtable_free(dev->pci, &buf->pt[0]);
1042         saa7146_pgtable_free(dev->pci, &buf->pt[1]);
1043         saa7146_pgtable_free(dev->pci, &buf->pt[2]);
1044 }
1045
1046 static int buffer_prepare(struct videobuf_queue *q,
1047                           struct videobuf_buffer *vb, enum v4l2_field field)
1048 {
1049         struct file *file = q->priv_data;
1050         struct saa7146_fh *fh = file->private_data;
1051         struct saa7146_dev *dev = fh->dev;
1052         struct saa7146_vv *vv = dev->vv_data;
1053         struct saa7146_buf *buf = (struct saa7146_buf *)vb;
1054         int size,err = 0;
1055
1056         DEB_CAP("vbuf:%p\n", vb);
1057
1058         /* sanity checks */
1059         if (vv->video_fmt.width  < 48 ||
1060             vv->video_fmt.height < 32 ||
1061             vv->video_fmt.width  > vv->standard->h_max_out ||
1062             vv->video_fmt.height > vv->standard->v_max_out) {
1063                 DEB_D("w (%d) / h (%d) out of bounds\n",
1064                       vv->video_fmt.width, vv->video_fmt.height);
1065                 return -EINVAL;
1066         }
1067
1068         size = vv->video_fmt.sizeimage;
1069         if (0 != buf->vb.baddr && buf->vb.bsize < size) {
1070                 DEB_D("size mismatch\n");
1071                 return -EINVAL;
1072         }
1073
1074         DEB_CAP("buffer_prepare [size=%dx%d,bytes=%d,fields=%s]\n",
1075                 vv->video_fmt.width, vv->video_fmt.height,
1076                 size, v4l2_field_names[vv->video_fmt.field]);
1077         if (buf->vb.width  != vv->video_fmt.width  ||
1078             buf->vb.bytesperline != vv->video_fmt.bytesperline ||
1079             buf->vb.height != vv->video_fmt.height ||
1080             buf->vb.size   != size ||
1081             buf->vb.field  != field      ||
1082             buf->vb.field  != vv->video_fmt.field  ||
1083             buf->fmt       != &vv->video_fmt) {
1084                 saa7146_dma_free(dev,q,buf);
1085         }
1086
1087         if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
1088                 struct saa7146_format *sfmt;
1089
1090                 buf->vb.bytesperline  = vv->video_fmt.bytesperline;
1091                 buf->vb.width  = vv->video_fmt.width;
1092                 buf->vb.height = vv->video_fmt.height;
1093                 buf->vb.size   = size;
1094                 buf->vb.field  = field;
1095                 buf->fmt       = &vv->video_fmt;
1096                 buf->vb.field  = vv->video_fmt.field;
1097
1098                 sfmt = saa7146_format_by_fourcc(dev,buf->fmt->pixelformat);
1099
1100                 release_all_pagetables(dev, buf);
1101                 if( 0 != IS_PLANAR(sfmt->trans)) {
1102                         saa7146_pgtable_alloc(dev->pci, &buf->pt[0]);
1103                         saa7146_pgtable_alloc(dev->pci, &buf->pt[1]);
1104                         saa7146_pgtable_alloc(dev->pci, &buf->pt[2]);
1105                 } else {
1106                         saa7146_pgtable_alloc(dev->pci, &buf->pt[0]);
1107                 }
1108
1109                 err = videobuf_iolock(q,&buf->vb, &vv->ov_fb);
1110                 if (err)
1111                         goto oops;
1112                 err = saa7146_pgtable_build(dev,buf);
1113                 if (err)
1114                         goto oops;
1115         }
1116         buf->vb.state = VIDEOBUF_PREPARED;
1117         buf->activate = buffer_activate;
1118
1119         return 0;
1120
1121  oops:
1122         DEB_D("error out\n");
1123         saa7146_dma_free(dev,q,buf);
1124
1125         return err;
1126 }
1127
1128 static int buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1129 {
1130         struct file *file = q->priv_data;
1131         struct saa7146_fh *fh = file->private_data;
1132         struct saa7146_vv *vv = fh->dev->vv_data;
1133
1134         if (0 == *count || *count > MAX_SAA7146_CAPTURE_BUFFERS)
1135                 *count = MAX_SAA7146_CAPTURE_BUFFERS;
1136
1137         *size = vv->video_fmt.sizeimage;
1138
1139         /* check if we exceed the "max_memory" parameter */
1140         if( (*count * *size) > (max_memory*1048576) ) {
1141                 *count = (max_memory*1048576) / *size;
1142         }
1143
1144         DEB_CAP("%d buffers, %d bytes each\n", *count, *size);
1145
1146         return 0;
1147 }
1148
1149 static void buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1150 {
1151         struct file *file = q->priv_data;
1152         struct saa7146_fh *fh = file->private_data;
1153         struct saa7146_dev *dev = fh->dev;
1154         struct saa7146_vv *vv = dev->vv_data;
1155         struct saa7146_buf *buf = (struct saa7146_buf *)vb;
1156
1157         DEB_CAP("vbuf:%p\n", vb);
1158         saa7146_buffer_queue(fh->dev,&vv->video_q,buf);
1159 }
1160
1161 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1162 {
1163         struct file *file = q->priv_data;
1164         struct saa7146_fh *fh = file->private_data;
1165         struct saa7146_dev *dev = fh->dev;
1166         struct saa7146_buf *buf = (struct saa7146_buf *)vb;
1167
1168         DEB_CAP("vbuf:%p\n", vb);
1169
1170         saa7146_dma_free(dev,q,buf);
1171
1172         release_all_pagetables(dev, buf);
1173 }
1174
1175 static struct videobuf_queue_ops video_qops = {
1176         .buf_setup    = buffer_setup,
1177         .buf_prepare  = buffer_prepare,
1178         .buf_queue    = buffer_queue,
1179         .buf_release  = buffer_release,
1180 };
1181
1182 /********************************************************************************/
1183 /* file operations */
1184
1185 static void video_init(struct saa7146_dev *dev, struct saa7146_vv *vv)
1186 {
1187         INIT_LIST_HEAD(&vv->video_q.queue);
1188
1189         init_timer(&vv->video_q.timeout);
1190         vv->video_q.timeout.function = saa7146_buffer_timeout;
1191         vv->video_q.timeout.data     = (unsigned long)(&vv->video_q);
1192         vv->video_q.dev              = dev;
1193
1194         /* set some default values */
1195         vv->standard = &dev->ext_vv_data->stds[0];
1196
1197         /* FIXME: what's this? */
1198         vv->current_hps_source = SAA7146_HPS_SOURCE_PORT_A;
1199         vv->current_hps_sync = SAA7146_HPS_SYNC_PORT_A;
1200 }
1201
1202
1203 static int video_open(struct saa7146_dev *dev, struct file *file)
1204 {
1205         struct saa7146_fh *fh = file->private_data;
1206
1207         videobuf_queue_sg_init(&fh->video_q, &video_qops,
1208                             &dev->pci->dev, &dev->slock,
1209                             V4L2_BUF_TYPE_VIDEO_CAPTURE,
1210                             V4L2_FIELD_INTERLACED,
1211                             sizeof(struct saa7146_buf),
1212                             file, &dev->v4l2_lock);
1213
1214         return 0;
1215 }
1216
1217
1218 static void video_close(struct saa7146_dev *dev, struct file *file)
1219 {
1220         struct saa7146_fh *fh = file->private_data;
1221         struct saa7146_vv *vv = dev->vv_data;
1222         struct videobuf_queue *q = &fh->video_q;
1223
1224         if (IS_CAPTURE_ACTIVE(fh) != 0)
1225                 video_end(fh, file);
1226         else if (IS_OVERLAY_ACTIVE(fh) != 0)
1227                 saa7146_stop_preview(fh);
1228
1229         videobuf_stop(q);
1230         /* hmm, why is this function declared void? */
1231 }
1232
1233
1234 static void video_irq_done(struct saa7146_dev *dev, unsigned long st)
1235 {
1236         struct saa7146_vv *vv = dev->vv_data;
1237         struct saa7146_dmaqueue *q = &vv->video_q;
1238
1239         spin_lock(&dev->slock);
1240         DEB_CAP("called\n");
1241
1242         /* only finish the buffer if we have one... */
1243         if( NULL != q->curr ) {
1244                 saa7146_buffer_finish(dev,q,VIDEOBUF_DONE);
1245         }
1246         saa7146_buffer_next(dev,q,0);
1247
1248         spin_unlock(&dev->slock);
1249 }
1250
1251 static ssize_t video_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1252 {
1253         struct saa7146_fh *fh = file->private_data;
1254         struct saa7146_dev *dev = fh->dev;
1255         struct saa7146_vv *vv = dev->vv_data;
1256         ssize_t ret = 0;
1257
1258         DEB_EE("called\n");
1259
1260         if ((vv->video_status & STATUS_CAPTURE) != 0) {
1261                 /* fixme: should we allow read() captures while streaming capture? */
1262                 if (vv->video_fh == fh) {
1263                         DEB_S("already capturing\n");
1264                         return -EBUSY;
1265                 }
1266                 DEB_S("already capturing in another open\n");
1267                 return -EBUSY;
1268         }
1269
1270         ret = video_begin(fh);
1271         if( 0 != ret) {
1272                 goto out;
1273         }
1274
1275         ret = videobuf_read_one(&fh->video_q , data, count, ppos,
1276                                 file->f_flags & O_NONBLOCK);
1277         if (ret != 0) {
1278                 video_end(fh, file);
1279         } else {
1280                 ret = video_end(fh, file);
1281         }
1282 out:
1283         /* restart overlay if it was active before */
1284         if (vv->ov_suspend != NULL) {
1285                 saa7146_start_preview(vv->ov_suspend);
1286                 vv->ov_suspend = NULL;
1287         }
1288
1289         return ret;
1290 }
1291
1292 struct saa7146_use_ops saa7146_video_uops = {
1293         .init = video_init,
1294         .open = video_open,
1295         .release = video_close,
1296         .irq_done = video_irq_done,
1297         .read = video_read,
1298 };