1 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 2 3 #include <media/drv-intf/saa7146_vv.h> 4 #include <media/v4l2-event.h> 5 #include <media/v4l2-ctrls.h> 6 #include <linux/module.h> 7 #include <linux/kernel.h> 8 9 static int max_memory = 32; 10 11 module_param(max_memory, int, 0644); 12 MODULE_PARM_DESC(max_memory, "maximum memory usage for capture buffers (default: 32Mb)"); 13 14 #define IS_CAPTURE_ACTIVE(fh) \ 15 (((vv->video_status & STATUS_CAPTURE) != 0) && (vv->video_fh == fh)) 16 17 /* format descriptions for capture and preview */ 18 static struct saa7146_format formats[] = { 19 { 20 .pixelformat = V4L2_PIX_FMT_RGB332, 21 .trans = RGB08_COMPOSED, 22 .depth = 8, 23 .flags = 0, 24 }, { 25 .pixelformat = V4L2_PIX_FMT_RGB565, 26 .trans = RGB16_COMPOSED, 27 .depth = 16, 28 .flags = 0, 29 }, { 30 .pixelformat = V4L2_PIX_FMT_BGR24, 31 .trans = RGB24_COMPOSED, 32 .depth = 24, 33 .flags = 0, 34 }, { 35 .pixelformat = V4L2_PIX_FMT_BGR32, 36 .trans = RGB32_COMPOSED, 37 .depth = 32, 38 .flags = 0, 39 }, { 40 .pixelformat = V4L2_PIX_FMT_RGB32, 41 .trans = RGB32_COMPOSED, 42 .depth = 32, 43 .flags = 0, 44 .swap = 0x2, 45 }, { 46 .pixelformat = V4L2_PIX_FMT_GREY, 47 .trans = Y8, 48 .depth = 8, 49 .flags = 0, 50 }, { 51 .pixelformat = V4L2_PIX_FMT_YUV422P, 52 .trans = YUV422_DECOMPOSED, 53 .depth = 16, 54 .flags = FORMAT_BYTE_SWAP|FORMAT_IS_PLANAR, 55 }, { 56 .pixelformat = V4L2_PIX_FMT_YVU420, 57 .trans = YUV420_DECOMPOSED, 58 .depth = 12, 59 .flags = FORMAT_BYTE_SWAP|FORMAT_IS_PLANAR, 60 }, { 61 .pixelformat = V4L2_PIX_FMT_YUV420, 62 .trans = YUV420_DECOMPOSED, 63 .depth = 12, 64 .flags = FORMAT_IS_PLANAR, 65 }, { 66 .pixelformat = V4L2_PIX_FMT_UYVY, 67 .trans = YUV422_COMPOSED, 68 .depth = 16, 69 .flags = 0, 70 } 71 }; 72 73 /* unfortunately, the saa7146 contains a bug which prevents it from doing on-the-fly byte swaps. 74 due to this, it's impossible to provide additional *packed* formats, which are simply byte swapped 75 (like V4L2_PIX_FMT_YUYV) ... 8-( */ 76 77 struct saa7146_format* saa7146_format_by_fourcc(struct saa7146_dev *dev, int fourcc) 78 { 79 int i; 80 81 for (i = 0; i < ARRAY_SIZE(formats); i++) { 82 if (formats[i].pixelformat == fourcc) { 83 return formats+i; 84 } 85 } 86 87 DEB_D("unknown pixelformat:'%4.4s'\n", (char *)&fourcc); 88 return NULL; 89 } 90 91 /********************************************************************************/ 92 /* common pagetable functions */ 93 94 static int saa7146_pgtable_build(struct saa7146_dev *dev, struct saa7146_buf *buf) 95 { 96 struct pci_dev *pci = dev->pci; 97 struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb); 98 struct scatterlist *list = dma->sglist; 99 int length = dma->sglen; 100 struct saa7146_format *sfmt = saa7146_format_by_fourcc(dev,buf->fmt->pixelformat); 101 102 DEB_EE("dev:%p, buf:%p, sg_len:%d\n", dev, buf, length); 103 104 if( 0 != IS_PLANAR(sfmt->trans)) { 105 struct saa7146_pgtable *pt1 = &buf->pt[0]; 106 struct saa7146_pgtable *pt2 = &buf->pt[1]; 107 struct saa7146_pgtable *pt3 = &buf->pt[2]; 108 __le32 *ptr1, *ptr2, *ptr3; 109 __le32 fill; 110 111 int size = buf->fmt->width*buf->fmt->height; 112 int i,p,m1,m2,m3,o1,o2; 113 114 switch( sfmt->depth ) { 115 case 12: { 116 /* create some offsets inside the page table */ 117 m1 = ((size+PAGE_SIZE)/PAGE_SIZE)-1; 118 m2 = ((size+(size/4)+PAGE_SIZE)/PAGE_SIZE)-1; 119 m3 = ((size+(size/2)+PAGE_SIZE)/PAGE_SIZE)-1; 120 o1 = size%PAGE_SIZE; 121 o2 = (size+(size/4))%PAGE_SIZE; 122 DEB_CAP("size:%d, m1:%d, m2:%d, m3:%d, o1:%d, o2:%d\n", 123 size, m1, m2, m3, o1, o2); 124 break; 125 } 126 case 16: { 127 /* create some offsets inside the page table */ 128 m1 = ((size+PAGE_SIZE)/PAGE_SIZE)-1; 129 m2 = ((size+(size/2)+PAGE_SIZE)/PAGE_SIZE)-1; 130 m3 = ((2*size+PAGE_SIZE)/PAGE_SIZE)-1; 131 o1 = size%PAGE_SIZE; 132 o2 = (size+(size/2))%PAGE_SIZE; 133 DEB_CAP("size:%d, m1:%d, m2:%d, m3:%d, o1:%d, o2:%d\n", 134 size, m1, m2, m3, o1, o2); 135 break; 136 } 137 default: { 138 return -1; 139 } 140 } 141 142 ptr1 = pt1->cpu; 143 ptr2 = pt2->cpu; 144 ptr3 = pt3->cpu; 145 146 /* walk all pages, copy all page addresses to ptr1 */ 147 for (i = 0; i < length; i++, list++) { 148 for (p = 0; p * 4096 < sg_dma_len(list); p++, ptr1++) 149 *ptr1 = cpu_to_le32(sg_dma_address(list) - list->offset); 150 } 151 /* 152 ptr1 = pt1->cpu; 153 for(j=0;j<40;j++) { 154 printk("ptr1 %d: 0x%08x\n",j,ptr1[j]); 155 } 156 */ 157 158 /* if we have a user buffer, the first page may not be 159 aligned to a page boundary. */ 160 pt1->offset = dma->sglist->offset; 161 pt2->offset = pt1->offset+o1; 162 pt3->offset = pt1->offset+o2; 163 164 /* create video-dma2 page table */ 165 ptr1 = pt1->cpu; 166 for(i = m1; i <= m2 ; i++, ptr2++) { 167 *ptr2 = ptr1[i]; 168 } 169 fill = *(ptr2-1); 170 for(;i<1024;i++,ptr2++) { 171 *ptr2 = fill; 172 } 173 /* create video-dma3 page table */ 174 ptr1 = pt1->cpu; 175 for(i = m2; i <= m3; i++,ptr3++) { 176 *ptr3 = ptr1[i]; 177 } 178 fill = *(ptr3-1); 179 for(;i<1024;i++,ptr3++) { 180 *ptr3 = fill; 181 } 182 /* finally: finish up video-dma1 page table */ 183 ptr1 = pt1->cpu+m1; 184 fill = pt1->cpu[m1]; 185 for(i=m1;i<1024;i++,ptr1++) { 186 *ptr1 = fill; 187 } 188 /* 189 ptr1 = pt1->cpu; 190 ptr2 = pt2->cpu; 191 ptr3 = pt3->cpu; 192 for(j=0;j<40;j++) { 193 printk("ptr1 %d: 0x%08x\n",j,ptr1[j]); 194 } 195 for(j=0;j<40;j++) { 196 printk("ptr2 %d: 0x%08x\n",j,ptr2[j]); 197 } 198 for(j=0;j<40;j++) { 199 printk("ptr3 %d: 0x%08x\n",j,ptr3[j]); 200 } 201 */ 202 } else { 203 struct saa7146_pgtable *pt = &buf->pt[0]; 204 return saa7146_pgtable_build_single(pci, pt, list, length); 205 } 206 207 return 0; 208 } 209 210 211 /********************************************************************************/ 212 /* file operations */ 213 214 static int video_begin(struct saa7146_fh *fh) 215 { 216 struct saa7146_dev *dev = fh->dev; 217 struct saa7146_vv *vv = dev->vv_data; 218 struct saa7146_format *fmt = NULL; 219 unsigned int resource; 220 int ret = 0; 221 222 DEB_EE("dev:%p, fh:%p\n", dev, fh); 223 224 if ((vv->video_status & STATUS_CAPTURE) != 0) { 225 if (vv->video_fh == fh) { 226 DEB_S("already capturing\n"); 227 return 0; 228 } 229 DEB_S("already capturing in another open\n"); 230 return -EBUSY; 231 } 232 233 fmt = saa7146_format_by_fourcc(dev, vv->video_fmt.pixelformat); 234 /* we need to have a valid format set here */ 235 if (!fmt) 236 return -EINVAL; 237 238 if (0 != (fmt->flags & FORMAT_IS_PLANAR)) { 239 resource = RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP|RESOURCE_DMA3_BRS; 240 } else { 241 resource = RESOURCE_DMA1_HPS; 242 } 243 244 ret = saa7146_res_get(fh, resource); 245 if (0 == ret) { 246 DEB_S("cannot get capture resource %d\n", resource); 247 return -EBUSY; 248 } 249 250 /* clear out beginning of streaming bit (rps register 0)*/ 251 saa7146_write(dev, MC2, MASK_27 ); 252 253 /* enable rps0 irqs */ 254 SAA7146_IER_ENABLE(dev, MASK_27); 255 256 vv->video_fh = fh; 257 vv->video_status = STATUS_CAPTURE; 258 259 return 0; 260 } 261 262 static int video_end(struct saa7146_fh *fh, struct file *file) 263 { 264 struct saa7146_dev *dev = fh->dev; 265 struct saa7146_vv *vv = dev->vv_data; 266 struct saa7146_dmaqueue *q = &vv->video_dmaq; 267 struct saa7146_format *fmt = NULL; 268 unsigned long flags; 269 unsigned int resource; 270 u32 dmas = 0; 271 DEB_EE("dev:%p, fh:%p\n", dev, fh); 272 273 if ((vv->video_status & STATUS_CAPTURE) != STATUS_CAPTURE) { 274 DEB_S("not capturing\n"); 275 return 0; 276 } 277 278 if (vv->video_fh != fh) { 279 DEB_S("capturing, but in another open\n"); 280 return -EBUSY; 281 } 282 283 fmt = saa7146_format_by_fourcc(dev, vv->video_fmt.pixelformat); 284 /* we need to have a valid format set here */ 285 if (!fmt) 286 return -EINVAL; 287 288 if (0 != (fmt->flags & FORMAT_IS_PLANAR)) { 289 resource = RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP|RESOURCE_DMA3_BRS; 290 dmas = MASK_22 | MASK_21 | MASK_20; 291 } else { 292 resource = RESOURCE_DMA1_HPS; 293 dmas = MASK_22; 294 } 295 spin_lock_irqsave(&dev->slock,flags); 296 297 /* disable rps0 */ 298 saa7146_write(dev, MC1, MASK_28); 299 300 /* disable rps0 irqs */ 301 SAA7146_IER_DISABLE(dev, MASK_27); 302 303 /* shut down all used video dma transfers */ 304 saa7146_write(dev, MC1, dmas); 305 306 if (q->curr) 307 saa7146_buffer_finish(dev, q, VIDEOBUF_DONE); 308 309 spin_unlock_irqrestore(&dev->slock, flags); 310 311 vv->video_fh = NULL; 312 vv->video_status = 0; 313 314 saa7146_res_free(fh, resource); 315 316 return 0; 317 } 318 319 static int vidioc_querycap(struct file *file, void *fh, struct v4l2_capability *cap) 320 { 321 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev; 322 323 strscpy((char *)cap->driver, "saa7146 v4l2", sizeof(cap->driver)); 324 strscpy((char *)cap->card, dev->ext->name, sizeof(cap->card)); 325 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | 326 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING | 327 V4L2_CAP_DEVICE_CAPS; 328 cap->capabilities |= dev->ext_vv_data->capabilities; 329 return 0; 330 } 331 332 static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *f) 333 { 334 if (f->index >= ARRAY_SIZE(formats)) 335 return -EINVAL; 336 f->pixelformat = formats[f->index].pixelformat; 337 return 0; 338 } 339 340 int saa7146_s_ctrl(struct v4l2_ctrl *ctrl) 341 { 342 struct saa7146_dev *dev = container_of(ctrl->handler, 343 struct saa7146_dev, ctrl_handler); 344 struct saa7146_vv *vv = dev->vv_data; 345 u32 val; 346 347 switch (ctrl->id) { 348 case V4L2_CID_BRIGHTNESS: 349 val = saa7146_read(dev, BCS_CTRL); 350 val &= 0x00ffffff; 351 val |= (ctrl->val << 24); 352 saa7146_write(dev, BCS_CTRL, val); 353 saa7146_write(dev, MC2, MASK_22 | MASK_06); 354 break; 355 356 case V4L2_CID_CONTRAST: 357 val = saa7146_read(dev, BCS_CTRL); 358 val &= 0xff00ffff; 359 val |= (ctrl->val << 16); 360 saa7146_write(dev, BCS_CTRL, val); 361 saa7146_write(dev, MC2, MASK_22 | MASK_06); 362 break; 363 364 case V4L2_CID_SATURATION: 365 val = saa7146_read(dev, BCS_CTRL); 366 val &= 0xffffff00; 367 val |= (ctrl->val << 0); 368 saa7146_write(dev, BCS_CTRL, val); 369 saa7146_write(dev, MC2, MASK_22 | MASK_06); 370 break; 371 372 case V4L2_CID_HFLIP: 373 /* fixme: we can support changing VFLIP and HFLIP here... */ 374 if ((vv->video_status & STATUS_CAPTURE)) 375 return -EBUSY; 376 vv->hflip = ctrl->val; 377 break; 378 379 case V4L2_CID_VFLIP: 380 if ((vv->video_status & STATUS_CAPTURE)) 381 return -EBUSY; 382 vv->vflip = ctrl->val; 383 break; 384 385 default: 386 return -EINVAL; 387 } 388 return 0; 389 } 390 391 static int vidioc_g_parm(struct file *file, void *fh, 392 struct v4l2_streamparm *parm) 393 { 394 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev; 395 struct saa7146_vv *vv = dev->vv_data; 396 397 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 398 return -EINVAL; 399 parm->parm.capture.readbuffers = 1; 400 v4l2_video_std_frame_period(vv->standard->id, 401 &parm->parm.capture.timeperframe); 402 return 0; 403 } 404 405 static int vidioc_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *f) 406 { 407 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev; 408 struct saa7146_vv *vv = dev->vv_data; 409 410 f->fmt.pix = vv->video_fmt; 411 return 0; 412 } 413 414 static int vidioc_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *f) 415 { 416 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev; 417 struct saa7146_vv *vv = dev->vv_data; 418 419 f->fmt.vbi = vv->vbi_fmt; 420 return 0; 421 } 422 423 static int vidioc_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *f) 424 { 425 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev; 426 struct saa7146_vv *vv = dev->vv_data; 427 struct saa7146_format *fmt; 428 enum v4l2_field field; 429 int maxw, maxh; 430 int calc_bpl; 431 432 DEB_EE("V4L2_BUF_TYPE_VIDEO_CAPTURE: dev:%p, fh:%p\n", dev, fh); 433 434 fmt = saa7146_format_by_fourcc(dev, f->fmt.pix.pixelformat); 435 if (NULL == fmt) 436 return -EINVAL; 437 438 field = f->fmt.pix.field; 439 maxw = vv->standard->h_max_out; 440 maxh = vv->standard->v_max_out; 441 442 if (V4L2_FIELD_ANY == field) { 443 field = (f->fmt.pix.height > maxh / 2) 444 ? V4L2_FIELD_INTERLACED 445 : V4L2_FIELD_BOTTOM; 446 } 447 switch (field) { 448 case V4L2_FIELD_ALTERNATE: 449 vv->last_field = V4L2_FIELD_TOP; 450 maxh = maxh / 2; 451 break; 452 case V4L2_FIELD_TOP: 453 case V4L2_FIELD_BOTTOM: 454 vv->last_field = V4L2_FIELD_INTERLACED; 455 maxh = maxh / 2; 456 break; 457 case V4L2_FIELD_INTERLACED: 458 vv->last_field = V4L2_FIELD_INTERLACED; 459 break; 460 default: 461 DEB_D("no known field mode '%d'\n", field); 462 return -EINVAL; 463 } 464 465 f->fmt.pix.field = field; 466 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 467 if (f->fmt.pix.width > maxw) 468 f->fmt.pix.width = maxw; 469 if (f->fmt.pix.height > maxh) 470 f->fmt.pix.height = maxh; 471 472 calc_bpl = (f->fmt.pix.width * fmt->depth) / 8; 473 474 if (f->fmt.pix.bytesperline < calc_bpl) 475 f->fmt.pix.bytesperline = calc_bpl; 476 477 if (f->fmt.pix.bytesperline > (2 * PAGE_SIZE * fmt->depth) / 8) /* arbitrary constraint */ 478 f->fmt.pix.bytesperline = calc_bpl; 479 480 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * f->fmt.pix.height; 481 DEB_D("w:%d, h:%d, bytesperline:%d, sizeimage:%d\n", 482 f->fmt.pix.width, f->fmt.pix.height, 483 f->fmt.pix.bytesperline, f->fmt.pix.sizeimage); 484 485 return 0; 486 } 487 488 static int vidioc_s_fmt_vid_cap(struct file *file, void *__fh, struct v4l2_format *f) 489 { 490 struct saa7146_fh *fh = __fh; 491 struct saa7146_dev *dev = fh->dev; 492 struct saa7146_vv *vv = dev->vv_data; 493 int err; 494 495 DEB_EE("V4L2_BUF_TYPE_VIDEO_CAPTURE: dev:%p, fh:%p\n", dev, fh); 496 if (IS_CAPTURE_ACTIVE(fh) != 0) { 497 DEB_EE("streaming capture is active\n"); 498 return -EBUSY; 499 } 500 err = vidioc_try_fmt_vid_cap(file, fh, f); 501 if (0 != err) 502 return err; 503 vv->video_fmt = f->fmt.pix; 504 DEB_EE("set to pixelformat '%4.4s'\n", 505 (char *)&vv->video_fmt.pixelformat); 506 return 0; 507 } 508 509 static int vidioc_g_std(struct file *file, void *fh, v4l2_std_id *norm) 510 { 511 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev; 512 struct saa7146_vv *vv = dev->vv_data; 513 514 *norm = vv->standard->id; 515 return 0; 516 } 517 518 /* the saa7146 supfhrts (used in conjunction with the saa7111a for example) 519 PAL / NTSC / SECAM. if your hardware does not (or does more) 520 -- override this function in your extension */ 521 /* 522 case VIDIOC_ENUMSTD: 523 { 524 struct v4l2_standard *e = arg; 525 if (e->index < 0 ) 526 return -EINVAL; 527 if( e->index < dev->ext_vv_data->num_stds ) { 528 DEB_EE("VIDIOC_ENUMSTD: index:%d\n", e->index); 529 v4l2_video_std_construct(e, dev->ext_vv_data->stds[e->index].id, dev->ext_vv_data->stds[e->index].name); 530 return 0; 531 } 532 return -EINVAL; 533 } 534 */ 535 536 static int vidioc_s_std(struct file *file, void *fh, v4l2_std_id id) 537 { 538 struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev; 539 struct saa7146_vv *vv = dev->vv_data; 540 int found = 0; 541 int i; 542 543 DEB_EE("VIDIOC_S_STD\n"); 544 545 if ((vv->video_status & STATUS_CAPTURE) == STATUS_CAPTURE) { 546 DEB_D("cannot change video standard while streaming capture is active\n"); 547 return -EBUSY; 548 } 549 550 for (i = 0; i < dev->ext_vv_data->num_stds; i++) 551 if (id & dev->ext_vv_data->stds[i].id) 552 break; 553 if (i != dev->ext_vv_data->num_stds) { 554 vv->standard = &dev->ext_vv_data->stds[i]; 555 if (NULL != dev->ext_vv_data->std_callback) 556 dev->ext_vv_data->std_callback(dev, vv->standard); 557 found = 1; 558 } 559 560 if (!found) { 561 DEB_EE("VIDIOC_S_STD: standard not found\n"); 562 return -EINVAL; 563 } 564 565 DEB_EE("VIDIOC_S_STD: set to standard to '%s'\n", vv->standard->name); 566 return 0; 567 } 568 569 static int vidioc_reqbufs(struct file *file, void *__fh, struct v4l2_requestbuffers *b) 570 { 571 struct saa7146_fh *fh = __fh; 572 573 if (b->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 574 return videobuf_reqbufs(&fh->video_q, b); 575 if (b->type == V4L2_BUF_TYPE_VBI_CAPTURE) 576 return videobuf_reqbufs(&fh->vbi_q, b); 577 return -EINVAL; 578 } 579 580 static int vidioc_querybuf(struct file *file, void *__fh, struct v4l2_buffer *buf) 581 { 582 struct saa7146_fh *fh = __fh; 583 584 if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 585 return videobuf_querybuf(&fh->video_q, buf); 586 if (buf->type == V4L2_BUF_TYPE_VBI_CAPTURE) 587 return videobuf_querybuf(&fh->vbi_q, buf); 588 return -EINVAL; 589 } 590 591 static int vidioc_qbuf(struct file *file, void *__fh, struct v4l2_buffer *buf) 592 { 593 struct saa7146_fh *fh = __fh; 594 595 if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 596 return videobuf_qbuf(&fh->video_q, buf); 597 if (buf->type == V4L2_BUF_TYPE_VBI_CAPTURE) 598 return videobuf_qbuf(&fh->vbi_q, buf); 599 return -EINVAL; 600 } 601 602 static int vidioc_dqbuf(struct file *file, void *__fh, struct v4l2_buffer *buf) 603 { 604 struct saa7146_fh *fh = __fh; 605 606 if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 607 return videobuf_dqbuf(&fh->video_q, buf, file->f_flags & O_NONBLOCK); 608 if (buf->type == V4L2_BUF_TYPE_VBI_CAPTURE) 609 return videobuf_dqbuf(&fh->vbi_q, buf, file->f_flags & O_NONBLOCK); 610 return -EINVAL; 611 } 612 613 static int vidioc_streamon(struct file *file, void *__fh, enum v4l2_buf_type type) 614 { 615 struct saa7146_fh *fh = __fh; 616 int err; 617 618 DEB_D("VIDIOC_STREAMON, type:%d\n", type); 619 620 err = video_begin(fh); 621 if (err) 622 return err; 623 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 624 return videobuf_streamon(&fh->video_q); 625 if (type == V4L2_BUF_TYPE_VBI_CAPTURE) 626 return videobuf_streamon(&fh->vbi_q); 627 return -EINVAL; 628 } 629 630 static int vidioc_streamoff(struct file *file, void *__fh, enum v4l2_buf_type type) 631 { 632 struct saa7146_fh *fh = __fh; 633 struct saa7146_dev *dev = fh->dev; 634 struct saa7146_vv *vv = dev->vv_data; 635 int err; 636 637 DEB_D("VIDIOC_STREAMOFF, type:%d\n", type); 638 639 /* ugly: we need to copy some checks from video_end(), 640 because videobuf_streamoff() relies on the capture running. 641 check and fix this */ 642 if ((vv->video_status & STATUS_CAPTURE) != STATUS_CAPTURE) { 643 DEB_S("not capturing\n"); 644 return 0; 645 } 646 647 if (vv->video_fh != fh) { 648 DEB_S("capturing, but in another open\n"); 649 return -EBUSY; 650 } 651 652 err = -EINVAL; 653 if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 654 err = videobuf_streamoff(&fh->video_q); 655 else if (type == V4L2_BUF_TYPE_VBI_CAPTURE) 656 err = videobuf_streamoff(&fh->vbi_q); 657 if (0 != err) { 658 DEB_D("warning: videobuf_streamoff() failed\n"); 659 video_end(fh, file); 660 } else { 661 err = video_end(fh, file); 662 } 663 return err; 664 } 665 666 const struct v4l2_ioctl_ops saa7146_video_ioctl_ops = { 667 .vidioc_querycap = vidioc_querycap, 668 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 669 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 670 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 671 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 672 673 .vidioc_reqbufs = vidioc_reqbufs, 674 .vidioc_querybuf = vidioc_querybuf, 675 .vidioc_qbuf = vidioc_qbuf, 676 .vidioc_dqbuf = vidioc_dqbuf, 677 .vidioc_g_std = vidioc_g_std, 678 .vidioc_s_std = vidioc_s_std, 679 .vidioc_streamon = vidioc_streamon, 680 .vidioc_streamoff = vidioc_streamoff, 681 .vidioc_g_parm = vidioc_g_parm, 682 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 683 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 684 }; 685 686 const struct v4l2_ioctl_ops saa7146_vbi_ioctl_ops = { 687 .vidioc_querycap = vidioc_querycap, 688 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap, 689 690 .vidioc_reqbufs = vidioc_reqbufs, 691 .vidioc_querybuf = vidioc_querybuf, 692 .vidioc_qbuf = vidioc_qbuf, 693 .vidioc_dqbuf = vidioc_dqbuf, 694 .vidioc_g_std = vidioc_g_std, 695 .vidioc_s_std = vidioc_s_std, 696 .vidioc_streamon = vidioc_streamon, 697 .vidioc_streamoff = vidioc_streamoff, 698 .vidioc_g_parm = vidioc_g_parm, 699 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 700 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 701 }; 702 703 /*********************************************************************************/ 704 /* buffer handling functions */ 705 706 static int buffer_activate (struct saa7146_dev *dev, 707 struct saa7146_buf *buf, 708 struct saa7146_buf *next) 709 { 710 struct saa7146_vv *vv = dev->vv_data; 711 712 buf->vb.state = VIDEOBUF_ACTIVE; 713 saa7146_set_capture(dev,buf,next); 714 715 mod_timer(&vv->video_dmaq.timeout, jiffies+BUFFER_TIMEOUT); 716 return 0; 717 } 718 719 static void release_all_pagetables(struct saa7146_dev *dev, struct saa7146_buf *buf) 720 { 721 saa7146_pgtable_free(dev->pci, &buf->pt[0]); 722 saa7146_pgtable_free(dev->pci, &buf->pt[1]); 723 saa7146_pgtable_free(dev->pci, &buf->pt[2]); 724 } 725 726 static int buffer_prepare(struct videobuf_queue *q, 727 struct videobuf_buffer *vb, enum v4l2_field field) 728 { 729 struct file *file = q->priv_data; 730 struct saa7146_fh *fh = file->private_data; 731 struct saa7146_dev *dev = fh->dev; 732 struct saa7146_vv *vv = dev->vv_data; 733 struct saa7146_buf *buf = (struct saa7146_buf *)vb; 734 int size,err = 0; 735 736 DEB_CAP("vbuf:%p\n", vb); 737 738 /* sanity checks */ 739 if (vv->video_fmt.width < 48 || 740 vv->video_fmt.height < 32 || 741 vv->video_fmt.width > vv->standard->h_max_out || 742 vv->video_fmt.height > vv->standard->v_max_out) { 743 DEB_D("w (%d) / h (%d) out of bounds\n", 744 vv->video_fmt.width, vv->video_fmt.height); 745 return -EINVAL; 746 } 747 748 size = vv->video_fmt.sizeimage; 749 if (0 != buf->vb.baddr && buf->vb.bsize < size) { 750 DEB_D("size mismatch\n"); 751 return -EINVAL; 752 } 753 754 DEB_CAP("buffer_prepare [size=%dx%d,bytes=%d,fields=%s]\n", 755 vv->video_fmt.width, vv->video_fmt.height, 756 size, v4l2_field_names[vv->video_fmt.field]); 757 if (buf->vb.width != vv->video_fmt.width || 758 buf->vb.bytesperline != vv->video_fmt.bytesperline || 759 buf->vb.height != vv->video_fmt.height || 760 buf->vb.size != size || 761 buf->vb.field != field || 762 buf->vb.field != vv->video_fmt.field || 763 buf->fmt != &vv->video_fmt) { 764 saa7146_dma_free(dev,q,buf); 765 } 766 767 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 768 struct saa7146_format *sfmt; 769 770 buf->vb.bytesperline = vv->video_fmt.bytesperline; 771 buf->vb.width = vv->video_fmt.width; 772 buf->vb.height = vv->video_fmt.height; 773 buf->vb.size = size; 774 buf->vb.field = field; 775 buf->fmt = &vv->video_fmt; 776 buf->vb.field = vv->video_fmt.field; 777 778 sfmt = saa7146_format_by_fourcc(dev,buf->fmt->pixelformat); 779 780 release_all_pagetables(dev, buf); 781 if( 0 != IS_PLANAR(sfmt->trans)) { 782 saa7146_pgtable_alloc(dev->pci, &buf->pt[0]); 783 saa7146_pgtable_alloc(dev->pci, &buf->pt[1]); 784 saa7146_pgtable_alloc(dev->pci, &buf->pt[2]); 785 } else { 786 saa7146_pgtable_alloc(dev->pci, &buf->pt[0]); 787 } 788 789 err = videobuf_iolock(q, &buf->vb, NULL); 790 if (err) 791 goto oops; 792 err = saa7146_pgtable_build(dev,buf); 793 if (err) 794 goto oops; 795 } 796 buf->vb.state = VIDEOBUF_PREPARED; 797 buf->activate = buffer_activate; 798 799 return 0; 800 801 oops: 802 DEB_D("error out\n"); 803 saa7146_dma_free(dev,q,buf); 804 805 return err; 806 } 807 808 static int buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size) 809 { 810 struct file *file = q->priv_data; 811 struct saa7146_fh *fh = file->private_data; 812 struct saa7146_vv *vv = fh->dev->vv_data; 813 814 if (0 == *count || *count > MAX_SAA7146_CAPTURE_BUFFERS) 815 *count = MAX_SAA7146_CAPTURE_BUFFERS; 816 817 *size = vv->video_fmt.sizeimage; 818 819 /* check if we exceed the "max_memory" parameter */ 820 if( (*count * *size) > (max_memory*1048576) ) { 821 *count = (max_memory*1048576) / *size; 822 } 823 824 DEB_CAP("%d buffers, %d bytes each\n", *count, *size); 825 826 return 0; 827 } 828 829 static void buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb) 830 { 831 struct file *file = q->priv_data; 832 struct saa7146_fh *fh = file->private_data; 833 struct saa7146_dev *dev = fh->dev; 834 struct saa7146_vv *vv = dev->vv_data; 835 struct saa7146_buf *buf = (struct saa7146_buf *)vb; 836 837 DEB_CAP("vbuf:%p\n", vb); 838 saa7146_buffer_queue(fh->dev, &vv->video_dmaq, buf); 839 } 840 841 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb) 842 { 843 struct file *file = q->priv_data; 844 struct saa7146_fh *fh = file->private_data; 845 struct saa7146_dev *dev = fh->dev; 846 struct saa7146_buf *buf = (struct saa7146_buf *)vb; 847 848 DEB_CAP("vbuf:%p\n", vb); 849 850 saa7146_dma_free(dev,q,buf); 851 852 release_all_pagetables(dev, buf); 853 } 854 855 static const struct videobuf_queue_ops video_qops = { 856 .buf_setup = buffer_setup, 857 .buf_prepare = buffer_prepare, 858 .buf_queue = buffer_queue, 859 .buf_release = buffer_release, 860 }; 861 862 /********************************************************************************/ 863 /* file operations */ 864 865 static void video_init(struct saa7146_dev *dev, struct saa7146_vv *vv) 866 { 867 INIT_LIST_HEAD(&vv->video_dmaq.queue); 868 869 timer_setup(&vv->video_dmaq.timeout, saa7146_buffer_timeout, 0); 870 vv->video_dmaq.dev = dev; 871 872 /* set some default values */ 873 vv->standard = &dev->ext_vv_data->stds[0]; 874 875 /* FIXME: what's this? */ 876 vv->current_hps_source = SAA7146_HPS_SOURCE_PORT_A; 877 vv->current_hps_sync = SAA7146_HPS_SYNC_PORT_A; 878 } 879 880 881 static int video_open(struct saa7146_dev *dev, struct file *file) 882 { 883 struct saa7146_fh *fh = file->private_data; 884 885 videobuf_queue_sg_init(&fh->video_q, &video_qops, 886 &dev->pci->dev, &dev->slock, 887 V4L2_BUF_TYPE_VIDEO_CAPTURE, 888 V4L2_FIELD_INTERLACED, 889 sizeof(struct saa7146_buf), 890 file, &dev->v4l2_lock); 891 892 return 0; 893 } 894 895 896 static void video_close(struct saa7146_dev *dev, struct file *file) 897 { 898 struct saa7146_fh *fh = file->private_data; 899 struct saa7146_vv *vv = dev->vv_data; 900 struct videobuf_queue *q = &fh->video_q; 901 902 if (IS_CAPTURE_ACTIVE(fh) != 0) 903 video_end(fh, file); 904 905 videobuf_stop(q); 906 /* hmm, why is this function declared void? */ 907 } 908 909 910 static void video_irq_done(struct saa7146_dev *dev, unsigned long st) 911 { 912 struct saa7146_vv *vv = dev->vv_data; 913 struct saa7146_dmaqueue *q = &vv->video_dmaq; 914 915 spin_lock(&dev->slock); 916 DEB_CAP("called\n"); 917 918 /* only finish the buffer if we have one... */ 919 if( NULL != q->curr ) { 920 saa7146_buffer_finish(dev,q,VIDEOBUF_DONE); 921 } 922 saa7146_buffer_next(dev,q,0); 923 924 spin_unlock(&dev->slock); 925 } 926 927 static ssize_t video_read(struct file *file, char __user *data, size_t count, loff_t *ppos) 928 { 929 struct saa7146_fh *fh = file->private_data; 930 struct saa7146_dev *dev = fh->dev; 931 struct saa7146_vv *vv = dev->vv_data; 932 ssize_t ret = 0; 933 934 DEB_EE("called\n"); 935 936 if ((vv->video_status & STATUS_CAPTURE) != 0) { 937 /* fixme: should we allow read() captures while streaming capture? */ 938 if (vv->video_fh == fh) { 939 DEB_S("already capturing\n"); 940 return -EBUSY; 941 } 942 DEB_S("already capturing in another open\n"); 943 return -EBUSY; 944 } 945 946 ret = video_begin(fh); 947 if( 0 != ret) { 948 goto out; 949 } 950 951 ret = videobuf_read_one(&fh->video_q , data, count, ppos, 952 file->f_flags & O_NONBLOCK); 953 if (ret != 0) { 954 video_end(fh, file); 955 } else { 956 ret = video_end(fh, file); 957 } 958 out: 959 return ret; 960 } 961 962 const struct saa7146_use_ops saa7146_video_uops = { 963 .init = video_init, 964 .open = video_open, 965 .release = video_close, 966 .irq_done = video_irq_done, 967 .read = video_read, 968 }; 969