1 #include <media/saa7146_vv.h>
2 #include <media/v4l2-chip-ident.h>
4 static int max_memory
= 32;
6 module_param(max_memory
, int, 0644);
7 MODULE_PARM_DESC(max_memory
, "maximum memory usage for capture buffers (default: 32Mb)");
9 #define IS_CAPTURE_ACTIVE(fh) \
10 (((vv->video_status & STATUS_CAPTURE) != 0) && (vv->video_fh == fh))
12 #define IS_OVERLAY_ACTIVE(fh) \
13 (((vv->video_status & STATUS_OVERLAY) != 0) && (vv->video_fh == fh))
15 /* format descriptions for capture and preview */
16 static struct saa7146_format formats
[] = {
18 .name
= "RGB-8 (3-3-2)",
19 .pixelformat
= V4L2_PIX_FMT_RGB332
,
20 .trans
= RGB08_COMPOSED
,
24 .name
= "RGB-16 (5/B-6/G-5/R)",
25 .pixelformat
= V4L2_PIX_FMT_RGB565
,
26 .trans
= RGB16_COMPOSED
,
30 .name
= "RGB-24 (B-G-R)",
31 .pixelformat
= V4L2_PIX_FMT_BGR24
,
32 .trans
= RGB24_COMPOSED
,
36 .name
= "RGB-32 (B-G-R)",
37 .pixelformat
= V4L2_PIX_FMT_BGR32
,
38 .trans
= RGB32_COMPOSED
,
42 .name
= "RGB-32 (R-G-B)",
43 .pixelformat
= V4L2_PIX_FMT_RGB32
,
44 .trans
= RGB32_COMPOSED
,
49 .name
= "Greyscale-8",
50 .pixelformat
= V4L2_PIX_FMT_GREY
,
55 .name
= "YUV 4:2:2 planar (Y-Cb-Cr)",
56 .pixelformat
= V4L2_PIX_FMT_YUV422P
,
57 .trans
= YUV422_DECOMPOSED
,
59 .flags
= FORMAT_BYTE_SWAP
|FORMAT_IS_PLANAR
,
61 .name
= "YVU 4:2:0 planar (Y-Cb-Cr)",
62 .pixelformat
= V4L2_PIX_FMT_YVU420
,
63 .trans
= YUV420_DECOMPOSED
,
65 .flags
= FORMAT_BYTE_SWAP
|FORMAT_IS_PLANAR
,
67 .name
= "YUV 4:2:0 planar (Y-Cb-Cr)",
68 .pixelformat
= V4L2_PIX_FMT_YUV420
,
69 .trans
= YUV420_DECOMPOSED
,
71 .flags
= FORMAT_IS_PLANAR
,
73 .name
= "YUV 4:2:2 (U-Y-V-Y)",
74 .pixelformat
= V4L2_PIX_FMT_UYVY
,
75 .trans
= YUV422_COMPOSED
,
81 /* unfortunately, the saa7146 contains a bug which prevents it from doing on-the-fly byte swaps.
82 due to this, it's impossible to provide additional *packed* formats, which are simply byte swapped
83 (like V4L2_PIX_FMT_YUYV) ... 8-( */
85 static int NUM_FORMATS
= sizeof(formats
)/sizeof(struct saa7146_format
);
87 struct saa7146_format
* format_by_fourcc(struct saa7146_dev
*dev
, int fourcc
)
89 int i
, j
= NUM_FORMATS
;
91 for (i
= 0; i
< j
; i
++) {
92 if (formats
[i
].pixelformat
== fourcc
) {
97 DEB_D(("unknown pixelformat:'%4.4s'\n",(char *)&fourcc
));
101 static int vidioc_try_fmt_vid_overlay(struct file
*file
, void *fh
, struct v4l2_format
*f
);
103 int saa7146_start_preview(struct saa7146_fh
*fh
)
105 struct saa7146_dev
*dev
= fh
->dev
;
106 struct saa7146_vv
*vv
= dev
->vv_data
;
107 struct v4l2_format fmt
;
108 int ret
= 0, err
= 0;
110 DEB_EE(("dev:%p, fh:%p\n",dev
,fh
));
112 /* check if we have overlay informations */
113 if( NULL
== fh
->ov
.fh
) {
114 DEB_D(("no overlay data available. try S_FMT first.\n"));
118 /* check if streaming capture is running */
119 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
120 DEB_D(("streaming capture is active.\n"));
124 /* check if overlay is running */
125 if (IS_OVERLAY_ACTIVE(fh
) != 0) {
126 if (vv
->video_fh
== fh
) {
127 DEB_D(("overlay is already active.\n"));
130 DEB_D(("overlay is already active in another open.\n"));
134 if (0 == saa7146_res_get(fh
, RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
)) {
135 DEB_D(("cannot get necessary overlay resources\n"));
139 fmt
.fmt
.win
= fh
->ov
.win
;
140 err
= vidioc_try_fmt_vid_overlay(NULL
, fh
, &fmt
);
142 saa7146_res_free(vv
->video_fh
, RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
);
145 fh
->ov
.win
= fmt
.fmt
.win
;
146 vv
->ov_data
= &fh
->ov
;
148 DEB_D(("%dx%d+%d+%d %s field=%s\n",
149 fh
->ov
.win
.w
.width
,fh
->ov
.win
.w
.height
,
150 fh
->ov
.win
.w
.left
,fh
->ov
.win
.w
.top
,
151 vv
->ov_fmt
->name
,v4l2_field_names
[fh
->ov
.win
.field
]));
153 if (0 != (ret
= saa7146_enable_overlay(fh
))) {
154 DEB_D(("enabling overlay failed: %d\n",ret
));
155 saa7146_res_free(vv
->video_fh
, RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
);
159 vv
->video_status
= STATUS_OVERLAY
;
164 EXPORT_SYMBOL_GPL(saa7146_start_preview
);
166 int saa7146_stop_preview(struct saa7146_fh
*fh
)
168 struct saa7146_dev
*dev
= fh
->dev
;
169 struct saa7146_vv
*vv
= dev
->vv_data
;
171 DEB_EE(("dev:%p, fh:%p\n",dev
,fh
));
173 /* check if streaming capture is running */
174 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
175 DEB_D(("streaming capture is active.\n"));
179 /* check if overlay is running at all */
180 if ((vv
->video_status
& STATUS_OVERLAY
) == 0) {
181 DEB_D(("no active overlay.\n"));
185 if (vv
->video_fh
!= fh
) {
186 DEB_D(("overlay is active, but in another open.\n"));
190 vv
->video_status
= 0;
193 saa7146_disable_overlay(fh
);
195 saa7146_res_free(fh
, RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
);
199 EXPORT_SYMBOL_GPL(saa7146_stop_preview
);
201 /********************************************************************************/
202 /* device controls */
204 static struct v4l2_queryctrl controls
[] = {
206 .id
= V4L2_CID_BRIGHTNESS
,
207 .name
= "Brightness",
211 .default_value
= 128,
212 .type
= V4L2_CTRL_TYPE_INTEGER
,
213 .flags
= V4L2_CTRL_FLAG_SLIDER
,
215 .id
= V4L2_CID_CONTRAST
,
221 .type
= V4L2_CTRL_TYPE_INTEGER
,
222 .flags
= V4L2_CTRL_FLAG_SLIDER
,
224 .id
= V4L2_CID_SATURATION
,
225 .name
= "Saturation",
230 .type
= V4L2_CTRL_TYPE_INTEGER
,
231 .flags
= V4L2_CTRL_FLAG_SLIDER
,
233 .id
= V4L2_CID_VFLIP
,
234 .name
= "Vertical Flip",
237 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
239 .id
= V4L2_CID_HFLIP
,
240 .name
= "Horizontal Flip",
243 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
246 static int NUM_CONTROLS
= sizeof(controls
)/sizeof(struct v4l2_queryctrl
);
248 #define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 0)
250 static struct v4l2_queryctrl
* ctrl_by_id(int id
)
254 for (i
= 0; i
< NUM_CONTROLS
; i
++)
255 if (controls
[i
].id
== id
)
260 /********************************************************************************/
261 /* common pagetable functions */
263 static int saa7146_pgtable_build(struct saa7146_dev
*dev
, struct saa7146_buf
*buf
)
265 struct pci_dev
*pci
= dev
->pci
;
266 struct videobuf_dmabuf
*dma
=videobuf_to_dma(&buf
->vb
);
267 struct scatterlist
*list
= dma
->sglist
;
268 int length
= dma
->sglen
;
269 struct saa7146_format
*sfmt
= format_by_fourcc(dev
,buf
->fmt
->pixelformat
);
271 DEB_EE(("dev:%p, buf:%p, sg_len:%d\n",dev
,buf
,length
));
273 if( 0 != IS_PLANAR(sfmt
->trans
)) {
274 struct saa7146_pgtable
*pt1
= &buf
->pt
[0];
275 struct saa7146_pgtable
*pt2
= &buf
->pt
[1];
276 struct saa7146_pgtable
*pt3
= &buf
->pt
[2];
277 __le32
*ptr1
, *ptr2
, *ptr3
;
280 int size
= buf
->fmt
->width
*buf
->fmt
->height
;
281 int i
,p
,m1
,m2
,m3
,o1
,o2
;
283 switch( sfmt
->depth
) {
285 /* create some offsets inside the page table */
286 m1
= ((size
+PAGE_SIZE
)/PAGE_SIZE
)-1;
287 m2
= ((size
+(size
/4)+PAGE_SIZE
)/PAGE_SIZE
)-1;
288 m3
= ((size
+(size
/2)+PAGE_SIZE
)/PAGE_SIZE
)-1;
290 o2
= (size
+(size
/4))%PAGE_SIZE
;
291 DEB_CAP(("size:%d, m1:%d, m2:%d, m3:%d, o1:%d, o2:%d\n",size
,m1
,m2
,m3
,o1
,o2
));
295 /* create some offsets inside the page table */
296 m1
= ((size
+PAGE_SIZE
)/PAGE_SIZE
)-1;
297 m2
= ((size
+(size
/2)+PAGE_SIZE
)/PAGE_SIZE
)-1;
298 m3
= ((2*size
+PAGE_SIZE
)/PAGE_SIZE
)-1;
300 o2
= (size
+(size
/2))%PAGE_SIZE
;
301 DEB_CAP(("size:%d, m1:%d, m2:%d, m3:%d, o1:%d, o2:%d\n",size
,m1
,m2
,m3
,o1
,o2
));
313 /* walk all pages, copy all page addresses to ptr1 */
314 for (i
= 0; i
< length
; i
++, list
++) {
315 for (p
= 0; p
* 4096 < list
->length
; p
++, ptr1
++) {
316 *ptr1
= cpu_to_le32(sg_dma_address(list
) - list
->offset
);
322 printk("ptr1 %d: 0x%08x\n",j,ptr1[j]);
326 /* if we have a user buffer, the first page may not be
327 aligned to a page boundary. */
328 pt1
->offset
= dma
->sglist
->offset
;
329 pt2
->offset
= pt1
->offset
+o1
;
330 pt3
->offset
= pt1
->offset
+o2
;
332 /* create video-dma2 page table */
334 for(i
= m1
; i
<= m2
; i
++, ptr2
++) {
338 for(;i
<1024;i
++,ptr2
++) {
341 /* create video-dma3 page table */
343 for(i
= m2
; i
<= m3
; i
++,ptr3
++) {
347 for(;i
<1024;i
++,ptr3
++) {
350 /* finally: finish up video-dma1 page table */
353 for(i
=m1
;i
<1024;i
++,ptr1
++) {
361 printk("ptr1 %d: 0x%08x\n",j,ptr1[j]);
364 printk("ptr2 %d: 0x%08x\n",j,ptr2[j]);
367 printk("ptr3 %d: 0x%08x\n",j,ptr3[j]);
371 struct saa7146_pgtable
*pt
= &buf
->pt
[0];
372 return saa7146_pgtable_build_single(pci
, pt
, list
, length
);
379 /********************************************************************************/
380 /* file operations */
382 static int video_begin(struct saa7146_fh
*fh
)
384 struct saa7146_dev
*dev
= fh
->dev
;
385 struct saa7146_vv
*vv
= dev
->vv_data
;
386 struct saa7146_format
*fmt
= NULL
;
387 unsigned int resource
;
388 int ret
= 0, err
= 0;
390 DEB_EE(("dev:%p, fh:%p\n",dev
,fh
));
392 if ((vv
->video_status
& STATUS_CAPTURE
) != 0) {
393 if (vv
->video_fh
== fh
) {
394 DEB_S(("already capturing.\n"));
397 DEB_S(("already capturing in another open.\n"));
401 if ((vv
->video_status
& STATUS_OVERLAY
) != 0) {
402 DEB_S(("warning: suspending overlay video for streaming capture.\n"));
403 vv
->ov_suspend
= vv
->video_fh
;
404 err
= saa7146_stop_preview(vv
->video_fh
); /* side effect: video_status is now 0, video_fh is NULL */
406 DEB_D(("suspending video failed. aborting\n"));
411 fmt
= format_by_fourcc(dev
,fh
->video_fmt
.pixelformat
);
412 /* we need to have a valid format set here */
415 if (0 != (fmt
->flags
& FORMAT_IS_PLANAR
)) {
416 resource
= RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
|RESOURCE_DMA3_BRS
;
418 resource
= RESOURCE_DMA1_HPS
;
421 ret
= saa7146_res_get(fh
, resource
);
423 DEB_S(("cannot get capture resource %d\n",resource
));
424 if (vv
->ov_suspend
!= NULL
) {
425 saa7146_start_preview(vv
->ov_suspend
);
426 vv
->ov_suspend
= NULL
;
431 /* clear out beginning of streaming bit (rps register 0)*/
432 saa7146_write(dev
, MC2
, MASK_27
);
434 /* enable rps0 irqs */
435 SAA7146_IER_ENABLE(dev
, MASK_27
);
438 vv
->video_status
= STATUS_CAPTURE
;
443 static int video_end(struct saa7146_fh
*fh
, struct file
*file
)
445 struct saa7146_dev
*dev
= fh
->dev
;
446 struct saa7146_vv
*vv
= dev
->vv_data
;
447 struct saa7146_format
*fmt
= NULL
;
449 unsigned int resource
;
451 DEB_EE(("dev:%p, fh:%p\n",dev
,fh
));
453 if ((vv
->video_status
& STATUS_CAPTURE
) != STATUS_CAPTURE
) {
454 DEB_S(("not capturing.\n"));
458 if (vv
->video_fh
!= fh
) {
459 DEB_S(("capturing, but in another open.\n"));
463 fmt
= format_by_fourcc(dev
,fh
->video_fmt
.pixelformat
);
464 /* we need to have a valid format set here */
467 if (0 != (fmt
->flags
& FORMAT_IS_PLANAR
)) {
468 resource
= RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
|RESOURCE_DMA3_BRS
;
469 dmas
= MASK_22
| MASK_21
| MASK_20
;
471 resource
= RESOURCE_DMA1_HPS
;
474 spin_lock_irqsave(&dev
->slock
,flags
);
477 saa7146_write(dev
, MC1
, MASK_28
);
479 /* disable rps0 irqs */
480 SAA7146_IER_DISABLE(dev
, MASK_27
);
482 /* shut down all used video dma transfers */
483 saa7146_write(dev
, MC1
, dmas
);
485 spin_unlock_irqrestore(&dev
->slock
, flags
);
488 vv
->video_status
= 0;
490 saa7146_res_free(fh
, resource
);
492 if (vv
->ov_suspend
!= NULL
) {
493 saa7146_start_preview(vv
->ov_suspend
);
494 vv
->ov_suspend
= NULL
;
500 static int vidioc_querycap(struct file
*file
, void *fh
, struct v4l2_capability
*cap
)
502 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
504 strcpy((char *)cap
->driver
, "saa7146 v4l2");
505 strlcpy((char *)cap
->card
, dev
->ext
->name
, sizeof(cap
->card
));
506 sprintf((char *)cap
->bus_info
, "PCI:%s", pci_name(dev
->pci
));
507 cap
->version
= SAA7146_VERSION_CODE
;
509 V4L2_CAP_VIDEO_CAPTURE
|
510 V4L2_CAP_VIDEO_OVERLAY
|
513 cap
->capabilities
|= dev
->ext_vv_data
->capabilities
;
517 static int vidioc_g_fbuf(struct file
*file
, void *fh
, struct v4l2_framebuffer
*fb
)
519 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
520 struct saa7146_vv
*vv
= dev
->vv_data
;
523 fb
->capability
= V4L2_FBUF_CAP_LIST_CLIPPING
;
527 static int vidioc_s_fbuf(struct file
*file
, void *fh
, struct v4l2_framebuffer
*fb
)
529 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
530 struct saa7146_vv
*vv
= dev
->vv_data
;
531 struct saa7146_format
*fmt
;
533 DEB_EE(("VIDIOC_S_FBUF\n"));
535 if (!capable(CAP_SYS_ADMIN
) && !capable(CAP_SYS_RAWIO
))
539 fmt
= format_by_fourcc(dev
, fb
->fmt
.pixelformat
);
543 /* planar formats are not allowed for overlay video, clipping and video dma would clash */
544 if (fmt
->flags
& FORMAT_IS_PLANAR
)
545 DEB_S(("planar pixelformat '%4.4s' not allowed for overlay\n",
546 (char *)&fmt
->pixelformat
));
548 /* check if overlay is running */
549 if (IS_OVERLAY_ACTIVE(fh
) != 0) {
550 if (vv
->video_fh
!= fh
) {
551 DEB_D(("refusing to change framebuffer informations while overlay is active in another open.\n"));
556 mutex_lock(&dev
->lock
);
562 if (vv
->ov_fb
.fmt
.bytesperline
< vv
->ov_fb
.fmt
.width
) {
563 vv
->ov_fb
.fmt
.bytesperline
= vv
->ov_fb
.fmt
.width
* fmt
->depth
/ 8;
564 DEB_D(("setting bytesperline to %d\n", vv
->ov_fb
.fmt
.bytesperline
));
567 mutex_unlock(&dev
->lock
);
571 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_fmtdesc
*f
)
573 if (f
->index
>= NUM_FORMATS
)
575 strlcpy((char *)f
->description
, formats
[f
->index
].name
,
576 sizeof(f
->description
));
577 f
->pixelformat
= formats
[f
->index
].pixelformat
;
581 static int vidioc_queryctrl(struct file
*file
, void *fh
, struct v4l2_queryctrl
*c
)
583 const struct v4l2_queryctrl
*ctrl
;
585 if ((c
->id
< V4L2_CID_BASE
||
586 c
->id
>= V4L2_CID_LASTP1
) &&
587 (c
->id
< V4L2_CID_PRIVATE_BASE
||
588 c
->id
>= V4L2_CID_PRIVATE_LASTP1
))
591 ctrl
= ctrl_by_id(c
->id
);
595 DEB_EE(("VIDIOC_QUERYCTRL: id:%d\n", c
->id
));
600 static int vidioc_g_ctrl(struct file
*file
, void *fh
, struct v4l2_control
*c
)
602 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
603 struct saa7146_vv
*vv
= dev
->vv_data
;
604 const struct v4l2_queryctrl
*ctrl
;
607 ctrl
= ctrl_by_id(c
->id
);
611 case V4L2_CID_BRIGHTNESS
:
612 value
= saa7146_read(dev
, BCS_CTRL
);
613 c
->value
= 0xff & (value
>> 24);
614 DEB_D(("V4L2_CID_BRIGHTNESS: %d\n", c
->value
));
616 case V4L2_CID_CONTRAST
:
617 value
= saa7146_read(dev
, BCS_CTRL
);
618 c
->value
= 0x7f & (value
>> 16);
619 DEB_D(("V4L2_CID_CONTRAST: %d\n", c
->value
));
621 case V4L2_CID_SATURATION
:
622 value
= saa7146_read(dev
, BCS_CTRL
);
623 c
->value
= 0x7f & (value
>> 0);
624 DEB_D(("V4L2_CID_SATURATION: %d\n", c
->value
));
627 c
->value
= vv
->vflip
;
628 DEB_D(("V4L2_CID_VFLIP: %d\n", c
->value
));
631 c
->value
= vv
->hflip
;
632 DEB_D(("V4L2_CID_HFLIP: %d\n", c
->value
));
640 static int vidioc_s_ctrl(struct file
*file
, void *fh
, struct v4l2_control
*c
)
642 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
643 struct saa7146_vv
*vv
= dev
->vv_data
;
644 const struct v4l2_queryctrl
*ctrl
;
646 ctrl
= ctrl_by_id(c
->id
);
648 DEB_D(("unknown control %d\n", c
->id
));
652 mutex_lock(&dev
->lock
);
654 switch (ctrl
->type
) {
655 case V4L2_CTRL_TYPE_BOOLEAN
:
656 case V4L2_CTRL_TYPE_MENU
:
657 case V4L2_CTRL_TYPE_INTEGER
:
658 if (c
->value
< ctrl
->minimum
)
659 c
->value
= ctrl
->minimum
;
660 if (c
->value
> ctrl
->maximum
)
661 c
->value
= ctrl
->maximum
;
668 case V4L2_CID_BRIGHTNESS
: {
669 u32 value
= saa7146_read(dev
, BCS_CTRL
);
671 value
|= (c
->value
<< 24);
672 saa7146_write(dev
, BCS_CTRL
, value
);
673 saa7146_write(dev
, MC2
, MASK_22
| MASK_06
);
676 case V4L2_CID_CONTRAST
: {
677 u32 value
= saa7146_read(dev
, BCS_CTRL
);
679 value
|= (c
->value
<< 16);
680 saa7146_write(dev
, BCS_CTRL
, value
);
681 saa7146_write(dev
, MC2
, MASK_22
| MASK_06
);
684 case V4L2_CID_SATURATION
: {
685 u32 value
= saa7146_read(dev
, BCS_CTRL
);
687 value
|= (c
->value
<< 0);
688 saa7146_write(dev
, BCS_CTRL
, value
);
689 saa7146_write(dev
, MC2
, MASK_22
| MASK_06
);
693 /* fixme: we can support changing VFLIP and HFLIP here... */
694 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
695 DEB_D(("V4L2_CID_HFLIP while active capture.\n"));
696 mutex_unlock(&dev
->lock
);
699 vv
->hflip
= c
->value
;
702 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
703 DEB_D(("V4L2_CID_VFLIP while active capture.\n"));
704 mutex_unlock(&dev
->lock
);
707 vv
->vflip
= c
->value
;
710 mutex_unlock(&dev
->lock
);
713 mutex_unlock(&dev
->lock
);
715 if (IS_OVERLAY_ACTIVE(fh
) != 0) {
716 saa7146_stop_preview(fh
);
717 saa7146_start_preview(fh
);
722 static int vidioc_g_parm(struct file
*file
, void *fh
,
723 struct v4l2_streamparm
*parm
)
725 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
726 struct saa7146_vv
*vv
= dev
->vv_data
;
728 parm
->parm
.capture
.readbuffers
= 1;
729 v4l2_video_std_frame_period(vv
->standard
->id
,
730 &parm
->parm
.capture
.timeperframe
);
734 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_format
*f
)
736 f
->fmt
.pix
= ((struct saa7146_fh
*)fh
)->video_fmt
;
740 static int vidioc_g_fmt_vid_overlay(struct file
*file
, void *fh
, struct v4l2_format
*f
)
742 f
->fmt
.win
= ((struct saa7146_fh
*)fh
)->ov
.win
;
746 static int vidioc_g_fmt_vbi_cap(struct file
*file
, void *fh
, struct v4l2_format
*f
)
748 f
->fmt
.vbi
= ((struct saa7146_fh
*)fh
)->vbi_fmt
;
752 static int vidioc_try_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_format
*f
)
754 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
755 struct saa7146_vv
*vv
= dev
->vv_data
;
756 struct saa7146_format
*fmt
;
757 enum v4l2_field field
;
761 DEB_EE(("V4L2_BUF_TYPE_VIDEO_CAPTURE: dev:%p, fh:%p\n", dev
, fh
));
763 fmt
= format_by_fourcc(dev
, f
->fmt
.pix
.pixelformat
);
767 field
= f
->fmt
.pix
.field
;
768 maxw
= vv
->standard
->h_max_out
;
769 maxh
= vv
->standard
->v_max_out
;
771 if (V4L2_FIELD_ANY
== field
) {
772 field
= (f
->fmt
.pix
.height
> maxh
/ 2)
773 ? V4L2_FIELD_INTERLACED
777 case V4L2_FIELD_ALTERNATE
:
778 vv
->last_field
= V4L2_FIELD_TOP
;
782 case V4L2_FIELD_BOTTOM
:
783 vv
->last_field
= V4L2_FIELD_INTERLACED
;
786 case V4L2_FIELD_INTERLACED
:
787 vv
->last_field
= V4L2_FIELD_INTERLACED
;
790 DEB_D(("no known field mode '%d'.\n", field
));
794 f
->fmt
.pix
.field
= field
;
795 if (f
->fmt
.pix
.width
> maxw
)
796 f
->fmt
.pix
.width
= maxw
;
797 if (f
->fmt
.pix
.height
> maxh
)
798 f
->fmt
.pix
.height
= maxh
;
800 calc_bpl
= (f
->fmt
.pix
.width
* fmt
->depth
) / 8;
802 if (f
->fmt
.pix
.bytesperline
< calc_bpl
)
803 f
->fmt
.pix
.bytesperline
= calc_bpl
;
805 if (f
->fmt
.pix
.bytesperline
> (2 * PAGE_SIZE
* fmt
->depth
) / 8) /* arbitrary constraint */
806 f
->fmt
.pix
.bytesperline
= calc_bpl
;
808 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
* f
->fmt
.pix
.height
;
809 DEB_D(("w:%d, h:%d, bytesperline:%d, sizeimage:%d\n", f
->fmt
.pix
.width
,
810 f
->fmt
.pix
.height
, f
->fmt
.pix
.bytesperline
, f
->fmt
.pix
.sizeimage
));
816 static int vidioc_try_fmt_vid_overlay(struct file
*file
, void *fh
, struct v4l2_format
*f
)
818 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
819 struct saa7146_vv
*vv
= dev
->vv_data
;
820 struct v4l2_window
*win
= &f
->fmt
.win
;
821 enum v4l2_field field
;
824 DEB_EE(("dev:%p\n", dev
));
826 if (NULL
== vv
->ov_fb
.base
) {
827 DEB_D(("no fb base set.\n"));
830 if (NULL
== vv
->ov_fmt
) {
831 DEB_D(("no fb fmt set.\n"));
834 if (win
->w
.width
< 48 || win
->w
.height
< 32) {
835 DEB_D(("min width/height. (%d,%d)\n", win
->w
.width
, win
->w
.height
));
838 if (win
->clipcount
> 16) {
839 DEB_D(("clipcount too big.\n"));
844 maxw
= vv
->standard
->h_max_out
;
845 maxh
= vv
->standard
->v_max_out
;
847 if (V4L2_FIELD_ANY
== field
) {
848 field
= (win
->w
.height
> maxh
/ 2)
849 ? V4L2_FIELD_INTERLACED
854 case V4L2_FIELD_BOTTOM
:
855 case V4L2_FIELD_ALTERNATE
:
858 case V4L2_FIELD_INTERLACED
:
861 DEB_D(("no known field mode '%d'.\n", field
));
866 if (win
->w
.width
> maxw
)
868 if (win
->w
.height
> maxh
)
869 win
->w
.height
= maxh
;
874 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *__fh
, struct v4l2_format
*f
)
876 struct saa7146_fh
*fh
= __fh
;
877 struct saa7146_dev
*dev
= fh
->dev
;
878 struct saa7146_vv
*vv
= dev
->vv_data
;
881 DEB_EE(("V4L2_BUF_TYPE_VIDEO_CAPTURE: dev:%p, fh:%p\n", dev
, fh
));
882 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
883 DEB_EE(("streaming capture is active\n"));
886 err
= vidioc_try_fmt_vid_cap(file
, fh
, f
);
889 fh
->video_fmt
= f
->fmt
.pix
;
890 DEB_EE(("set to pixelformat '%4.4s'\n", (char *)&fh
->video_fmt
.pixelformat
));
894 static int vidioc_s_fmt_vid_overlay(struct file
*file
, void *__fh
, struct v4l2_format
*f
)
896 struct saa7146_fh
*fh
= __fh
;
897 struct saa7146_dev
*dev
= fh
->dev
;
898 struct saa7146_vv
*vv
= dev
->vv_data
;
901 DEB_EE(("V4L2_BUF_TYPE_VIDEO_OVERLAY: dev:%p, fh:%p\n", dev
, fh
));
902 err
= vidioc_try_fmt_vid_overlay(file
, fh
, f
);
905 mutex_lock(&dev
->lock
);
906 fh
->ov
.win
= f
->fmt
.win
;
907 fh
->ov
.nclips
= f
->fmt
.win
.clipcount
;
908 if (fh
->ov
.nclips
> 16)
910 if (copy_from_user(fh
->ov
.clips
, f
->fmt
.win
.clips
,
911 sizeof(struct v4l2_clip
) * fh
->ov
.nclips
)) {
912 mutex_unlock(&dev
->lock
);
916 /* fh->ov.fh is used to indicate that we have valid overlay informations, too */
919 mutex_unlock(&dev
->lock
);
921 /* check if our current overlay is active */
922 if (IS_OVERLAY_ACTIVE(fh
) != 0) {
923 saa7146_stop_preview(fh
);
924 saa7146_start_preview(fh
);
929 static int vidioc_g_std(struct file
*file
, void *fh
, v4l2_std_id
*norm
)
931 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
932 struct saa7146_vv
*vv
= dev
->vv_data
;
934 *norm
= vv
->standard
->id
;
938 /* the saa7146 supfhrts (used in conjunction with the saa7111a for example)
939 PAL / NTSC / SECAM. if your hardware does not (or does more)
940 -- override this function in your extension */
944 struct v4l2_standard *e = arg;
947 if( e->index < dev->ext_vv_data->num_stds ) {
948 DEB_EE(("VIDIOC_ENUMSTD: index:%d\n",e->index));
949 v4l2_video_std_construct(e, dev->ext_vv_data->stds[e->index].id, dev->ext_vv_data->stds[e->index].name);
956 static int vidioc_s_std(struct file
*file
, void *fh
, v4l2_std_id
*id
)
958 struct saa7146_dev
*dev
= ((struct saa7146_fh
*)fh
)->dev
;
959 struct saa7146_vv
*vv
= dev
->vv_data
;
963 DEB_EE(("VIDIOC_S_STD\n"));
965 if ((vv
->video_status
& STATUS_CAPTURE
) == STATUS_CAPTURE
) {
966 DEB_D(("cannot change video standard while streaming capture is active\n"));
970 if ((vv
->video_status
& STATUS_OVERLAY
) != 0) {
971 vv
->ov_suspend
= vv
->video_fh
;
972 err
= saa7146_stop_preview(vv
->video_fh
); /* side effect: video_status is now 0, video_fh is NULL */
974 DEB_D(("suspending video failed. aborting\n"));
979 mutex_lock(&dev
->lock
);
981 for (i
= 0; i
< dev
->ext_vv_data
->num_stds
; i
++)
982 if (*id
& dev
->ext_vv_data
->stds
[i
].id
)
984 if (i
!= dev
->ext_vv_data
->num_stds
) {
985 vv
->standard
= &dev
->ext_vv_data
->stds
[i
];
986 if (NULL
!= dev
->ext_vv_data
->std_callback
)
987 dev
->ext_vv_data
->std_callback(dev
, vv
->standard
);
991 mutex_unlock(&dev
->lock
);
993 if (vv
->ov_suspend
!= NULL
) {
994 saa7146_start_preview(vv
->ov_suspend
);
995 vv
->ov_suspend
= NULL
;
999 DEB_EE(("VIDIOC_S_STD: standard not found.\n"));
1003 DEB_EE(("VIDIOC_S_STD: set to standard to '%s'\n", vv
->standard
->name
));
1007 static int vidioc_overlay(struct file
*file
, void *fh
, unsigned int on
)
1011 DEB_D(("VIDIOC_OVERLAY on:%d\n", on
));
1013 err
= saa7146_start_preview(fh
);
1015 err
= saa7146_stop_preview(fh
);
1019 static int vidioc_reqbufs(struct file
*file
, void *__fh
, struct v4l2_requestbuffers
*b
)
1021 struct saa7146_fh
*fh
= __fh
;
1023 if (b
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1024 return videobuf_reqbufs(&fh
->video_q
, b
);
1025 if (b
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
1026 return videobuf_reqbufs(&fh
->vbi_q
, b
);
1030 static int vidioc_querybuf(struct file
*file
, void *__fh
, struct v4l2_buffer
*buf
)
1032 struct saa7146_fh
*fh
= __fh
;
1034 if (buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1035 return videobuf_querybuf(&fh
->video_q
, buf
);
1036 if (buf
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
1037 return videobuf_querybuf(&fh
->vbi_q
, buf
);
1041 static int vidioc_qbuf(struct file
*file
, void *__fh
, struct v4l2_buffer
*buf
)
1043 struct saa7146_fh
*fh
= __fh
;
1045 if (buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1046 return videobuf_qbuf(&fh
->video_q
, buf
);
1047 if (buf
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
1048 return videobuf_qbuf(&fh
->vbi_q
, buf
);
1052 static int vidioc_dqbuf(struct file
*file
, void *__fh
, struct v4l2_buffer
*buf
)
1054 struct saa7146_fh
*fh
= __fh
;
1056 if (buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1057 return videobuf_dqbuf(&fh
->video_q
, buf
, file
->f_flags
& O_NONBLOCK
);
1058 if (buf
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
1059 return videobuf_dqbuf(&fh
->vbi_q
, buf
, file
->f_flags
& O_NONBLOCK
);
1063 static int vidioc_streamon(struct file
*file
, void *__fh
, enum v4l2_buf_type type
)
1065 struct saa7146_fh
*fh
= __fh
;
1068 DEB_D(("VIDIOC_STREAMON, type:%d\n", type
));
1070 err
= video_begin(fh
);
1073 if (type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1074 return videobuf_streamon(&fh
->video_q
);
1075 if (type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
1076 return videobuf_streamon(&fh
->vbi_q
);
1080 static int vidioc_streamoff(struct file
*file
, void *__fh
, enum v4l2_buf_type type
)
1082 struct saa7146_fh
*fh
= __fh
;
1083 struct saa7146_dev
*dev
= fh
->dev
;
1084 struct saa7146_vv
*vv
= dev
->vv_data
;
1087 DEB_D(("VIDIOC_STREAMOFF, type:%d\n", type
));
1089 /* ugly: we need to copy some checks from video_end(),
1090 because videobuf_streamoff() relies on the capture running.
1091 check and fix this */
1092 if ((vv
->video_status
& STATUS_CAPTURE
) != STATUS_CAPTURE
) {
1093 DEB_S(("not capturing.\n"));
1097 if (vv
->video_fh
!= fh
) {
1098 DEB_S(("capturing, but in another open.\n"));
1103 if (type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1104 err
= videobuf_streamoff(&fh
->video_q
);
1105 else if (type
== V4L2_BUF_TYPE_VBI_CAPTURE
)
1106 err
= videobuf_streamoff(&fh
->vbi_q
);
1108 DEB_D(("warning: videobuf_streamoff() failed.\n"));
1109 video_end(fh
, file
);
1111 err
= video_end(fh
, file
);
1116 static int vidioc_g_chip_ident(struct file
*file
, void *__fh
,
1117 struct v4l2_dbg_chip_ident
*chip
)
1119 struct saa7146_fh
*fh
= __fh
;
1120 struct saa7146_dev
*dev
= fh
->dev
;
1122 chip
->ident
= V4L2_IDENT_NONE
;
1124 if (chip
->match
.type
== V4L2_CHIP_MATCH_HOST
&& !chip
->match
.addr
) {
1125 chip
->ident
= V4L2_IDENT_SAA7146
;
1128 return v4l2_device_call_until_err(&dev
->v4l2_dev
, 0,
1129 core
, g_chip_ident
, chip
);
1132 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1133 static int vidiocgmbuf(struct file
*file
, void *__fh
, struct video_mbuf
*mbuf
)
1135 struct saa7146_fh
*fh
= __fh
;
1136 struct videobuf_queue
*q
= &fh
->video_q
;
1139 /* fixme: number of capture buffers and sizes for v4l apps */
1141 int gbufsize
= 768 * 576 * 4;
1143 DEB_D(("VIDIOCGMBUF \n"));
1146 err
= videobuf_mmap_setup(q
, gbuffers
, gbufsize
,
1152 memset(mbuf
, 0, sizeof(*mbuf
));
1153 mbuf
->frames
= gbuffers
;
1154 mbuf
->size
= gbuffers
* gbufsize
;
1155 for (i
= 0; i
< gbuffers
; i
++)
1156 mbuf
->offsets
[i
] = i
* gbufsize
;
1161 const struct v4l2_ioctl_ops saa7146_video_ioctl_ops
= {
1162 .vidioc_querycap
= vidioc_querycap
,
1163 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
1164 .vidioc_enum_fmt_vid_overlay
= vidioc_enum_fmt_vid_cap
,
1165 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
1166 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
1167 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
1168 .vidioc_g_fmt_vid_overlay
= vidioc_g_fmt_vid_overlay
,
1169 .vidioc_try_fmt_vid_overlay
= vidioc_try_fmt_vid_overlay
,
1170 .vidioc_s_fmt_vid_overlay
= vidioc_s_fmt_vid_overlay
,
1171 .vidioc_g_fmt_vbi_cap
= vidioc_g_fmt_vbi_cap
,
1172 .vidioc_g_chip_ident
= vidioc_g_chip_ident
,
1174 .vidioc_overlay
= vidioc_overlay
,
1175 .vidioc_g_fbuf
= vidioc_g_fbuf
,
1176 .vidioc_s_fbuf
= vidioc_s_fbuf
,
1177 .vidioc_reqbufs
= vidioc_reqbufs
,
1178 .vidioc_querybuf
= vidioc_querybuf
,
1179 .vidioc_qbuf
= vidioc_qbuf
,
1180 .vidioc_dqbuf
= vidioc_dqbuf
,
1181 .vidioc_g_std
= vidioc_g_std
,
1182 .vidioc_s_std
= vidioc_s_std
,
1183 .vidioc_queryctrl
= vidioc_queryctrl
,
1184 .vidioc_g_ctrl
= vidioc_g_ctrl
,
1185 .vidioc_s_ctrl
= vidioc_s_ctrl
,
1186 .vidioc_streamon
= vidioc_streamon
,
1187 .vidioc_streamoff
= vidioc_streamoff
,
1188 .vidioc_g_parm
= vidioc_g_parm
,
1189 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1190 .vidiocgmbuf
= vidiocgmbuf
,
1194 /*********************************************************************************/
1195 /* buffer handling functions */
1197 static int buffer_activate (struct saa7146_dev
*dev
,
1198 struct saa7146_buf
*buf
,
1199 struct saa7146_buf
*next
)
1201 struct saa7146_vv
*vv
= dev
->vv_data
;
1203 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
1204 saa7146_set_capture(dev
,buf
,next
);
1206 mod_timer(&vv
->video_q
.timeout
, jiffies
+BUFFER_TIMEOUT
);
1210 static void release_all_pagetables(struct saa7146_dev
*dev
, struct saa7146_buf
*buf
)
1212 saa7146_pgtable_free(dev
->pci
, &buf
->pt
[0]);
1213 saa7146_pgtable_free(dev
->pci
, &buf
->pt
[1]);
1214 saa7146_pgtable_free(dev
->pci
, &buf
->pt
[2]);
1217 static int buffer_prepare(struct videobuf_queue
*q
,
1218 struct videobuf_buffer
*vb
, enum v4l2_field field
)
1220 struct file
*file
= q
->priv_data
;
1221 struct saa7146_fh
*fh
= file
->private_data
;
1222 struct saa7146_dev
*dev
= fh
->dev
;
1223 struct saa7146_vv
*vv
= dev
->vv_data
;
1224 struct saa7146_buf
*buf
= (struct saa7146_buf
*)vb
;
1227 DEB_CAP(("vbuf:%p\n",vb
));
1230 if (fh
->video_fmt
.width
< 48 ||
1231 fh
->video_fmt
.height
< 32 ||
1232 fh
->video_fmt
.width
> vv
->standard
->h_max_out
||
1233 fh
->video_fmt
.height
> vv
->standard
->v_max_out
) {
1234 DEB_D(("w (%d) / h (%d) out of bounds.\n",fh
->video_fmt
.width
,fh
->video_fmt
.height
));
1238 size
= fh
->video_fmt
.sizeimage
;
1239 if (0 != buf
->vb
.baddr
&& buf
->vb
.bsize
< size
) {
1240 DEB_D(("size mismatch.\n"));
1244 DEB_CAP(("buffer_prepare [size=%dx%d,bytes=%d,fields=%s]\n",
1245 fh
->video_fmt
.width
,fh
->video_fmt
.height
,size
,v4l2_field_names
[fh
->video_fmt
.field
]));
1246 if (buf
->vb
.width
!= fh
->video_fmt
.width
||
1247 buf
->vb
.bytesperline
!= fh
->video_fmt
.bytesperline
||
1248 buf
->vb
.height
!= fh
->video_fmt
.height
||
1249 buf
->vb
.size
!= size
||
1250 buf
->vb
.field
!= field
||
1251 buf
->vb
.field
!= fh
->video_fmt
.field
||
1252 buf
->fmt
!= &fh
->video_fmt
) {
1253 saa7146_dma_free(dev
,q
,buf
);
1256 if (VIDEOBUF_NEEDS_INIT
== buf
->vb
.state
) {
1257 struct saa7146_format
*sfmt
;
1259 buf
->vb
.bytesperline
= fh
->video_fmt
.bytesperline
;
1260 buf
->vb
.width
= fh
->video_fmt
.width
;
1261 buf
->vb
.height
= fh
->video_fmt
.height
;
1262 buf
->vb
.size
= size
;
1263 buf
->vb
.field
= field
;
1264 buf
->fmt
= &fh
->video_fmt
;
1265 buf
->vb
.field
= fh
->video_fmt
.field
;
1267 sfmt
= format_by_fourcc(dev
,buf
->fmt
->pixelformat
);
1269 release_all_pagetables(dev
, buf
);
1270 if( 0 != IS_PLANAR(sfmt
->trans
)) {
1271 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[0]);
1272 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[1]);
1273 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[2]);
1275 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[0]);
1278 err
= videobuf_iolock(q
,&buf
->vb
, &vv
->ov_fb
);
1281 err
= saa7146_pgtable_build(dev
,buf
);
1285 buf
->vb
.state
= VIDEOBUF_PREPARED
;
1286 buf
->activate
= buffer_activate
;
1291 DEB_D(("error out.\n"));
1292 saa7146_dma_free(dev
,q
,buf
);
1297 static int buffer_setup(struct videobuf_queue
*q
, unsigned int *count
, unsigned int *size
)
1299 struct file
*file
= q
->priv_data
;
1300 struct saa7146_fh
*fh
= file
->private_data
;
1302 if (0 == *count
|| *count
> MAX_SAA7146_CAPTURE_BUFFERS
)
1303 *count
= MAX_SAA7146_CAPTURE_BUFFERS
;
1305 *size
= fh
->video_fmt
.sizeimage
;
1307 /* check if we exceed the "max_memory" parameter */
1308 if( (*count
* *size
) > (max_memory
*1048576) ) {
1309 *count
= (max_memory
*1048576) / *size
;
1312 DEB_CAP(("%d buffers, %d bytes each.\n",*count
,*size
));
1317 static void buffer_queue(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1319 struct file
*file
= q
->priv_data
;
1320 struct saa7146_fh
*fh
= file
->private_data
;
1321 struct saa7146_dev
*dev
= fh
->dev
;
1322 struct saa7146_vv
*vv
= dev
->vv_data
;
1323 struct saa7146_buf
*buf
= (struct saa7146_buf
*)vb
;
1325 DEB_CAP(("vbuf:%p\n",vb
));
1326 saa7146_buffer_queue(fh
->dev
,&vv
->video_q
,buf
);
1329 static void buffer_release(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1331 struct file
*file
= q
->priv_data
;
1332 struct saa7146_fh
*fh
= file
->private_data
;
1333 struct saa7146_dev
*dev
= fh
->dev
;
1334 struct saa7146_buf
*buf
= (struct saa7146_buf
*)vb
;
1336 DEB_CAP(("vbuf:%p\n",vb
));
1338 saa7146_dma_free(dev
,q
,buf
);
1340 release_all_pagetables(dev
, buf
);
1343 static struct videobuf_queue_ops video_qops
= {
1344 .buf_setup
= buffer_setup
,
1345 .buf_prepare
= buffer_prepare
,
1346 .buf_queue
= buffer_queue
,
1347 .buf_release
= buffer_release
,
1350 /********************************************************************************/
1351 /* file operations */
1353 static void video_init(struct saa7146_dev
*dev
, struct saa7146_vv
*vv
)
1355 INIT_LIST_HEAD(&vv
->video_q
.queue
);
1357 init_timer(&vv
->video_q
.timeout
);
1358 vv
->video_q
.timeout
.function
= saa7146_buffer_timeout
;
1359 vv
->video_q
.timeout
.data
= (unsigned long)(&vv
->video_q
);
1360 vv
->video_q
.dev
= dev
;
1362 /* set some default values */
1363 vv
->standard
= &dev
->ext_vv_data
->stds
[0];
1365 /* FIXME: what's this? */
1366 vv
->current_hps_source
= SAA7146_HPS_SOURCE_PORT_A
;
1367 vv
->current_hps_sync
= SAA7146_HPS_SYNC_PORT_A
;
1371 static int video_open(struct saa7146_dev
*dev
, struct file
*file
)
1373 struct saa7146_fh
*fh
= file
->private_data
;
1374 struct saa7146_format
*sfmt
;
1376 fh
->video_fmt
.width
= 384;
1377 fh
->video_fmt
.height
= 288;
1378 fh
->video_fmt
.pixelformat
= V4L2_PIX_FMT_BGR24
;
1379 fh
->video_fmt
.bytesperline
= 0;
1380 fh
->video_fmt
.field
= V4L2_FIELD_ANY
;
1381 sfmt
= format_by_fourcc(dev
,fh
->video_fmt
.pixelformat
);
1382 fh
->video_fmt
.sizeimage
= (fh
->video_fmt
.width
* fh
->video_fmt
.height
* sfmt
->depth
)/8;
1384 videobuf_queue_sg_init(&fh
->video_q
, &video_qops
,
1385 &dev
->pci
->dev
, &dev
->slock
,
1386 V4L2_BUF_TYPE_VIDEO_CAPTURE
,
1387 V4L2_FIELD_INTERLACED
,
1388 sizeof(struct saa7146_buf
),
1395 static void video_close(struct saa7146_dev
*dev
, struct file
*file
)
1397 struct saa7146_fh
*fh
= file
->private_data
;
1398 struct saa7146_vv
*vv
= dev
->vv_data
;
1399 struct videobuf_queue
*q
= &fh
->video_q
;
1402 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
1403 err
= video_end(fh
, file
);
1404 } else if (IS_OVERLAY_ACTIVE(fh
) != 0) {
1405 err
= saa7146_stop_preview(fh
);
1410 /* hmm, why is this function declared void? */
1415 static void video_irq_done(struct saa7146_dev
*dev
, unsigned long st
)
1417 struct saa7146_vv
*vv
= dev
->vv_data
;
1418 struct saa7146_dmaqueue
*q
= &vv
->video_q
;
1420 spin_lock(&dev
->slock
);
1421 DEB_CAP(("called.\n"));
1423 /* only finish the buffer if we have one... */
1424 if( NULL
!= q
->curr
) {
1425 saa7146_buffer_finish(dev
,q
,VIDEOBUF_DONE
);
1427 saa7146_buffer_next(dev
,q
,0);
1429 spin_unlock(&dev
->slock
);
1432 static ssize_t
video_read(struct file
*file
, char __user
*data
, size_t count
, loff_t
*ppos
)
1434 struct saa7146_fh
*fh
= file
->private_data
;
1435 struct saa7146_dev
*dev
= fh
->dev
;
1436 struct saa7146_vv
*vv
= dev
->vv_data
;
1439 DEB_EE(("called.\n"));
1441 if ((vv
->video_status
& STATUS_CAPTURE
) != 0) {
1442 /* fixme: should we allow read() captures while streaming capture? */
1443 if (vv
->video_fh
== fh
) {
1444 DEB_S(("already capturing.\n"));
1447 DEB_S(("already capturing in another open.\n"));
1451 ret
= video_begin(fh
);
1456 ret
= videobuf_read_one(&fh
->video_q
, data
, count
, ppos
,
1457 file
->f_flags
& O_NONBLOCK
);
1459 video_end(fh
, file
);
1461 ret
= video_end(fh
, file
);
1464 /* restart overlay if it was active before */
1465 if (vv
->ov_suspend
!= NULL
) {
1466 saa7146_start_preview(vv
->ov_suspend
);
1467 vv
->ov_suspend
= NULL
;
1473 struct saa7146_use_ops saa7146_video_uops
= {
1476 .release
= video_close
,
1477 .irq_done
= video_irq_done
,