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 __le32
*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
= dma
->sglist
->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 long saa7146_video_do_ioctl(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
;
844 int result
= 0, ee
= 0;
846 struct saa7146_use_ops
*ops
;
847 struct videobuf_queue
*q
;
849 /* check if extension handles the command */
850 for(ee
= 0; dev
->ext_vv_data
->ioctls
[ee
].flags
!= 0; ee
++) {
851 if( cmd
== dev
->ext_vv_data
->ioctls
[ee
].cmd
)
855 if( 0 != (dev
->ext_vv_data
->ioctls
[ee
].flags
& SAA7146_EXCLUSIVE
) ) {
856 DEB_D(("extension handles ioctl exclusive.\n"));
857 result
= dev
->ext_vv_data
->ioctl(fh
, cmd
, arg
);
860 if( 0 != (dev
->ext_vv_data
->ioctls
[ee
].flags
& SAA7146_BEFORE
) ) {
861 DEB_D(("extension handles ioctl before.\n"));
862 result
= dev
->ext_vv_data
->ioctl(fh
, cmd
, arg
);
863 if( -EAGAIN
!= result
) {
868 /* fixme: add handle "after" case (is it still needed?) */
871 case V4L2_BUF_TYPE_VIDEO_CAPTURE
: {
872 ops
= &saa7146_video_uops
;
876 case V4L2_BUF_TYPE_VBI_CAPTURE
: {
877 ops
= &saa7146_vbi_uops
;
887 case VIDIOC_QUERYCAP
:
889 struct v4l2_capability
*cap
= arg
;
890 memset(cap
,0,sizeof(*cap
));
892 DEB_EE(("VIDIOC_QUERYCAP\n"));
894 strcpy((char *)cap
->driver
, "saa7146 v4l2");
895 strlcpy((char *)cap
->card
, dev
->ext
->name
, sizeof(cap
->card
));
896 sprintf((char *)cap
->bus_info
,"PCI:%s", pci_name(dev
->pci
));
897 cap
->version
= SAA7146_VERSION_CODE
;
899 V4L2_CAP_VIDEO_CAPTURE
|
900 V4L2_CAP_VIDEO_OVERLAY
|
903 cap
->capabilities
|= dev
->ext_vv_data
->capabilities
;
908 struct v4l2_framebuffer
*fb
= arg
;
910 DEB_EE(("VIDIOC_G_FBUF\n"));
913 fb
->capability
= V4L2_FBUF_CAP_LIST_CLIPPING
;
918 struct v4l2_framebuffer
*fb
= arg
;
919 struct saa7146_format
*fmt
;
921 DEB_EE(("VIDIOC_S_FBUF\n"));
923 if(!capable(CAP_SYS_ADMIN
) &&
924 !capable(CAP_SYS_RAWIO
))
928 fmt
= format_by_fourcc(dev
,fb
->fmt
.pixelformat
);
933 /* planar formats are not allowed for overlay video, clipping and video dma would clash */
934 if (0 != (fmt
->flags
& FORMAT_IS_PLANAR
)) {
935 DEB_S(("planar pixelformat '%4.4s' not allowed for overlay\n",(char *)&fmt
->pixelformat
));
938 /* check if overlay is running */
939 if (IS_OVERLAY_ACTIVE(fh
) != 0) {
940 if (vv
->video_fh
!= fh
) {
941 DEB_D(("refusing to change framebuffer informations while overlay is active in another open.\n"));
946 mutex_lock(&dev
->lock
);
951 if (0 == vv
->ov_fb
.fmt
.bytesperline
)
952 vv
->ov_fb
.fmt
.bytesperline
=
953 vv
->ov_fb
.fmt
.width
*fmt
->depth
/8;
955 mutex_unlock(&dev
->lock
);
959 case VIDIOC_ENUM_FMT
:
961 struct v4l2_fmtdesc
*f
= arg
;
964 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
965 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
966 if (f
->index
>= NUM_FORMATS
)
968 strlcpy((char *)f
->description
, formats
[f
->index
].name
,
969 sizeof(f
->description
));
970 f
->pixelformat
= formats
[f
->index
].pixelformat
;
972 memset(f
->reserved
, 0, sizeof(f
->reserved
));
978 DEB_EE(("VIDIOC_ENUM_FMT: type:%d, index:%d\n",f
->type
,f
->index
));
981 case VIDIOC_QUERYCTRL
:
983 const struct v4l2_queryctrl
*ctrl
;
984 struct v4l2_queryctrl
*c
= arg
;
986 if ((c
->id
< V4L2_CID_BASE
||
987 c
->id
>= V4L2_CID_LASTP1
) &&
988 (c
->id
< V4L2_CID_PRIVATE_BASE
||
989 c
->id
>= V4L2_CID_PRIVATE_LASTP1
))
992 ctrl
= ctrl_by_id(c
->id
);
996 c->flags = V4L2_CTRL_FLAG_DISABLED;
1001 DEB_EE(("VIDIOC_QUERYCTRL: id:%d\n",c
->id
));
1005 case VIDIOC_G_CTRL
: {
1006 DEB_EE(("VIDIOC_G_CTRL\n"));
1007 return get_control(fh
,arg
);
1011 DEB_EE(("VIDIOC_S_CTRL\n"));
1012 err
= set_control(fh
,arg
);
1017 struct v4l2_streamparm
*parm
= arg
;
1018 if( parm
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
1021 memset(&parm
->parm
.capture
,0,sizeof(struct v4l2_captureparm
));
1022 parm
->parm
.capture
.readbuffers
= 1;
1023 // fixme: only for PAL!
1024 parm
->parm
.capture
.timeperframe
.numerator
= 1;
1025 parm
->parm
.capture
.timeperframe
.denominator
= 25;
1030 struct v4l2_format
*f
= arg
;
1031 DEB_EE(("VIDIOC_G_FMT\n"));
1036 struct v4l2_format
*f
= arg
;
1037 DEB_EE(("VIDIOC_S_FMT\n"));
1040 case VIDIOC_TRY_FMT
:
1042 struct v4l2_format
*f
= arg
;
1043 DEB_EE(("VIDIOC_TRY_FMT\n"));
1044 return try_fmt(fh
,f
);
1048 v4l2_std_id
*id
= arg
;
1049 DEB_EE(("VIDIOC_G_STD\n"));
1050 *id
= vv
->standard
->id
;
1053 /* the saa7146 supfhrts (used in conjunction with the saa7111a for example)
1054 PAL / NTSC / SECAM. if your hardware does not (or does more)
1055 -- override this function in your extension */
1056 case VIDIOC_ENUMSTD
:
1058 struct v4l2_standard
*e
= arg
;
1061 if( e
->index
< dev
->ext_vv_data
->num_stds
) {
1062 DEB_EE(("VIDIOC_ENUMSTD: index:%d\n",e
->index
));
1063 v4l2_video_std_construct(e
, dev
->ext_vv_data
->stds
[e
->index
].id
, dev
->ext_vv_data
->stds
[e
->index
].name
);
1070 v4l2_std_id
*id
= arg
;
1074 DEB_EE(("VIDIOC_S_STD\n"));
1076 if ((vv
->video_status
& STATUS_CAPTURE
) == STATUS_CAPTURE
) {
1077 DEB_D(("cannot change video standard while streaming capture is active\n"));
1081 if ((vv
->video_status
& STATUS_OVERLAY
) != 0) {
1082 vv
->ov_suspend
= vv
->video_fh
;
1083 err
= saa7146_stop_preview(vv
->video_fh
); /* side effect: video_status is now 0, video_fh is NULL */
1085 DEB_D(("suspending video failed. aborting\n"));
1090 mutex_lock(&dev
->lock
);
1092 for(i
= 0; i
< dev
->ext_vv_data
->num_stds
; i
++)
1093 if (*id
& dev
->ext_vv_data
->stds
[i
].id
)
1095 if (i
!= dev
->ext_vv_data
->num_stds
) {
1096 vv
->standard
= &dev
->ext_vv_data
->stds
[i
];
1097 if( NULL
!= dev
->ext_vv_data
->std_callback
)
1098 dev
->ext_vv_data
->std_callback(dev
, vv
->standard
);
1102 mutex_unlock(&dev
->lock
);
1104 if (vv
->ov_suspend
!= NULL
) {
1105 saa7146_start_preview(vv
->ov_suspend
);
1106 vv
->ov_suspend
= NULL
;
1110 DEB_EE(("VIDIOC_S_STD: standard not found.\n"));
1114 DEB_EE(("VIDIOC_S_STD: set to standard to '%s'\n",vv
->standard
->name
));
1117 case VIDIOC_OVERLAY
:
1119 int on
= *(int *)arg
;
1121 DEB_D(("VIDIOC_OVERLAY on:%d\n",on
));
1123 err
= saa7146_start_preview(fh
);
1125 err
= saa7146_stop_preview(fh
);
1129 case VIDIOC_REQBUFS
: {
1130 struct v4l2_requestbuffers
*req
= arg
;
1131 DEB_D(("VIDIOC_REQBUFS, type:%d\n",req
->type
));
1132 return videobuf_reqbufs(q
,req
);
1134 case VIDIOC_QUERYBUF
: {
1135 struct v4l2_buffer
*buf
= arg
;
1136 DEB_D(("VIDIOC_QUERYBUF, type:%d, offset:%d\n",buf
->type
,buf
->m
.offset
));
1137 return videobuf_querybuf(q
,buf
);
1140 struct v4l2_buffer
*buf
= arg
;
1142 ret
= videobuf_qbuf(q
,buf
);
1143 DEB_D(("VIDIOC_QBUF: ret:%d, index:%d\n",ret
,buf
->index
));
1146 case VIDIOC_DQBUF
: {
1147 struct v4l2_buffer
*buf
= arg
;
1149 ret
= videobuf_dqbuf(q
,buf
,file
->f_flags
& O_NONBLOCK
);
1150 DEB_D(("VIDIOC_DQBUF: ret:%d, index:%d\n",ret
,buf
->index
));
1153 case VIDIOC_STREAMON
: {
1155 DEB_D(("VIDIOC_STREAMON, type:%d\n",*type
));
1157 err
= video_begin(fh
);
1161 err
= videobuf_streamon(q
);
1164 case VIDIOC_STREAMOFF
: {
1167 DEB_D(("VIDIOC_STREAMOFF, type:%d\n",*type
));
1169 /* ugly: we need to copy some checks from video_end(),
1170 because videobuf_streamoff() relies on the capture running.
1171 check and fix this */
1172 if ((vv
->video_status
& STATUS_CAPTURE
) != STATUS_CAPTURE
) {
1173 DEB_S(("not capturing.\n"));
1177 if (vv
->video_fh
!= fh
) {
1178 DEB_S(("capturing, but in another open.\n"));
1182 err
= videobuf_streamoff(q
);
1184 DEB_D(("warning: videobuf_streamoff() failed.\n"));
1185 video_end(fh
, file
);
1187 err
= video_end(fh
, file
);
1191 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1194 struct video_mbuf
*mbuf
= arg
;
1197 /* fixme: number of capture buffers and sizes for v4l apps */
1199 int gbufsize
= 768*576*4;
1201 DEB_D(("VIDIOCGMBUF \n"));
1204 err
= videobuf_mmap_setup(q
,gbuffers
,gbufsize
,
1210 memset(mbuf
,0,sizeof(*mbuf
));
1211 mbuf
->frames
= gbuffers
;
1212 mbuf
->size
= gbuffers
* gbufsize
;
1213 for (i
= 0; i
< gbuffers
; i
++)
1214 mbuf
->offsets
[i
] = i
* gbufsize
;
1219 return v4l_compat_translate_ioctl(file
, cmd
, arg
,
1220 saa7146_video_do_ioctl
);
1225 /*********************************************************************************/
1226 /* buffer handling functions */
1228 static int buffer_activate (struct saa7146_dev
*dev
,
1229 struct saa7146_buf
*buf
,
1230 struct saa7146_buf
*next
)
1232 struct saa7146_vv
*vv
= dev
->vv_data
;
1234 buf
->vb
.state
= VIDEOBUF_ACTIVE
;
1235 saa7146_set_capture(dev
,buf
,next
);
1237 mod_timer(&vv
->video_q
.timeout
, jiffies
+BUFFER_TIMEOUT
);
1241 static int buffer_prepare(struct videobuf_queue
*q
,
1242 struct videobuf_buffer
*vb
, enum v4l2_field field
)
1244 struct file
*file
= q
->priv_data
;
1245 struct saa7146_fh
*fh
= file
->private_data
;
1246 struct saa7146_dev
*dev
= fh
->dev
;
1247 struct saa7146_vv
*vv
= dev
->vv_data
;
1248 struct saa7146_buf
*buf
= (struct saa7146_buf
*)vb
;
1251 DEB_CAP(("vbuf:%p\n",vb
));
1254 if (fh
->video_fmt
.width
< 48 ||
1255 fh
->video_fmt
.height
< 32 ||
1256 fh
->video_fmt
.width
> vv
->standard
->h_max_out
||
1257 fh
->video_fmt
.height
> vv
->standard
->v_max_out
) {
1258 DEB_D(("w (%d) / h (%d) out of bounds.\n",fh
->video_fmt
.width
,fh
->video_fmt
.height
));
1262 size
= fh
->video_fmt
.sizeimage
;
1263 if (0 != buf
->vb
.baddr
&& buf
->vb
.bsize
< size
) {
1264 DEB_D(("size mismatch.\n"));
1268 DEB_CAP(("buffer_prepare [size=%dx%d,bytes=%d,fields=%s]\n",
1269 fh
->video_fmt
.width
,fh
->video_fmt
.height
,size
,v4l2_field_names
[fh
->video_fmt
.field
]));
1270 if (buf
->vb
.width
!= fh
->video_fmt
.width
||
1271 buf
->vb
.bytesperline
!= fh
->video_fmt
.bytesperline
||
1272 buf
->vb
.height
!= fh
->video_fmt
.height
||
1273 buf
->vb
.size
!= size
||
1274 buf
->vb
.field
!= field
||
1275 buf
->vb
.field
!= fh
->video_fmt
.field
||
1276 buf
->fmt
!= &fh
->video_fmt
) {
1277 saa7146_dma_free(dev
,q
,buf
);
1280 if (VIDEOBUF_NEEDS_INIT
== buf
->vb
.state
) {
1281 struct saa7146_format
*sfmt
;
1283 buf
->vb
.bytesperline
= fh
->video_fmt
.bytesperline
;
1284 buf
->vb
.width
= fh
->video_fmt
.width
;
1285 buf
->vb
.height
= fh
->video_fmt
.height
;
1286 buf
->vb
.size
= size
;
1287 buf
->vb
.field
= field
;
1288 buf
->fmt
= &fh
->video_fmt
;
1289 buf
->vb
.field
= fh
->video_fmt
.field
;
1291 sfmt
= format_by_fourcc(dev
,buf
->fmt
->pixelformat
);
1293 if( 0 != IS_PLANAR(sfmt
->trans
)) {
1294 saa7146_pgtable_free(dev
->pci
, &buf
->pt
[0]);
1295 saa7146_pgtable_free(dev
->pci
, &buf
->pt
[1]);
1296 saa7146_pgtable_free(dev
->pci
, &buf
->pt
[2]);
1298 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[0]);
1299 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[1]);
1300 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[2]);
1302 saa7146_pgtable_free(dev
->pci
, &buf
->pt
[0]);
1303 saa7146_pgtable_alloc(dev
->pci
, &buf
->pt
[0]);
1306 err
= videobuf_iolock(q
,&buf
->vb
, &vv
->ov_fb
);
1309 err
= saa7146_pgtable_build(dev
,buf
);
1313 buf
->vb
.state
= VIDEOBUF_PREPARED
;
1314 buf
->activate
= buffer_activate
;
1319 DEB_D(("error out.\n"));
1320 saa7146_dma_free(dev
,q
,buf
);
1325 static int buffer_setup(struct videobuf_queue
*q
, unsigned int *count
, unsigned int *size
)
1327 struct file
*file
= q
->priv_data
;
1328 struct saa7146_fh
*fh
= file
->private_data
;
1330 if (0 == *count
|| *count
> MAX_SAA7146_CAPTURE_BUFFERS
)
1331 *count
= MAX_SAA7146_CAPTURE_BUFFERS
;
1333 *size
= fh
->video_fmt
.sizeimage
;
1335 /* check if we exceed the "max_memory" parameter */
1336 if( (*count
* *size
) > (max_memory
*1048576) ) {
1337 *count
= (max_memory
*1048576) / *size
;
1340 DEB_CAP(("%d buffers, %d bytes each.\n",*count
,*size
));
1345 static void buffer_queue(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1347 struct file
*file
= q
->priv_data
;
1348 struct saa7146_fh
*fh
= file
->private_data
;
1349 struct saa7146_dev
*dev
= fh
->dev
;
1350 struct saa7146_vv
*vv
= dev
->vv_data
;
1351 struct saa7146_buf
*buf
= (struct saa7146_buf
*)vb
;
1353 DEB_CAP(("vbuf:%p\n",vb
));
1354 saa7146_buffer_queue(fh
->dev
,&vv
->video_q
,buf
);
1357 static void buffer_release(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1359 struct file
*file
= q
->priv_data
;
1360 struct saa7146_fh
*fh
= file
->private_data
;
1361 struct saa7146_dev
*dev
= fh
->dev
;
1362 struct saa7146_buf
*buf
= (struct saa7146_buf
*)vb
;
1364 DEB_CAP(("vbuf:%p\n",vb
));
1365 saa7146_dma_free(dev
,q
,buf
);
1368 static struct videobuf_queue_ops video_qops
= {
1369 .buf_setup
= buffer_setup
,
1370 .buf_prepare
= buffer_prepare
,
1371 .buf_queue
= buffer_queue
,
1372 .buf_release
= buffer_release
,
1375 /********************************************************************************/
1376 /* file operations */
1378 static void video_init(struct saa7146_dev
*dev
, struct saa7146_vv
*vv
)
1380 INIT_LIST_HEAD(&vv
->video_q
.queue
);
1382 init_timer(&vv
->video_q
.timeout
);
1383 vv
->video_q
.timeout
.function
= saa7146_buffer_timeout
;
1384 vv
->video_q
.timeout
.data
= (unsigned long)(&vv
->video_q
);
1385 vv
->video_q
.dev
= dev
;
1387 /* set some default values */
1388 vv
->standard
= &dev
->ext_vv_data
->stds
[0];
1390 /* FIXME: what's this? */
1391 vv
->current_hps_source
= SAA7146_HPS_SOURCE_PORT_A
;
1392 vv
->current_hps_sync
= SAA7146_HPS_SYNC_PORT_A
;
1396 static int video_open(struct saa7146_dev
*dev
, struct file
*file
)
1398 struct saa7146_fh
*fh
= (struct saa7146_fh
*)file
->private_data
;
1399 struct saa7146_format
*sfmt
;
1401 fh
->video_fmt
.width
= 384;
1402 fh
->video_fmt
.height
= 288;
1403 fh
->video_fmt
.pixelformat
= V4L2_PIX_FMT_BGR24
;
1404 fh
->video_fmt
.bytesperline
= 0;
1405 fh
->video_fmt
.field
= V4L2_FIELD_ANY
;
1406 sfmt
= format_by_fourcc(dev
,fh
->video_fmt
.pixelformat
);
1407 fh
->video_fmt
.sizeimage
= (fh
->video_fmt
.width
* fh
->video_fmt
.height
* sfmt
->depth
)/8;
1409 videobuf_queue_sg_init(&fh
->video_q
, &video_qops
,
1410 &dev
->pci
->dev
, &dev
->slock
,
1411 V4L2_BUF_TYPE_VIDEO_CAPTURE
,
1412 V4L2_FIELD_INTERLACED
,
1413 sizeof(struct saa7146_buf
),
1420 static void video_close(struct saa7146_dev
*dev
, struct file
*file
)
1422 struct saa7146_fh
*fh
= (struct saa7146_fh
*)file
->private_data
;
1423 struct saa7146_vv
*vv
= dev
->vv_data
;
1424 struct videobuf_queue
*q
= &fh
->video_q
;
1427 if (IS_CAPTURE_ACTIVE(fh
) != 0) {
1428 err
= video_end(fh
, file
);
1429 } else if (IS_OVERLAY_ACTIVE(fh
) != 0) {
1430 err
= saa7146_stop_preview(fh
);
1435 /* hmm, why is this function declared void? */
1440 static void video_irq_done(struct saa7146_dev
*dev
, unsigned long st
)
1442 struct saa7146_vv
*vv
= dev
->vv_data
;
1443 struct saa7146_dmaqueue
*q
= &vv
->video_q
;
1445 spin_lock(&dev
->slock
);
1446 DEB_CAP(("called.\n"));
1448 /* only finish the buffer if we have one... */
1449 if( NULL
!= q
->curr
) {
1450 saa7146_buffer_finish(dev
,q
,VIDEOBUF_DONE
);
1452 saa7146_buffer_next(dev
,q
,0);
1454 spin_unlock(&dev
->slock
);
1457 static ssize_t
video_read(struct file
*file
, char __user
*data
, size_t count
, loff_t
*ppos
)
1459 struct saa7146_fh
*fh
= file
->private_data
;
1460 struct saa7146_dev
*dev
= fh
->dev
;
1461 struct saa7146_vv
*vv
= dev
->vv_data
;
1464 DEB_EE(("called.\n"));
1466 if ((vv
->video_status
& STATUS_CAPTURE
) != 0) {
1467 /* fixme: should we allow read() captures while streaming capture? */
1468 if (vv
->video_fh
== fh
) {
1469 DEB_S(("already capturing.\n"));
1472 DEB_S(("already capturing in another open.\n"));
1476 ret
= video_begin(fh
);
1481 ret
= videobuf_read_one(&fh
->video_q
, data
, count
, ppos
,
1482 file
->f_flags
& O_NONBLOCK
);
1484 video_end(fh
, file
);
1486 ret
= video_end(fh
, file
);
1489 /* restart overlay if it was active before */
1490 if (vv
->ov_suspend
!= NULL
) {
1491 saa7146_start_preview(vv
->ov_suspend
);
1492 vv
->ov_suspend
= NULL
;
1498 struct saa7146_use_ops saa7146_video_uops
= {
1501 .release
= video_close
,
1502 .irq_done
= video_irq_done
,