1 #include <media/saa7146_vv.h>
3 static int max_memory
= 32;
5 module_param(max_memory
, int, 0644);
6 MODULE_PARM_DESC(max_memory
, "maximum memory usage for capture buffers (default: 32Mb)");
8 #define IS_CAPTURE_ACTIVE(fh) \
9 (((vv->video_status & STATUS_CAPTURE) != 0) && (vv->video_fh == fh))
11 #define IS_OVERLAY_ACTIVE(fh) \
12 (((vv->video_status & STATUS_OVERLAY) != 0) && (vv->video_fh == fh))
14 /* format descriptions for capture and preview */
15 static struct saa7146_format formats
[] = {
17 .name
= "RGB-8 (3-3-2)",
18 .pixelformat
= V4L2_PIX_FMT_RGB332
,
19 .trans
= RGB08_COMPOSED
,
23 .name
= "RGB-16 (5/B-6/G-5/R)",
24 .pixelformat
= V4L2_PIX_FMT_RGB565
,
25 .trans
= RGB16_COMPOSED
,
29 .name
= "RGB-24 (B-G-R)",
30 .pixelformat
= V4L2_PIX_FMT_BGR24
,
31 .trans
= RGB24_COMPOSED
,
35 .name
= "RGB-32 (B-G-R)",
36 .pixelformat
= V4L2_PIX_FMT_BGR32
,
37 .trans
= RGB32_COMPOSED
,
41 .name
= "RGB-32 (R-G-B)",
42 .pixelformat
= V4L2_PIX_FMT_RGB32
,
43 .trans
= RGB32_COMPOSED
,
48 .name
= "Greyscale-8",
49 .pixelformat
= V4L2_PIX_FMT_GREY
,
54 .name
= "YUV 4:2:2 planar (Y-Cb-Cr)",
55 .pixelformat
= V4L2_PIX_FMT_YUV422P
,
56 .trans
= YUV422_DECOMPOSED
,
58 .flags
= FORMAT_BYTE_SWAP
|FORMAT_IS_PLANAR
,
60 .name
= "YVU 4:2:0 planar (Y-Cb-Cr)",
61 .pixelformat
= V4L2_PIX_FMT_YVU420
,
62 .trans
= YUV420_DECOMPOSED
,
64 .flags
= FORMAT_BYTE_SWAP
|FORMAT_IS_PLANAR
,
66 .name
= "YUV 4:2:0 planar (Y-Cb-Cr)",
67 .pixelformat
= V4L2_PIX_FMT_YUV420
,
68 .trans
= YUV420_DECOMPOSED
,
70 .flags
= FORMAT_IS_PLANAR
,
72 .name
= "YUV 4:2:2 (U-Y-V-Y)",
73 .pixelformat
= V4L2_PIX_FMT_UYVY
,
74 .trans
= YUV422_COMPOSED
,
80 /* unfortunately, the saa7146 contains a bug which prevents it from doing on-the-fly byte swaps.
81 due to this, it's impossible to provide additional *packed* formats, which are simply byte swapped
82 (like V4L2_PIX_FMT_YUYV) ... 8-( */
84 static int NUM_FORMATS
= sizeof(formats
)/sizeof(struct saa7146_format
);
86 struct saa7146_format
* format_by_fourcc(struct saa7146_dev
*dev
, int fourcc
)
88 int i
, j
= NUM_FORMATS
;
90 for (i
= 0; i
< j
; i
++) {
91 if (formats
[i
].pixelformat
== fourcc
) {
96 DEB_D(("unknown pixelformat:'%4.4s'\n",(char *)&fourcc
));
100 static int g_fmt(struct saa7146_fh
*fh
, struct v4l2_format
*f
)
102 struct saa7146_dev
*dev
= fh
->dev
;
103 DEB_EE(("dev:%p, fh:%p\n",dev
,fh
));
106 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
107 f
->fmt
.pix
= fh
->video_fmt
;
109 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
110 f
->fmt
.win
= fh
->ov
.win
;
112 case V4L2_BUF_TYPE_VBI_CAPTURE
:
114 f
->fmt
.vbi
= fh
->vbi_fmt
;
118 DEB_D(("invalid format type '%d'.\n",f
->type
));
123 static int try_win(struct saa7146_dev
*dev
, struct v4l2_window
*win
)
125 struct saa7146_vv
*vv
= dev
->vv_data
;
126 enum v4l2_field field
;
129 DEB_EE(("dev:%p\n",dev
));
131 if (NULL
== vv
->ov_fb
.base
) {
132 DEB_D(("no fb base set.\n"));
135 if (NULL
== vv
->ov_fmt
) {
136 DEB_D(("no fb fmt set.\n"));
139 if (win
->w
.width
< 48 || win
->w
.height
< 32) {
140 DEB_D(("min width/height. (%d,%d)\n",win
->w
.width
,win
->w
.height
));
143 if (win
->clipcount
> 16) {
144 DEB_D(("clipcount too big.\n"));
149 maxw
= vv
->standard
->h_max_out
;
150 maxh
= vv
->standard
->v_max_out
;
152 if (V4L2_FIELD_ANY
== field
) {
153 field
= (win
->w
.height
> maxh
/2)
154 ? V4L2_FIELD_INTERLACED
159 case V4L2_FIELD_BOTTOM
:
160 case V4L2_FIELD_ALTERNATE
:
163 case V4L2_FIELD_INTERLACED
:
166 DEB_D(("no known field mode '%d'.\n",field
));
172 if (win
->w
.width
> maxw
)
174 if (win
->w
.height
> maxh
)
175 win
->w
.height
= maxh
;
180 static int try_fmt(struct saa7146_fh
*fh
, struct v4l2_format
*f
)
182 struct saa7146_dev
*dev
= fh
->dev
;
183 struct saa7146_vv
*vv
= dev
->vv_data
;
187 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
189 struct saa7146_format
*fmt
;
190 enum v4l2_field field
;
194 DEB_EE(("V4L2_BUF_TYPE_VIDEO_CAPTURE: dev:%p, fh:%p\n",dev
,fh
));
196 fmt
= format_by_fourcc(dev
,f
->fmt
.pix
.pixelformat
);
201 field
= f
->fmt
.pix
.field
;
202 maxw
= vv
->standard
->h_max_out
;
203 maxh
= vv
->standard
->v_max_out
;
205 if (V4L2_FIELD_ANY
== field
) {
206 field
= (f
->fmt
.pix
.height
> maxh
/2)
207 ? V4L2_FIELD_INTERLACED
211 case V4L2_FIELD_ALTERNATE
: {
212 vv
->last_field
= V4L2_FIELD_TOP
;
217 case V4L2_FIELD_BOTTOM
:
218 vv
->last_field
= V4L2_FIELD_INTERLACED
;
221 case V4L2_FIELD_INTERLACED
:
222 vv
->last_field
= V4L2_FIELD_INTERLACED
;
225 DEB_D(("no known field mode '%d'.\n",field
));
230 f
->fmt
.pix
.field
= field
;
231 if (f
->fmt
.pix
.width
> maxw
)
232 f
->fmt
.pix
.width
= maxw
;
233 if (f
->fmt
.pix
.height
> maxh
)
234 f
->fmt
.pix
.height
= maxh
;
236 calc_bpl
= (f
->fmt
.pix
.width
* fmt
->depth
)/8;
238 if (f
->fmt
.pix
.bytesperline
< calc_bpl
)
239 f
->fmt
.pix
.bytesperline
= calc_bpl
;
241 if (f
->fmt
.pix
.bytesperline
> (2*PAGE_SIZE
* fmt
->depth
)/8) /* arbitrary constraint */
242 f
->fmt
.pix
.bytesperline
= calc_bpl
;
244 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.bytesperline
* f
->fmt
.pix
.height
;
245 DEB_D(("w:%d, h:%d, bytesperline:%d, sizeimage:%d\n",f
->fmt
.pix
.width
,f
->fmt
.pix
.height
,f
->fmt
.pix
.bytesperline
,f
->fmt
.pix
.sizeimage
));
249 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
250 DEB_EE(("V4L2_BUF_TYPE_VIDEO_OVERLAY: dev:%p, fh:%p\n",dev
,fh
));
251 err
= try_win(dev
,&f
->fmt
.win
);
257 DEB_EE(("unknown format type '%d'\n",f
->type
));
262 int saa7146_start_preview(struct saa7146_fh
*fh
)
264 struct saa7146_dev
*dev
= fh
->dev
;
265 struct saa7146_vv
*vv
= dev
->vv_data
;
266 int ret
= 0, err
= 0;
268 DEB_EE(("dev:%p, fh:%p\n",dev
,fh
));
270 /* check if we have overlay informations */
271 if( NULL
== fh
->ov
.fh
) {
272 DEB_D(("no overlay data available. try S_FMT first.\n"));
276 /* check if streaming capture is running */
277 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
278 DEB_D(("streaming capture is active.\n"));
282 /* check if overlay is running */
283 if (IS_OVERLAY_ACTIVE(fh
) != 0) {
284 if (vv
->video_fh
== fh
) {
285 DEB_D(("overlay is already active.\n"));
288 DEB_D(("overlay is already active in another open.\n"));
292 if (0 == saa7146_res_get(fh
, RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
)) {
293 DEB_D(("cannot get necessary overlay resources\n"));
297 err
= try_win(dev
,&fh
->ov
.win
);
299 saa7146_res_free(vv
->video_fh
, RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
);
303 vv
->ov_data
= &fh
->ov
;
305 DEB_D(("%dx%d+%d+%d %s field=%s\n",
306 fh
->ov
.win
.w
.width
,fh
->ov
.win
.w
.height
,
307 fh
->ov
.win
.w
.left
,fh
->ov
.win
.w
.top
,
308 vv
->ov_fmt
->name
,v4l2_field_names
[fh
->ov
.win
.field
]));
310 if (0 != (ret
= saa7146_enable_overlay(fh
))) {
311 DEB_D(("enabling overlay failed: %d\n",ret
));
312 saa7146_res_free(vv
->video_fh
, RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
);
316 vv
->video_status
= STATUS_OVERLAY
;
321 EXPORT_SYMBOL_GPL(saa7146_start_preview
);
323 int saa7146_stop_preview(struct saa7146_fh
*fh
)
325 struct saa7146_dev
*dev
= fh
->dev
;
326 struct saa7146_vv
*vv
= dev
->vv_data
;
328 DEB_EE(("dev:%p, fh:%p\n",dev
,fh
));
330 /* check if streaming capture is running */
331 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
332 DEB_D(("streaming capture is active.\n"));
336 /* check if overlay is running at all */
337 if ((vv
->video_status
& STATUS_OVERLAY
) == 0) {
338 DEB_D(("no active overlay.\n"));
342 if (vv
->video_fh
!= fh
) {
343 DEB_D(("overlay is active, but in another open.\n"));
347 vv
->video_status
= 0;
350 saa7146_disable_overlay(fh
);
352 saa7146_res_free(fh
, RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
);
356 EXPORT_SYMBOL_GPL(saa7146_stop_preview
);
358 static int s_fmt(struct saa7146_fh
*fh
, struct v4l2_format
*f
)
360 struct saa7146_dev
*dev
= fh
->dev
;
361 struct saa7146_vv
*vv
= dev
->vv_data
;
366 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
367 DEB_EE(("V4L2_BUF_TYPE_VIDEO_CAPTURE: dev:%p, fh:%p\n",dev
,fh
));
368 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
369 DEB_EE(("streaming capture is active\n"));
375 fh
->video_fmt
= f
->fmt
.pix
;
376 DEB_EE(("set to pixelformat '%4.4s'\n",(char *)&fh
->video_fmt
.pixelformat
));
378 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
379 DEB_EE(("V4L2_BUF_TYPE_VIDEO_OVERLAY: dev:%p, fh:%p\n",dev
,fh
));
380 err
= try_win(dev
,&f
->fmt
.win
);
383 mutex_lock(&dev
->lock
);
384 fh
->ov
.win
= f
->fmt
.win
;
385 fh
->ov
.nclips
= f
->fmt
.win
.clipcount
;
386 if (fh
->ov
.nclips
> 16)
388 if (copy_from_user(fh
->ov
.clips
,f
->fmt
.win
.clips
,sizeof(struct v4l2_clip
)*fh
->ov
.nclips
)) {
389 mutex_unlock(&dev
->lock
);
393 /* fh->ov.fh is used to indicate that we have valid overlay informations, too */
396 mutex_unlock(&dev
->lock
);
398 /* check if our current overlay is active */
399 if (IS_OVERLAY_ACTIVE(fh
) != 0) {
400 saa7146_stop_preview(fh
);
401 saa7146_start_preview(fh
);
405 DEB_D(("unknown format type '%d'\n",f
->type
));
410 /********************************************************************************/
411 /* device controls */
413 static struct v4l2_queryctrl controls
[] = {
415 .id
= V4L2_CID_BRIGHTNESS
,
416 .name
= "Brightness",
420 .default_value
= 128,
421 .type
= V4L2_CTRL_TYPE_INTEGER
,
423 .id
= V4L2_CID_CONTRAST
,
429 .type
= V4L2_CTRL_TYPE_INTEGER
,
431 .id
= V4L2_CID_SATURATION
,
432 .name
= "Saturation",
437 .type
= V4L2_CTRL_TYPE_INTEGER
,
439 .id
= V4L2_CID_VFLIP
,
440 .name
= "Vertical flip",
443 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
445 .id
= V4L2_CID_HFLIP
,
446 .name
= "Horizontal flip",
449 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
452 static int NUM_CONTROLS
= sizeof(controls
)/sizeof(struct v4l2_queryctrl
);
454 #define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 0)
456 static struct v4l2_queryctrl
* ctrl_by_id(int id
)
460 for (i
= 0; i
< NUM_CONTROLS
; i
++)
461 if (controls
[i
].id
== id
)
466 static int get_control(struct saa7146_fh
*fh
, struct v4l2_control
*c
)
468 struct saa7146_dev
*dev
= fh
->dev
;
469 struct saa7146_vv
*vv
= dev
->vv_data
;
471 const struct v4l2_queryctrl
* ctrl
;
474 ctrl
= ctrl_by_id(c
->id
);
478 case V4L2_CID_BRIGHTNESS
:
479 value
= saa7146_read(dev
, BCS_CTRL
);
480 c
->value
= 0xff & (value
>> 24);
481 DEB_D(("V4L2_CID_BRIGHTNESS: %d\n",c
->value
));
483 case V4L2_CID_CONTRAST
:
484 value
= saa7146_read(dev
, BCS_CTRL
);
485 c
->value
= 0x7f & (value
>> 16);
486 DEB_D(("V4L2_CID_CONTRAST: %d\n",c
->value
));
488 case V4L2_CID_SATURATION
:
489 value
= saa7146_read(dev
, BCS_CTRL
);
490 c
->value
= 0x7f & (value
>> 0);
491 DEB_D(("V4L2_CID_SATURATION: %d\n",c
->value
));
494 c
->value
= vv
->vflip
;
495 DEB_D(("V4L2_CID_VFLIP: %d\n",c
->value
));
498 c
->value
= vv
->hflip
;
499 DEB_D(("V4L2_CID_HFLIP: %d\n",c
->value
));
508 static int set_control(struct saa7146_fh
*fh
, struct v4l2_control
*c
)
510 struct saa7146_dev
*dev
= fh
->dev
;
511 struct saa7146_vv
*vv
= dev
->vv_data
;
513 const struct v4l2_queryctrl
* ctrl
;
515 ctrl
= ctrl_by_id(c
->id
);
517 DEB_D(("unknown control %d\n",c
->id
));
521 mutex_lock(&dev
->lock
);
523 switch (ctrl
->type
) {
524 case V4L2_CTRL_TYPE_BOOLEAN
:
525 case V4L2_CTRL_TYPE_MENU
:
526 case V4L2_CTRL_TYPE_INTEGER
:
527 if (c
->value
< ctrl
->minimum
)
528 c
->value
= ctrl
->minimum
;
529 if (c
->value
> ctrl
->maximum
)
530 c
->value
= ctrl
->maximum
;
537 case V4L2_CID_BRIGHTNESS
: {
538 u32 value
= saa7146_read(dev
, BCS_CTRL
);
540 value
|= (c
->value
<< 24);
541 saa7146_write(dev
, BCS_CTRL
, value
);
542 saa7146_write(dev
, MC2
, MASK_22
| MASK_06
);
545 case V4L2_CID_CONTRAST
: {
546 u32 value
= saa7146_read(dev
, BCS_CTRL
);
548 value
|= (c
->value
<< 16);
549 saa7146_write(dev
, BCS_CTRL
, value
);
550 saa7146_write(dev
, MC2
, MASK_22
| MASK_06
);
553 case V4L2_CID_SATURATION
: {
554 u32 value
= saa7146_read(dev
, BCS_CTRL
);
556 value
|= (c
->value
<< 0);
557 saa7146_write(dev
, BCS_CTRL
, value
);
558 saa7146_write(dev
, MC2
, MASK_22
| MASK_06
);
562 /* fixme: we can support changing VFLIP and HFLIP here... */
563 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
564 DEB_D(("V4L2_CID_HFLIP while active capture.\n"));
565 mutex_unlock(&dev
->lock
);
568 vv
->hflip
= c
->value
;
571 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
572 DEB_D(("V4L2_CID_VFLIP while active capture.\n"));
573 mutex_unlock(&dev
->lock
);
576 vv
->vflip
= c
->value
;
582 mutex_unlock(&dev
->lock
);
584 if (IS_OVERLAY_ACTIVE(fh
) != 0) {
585 saa7146_stop_preview(fh
);
586 saa7146_start_preview(fh
);
591 /********************************************************************************/
592 /* common pagetable functions */
594 static int saa7146_pgtable_build(struct saa7146_dev
*dev
, struct saa7146_buf
*buf
)
596 struct pci_dev
*pci
= dev
->pci
;
597 struct videobuf_dmabuf
*dma
=videobuf_to_dma(&buf
->vb
);
598 struct scatterlist
*list
= dma
->sglist
;
599 int length
= dma
->sglen
;
600 struct saa7146_format
*sfmt
= format_by_fourcc(dev
,buf
->fmt
->pixelformat
);
602 DEB_EE(("dev:%p, buf:%p, sg_len:%d\n",dev
,buf
,length
));
604 if( 0 != IS_PLANAR(sfmt
->trans
)) {
605 struct saa7146_pgtable
*pt1
= &buf
->pt
[0];
606 struct saa7146_pgtable
*pt2
= &buf
->pt
[1];
607 struct saa7146_pgtable
*pt3
= &buf
->pt
[2];
608 u32
*ptr1
, *ptr2
, *ptr3
;
611 int size
= buf
->fmt
->width
*buf
->fmt
->height
;
612 int i
,p
,m1
,m2
,m3
,o1
,o2
;
614 switch( sfmt
->depth
) {
616 /* create some offsets inside the page table */
617 m1
= ((size
+PAGE_SIZE
)/PAGE_SIZE
)-1;
618 m2
= ((size
+(size
/4)+PAGE_SIZE
)/PAGE_SIZE
)-1;
619 m3
= ((size
+(size
/2)+PAGE_SIZE
)/PAGE_SIZE
)-1;
621 o2
= (size
+(size
/4))%PAGE_SIZE
;
622 DEB_CAP(("size:%d, m1:%d, m2:%d, m3:%d, o1:%d, o2:%d\n",size
,m1
,m2
,m3
,o1
,o2
));
626 /* create some offsets inside the page table */
627 m1
= ((size
+PAGE_SIZE
)/PAGE_SIZE
)-1;
628 m2
= ((size
+(size
/2)+PAGE_SIZE
)/PAGE_SIZE
)-1;
629 m3
= ((2*size
+PAGE_SIZE
)/PAGE_SIZE
)-1;
631 o2
= (size
+(size
/2))%PAGE_SIZE
;
632 DEB_CAP(("size:%d, m1:%d, m2:%d, m3:%d, o1:%d, o2:%d\n",size
,m1
,m2
,m3
,o1
,o2
));
644 /* walk all pages, copy all page addresses to ptr1 */
645 for (i
= 0; i
< length
; i
++, list
++) {
646 for (p
= 0; p
* 4096 < list
->length
; p
++, ptr1
++) {
647 *ptr1
= cpu_to_le32(sg_dma_address(list
) - list
->offset
);
653 printk("ptr1 %d: 0x%08x\n",j,ptr1[j]);
657 /* if we have a user buffer, the first page may not be
658 aligned to a page boundary. */
659 pt1
->offset
= list
->offset
;
660 pt2
->offset
= pt1
->offset
+o1
;
661 pt3
->offset
= pt1
->offset
+o2
;
663 /* create video-dma2 page table */
665 for(i
= m1
; i
<= m2
; i
++, ptr2
++) {
669 for(;i
<1024;i
++,ptr2
++) {
672 /* create video-dma3 page table */
674 for(i
= m2
; i
<= m3
; i
++,ptr3
++) {
678 for(;i
<1024;i
++,ptr3
++) {
681 /* finally: finish up video-dma1 page table */
684 for(i
=m1
;i
<1024;i
++,ptr1
++) {
692 printk("ptr1 %d: 0x%08x\n",j,ptr1[j]);
695 printk("ptr2 %d: 0x%08x\n",j,ptr2[j]);
698 printk("ptr3 %d: 0x%08x\n",j,ptr3[j]);
702 struct saa7146_pgtable
*pt
= &buf
->pt
[0];
703 return saa7146_pgtable_build_single(pci
, pt
, list
, length
);
710 /********************************************************************************/
711 /* file operations */
713 static int video_begin(struct saa7146_fh
*fh
)
715 struct saa7146_dev
*dev
= fh
->dev
;
716 struct saa7146_vv
*vv
= dev
->vv_data
;
717 struct saa7146_format
*fmt
= NULL
;
718 unsigned int resource
;
719 int ret
= 0, err
= 0;
721 DEB_EE(("dev:%p, fh:%p\n",dev
,fh
));
723 if ((vv
->video_status
& STATUS_CAPTURE
) != 0) {
724 if (vv
->video_fh
== fh
) {
725 DEB_S(("already capturing.\n"));
728 DEB_S(("already capturing in another open.\n"));
732 if ((vv
->video_status
& STATUS_OVERLAY
) != 0) {
733 DEB_S(("warning: suspending overlay video for streaming capture.\n"));
734 vv
->ov_suspend
= vv
->video_fh
;
735 err
= saa7146_stop_preview(vv
->video_fh
); /* side effect: video_status is now 0, video_fh is NULL */
737 DEB_D(("suspending video failed. aborting\n"));
742 fmt
= format_by_fourcc(dev
,fh
->video_fmt
.pixelformat
);
743 /* we need to have a valid format set here */
746 if (0 != (fmt
->flags
& FORMAT_IS_PLANAR
)) {
747 resource
= RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
|RESOURCE_DMA3_BRS
;
749 resource
= RESOURCE_DMA1_HPS
;
752 ret
= saa7146_res_get(fh
, resource
);
754 DEB_S(("cannot get capture resource %d\n",resource
));
755 if (vv
->ov_suspend
!= NULL
) {
756 saa7146_start_preview(vv
->ov_suspend
);
757 vv
->ov_suspend
= NULL
;
762 /* clear out beginning of streaming bit (rps register 0)*/
763 saa7146_write(dev
, MC2
, MASK_27
);
765 /* enable rps0 irqs */
766 SAA7146_IER_ENABLE(dev
, MASK_27
);
769 vv
->video_status
= STATUS_CAPTURE
;
774 static int video_end(struct saa7146_fh
*fh
, struct file
*file
)
776 struct saa7146_dev
*dev
= fh
->dev
;
777 struct saa7146_vv
*vv
= dev
->vv_data
;
778 struct saa7146_format
*fmt
= NULL
;
780 unsigned int resource
;
782 DEB_EE(("dev:%p, fh:%p\n",dev
,fh
));
784 if ((vv
->video_status
& STATUS_CAPTURE
) != STATUS_CAPTURE
) {
785 DEB_S(("not capturing.\n"));
789 if (vv
->video_fh
!= fh
) {
790 DEB_S(("capturing, but in another open.\n"));
794 fmt
= format_by_fourcc(dev
,fh
->video_fmt
.pixelformat
);
795 /* we need to have a valid format set here */
798 if (0 != (fmt
->flags
& FORMAT_IS_PLANAR
)) {
799 resource
= RESOURCE_DMA1_HPS
|RESOURCE_DMA2_CLP
|RESOURCE_DMA3_BRS
;
800 dmas
= MASK_22
| MASK_21
| MASK_20
;
802 resource
= RESOURCE_DMA1_HPS
;
805 spin_lock_irqsave(&dev
->slock
,flags
);
808 saa7146_write(dev
, MC1
, MASK_28
);
810 /* disable rps0 irqs */
811 SAA7146_IER_DISABLE(dev
, MASK_27
);
813 /* shut down all used video dma transfers */
814 saa7146_write(dev
, MC1
, dmas
);
816 spin_unlock_irqrestore(&dev
->slock
, flags
);
819 vv
->video_status
= 0;
821 saa7146_res_free(fh
, resource
);
823 if (vv
->ov_suspend
!= NULL
) {
824 saa7146_start_preview(vv
->ov_suspend
);
825 vv
->ov_suspend
= NULL
;
832 * This function is _not_ called directly, but from
833 * video_generic_ioctl (and maybe others). userspace
834 * copying is done already, arg is a kernel pointer.
837 int saa7146_video_do_ioctl(struct inode
*inode
, struct file
*file
, unsigned int cmd
, void *arg
)
839 struct saa7146_fh
*fh
= file
->private_data
;
840 struct saa7146_dev
*dev
= fh
->dev
;
841 struct saa7146_vv
*vv
= dev
->vv_data
;
843 int err
= 0, result
= 0, ee
= 0;
845 struct saa7146_use_ops
*ops
;
846 struct videobuf_queue
*q
;
848 /* check if extension handles the command */
849 for(ee
= 0; dev
->ext_vv_data
->ioctls
[ee
].flags
!= 0; ee
++) {
850 if( cmd
== dev
->ext_vv_data
->ioctls
[ee
].cmd
)
854 if( 0 != (dev
->ext_vv_data
->ioctls
[ee
].flags
& SAA7146_EXCLUSIVE
) ) {
855 DEB_D(("extension handles ioctl exclusive.\n"));
856 result
= dev
->ext_vv_data
->ioctl(fh
, cmd
, arg
);
859 if( 0 != (dev
->ext_vv_data
->ioctls
[ee
].flags
& SAA7146_BEFORE
) ) {
860 DEB_D(("extension handles ioctl before.\n"));
861 result
= dev
->ext_vv_data
->ioctl(fh
, cmd
, arg
);
862 if( -EAGAIN
!= result
) {
867 /* fixme: add handle "after" case (is it still needed?) */
870 case V4L2_BUF_TYPE_VIDEO_CAPTURE
: {
871 ops
= &saa7146_video_uops
;
875 case V4L2_BUF_TYPE_VBI_CAPTURE
: {
876 ops
= &saa7146_vbi_uops
;
886 case VIDIOC_QUERYCAP
:
888 struct v4l2_capability
*cap
= arg
;
889 memset(cap
,0,sizeof(*cap
));
891 DEB_EE(("VIDIOC_QUERYCAP\n"));
893 strcpy((char *)cap
->driver
, "saa7146 v4l2");
894 strlcpy((char *)cap
->card
, dev
->ext
->name
, sizeof(cap
->card
));
895 sprintf((char *)cap
->bus_info
,"PCI:%s", pci_name(dev
->pci
));
896 cap
->version
= SAA7146_VERSION_CODE
;
898 V4L2_CAP_VIDEO_CAPTURE
|
899 V4L2_CAP_VIDEO_OVERLAY
|
902 cap
->capabilities
|= dev
->ext_vv_data
->capabilities
;
907 struct v4l2_framebuffer
*fb
= arg
;
909 DEB_EE(("VIDIOC_G_FBUF\n"));
912 fb
->capability
= V4L2_FBUF_CAP_LIST_CLIPPING
;
917 struct v4l2_framebuffer
*fb
= arg
;
918 struct saa7146_format
*fmt
;
920 DEB_EE(("VIDIOC_S_FBUF\n"));
922 if(!capable(CAP_SYS_ADMIN
) &&
923 !capable(CAP_SYS_RAWIO
))
927 fmt
= format_by_fourcc(dev
,fb
->fmt
.pixelformat
);
932 /* planar formats are not allowed for overlay video, clipping and video dma would clash */
933 if (0 != (fmt
->flags
& FORMAT_IS_PLANAR
)) {
934 DEB_S(("planar pixelformat '%4.4s' not allowed for overlay\n",(char *)&fmt
->pixelformat
));
937 /* check if overlay is running */
938 if (IS_OVERLAY_ACTIVE(fh
) != 0) {
939 if (vv
->video_fh
!= fh
) {
940 DEB_D(("refusing to change framebuffer informations while overlay is active in another open.\n"));
945 mutex_lock(&dev
->lock
);
950 if (0 == vv
->ov_fb
.fmt
.bytesperline
)
951 vv
->ov_fb
.fmt
.bytesperline
=
952 vv
->ov_fb
.fmt
.width
*fmt
->depth
/8;
954 mutex_unlock(&dev
->lock
);
958 case VIDIOC_ENUM_FMT
:
960 struct v4l2_fmtdesc
*f
= arg
;
964 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
965 case V4L2_BUF_TYPE_VIDEO_OVERLAY
: {
967 if (index
< 0 || index
>= NUM_FORMATS
) {
970 memset(f
,0,sizeof(*f
));
972 strlcpy((char *)f
->description
,formats
[index
].name
,sizeof(f
->description
));
973 f
->pixelformat
= formats
[index
].pixelformat
;
980 DEB_EE(("VIDIOC_ENUM_FMT: type:%d, index:%d\n",f
->type
,f
->index
));
983 case VIDIOC_QUERYCTRL
:
985 const struct v4l2_queryctrl
*ctrl
;
986 struct v4l2_queryctrl
*c
= arg
;
988 if ((c
->id
< V4L2_CID_BASE
||
989 c
->id
>= V4L2_CID_LASTP1
) &&
990 (c
->id
< V4L2_CID_PRIVATE_BASE
||
991 c
->id
>= V4L2_CID_PRIVATE_LASTP1
))
994 ctrl
= ctrl_by_id(c
->id
);
998 c->flags = V4L2_CTRL_FLAG_DISABLED;
1003 DEB_EE(("VIDIOC_QUERYCTRL: id:%d\n",c
->id
));
1007 case VIDIOC_G_CTRL
: {
1008 DEB_EE(("VIDIOC_G_CTRL\n"));
1009 return get_control(fh
,arg
);
1013 DEB_EE(("VIDIOC_S_CTRL\n"));
1014 err
= set_control(fh
,arg
);
1019 struct v4l2_streamparm
*parm
= arg
;
1020 if( parm
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
1023 memset(&parm
->parm
.capture
,0,sizeof(struct v4l2_captureparm
));
1024 parm
->parm
.capture
.readbuffers
= 1;
1025 // fixme: only for PAL!
1026 parm
->parm
.capture
.timeperframe
.numerator
= 1;
1027 parm
->parm
.capture
.timeperframe
.denominator
= 25;
1032 struct v4l2_format
*f
= arg
;
1033 DEB_EE(("VIDIOC_G_FMT\n"));
1038 struct v4l2_format
*f
= arg
;
1039 DEB_EE(("VIDIOC_S_FMT\n"));
1042 case VIDIOC_TRY_FMT
:
1044 struct v4l2_format
*f
= arg
;
1045 DEB_EE(("VIDIOC_TRY_FMT\n"));
1046 return try_fmt(fh
,f
);
1050 v4l2_std_id
*id
= arg
;
1051 DEB_EE(("VIDIOC_G_STD\n"));
1052 *id
= vv
->standard
->id
;
1055 /* the saa7146 supfhrts (used in conjunction with the saa7111a for example)
1056 PAL / NTSC / SECAM. if your hardware does not (or does more)
1057 -- override this function in your extension */
1058 case VIDIOC_ENUMSTD
:
1060 struct v4l2_standard
*e
= arg
;
1063 if( e
->index
< dev
->ext_vv_data
->num_stds
) {
1064 DEB_EE(("VIDIOC_ENUMSTD: index:%d\n",e
->index
));
1065 v4l2_video_std_construct(e
, dev
->ext_vv_data
->stds
[e
->index
].id
, dev
->ext_vv_data
->stds
[e
->index
].name
);
1072 v4l2_std_id
*id
= arg
;
1076 DEB_EE(("VIDIOC_S_STD\n"));
1078 if ((vv
->video_status
& STATUS_CAPTURE
) == STATUS_CAPTURE
) {
1079 DEB_D(("cannot change video standard while streaming capture is active\n"));
1083 if ((vv
->video_status
& STATUS_OVERLAY
) != 0) {
1084 vv
->ov_suspend
= vv
->video_fh
;
1085 err
= saa7146_stop_preview(vv
->video_fh
); /* side effect: video_status is now 0, video_fh is NULL */
1087 DEB_D(("suspending video failed. aborting\n"));
1092 mutex_lock(&dev
->lock
);
1094 for(i
= 0; i
< dev
->ext_vv_data
->num_stds
; i
++)
1095 if (*id
& dev
->ext_vv_data
->stds
[i
].id
)
1097 if (i
!= dev
->ext_vv_data
->num_stds
) {
1098 vv
->standard
= &dev
->ext_vv_data
->stds
[i
];
1099 if( NULL
!= dev
->ext_vv_data
->std_callback
)
1100 dev
->ext_vv_data
->std_callback(dev
, vv
->standard
);
1104 mutex_unlock(&dev
->lock
);
1106 if (vv
->ov_suspend
!= NULL
) {
1107 saa7146_start_preview(vv
->ov_suspend
);
1108 vv
->ov_suspend
= NULL
;
1112 DEB_EE(("VIDIOC_S_STD: standard not found.\n"));
1116 DEB_EE(("VIDIOC_S_STD: set to standard to '%s'\n",vv
->standard
->name
));
1119 case VIDIOC_OVERLAY
:
1121 int on
= *(int *)arg
;
1124 DEB_D(("VIDIOC_OVERLAY on:%d\n",on
));
1126 err
= saa7146_start_preview(fh
);
1128 err
= saa7146_stop_preview(fh
);
1132 case VIDIOC_REQBUFS
: {
1133 struct v4l2_requestbuffers
*req
= arg
;
1134 DEB_D(("VIDIOC_REQBUFS, type:%d\n",req
->type
));
1135 return videobuf_reqbufs(q
,req
);
1137 case VIDIOC_QUERYBUF
: {
1138 struct v4l2_buffer
*buf
= arg
;
1139 DEB_D(("VIDIOC_QUERYBUF, type:%d, offset:%d\n",buf
->type
,buf
->m
.offset
));
1140 return videobuf_querybuf(q
,buf
);
1143 struct v4l2_buffer
*buf
= arg
;
1145 ret
= videobuf_qbuf(q
,buf
);
1146 DEB_D(("VIDIOC_QBUF: ret:%d, index:%d\n",ret
,buf
->index
));
1149 case VIDIOC_DQBUF
: {
1150 struct v4l2_buffer
*buf
= arg
;
1152 ret
= videobuf_dqbuf(q
,buf
,file
->f_flags
& O_NONBLOCK
);
1153 DEB_D(("VIDIOC_DQBUF: ret:%d, index:%d\n",ret
,buf
->index
));
1156 case VIDIOC_STREAMON
: {
1158 DEB_D(("VIDIOC_STREAMON, type:%d\n",*type
));
1160 err
= video_begin(fh
);
1164 err
= videobuf_streamon(q
);
1167 case VIDIOC_STREAMOFF
: {
1170 DEB_D(("VIDIOC_STREAMOFF, type:%d\n",*type
));
1172 /* ugly: we need to copy some checks from video_end(),
1173 because videobuf_streamoff() relies on the capture running.
1174 check and fix this */
1175 if ((vv
->video_status
& STATUS_CAPTURE
) != STATUS_CAPTURE
) {
1176 DEB_S(("not capturing.\n"));
1180 if (vv
->video_fh
!= fh
) {
1181 DEB_S(("capturing, but in another open.\n"));
1185 err
= videobuf_streamoff(q
);
1187 DEB_D(("warning: videobuf_streamoff() failed.\n"));
1188 video_end(fh
, file
);
1190 err
= video_end(fh
, file
);
1194 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1197 struct video_mbuf
*mbuf
= arg
;
1198 struct videobuf_queue
*q
;
1201 /* fixme: number of capture buffers and sizes for v4l apps */
1203 int gbufsize
= 768*576*4;
1205 DEB_D(("VIDIOCGMBUF \n"));
1208 mutex_lock(&q
->lock
);
1209 err
= videobuf_mmap_setup(q
,gbuffers
,gbufsize
,
1212 mutex_unlock(&q
->lock
);
1217 memset(mbuf
,0,sizeof(*mbuf
));
1218 mbuf
->frames
= gbuffers
;
1219 mbuf
->size
= gbuffers
* gbufsize
;
1220 for (i
= 0; i
< gbuffers
; i
++)
1221 mbuf
->offsets
[i
] = i
* gbufsize
;
1222 mutex_unlock(&q
->lock
);
1227 return v4l_compat_translate_ioctl(inode
,file
,cmd
,arg
,
1228 saa7146_video_do_ioctl
);
1233 /*********************************************************************************/
1234 /* buffer handling functions */
1236 static int buffer_activate (struct saa7146_dev
*dev
,
1237 struct saa7146_buf
*buf
,
1238 struct saa7146_buf
*next
)
1240 struct saa7146_vv
*vv
= dev
->vv_data
;
1242 buf
->vb
.state
= STATE_ACTIVE
;
1243 saa7146_set_capture(dev
,buf
,next
);
1245 mod_timer(&vv
->video_q
.timeout
, jiffies
+BUFFER_TIMEOUT
);
1249 static int buffer_prepare(struct videobuf_queue
*q
,
1250 struct videobuf_buffer
*vb
, enum v4l2_field field
)
1252 struct file
*file
= q
->priv_data
;
1253 struct saa7146_fh
*fh
= file
->private_data
;
1254 struct saa7146_dev
*dev
= fh
->dev
;
1255 struct saa7146_vv
*vv
= dev
->vv_data
;
1256 struct saa7146_buf
*buf
= (struct saa7146_buf
*)vb
;
1259 DEB_CAP(("vbuf:%p\n",vb
));
1262 if (fh
->video_fmt
.width
< 48 ||
1263 fh
->video_fmt
.height
< 32 ||
1264 fh
->video_fmt
.width
> vv
->standard
->h_max_out
||
1265 fh
->video_fmt
.height
> vv
->standard
->v_max_out
) {
1266 DEB_D(("w (%d) / h (%d) out of bounds.\n",fh
->video_fmt
.width
,fh
->video_fmt
.height
));
1270 size
= fh
->video_fmt
.sizeimage
;
1271 if (0 != buf
->vb
.baddr
&& buf
->vb
.bsize
< size
) {
1272 DEB_D(("size mismatch.\n"));
1276 DEB_CAP(("buffer_prepare [size=%dx%d,bytes=%d,fields=%s]\n",
1277 fh
->video_fmt
.width
,fh
->video_fmt
.height
,size
,v4l2_field_names
[fh
->video_fmt
.field
]));
1278 if (buf
->vb
.width
!= fh
->video_fmt
.width
||
1279 buf
->vb
.bytesperline
!= fh
->video_fmt
.bytesperline
||
1280 buf
->vb
.height
!= fh
->video_fmt
.height
||
1281 buf
->vb
.size
!= size
||
1282 buf
->vb
.field
!= field
||
1283 buf
->vb
.field
!= fh
->video_fmt
.field
||
1284 buf
->fmt
!= &fh
->video_fmt
) {
1285 saa7146_dma_free(dev
,q
,buf
);
1288 if (STATE_NEEDS_INIT
== buf
->vb
.state
) {
1289 struct saa7146_format
*sfmt
;
1291 buf
->vb
.bytesperline
= fh
->video_fmt
.bytesperline
;
1292 buf
->vb
.width
= fh
->video_fmt
.width
;
1293 buf
->vb
.height
= fh
->video_fmt
.height
;
1294 buf
->vb
.size
= size
;
1295 buf
->vb
.field
= field
;
1296 buf
->fmt
= &fh
->video_fmt
;
1297 buf
->vb
.field
= fh
->video_fmt
.field
;
1299 sfmt
= format_by_fourcc(dev
,buf
->fmt
->pixelformat
);
1301 if( 0 != IS_PLANAR(sfmt
->trans
)) {
1302 saa7146_pgtable_free(dev
->pci
, &buf
->pt
[0]);
1303 saa7146_pgtable_free(dev
->pci
, &buf
->pt
[1]);
1304 saa7146_pgtable_free(dev
->pci
, &buf
->pt
[2]);
1306 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[0]);
1307 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[1]);
1308 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[2]);
1310 saa7146_pgtable_free(dev
->pci
, &buf
->pt
[0]);
1311 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[0]);
1314 err
= videobuf_iolock(q
,&buf
->vb
, &vv
->ov_fb
);
1317 err
= saa7146_pgtable_build(dev
,buf
);
1321 buf
->vb
.state
= STATE_PREPARED
;
1322 buf
->activate
= buffer_activate
;
1327 DEB_D(("error out.\n"));
1328 saa7146_dma_free(dev
,q
,buf
);
1333 static int buffer_setup(struct videobuf_queue
*q
, unsigned int *count
, unsigned int *size
)
1335 struct file
*file
= q
->priv_data
;
1336 struct saa7146_fh
*fh
= file
->private_data
;
1338 if (0 == *count
|| *count
> MAX_SAA7146_CAPTURE_BUFFERS
)
1339 *count
= MAX_SAA7146_CAPTURE_BUFFERS
;
1341 *size
= fh
->video_fmt
.sizeimage
;
1343 /* check if we exceed the "max_memory" parameter */
1344 if( (*count
* *size
) > (max_memory
*1048576) ) {
1345 *count
= (max_memory
*1048576) / *size
;
1348 DEB_CAP(("%d buffers, %d bytes each.\n",*count
,*size
));
1353 static void buffer_queue(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1355 struct file
*file
= q
->priv_data
;
1356 struct saa7146_fh
*fh
= file
->private_data
;
1357 struct saa7146_dev
*dev
= fh
->dev
;
1358 struct saa7146_vv
*vv
= dev
->vv_data
;
1359 struct saa7146_buf
*buf
= (struct saa7146_buf
*)vb
;
1361 DEB_CAP(("vbuf:%p\n",vb
));
1362 saa7146_buffer_queue(fh
->dev
,&vv
->video_q
,buf
);
1365 static void buffer_release(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1367 struct file
*file
= q
->priv_data
;
1368 struct saa7146_fh
*fh
= file
->private_data
;
1369 struct saa7146_dev
*dev
= fh
->dev
;
1370 struct saa7146_buf
*buf
= (struct saa7146_buf
*)vb
;
1372 DEB_CAP(("vbuf:%p\n",vb
));
1373 saa7146_dma_free(dev
,q
,buf
);
1376 static struct videobuf_queue_ops video_qops
= {
1377 .buf_setup
= buffer_setup
,
1378 .buf_prepare
= buffer_prepare
,
1379 .buf_queue
= buffer_queue
,
1380 .buf_release
= buffer_release
,
1383 /********************************************************************************/
1384 /* file operations */
1386 static void video_init(struct saa7146_dev
*dev
, struct saa7146_vv
*vv
)
1388 INIT_LIST_HEAD(&vv
->video_q
.queue
);
1390 init_timer(&vv
->video_q
.timeout
);
1391 vv
->video_q
.timeout
.function
= saa7146_buffer_timeout
;
1392 vv
->video_q
.timeout
.data
= (unsigned long)(&vv
->video_q
);
1393 vv
->video_q
.dev
= dev
;
1395 /* set some default values */
1396 vv
->standard
= &dev
->ext_vv_data
->stds
[0];
1398 /* FIXME: what's this? */
1399 vv
->current_hps_source
= SAA7146_HPS_SOURCE_PORT_A
;
1400 vv
->current_hps_sync
= SAA7146_HPS_SYNC_PORT_A
;
1404 static int video_open(struct saa7146_dev
*dev
, struct file
*file
)
1406 struct saa7146_fh
*fh
= (struct saa7146_fh
*)file
->private_data
;
1407 struct saa7146_format
*sfmt
;
1409 fh
->video_fmt
.width
= 384;
1410 fh
->video_fmt
.height
= 288;
1411 fh
->video_fmt
.pixelformat
= V4L2_PIX_FMT_BGR24
;
1412 fh
->video_fmt
.bytesperline
= 0;
1413 fh
->video_fmt
.field
= V4L2_FIELD_ANY
;
1414 sfmt
= format_by_fourcc(dev
,fh
->video_fmt
.pixelformat
);
1415 fh
->video_fmt
.sizeimage
= (fh
->video_fmt
.width
* fh
->video_fmt
.height
* sfmt
->depth
)/8;
1417 videobuf_queue_pci_init(&fh
->video_q
, &video_qops
,
1418 dev
->pci
, &dev
->slock
,
1419 V4L2_BUF_TYPE_VIDEO_CAPTURE
,
1420 V4L2_FIELD_INTERLACED
,
1421 sizeof(struct saa7146_buf
),
1424 mutex_init(&fh
->video_q
.lock
);
1430 static void video_close(struct saa7146_dev
*dev
, struct file
*file
)
1432 struct saa7146_fh
*fh
= (struct saa7146_fh
*)file
->private_data
;
1433 struct saa7146_vv
*vv
= dev
->vv_data
;
1434 struct videobuf_queue
*q
= &fh
->video_q
;
1437 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
1438 err
= video_end(fh
, file
);
1439 } else if (IS_OVERLAY_ACTIVE(fh
) != 0) {
1440 err
= saa7146_stop_preview(fh
);
1445 /* hmm, why is this function declared void? */
1450 static void video_irq_done(struct saa7146_dev
*dev
, unsigned long st
)
1452 struct saa7146_vv
*vv
= dev
->vv_data
;
1453 struct saa7146_dmaqueue
*q
= &vv
->video_q
;
1455 spin_lock(&dev
->slock
);
1456 DEB_CAP(("called.\n"));
1458 /* only finish the buffer if we have one... */
1459 if( NULL
!= q
->curr
) {
1460 saa7146_buffer_finish(dev
,q
,STATE_DONE
);
1462 saa7146_buffer_next(dev
,q
,0);
1464 spin_unlock(&dev
->slock
);
1467 static ssize_t
video_read(struct file
*file
, char __user
*data
, size_t count
, loff_t
*ppos
)
1469 struct saa7146_fh
*fh
= file
->private_data
;
1470 struct saa7146_dev
*dev
= fh
->dev
;
1471 struct saa7146_vv
*vv
= dev
->vv_data
;
1474 DEB_EE(("called.\n"));
1476 if ((vv
->video_status
& STATUS_CAPTURE
) != 0) {
1477 /* fixme: should we allow read() captures while streaming capture? */
1478 if (vv
->video_fh
== fh
) {
1479 DEB_S(("already capturing.\n"));
1482 DEB_S(("already capturing in another open.\n"));
1486 ret
= video_begin(fh
);
1491 ret
= videobuf_read_one(&fh
->video_q
, data
, count
, ppos
,
1492 file
->f_flags
& O_NONBLOCK
);
1494 video_end(fh
, file
);
1496 ret
= video_end(fh
, file
);
1499 /* restart overlay if it was active before */
1500 if (vv
->ov_suspend
!= NULL
) {
1501 saa7146_start_preview(vv
->ov_suspend
);
1502 vv
->ov_suspend
= NULL
;
1508 struct saa7146_use_ops saa7146_video_uops
= {
1511 .release
= video_close
,
1512 .irq_done
= video_irq_done
,