1 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
3 #include <media/saa7146_vv.h>
4 #include <media/v4l2-chip-ident.h>
5 #include <linux/module.h>
7 static int max_memory
= 32;
9 module_param(max_memory
, int, 0644);
10 MODULE_PARM_DESC(max_memory
, "maximum memory usage for capture buffers (default: 32Mb)");
12 #define IS_CAPTURE_ACTIVE(fh) \
13 (((vv->video_status & STATUS_CAPTURE) != 0) && (vv->video_fh == fh))
15 #define IS_OVERLAY_ACTIVE(fh) \
16 (((vv->video_status & STATUS_OVERLAY) != 0) && (vv->video_fh == fh))
18 /* format descriptions for capture and preview */
19 static struct saa7146_format formats
[] = {
21 .name
= "RGB-8 (3-3-2)",
22 .pixelformat
= V4L2_PIX_FMT_RGB332
,
23 .trans
= RGB08_COMPOSED
,
27 .name
= "RGB-16 (5/B-6/G-5/R)",
28 .pixelformat
= V4L2_PIX_FMT_RGB565
,
29 .trans
= RGB16_COMPOSED
,
33 .name
= "RGB-24 (B-G-R)",
34 .pixelformat
= V4L2_PIX_FMT_BGR24
,
35 .trans
= RGB24_COMPOSED
,
39 .name
= "RGB-32 (B-G-R)",
40 .pixelformat
= V4L2_PIX_FMT_BGR32
,
41 .trans
= RGB32_COMPOSED
,
45 .name
= "RGB-32 (R-G-B)",
46 .pixelformat
= V4L2_PIX_FMT_RGB32
,
47 .trans
= RGB32_COMPOSED
,
52 .name
= "Greyscale-8",
53 .pixelformat
= V4L2_PIX_FMT_GREY
,
58 .name
= "YUV 4:2:2 planar (Y-Cb-Cr)",
59 .pixelformat
= V4L2_PIX_FMT_YUV422P
,
60 .trans
= YUV422_DECOMPOSED
,
62 .flags
= FORMAT_BYTE_SWAP
|FORMAT_IS_PLANAR
,
64 .name
= "YVU 4:2:0 planar (Y-Cb-Cr)",
65 .pixelformat
= V4L2_PIX_FMT_YVU420
,
66 .trans
= YUV420_DECOMPOSED
,
68 .flags
= FORMAT_BYTE_SWAP
|FORMAT_IS_PLANAR
,
70 .name
= "YUV 4:2:0 planar (Y-Cb-Cr)",
71 .pixelformat
= V4L2_PIX_FMT_YUV420
,
72 .trans
= YUV420_DECOMPOSED
,
74 .flags
= FORMAT_IS_PLANAR
,
76 .name
= "YUV 4:2:2 (U-Y-V-Y)",
77 .pixelformat
= V4L2_PIX_FMT_UYVY
,
78 .trans
= YUV422_COMPOSED
,
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-( */
88 static int NUM_FORMATS
= sizeof(formats
)/sizeof(struct saa7146_format
);
90 struct saa7146_format
* saa7146_format_by_fourcc(struct saa7146_dev
*dev
, int fourcc
)
92 int i
, j
= NUM_FORMATS
;
94 for (i
= 0; i
< j
; i
++) {
95 if (formats
[i
].pixelformat
== fourcc
) {
100 DEB_D("unknown pixelformat:'%4.4s'\n", (char *)&fourcc
);
104 static int vidioc_try_fmt_vid_overlay(struct file
*file
, void *fh
, struct v4l2_format
*f
);
106 int saa7146_start_preview(struct saa7146_fh
*fh
)
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;
113 DEB_EE("dev:%p, fh:%p\n", dev
, fh
);
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");
121 /* check if streaming capture is running */
122 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
123 DEB_D("streaming capture is active\n");
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");
133 DEB_D("overlay is already active in another open\n");
137 if (0 == saa7146_res_get(fh
, RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
)) {
138 DEB_D("cannot get necessary overlay resources\n");
142 fmt
.fmt
.win
= vv
->ov
.win
;
143 err
= vidioc_try_fmt_vid_overlay(NULL
, fh
, &fmt
);
145 saa7146_res_free(vv
->video_fh
, RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
);
148 vv
->ov
.win
= fmt
.fmt
.win
;
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
]);
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
);
161 vv
->video_status
= STATUS_OVERLAY
;
166 EXPORT_SYMBOL_GPL(saa7146_start_preview
);
168 int saa7146_stop_preview(struct saa7146_fh
*fh
)
170 struct saa7146_dev
*dev
= fh
->dev
;
171 struct saa7146_vv
*vv
= dev
->vv_data
;
173 DEB_EE("dev:%p, fh:%p\n", dev
, fh
);
175 /* check if streaming capture is running */
176 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
177 DEB_D("streaming capture is active\n");
181 /* check if overlay is running at all */
182 if ((vv
->video_status
& STATUS_OVERLAY
) == 0) {
183 DEB_D("no active overlay\n");
187 if (vv
->video_fh
!= fh
) {
188 DEB_D("overlay is active, but in another open\n");
192 vv
->video_status
= 0;
195 saa7146_disable_overlay(fh
);
197 saa7146_res_free(fh
, RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
);
201 EXPORT_SYMBOL_GPL(saa7146_stop_preview
);
203 /********************************************************************************/
204 /* common pagetable functions */
206 static int saa7146_pgtable_build(struct saa7146_dev
*dev
, struct saa7146_buf
*buf
)
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
);
214 DEB_EE("dev:%p, buf:%p, sg_len:%d\n", dev
, buf
, length
);
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
;
223 int size
= buf
->fmt
->width
*buf
->fmt
->height
;
224 int i
,p
,m1
,m2
,m3
,o1
,o2
;
226 switch( sfmt
->depth
) {
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;
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
);
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;
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
);
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
);
267 printk("ptr1 %d: 0x%08x\n",j,ptr1[j]);
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
;
277 /* create video-dma2 page table */
279 for(i
= m1
; i
<= m2
; i
++, ptr2
++) {
283 for(;i
<1024;i
++,ptr2
++) {
286 /* create video-dma3 page table */
288 for(i
= m2
; i
<= m3
; i
++,ptr3
++) {
292 for(;i
<1024;i
++,ptr3
++) {
295 /* finally: finish up video-dma1 page table */
298 for(i
=m1
;i
<1024;i
++,ptr1
++) {
306 printk("ptr1 %d: 0x%08x\n",j,ptr1[j]);
309 printk("ptr2 %d: 0x%08x\n",j,ptr2[j]);
312 printk("ptr3 %d: 0x%08x\n",j,ptr3[j]);
316 struct saa7146_pgtable
*pt
= &buf
->pt
[0];
317 return saa7146_pgtable_build_single(pci
, pt
, list
, length
);
324 /********************************************************************************/
325 /* file operations */
327 static int video_begin(struct saa7146_fh
*fh
)
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;
335 DEB_EE("dev:%p, fh:%p\n", dev
, fh
);
337 if ((vv
->video_status
& STATUS_CAPTURE
) != 0) {
338 if (vv
->video_fh
== fh
) {
339 DEB_S("already capturing\n");
342 DEB_S("already capturing in another open\n");
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 */
351 DEB_D("suspending video failed. aborting\n");
356 fmt
= saa7146_format_by_fourcc(dev
, vv
->video_fmt
.pixelformat
);
357 /* we need to have a valid format set here */
360 if (0 != (fmt
->flags
& FORMAT_IS_PLANAR
)) {
361 resource
= RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
|RESOURCE_DMA3_BRS
;
363 resource
= RESOURCE_DMA1_HPS
;
366 ret
= saa7146_res_get(fh
, resource
);
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
;
376 /* clear out beginning of streaming bit (rps register 0)*/
377 saa7146_write(dev
, MC2
, MASK_27
);
379 /* enable rps0 irqs */
380 SAA7146_IER_ENABLE(dev
, MASK_27
);
383 vv
->video_status
= STATUS_CAPTURE
;
388 static int video_end(struct saa7146_fh
*fh
, struct file
*file
)
390 struct saa7146_dev
*dev
= fh
->dev
;
391 struct saa7146_vv
*vv
= dev
->vv_data
;
392 struct saa7146_format
*fmt
= NULL
;
394 unsigned int resource
;
396 DEB_EE("dev:%p, fh:%p\n", dev
, fh
);
398 if ((vv
->video_status
& STATUS_CAPTURE
) != STATUS_CAPTURE
) {
399 DEB_S("not capturing\n");
403 if (vv
->video_fh
!= fh
) {
404 DEB_S("capturing, but in another open\n");
408 fmt
= saa7146_format_by_fourcc(dev
, vv
->video_fmt
.pixelformat
);
409 /* we need to have a valid format set here */
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
;
416 resource
= RESOURCE_DMA1_HPS
;
419 spin_lock_irqsave(&dev
->slock
,flags
);
422 saa7146_write(dev
, MC1
, MASK_28
);
424 /* disable rps0 irqs */
425 SAA7146_IER_DISABLE(dev
, MASK_27
);
427 /* shut down all used video dma transfers */
428 saa7146_write(dev
, MC1
, dmas
);
430 spin_unlock_irqrestore(&dev
->slock
, flags
);
433 vv
->video_status
= 0;
435 saa7146_res_free(fh
, resource
);
437 if (vv
->ov_suspend
!= NULL
) {
438 saa7146_start_preview(vv
->ov_suspend
);
439 vv
->ov_suspend
= NULL
;
445 static int vidioc_querycap(struct file
*file
, void *fh
, struct v4l2_capability
*cap
)
447 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
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
;
454 V4L2_CAP_VIDEO_CAPTURE
|
455 V4L2_CAP_VIDEO_OVERLAY
|
458 cap
->device_caps
|= dev
->ext_vv_data
->capabilities
;
459 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
463 static int vidioc_g_fbuf(struct file
*file
, void *fh
, struct v4l2_framebuffer
*fb
)
465 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
466 struct saa7146_vv
*vv
= dev
->vv_data
;
469 fb
->capability
= V4L2_FBUF_CAP_LIST_CLIPPING
;
470 fb
->flags
= V4L2_FBUF_FLAG_PRIMARY
;
474 static int vidioc_s_fbuf(struct file
*file
, void *fh
, struct v4l2_framebuffer
*fb
)
476 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
477 struct saa7146_vv
*vv
= dev
->vv_data
;
478 struct saa7146_format
*fmt
;
480 DEB_EE("VIDIOC_S_FBUF\n");
482 if (!capable(CAP_SYS_ADMIN
) && !capable(CAP_SYS_RAWIO
))
486 fmt
= saa7146_format_by_fourcc(dev
, fb
->fmt
.pixelformat
);
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
);
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");
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
);
514 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_fmtdesc
*f
)
516 if (f
->index
>= NUM_FORMATS
)
518 strlcpy((char *)f
->description
, formats
[f
->index
].name
,
519 sizeof(f
->description
));
520 f
->pixelformat
= formats
[f
->index
].pixelformat
;
524 int saa7146_s_ctrl(struct v4l2_ctrl
*ctrl
)
526 struct saa7146_dev
*dev
= container_of(ctrl
->handler
,
527 struct saa7146_dev
, ctrl_handler
);
528 struct saa7146_vv
*vv
= dev
->vv_data
;
532 case V4L2_CID_BRIGHTNESS
:
533 val
= saa7146_read(dev
, BCS_CTRL
);
535 val
|= (ctrl
->val
<< 24);
536 saa7146_write(dev
, BCS_CTRL
, val
);
537 saa7146_write(dev
, MC2
, MASK_22
| MASK_06
);
540 case V4L2_CID_CONTRAST
:
541 val
= saa7146_read(dev
, BCS_CTRL
);
543 val
|= (ctrl
->val
<< 16);
544 saa7146_write(dev
, BCS_CTRL
, val
);
545 saa7146_write(dev
, MC2
, MASK_22
| MASK_06
);
548 case V4L2_CID_SATURATION
:
549 val
= saa7146_read(dev
, BCS_CTRL
);
551 val
|= (ctrl
->val
<< 0);
552 saa7146_write(dev
, BCS_CTRL
, val
);
553 saa7146_write(dev
, MC2
, MASK_22
| MASK_06
);
557 /* fixme: we can support changing VFLIP and HFLIP here... */
558 if ((vv
->video_status
& STATUS_CAPTURE
))
560 vv
->hflip
= ctrl
->val
;
564 if ((vv
->video_status
& STATUS_CAPTURE
))
566 vv
->vflip
= ctrl
->val
;
573 if ((vv
->video_status
& STATUS_OVERLAY
) != 0) { /* CHECK: && (vv->video_fh == fh)) */
574 struct saa7146_fh
*fh
= vv
->video_fh
;
576 saa7146_stop_preview(fh
);
577 saa7146_start_preview(fh
);
582 static int vidioc_g_parm(struct file
*file
, void *fh
,
583 struct v4l2_streamparm
*parm
)
585 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
586 struct saa7146_vv
*vv
= dev
->vv_data
;
588 if (parm
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
590 parm
->parm
.capture
.readbuffers
= 1;
591 v4l2_video_std_frame_period(vv
->standard
->id
,
592 &parm
->parm
.capture
.timeperframe
);
596 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_format
*f
)
598 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
599 struct saa7146_vv
*vv
= dev
->vv_data
;
601 f
->fmt
.pix
= vv
->video_fmt
;
605 static int vidioc_g_fmt_vid_overlay(struct file
*file
, void *fh
, struct v4l2_format
*f
)
607 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
608 struct saa7146_vv
*vv
= dev
->vv_data
;
610 f
->fmt
.win
= vv
->ov
.win
;
614 static int vidioc_g_fmt_vbi_cap(struct file
*file
, void *fh
, struct v4l2_format
*f
)
616 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
617 struct saa7146_vv
*vv
= dev
->vv_data
;
619 f
->fmt
.vbi
= vv
->vbi_fmt
;
623 static int vidioc_try_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_format
*f
)
625 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
626 struct saa7146_vv
*vv
= dev
->vv_data
;
627 struct saa7146_format
*fmt
;
628 enum v4l2_field field
;
632 DEB_EE("V4L2_BUF_TYPE_VIDEO_CAPTURE: dev:%p, fh:%p\n", dev
, fh
);
634 fmt
= saa7146_format_by_fourcc(dev
, f
->fmt
.pix
.pixelformat
);
638 field
= f
->fmt
.pix
.field
;
639 maxw
= vv
->standard
->h_max_out
;
640 maxh
= vv
->standard
->v_max_out
;
642 if (V4L2_FIELD_ANY
== field
) {
643 field
= (f
->fmt
.pix
.height
> maxh
/ 2)
644 ? V4L2_FIELD_INTERLACED
648 case V4L2_FIELD_ALTERNATE
:
649 vv
->last_field
= V4L2_FIELD_TOP
;
653 case V4L2_FIELD_BOTTOM
:
654 vv
->last_field
= V4L2_FIELD_INTERLACED
;
657 case V4L2_FIELD_INTERLACED
:
658 vv
->last_field
= V4L2_FIELD_INTERLACED
;
661 DEB_D("no known field mode '%d'\n", field
);
665 f
->fmt
.pix
.field
= field
;
666 f
->fmt
.pix
.colorspace
= V4L2_COLORSPACE_SMPTE170M
;
667 if (f
->fmt
.pix
.width
> maxw
)
668 f
->fmt
.pix
.width
= maxw
;
669 if (f
->fmt
.pix
.height
> maxh
)
670 f
->fmt
.pix
.height
= maxh
;
672 calc_bpl
= (f
->fmt
.pix
.width
* fmt
->depth
) / 8;
674 if (f
->fmt
.pix
.bytesperline
< calc_bpl
)
675 f
->fmt
.pix
.bytesperline
= calc_bpl
;
677 if (f
->fmt
.pix
.bytesperline
> (2 * PAGE_SIZE
* fmt
->depth
) / 8) /* arbitrary constraint */
678 f
->fmt
.pix
.bytesperline
= calc_bpl
;
680 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
* f
->fmt
.pix
.height
;
681 DEB_D("w:%d, h:%d, bytesperline:%d, sizeimage:%d\n",
682 f
->fmt
.pix
.width
, f
->fmt
.pix
.height
,
683 f
->fmt
.pix
.bytesperline
, f
->fmt
.pix
.sizeimage
);
689 static int vidioc_try_fmt_vid_overlay(struct file
*file
, void *fh
, struct v4l2_format
*f
)
691 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
692 struct saa7146_vv
*vv
= dev
->vv_data
;
693 struct v4l2_window
*win
= &f
->fmt
.win
;
694 enum v4l2_field field
;
697 DEB_EE("dev:%p\n", dev
);
699 if (NULL
== vv
->ov_fb
.base
) {
700 DEB_D("no fb base set\n");
703 if (NULL
== vv
->ov_fmt
) {
704 DEB_D("no fb fmt set\n");
707 if (win
->w
.width
< 48 || win
->w
.height
< 32) {
708 DEB_D("min width/height. (%d,%d)\n",
709 win
->w
.width
, win
->w
.height
);
712 if (win
->clipcount
> 16) {
713 DEB_D("clipcount too big\n");
718 maxw
= vv
->standard
->h_max_out
;
719 maxh
= vv
->standard
->v_max_out
;
721 if (V4L2_FIELD_ANY
== field
) {
722 field
= (win
->w
.height
> maxh
/ 2)
723 ? V4L2_FIELD_INTERLACED
728 case V4L2_FIELD_BOTTOM
:
729 case V4L2_FIELD_ALTERNATE
:
732 case V4L2_FIELD_INTERLACED
:
735 DEB_D("no known field mode '%d'\n", field
);
740 if (win
->w
.width
> maxw
)
742 if (win
->w
.height
> maxh
)
743 win
->w
.height
= maxh
;
748 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *__fh
, struct v4l2_format
*f
)
750 struct saa7146_fh
*fh
= __fh
;
751 struct saa7146_dev
*dev
= fh
->dev
;
752 struct saa7146_vv
*vv
= dev
->vv_data
;
755 DEB_EE("V4L2_BUF_TYPE_VIDEO_CAPTURE: dev:%p, fh:%p\n", dev
, fh
);
756 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
757 DEB_EE("streaming capture is active\n");
760 err
= vidioc_try_fmt_vid_cap(file
, fh
, f
);
763 vv
->video_fmt
= f
->fmt
.pix
;
764 DEB_EE("set to pixelformat '%4.4s'\n",
765 (char *)&vv
->video_fmt
.pixelformat
);
769 static int vidioc_s_fmt_vid_overlay(struct file
*file
, void *__fh
, struct v4l2_format
*f
)
771 struct saa7146_fh
*fh
= __fh
;
772 struct saa7146_dev
*dev
= fh
->dev
;
773 struct saa7146_vv
*vv
= dev
->vv_data
;
776 DEB_EE("V4L2_BUF_TYPE_VIDEO_OVERLAY: dev:%p, fh:%p\n", dev
, fh
);
777 err
= vidioc_try_fmt_vid_overlay(file
, fh
, f
);
780 vv
->ov
.win
= f
->fmt
.win
;
781 vv
->ov
.nclips
= f
->fmt
.win
.clipcount
;
782 if (vv
->ov
.nclips
> 16)
784 if (copy_from_user(vv
->ov
.clips
, f
->fmt
.win
.clips
,
785 sizeof(struct v4l2_clip
) * vv
->ov
.nclips
)) {
789 /* vv->ov.fh is used to indicate that we have valid overlay informations, too */
792 /* check if our current overlay is active */
793 if (IS_OVERLAY_ACTIVE(fh
) != 0) {
794 saa7146_stop_preview(fh
);
795 saa7146_start_preview(fh
);
800 static int vidioc_g_std(struct file
*file
, void *fh
, v4l2_std_id
*norm
)
802 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
803 struct saa7146_vv
*vv
= dev
->vv_data
;
805 *norm
= vv
->standard
->id
;
809 /* the saa7146 supfhrts (used in conjunction with the saa7111a for example)
810 PAL / NTSC / SECAM. if your hardware does not (or does more)
811 -- override this function in your extension */
815 struct v4l2_standard *e = arg;
818 if( e->index < dev->ext_vv_data->num_stds ) {
819 DEB_EE("VIDIOC_ENUMSTD: index:%d\n", e->index);
820 v4l2_video_std_construct(e, dev->ext_vv_data->stds[e->index].id, dev->ext_vv_data->stds[e->index].name);
827 static int vidioc_s_std(struct file
*file
, void *fh
, v4l2_std_id
*id
)
829 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
830 struct saa7146_vv
*vv
= dev
->vv_data
;
834 DEB_EE("VIDIOC_S_STD\n");
836 if ((vv
->video_status
& STATUS_CAPTURE
) == STATUS_CAPTURE
) {
837 DEB_D("cannot change video standard while streaming capture is active\n");
841 if ((vv
->video_status
& STATUS_OVERLAY
) != 0) {
842 vv
->ov_suspend
= vv
->video_fh
;
843 err
= saa7146_stop_preview(vv
->video_fh
); /* side effect: video_status is now 0, video_fh is NULL */
845 DEB_D("suspending video failed. aborting\n");
850 for (i
= 0; i
< dev
->ext_vv_data
->num_stds
; i
++)
851 if (*id
& dev
->ext_vv_data
->stds
[i
].id
)
853 if (i
!= dev
->ext_vv_data
->num_stds
) {
854 vv
->standard
= &dev
->ext_vv_data
->stds
[i
];
855 if (NULL
!= dev
->ext_vv_data
->std_callback
)
856 dev
->ext_vv_data
->std_callback(dev
, vv
->standard
);
860 if (vv
->ov_suspend
!= NULL
) {
861 saa7146_start_preview(vv
->ov_suspend
);
862 vv
->ov_suspend
= NULL
;
866 DEB_EE("VIDIOC_S_STD: standard not found\n");
870 DEB_EE("VIDIOC_S_STD: set to standard to '%s'\n", vv
->standard
->name
);
874 static int vidioc_overlay(struct file
*file
, void *fh
, unsigned int on
)
878 DEB_D("VIDIOC_OVERLAY on:%d\n", on
);
880 err
= saa7146_start_preview(fh
);
882 err
= saa7146_stop_preview(fh
);
886 static int vidioc_reqbufs(struct file
*file
, void *__fh
, struct v4l2_requestbuffers
*b
)
888 struct saa7146_fh
*fh
= __fh
;
890 if (b
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
891 return videobuf_reqbufs(&fh
->video_q
, b
);
892 if (b
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
893 return videobuf_reqbufs(&fh
->vbi_q
, b
);
897 static int vidioc_querybuf(struct file
*file
, void *__fh
, struct v4l2_buffer
*buf
)
899 struct saa7146_fh
*fh
= __fh
;
901 if (buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
902 return videobuf_querybuf(&fh
->video_q
, buf
);
903 if (buf
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
904 return videobuf_querybuf(&fh
->vbi_q
, buf
);
908 static int vidioc_qbuf(struct file
*file
, void *__fh
, struct v4l2_buffer
*buf
)
910 struct saa7146_fh
*fh
= __fh
;
912 if (buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
913 return videobuf_qbuf(&fh
->video_q
, buf
);
914 if (buf
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
915 return videobuf_qbuf(&fh
->vbi_q
, buf
);
919 static int vidioc_dqbuf(struct file
*file
, void *__fh
, struct v4l2_buffer
*buf
)
921 struct saa7146_fh
*fh
= __fh
;
923 if (buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
924 return videobuf_dqbuf(&fh
->video_q
, buf
, file
->f_flags
& O_NONBLOCK
);
925 if (buf
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
926 return videobuf_dqbuf(&fh
->vbi_q
, buf
, file
->f_flags
& O_NONBLOCK
);
930 static int vidioc_streamon(struct file
*file
, void *__fh
, enum v4l2_buf_type type
)
932 struct saa7146_fh
*fh
= __fh
;
935 DEB_D("VIDIOC_STREAMON, type:%d\n", type
);
937 err
= video_begin(fh
);
940 if (type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
941 return videobuf_streamon(&fh
->video_q
);
942 if (type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
943 return videobuf_streamon(&fh
->vbi_q
);
947 static int vidioc_streamoff(struct file
*file
, void *__fh
, enum v4l2_buf_type type
)
949 struct saa7146_fh
*fh
= __fh
;
950 struct saa7146_dev
*dev
= fh
->dev
;
951 struct saa7146_vv
*vv
= dev
->vv_data
;
954 DEB_D("VIDIOC_STREAMOFF, type:%d\n", type
);
956 /* ugly: we need to copy some checks from video_end(),
957 because videobuf_streamoff() relies on the capture running.
958 check and fix this */
959 if ((vv
->video_status
& STATUS_CAPTURE
) != STATUS_CAPTURE
) {
960 DEB_S("not capturing\n");
964 if (vv
->video_fh
!= fh
) {
965 DEB_S("capturing, but in another open\n");
970 if (type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
971 err
= videobuf_streamoff(&fh
->video_q
);
972 else if (type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
973 err
= videobuf_streamoff(&fh
->vbi_q
);
975 DEB_D("warning: videobuf_streamoff() failed\n");
978 err
= video_end(fh
, file
);
983 static int vidioc_g_chip_ident(struct file
*file
, void *__fh
,
984 struct v4l2_dbg_chip_ident
*chip
)
986 struct saa7146_fh
*fh
= __fh
;
987 struct saa7146_dev
*dev
= fh
->dev
;
989 chip
->ident
= V4L2_IDENT_NONE
;
991 if (chip
->match
.type
== V4L2_CHIP_MATCH_HOST
&& !chip
->match
.addr
) {
992 chip
->ident
= V4L2_IDENT_SAA7146
;
995 return v4l2_device_call_until_err(&dev
->v4l2_dev
, 0,
996 core
, g_chip_ident
, chip
);
999 const struct v4l2_ioctl_ops saa7146_video_ioctl_ops
= {
1000 .vidioc_querycap
= vidioc_querycap
,
1001 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
1002 .vidioc_enum_fmt_vid_overlay
= vidioc_enum_fmt_vid_cap
,
1003 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
1004 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
1005 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
1006 .vidioc_g_fmt_vid_overlay
= vidioc_g_fmt_vid_overlay
,
1007 .vidioc_try_fmt_vid_overlay
= vidioc_try_fmt_vid_overlay
,
1008 .vidioc_s_fmt_vid_overlay
= vidioc_s_fmt_vid_overlay
,
1009 .vidioc_g_fmt_vbi_cap
= vidioc_g_fmt_vbi_cap
,
1010 .vidioc_g_chip_ident
= vidioc_g_chip_ident
,
1012 .vidioc_overlay
= vidioc_overlay
,
1013 .vidioc_g_fbuf
= vidioc_g_fbuf
,
1014 .vidioc_s_fbuf
= vidioc_s_fbuf
,
1015 .vidioc_reqbufs
= vidioc_reqbufs
,
1016 .vidioc_querybuf
= vidioc_querybuf
,
1017 .vidioc_qbuf
= vidioc_qbuf
,
1018 .vidioc_dqbuf
= vidioc_dqbuf
,
1019 .vidioc_g_std
= vidioc_g_std
,
1020 .vidioc_s_std
= vidioc_s_std
,
1021 .vidioc_streamon
= vidioc_streamon
,
1022 .vidioc_streamoff
= vidioc_streamoff
,
1023 .vidioc_g_parm
= vidioc_g_parm
,
1026 /*********************************************************************************/
1027 /* buffer handling functions */
1029 static int buffer_activate (struct saa7146_dev
*dev
,
1030 struct saa7146_buf
*buf
,
1031 struct saa7146_buf
*next
)
1033 struct saa7146_vv
*vv
= dev
->vv_data
;
1035 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
1036 saa7146_set_capture(dev
,buf
,next
);
1038 mod_timer(&vv
->video_dmaq
.timeout
, jiffies
+BUFFER_TIMEOUT
);
1042 static void release_all_pagetables(struct saa7146_dev
*dev
, struct saa7146_buf
*buf
)
1044 saa7146_pgtable_free(dev
->pci
, &buf
->pt
[0]);
1045 saa7146_pgtable_free(dev
->pci
, &buf
->pt
[1]);
1046 saa7146_pgtable_free(dev
->pci
, &buf
->pt
[2]);
1049 static int buffer_prepare(struct videobuf_queue
*q
,
1050 struct videobuf_buffer
*vb
, enum v4l2_field field
)
1052 struct file
*file
= q
->priv_data
;
1053 struct saa7146_fh
*fh
= file
->private_data
;
1054 struct saa7146_dev
*dev
= fh
->dev
;
1055 struct saa7146_vv
*vv
= dev
->vv_data
;
1056 struct saa7146_buf
*buf
= (struct saa7146_buf
*)vb
;
1059 DEB_CAP("vbuf:%p\n", vb
);
1062 if (vv
->video_fmt
.width
< 48 ||
1063 vv
->video_fmt
.height
< 32 ||
1064 vv
->video_fmt
.width
> vv
->standard
->h_max_out
||
1065 vv
->video_fmt
.height
> vv
->standard
->v_max_out
) {
1066 DEB_D("w (%d) / h (%d) out of bounds\n",
1067 vv
->video_fmt
.width
, vv
->video_fmt
.height
);
1071 size
= vv
->video_fmt
.sizeimage
;
1072 if (0 != buf
->vb
.baddr
&& buf
->vb
.bsize
< size
) {
1073 DEB_D("size mismatch\n");
1077 DEB_CAP("buffer_prepare [size=%dx%d,bytes=%d,fields=%s]\n",
1078 vv
->video_fmt
.width
, vv
->video_fmt
.height
,
1079 size
, v4l2_field_names
[vv
->video_fmt
.field
]);
1080 if (buf
->vb
.width
!= vv
->video_fmt
.width
||
1081 buf
->vb
.bytesperline
!= vv
->video_fmt
.bytesperline
||
1082 buf
->vb
.height
!= vv
->video_fmt
.height
||
1083 buf
->vb
.size
!= size
||
1084 buf
->vb
.field
!= field
||
1085 buf
->vb
.field
!= vv
->video_fmt
.field
||
1086 buf
->fmt
!= &vv
->video_fmt
) {
1087 saa7146_dma_free(dev
,q
,buf
);
1090 if (VIDEOBUF_NEEDS_INIT
== buf
->vb
.state
) {
1091 struct saa7146_format
*sfmt
;
1093 buf
->vb
.bytesperline
= vv
->video_fmt
.bytesperline
;
1094 buf
->vb
.width
= vv
->video_fmt
.width
;
1095 buf
->vb
.height
= vv
->video_fmt
.height
;
1096 buf
->vb
.size
= size
;
1097 buf
->vb
.field
= field
;
1098 buf
->fmt
= &vv
->video_fmt
;
1099 buf
->vb
.field
= vv
->video_fmt
.field
;
1101 sfmt
= saa7146_format_by_fourcc(dev
,buf
->fmt
->pixelformat
);
1103 release_all_pagetables(dev
, buf
);
1104 if( 0 != IS_PLANAR(sfmt
->trans
)) {
1105 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[0]);
1106 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[1]);
1107 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[2]);
1109 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[0]);
1112 err
= videobuf_iolock(q
,&buf
->vb
, &vv
->ov_fb
);
1115 err
= saa7146_pgtable_build(dev
,buf
);
1119 buf
->vb
.state
= VIDEOBUF_PREPARED
;
1120 buf
->activate
= buffer_activate
;
1125 DEB_D("error out\n");
1126 saa7146_dma_free(dev
,q
,buf
);
1131 static int buffer_setup(struct videobuf_queue
*q
, unsigned int *count
, unsigned int *size
)
1133 struct file
*file
= q
->priv_data
;
1134 struct saa7146_fh
*fh
= file
->private_data
;
1135 struct saa7146_vv
*vv
= fh
->dev
->vv_data
;
1137 if (0 == *count
|| *count
> MAX_SAA7146_CAPTURE_BUFFERS
)
1138 *count
= MAX_SAA7146_CAPTURE_BUFFERS
;
1140 *size
= vv
->video_fmt
.sizeimage
;
1142 /* check if we exceed the "max_memory" parameter */
1143 if( (*count
* *size
) > (max_memory
*1048576) ) {
1144 *count
= (max_memory
*1048576) / *size
;
1147 DEB_CAP("%d buffers, %d bytes each\n", *count
, *size
);
1152 static void buffer_queue(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1154 struct file
*file
= q
->priv_data
;
1155 struct saa7146_fh
*fh
= file
->private_data
;
1156 struct saa7146_dev
*dev
= fh
->dev
;
1157 struct saa7146_vv
*vv
= dev
->vv_data
;
1158 struct saa7146_buf
*buf
= (struct saa7146_buf
*)vb
;
1160 DEB_CAP("vbuf:%p\n", vb
);
1161 saa7146_buffer_queue(fh
->dev
, &vv
->video_dmaq
, buf
);
1164 static void buffer_release(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1166 struct file
*file
= q
->priv_data
;
1167 struct saa7146_fh
*fh
= file
->private_data
;
1168 struct saa7146_dev
*dev
= fh
->dev
;
1169 struct saa7146_buf
*buf
= (struct saa7146_buf
*)vb
;
1171 DEB_CAP("vbuf:%p\n", vb
);
1173 saa7146_dma_free(dev
,q
,buf
);
1175 release_all_pagetables(dev
, buf
);
1178 static struct videobuf_queue_ops video_qops
= {
1179 .buf_setup
= buffer_setup
,
1180 .buf_prepare
= buffer_prepare
,
1181 .buf_queue
= buffer_queue
,
1182 .buf_release
= buffer_release
,
1185 /********************************************************************************/
1186 /* file operations */
1188 static void video_init(struct saa7146_dev
*dev
, struct saa7146_vv
*vv
)
1190 INIT_LIST_HEAD(&vv
->video_dmaq
.queue
);
1192 init_timer(&vv
->video_dmaq
.timeout
);
1193 vv
->video_dmaq
.timeout
.function
= saa7146_buffer_timeout
;
1194 vv
->video_dmaq
.timeout
.data
= (unsigned long)(&vv
->video_dmaq
);
1195 vv
->video_dmaq
.dev
= dev
;
1197 /* set some default values */
1198 vv
->standard
= &dev
->ext_vv_data
->stds
[0];
1200 /* FIXME: what's this? */
1201 vv
->current_hps_source
= SAA7146_HPS_SOURCE_PORT_A
;
1202 vv
->current_hps_sync
= SAA7146_HPS_SYNC_PORT_A
;
1206 static int video_open(struct saa7146_dev
*dev
, struct file
*file
)
1208 struct saa7146_fh
*fh
= file
->private_data
;
1210 videobuf_queue_sg_init(&fh
->video_q
, &video_qops
,
1211 &dev
->pci
->dev
, &dev
->slock
,
1212 V4L2_BUF_TYPE_VIDEO_CAPTURE
,
1213 V4L2_FIELD_INTERLACED
,
1214 sizeof(struct saa7146_buf
),
1215 file
, &dev
->v4l2_lock
);
1221 static void video_close(struct saa7146_dev
*dev
, struct file
*file
)
1223 struct saa7146_fh
*fh
= file
->private_data
;
1224 struct saa7146_vv
*vv
= dev
->vv_data
;
1225 struct videobuf_queue
*q
= &fh
->video_q
;
1227 if (IS_CAPTURE_ACTIVE(fh
) != 0)
1228 video_end(fh
, file
);
1229 else if (IS_OVERLAY_ACTIVE(fh
) != 0)
1230 saa7146_stop_preview(fh
);
1233 /* hmm, why is this function declared void? */
1237 static void video_irq_done(struct saa7146_dev
*dev
, unsigned long st
)
1239 struct saa7146_vv
*vv
= dev
->vv_data
;
1240 struct saa7146_dmaqueue
*q
= &vv
->video_dmaq
;
1242 spin_lock(&dev
->slock
);
1243 DEB_CAP("called\n");
1245 /* only finish the buffer if we have one... */
1246 if( NULL
!= q
->curr
) {
1247 saa7146_buffer_finish(dev
,q
,VIDEOBUF_DONE
);
1249 saa7146_buffer_next(dev
,q
,0);
1251 spin_unlock(&dev
->slock
);
1254 static ssize_t
video_read(struct file
*file
, char __user
*data
, size_t count
, loff_t
*ppos
)
1256 struct saa7146_fh
*fh
= file
->private_data
;
1257 struct saa7146_dev
*dev
= fh
->dev
;
1258 struct saa7146_vv
*vv
= dev
->vv_data
;
1263 if ((vv
->video_status
& STATUS_CAPTURE
) != 0) {
1264 /* fixme: should we allow read() captures while streaming capture? */
1265 if (vv
->video_fh
== fh
) {
1266 DEB_S("already capturing\n");
1269 DEB_S("already capturing in another open\n");
1273 ret
= video_begin(fh
);
1278 ret
= videobuf_read_one(&fh
->video_q
, data
, count
, ppos
,
1279 file
->f_flags
& O_NONBLOCK
);
1281 video_end(fh
, file
);
1283 ret
= video_end(fh
, file
);
1286 /* restart overlay if it was active before */
1287 if (vv
->ov_suspend
!= NULL
) {
1288 saa7146_start_preview(vv
->ov_suspend
);
1289 vv
->ov_suspend
= NULL
;
1295 struct saa7146_use_ops saa7146_video_uops
= {
1298 .release
= video_close
,
1299 .irq_done
= video_irq_done
,