2 #include <linux/vmalloc.h>
3 #include <linux/videodev2.h>
6 #include <linux/sched.h>
7 #include <linux/slab.h>
9 #include <media/v4l2-ioctl.h>
10 #include <media/v4l2-dev.h>
12 #include "pd-common.h"
13 #include "vendorcmds.h"
16 static int pm_video_suspend(struct poseidon
*pd
);
17 static int pm_video_resume(struct poseidon
*pd
);
19 static void iso_bubble_handler(struct work_struct
*w
);
21 static int usb_transfer_mode
;
22 module_param(usb_transfer_mode
, int, 0644);
23 MODULE_PARM_DESC(usb_transfer_mode
, "0 = Bulk, 1 = Isochronous");
25 static const struct poseidon_format poseidon_formats
[] = {
26 { "YUV 422", V4L2_PIX_FMT_YUYV
, 16, 0},
27 { "RGB565", V4L2_PIX_FMT_RGB565
, 16, 0},
30 static const struct poseidon_tvnorm poseidon_tvnorms
[] = {
31 { V4L2_STD_PAL_D
, "PAL-D", TLG_TUNE_VSTD_PAL_D
},
32 { V4L2_STD_PAL_B
, "PAL-B", TLG_TUNE_VSTD_PAL_B
},
33 { V4L2_STD_PAL_G
, "PAL-G", TLG_TUNE_VSTD_PAL_G
},
34 { V4L2_STD_PAL_H
, "PAL-H", TLG_TUNE_VSTD_PAL_H
},
35 { V4L2_STD_PAL_I
, "PAL-I", TLG_TUNE_VSTD_PAL_I
},
36 { V4L2_STD_PAL_M
, "PAL-M", TLG_TUNE_VSTD_PAL_M
},
37 { V4L2_STD_PAL_N
, "PAL-N", TLG_TUNE_VSTD_PAL_N_COMBO
},
38 { V4L2_STD_PAL_Nc
, "PAL-Nc", TLG_TUNE_VSTD_PAL_N_COMBO
},
39 { V4L2_STD_NTSC_M
, "NTSC-M", TLG_TUNE_VSTD_NTSC_M
},
40 { V4L2_STD_NTSC_M_JP
, "NTSC-JP", TLG_TUNE_VSTD_NTSC_M_J
},
41 { V4L2_STD_SECAM_B
, "SECAM-B", TLG_TUNE_VSTD_SECAM_B
},
42 { V4L2_STD_SECAM_D
, "SECAM-D", TLG_TUNE_VSTD_SECAM_D
},
43 { V4L2_STD_SECAM_G
, "SECAM-G", TLG_TUNE_VSTD_SECAM_G
},
44 { V4L2_STD_SECAM_H
, "SECAM-H", TLG_TUNE_VSTD_SECAM_H
},
45 { V4L2_STD_SECAM_K
, "SECAM-K", TLG_TUNE_VSTD_SECAM_K
},
46 { V4L2_STD_SECAM_K1
, "SECAM-K1", TLG_TUNE_VSTD_SECAM_K1
},
47 { V4L2_STD_SECAM_L
, "SECAM-L", TLG_TUNE_VSTD_SECAM_L
},
48 { V4L2_STD_SECAM_LC
, "SECAM-LC", TLG_TUNE_VSTD_SECAM_L1
},
50 static const unsigned int POSEIDON_TVNORMS
= ARRAY_SIZE(poseidon_tvnorms
);
52 struct pd_audio_mode
{
58 static const struct pd_audio_mode pd_audio_modes
[] = {
59 { TLG_TUNE_TVAUDIO_MODE_MONO
, V4L2_TUNER_SUB_MONO
,
60 V4L2_TUNER_MODE_MONO
},
61 { TLG_TUNE_TVAUDIO_MODE_STEREO
, V4L2_TUNER_SUB_STEREO
,
62 V4L2_TUNER_MODE_STEREO
},
63 { TLG_TUNE_TVAUDIO_MODE_LANG_A
, V4L2_TUNER_SUB_LANG1
,
64 V4L2_TUNER_MODE_LANG1
},
65 { TLG_TUNE_TVAUDIO_MODE_LANG_B
, V4L2_TUNER_SUB_LANG2
,
66 V4L2_TUNER_MODE_LANG2
},
67 { TLG_TUNE_TVAUDIO_MODE_LANG_C
, V4L2_TUNER_SUB_LANG1
,
68 V4L2_TUNER_MODE_LANG1_LANG2
}
70 static const unsigned int POSEIDON_AUDIOMODS
= ARRAY_SIZE(pd_audio_modes
);
77 static const struct pd_input pd_inputs
[] = {
78 { "TV Antenna", TLG_SIG_SRC_ANTENNA
},
79 { "TV Cable", TLG_SIG_SRC_CABLE
},
80 { "TV SVideo", TLG_SIG_SRC_SVIDEO
},
81 { "TV Composite", TLG_SIG_SRC_COMPOSITE
}
83 static const unsigned int POSEIDON_INPUTS
= ARRAY_SIZE(pd_inputs
);
85 struct poseidon_control
{
86 struct v4l2_queryctrl v4l2_ctrl
;
87 enum cmd_custom_param_id vc_id
;
90 static struct poseidon_control controls
[] = {
92 { V4L2_CID_BRIGHTNESS
, V4L2_CTRL_TYPE_INTEGER
,
93 "brightness", 0, 10000, 1, 100, 0, },
94 CUST_PARM_ID_BRIGHTNESS_CTRL
96 { V4L2_CID_CONTRAST
, V4L2_CTRL_TYPE_INTEGER
,
97 "contrast", 0, 10000, 1, 100, 0, },
98 CUST_PARM_ID_CONTRAST_CTRL
,
100 { V4L2_CID_HUE
, V4L2_CTRL_TYPE_INTEGER
,
101 "hue", 0, 10000, 1, 100, 0, },
102 CUST_PARM_ID_HUE_CTRL
,
104 { V4L2_CID_SATURATION
, V4L2_CTRL_TYPE_INTEGER
,
105 "saturation", 0, 10000, 1, 100, 0, },
106 CUST_PARM_ID_SATURATION_CTRL
,
110 struct video_std_to_audio_std
{
111 v4l2_std_id video_std
;
115 static const struct video_std_to_audio_std video_to_audio_map
[] = {
116 /* country : { 27, 32, 33, 34, 36, 44, 45, 46, 47, 48, 64,
117 65, 86, 351, 352, 353, 354, 358, 372, 852, 972 } */
118 { (V4L2_STD_PAL_I
| V4L2_STD_PAL_B
| V4L2_STD_PAL_D
|
119 V4L2_STD_SECAM_L
| V4L2_STD_SECAM_D
), TLG_TUNE_ASTD_NICAM
},
121 /* country : { 1, 52, 54, 55, 886 } */
122 {V4L2_STD_NTSC_M
| V4L2_STD_PAL_N
| V4L2_STD_PAL_M
, TLG_TUNE_ASTD_BTSC
},
124 /* country : { 81 } */
125 { V4L2_STD_NTSC_M_JP
, TLG_TUNE_ASTD_EIAJ
},
127 /* other country : TLG_TUNE_ASTD_A2 */
129 static const unsigned int map_size
= ARRAY_SIZE(video_to_audio_map
);
131 static int get_audio_std(v4l2_std_id v4l2_std
)
135 for (; i
< map_size
; i
++) {
136 if (v4l2_std
& video_to_audio_map
[i
].video_std
)
137 return video_to_audio_map
[i
].audio_std
;
139 return TLG_TUNE_ASTD_A2
;
142 static int vidioc_querycap(struct file
*file
, void *fh
,
143 struct v4l2_capability
*cap
)
145 struct front_face
*front
= fh
;
146 struct poseidon
*p
= front
->pd
;
150 strcpy(cap
->driver
, "tele-video");
151 strcpy(cap
->card
, "Telegent Poseidon");
152 usb_make_path(p
->udev
, cap
->bus_info
, sizeof(cap
->bus_info
));
153 cap
->version
= KERNEL_VERSION(0, 0, 1);
154 cap
->capabilities
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_TUNER
|
155 V4L2_CAP_AUDIO
| V4L2_CAP_STREAMING
|
156 V4L2_CAP_READWRITE
| V4L2_CAP_VBI_CAPTURE
;
160 /*====================================================================*/
161 static void init_copy(struct video_data
*video
, bool index
)
163 struct front_face
*front
= video
->front
;
165 video
->field_count
= index
;
166 video
->lines_copied
= 0;
167 video
->prev_left
= 0 ;
168 video
->dst
= (char *)videobuf_to_vmalloc(front
->curr_frame
)
169 + index
* video
->lines_size
;
170 video
->vbi
->copied
= 0; /* set it here */
173 static bool get_frame(struct front_face
*front
, int *need_init
)
175 struct videobuf_buffer
*vb
= front
->curr_frame
;
180 spin_lock(&front
->queue_lock
);
181 if (!list_empty(&front
->active
)) {
182 vb
= list_entry(front
->active
.next
,
183 struct videobuf_buffer
, queue
);
186 front
->curr_frame
= vb
;
187 list_del_init(&vb
->queue
);
189 spin_unlock(&front
->queue_lock
);
194 /* check if the video's buffer is ready */
195 static bool get_video_frame(struct front_face
*front
, struct video_data
*video
)
200 ret
= get_frame(front
, &need_init
);
201 if (ret
&& need_init
)
206 static void submit_frame(struct front_face
*front
)
208 struct videobuf_buffer
*vb
= front
->curr_frame
;
213 front
->curr_frame
= NULL
;
214 vb
->state
= VIDEOBUF_DONE
;
216 do_gettimeofday(&vb
->ts
);
222 * A frame is composed of two fields. If we receive all the two fields,
223 * call the submit_frame() to submit the whole frame to applications.
225 static void end_field(struct video_data
*video
)
227 /* logs(video->front); */
228 if (1 == video
->field_count
)
229 submit_frame(video
->front
);
234 static void copy_video_data(struct video_data
*video
, char *src
,
237 #define copy_data(len) \
239 if (++video->lines_copied > video->lines_per_field) \
241 memcpy(video->dst, src, len);\
242 video->dst += len + video->lines_size; \
247 while (count
&& count
>= video
->lines_size
) {
248 if (video
->prev_left
) {
249 copy_data(video
->prev_left
);
250 video
->prev_left
= 0;
253 copy_data(video
->lines_size
);
255 if (count
&& count
< video
->lines_size
) {
256 memcpy(video
->dst
, src
, count
);
258 video
->prev_left
= video
->lines_size
- count
;
267 static void check_trailer(struct video_data
*video
, char *src
, int count
)
269 struct vbi_data
*vbi
= video
->vbi
;
270 int offset
; /* trailer's offset */
273 offset
= (video
->context
.pix
.sizeimage
/ 2 + vbi
->vbi_size
/ 2)
274 - (vbi
->copied
+ video
->lines_size
* video
->lines_copied
);
275 if (video
->prev_left
)
276 offset
-= (video
->lines_size
- video
->prev_left
);
278 if (offset
> count
|| offset
<= 0)
283 /* trailer : (VFHS) + U32 + U32 + field_num */
284 if (!strncmp(buf
, "VFHS", 4)) {
285 int field_num
= *((u32
*)(buf
+ 12));
287 if ((field_num
& 1) ^ video
->field_count
) {
288 init_copy(video
, video
->field_count
);
291 copy_video_data(video
, src
, offset
);
297 /* ========== Check this more carefully! =========== */
298 static inline void copy_vbi_data(struct vbi_data
*vbi
,
299 char *src
, unsigned int count
)
301 struct front_face
*front
= vbi
->front
;
303 if (front
&& get_frame(front
, NULL
)) {
304 char *buf
= videobuf_to_vmalloc(front
->curr_frame
);
306 if (vbi
->video
->field_count
)
307 buf
+= (vbi
->vbi_size
/ 2);
308 memcpy(buf
+ vbi
->copied
, src
, count
);
310 vbi
->copied
+= count
;
314 * Copy the normal data (VBI or VIDEO) without the trailer.
315 * VBI is not interlaced, while VIDEO is interlaced.
317 static inline void copy_vbi_video_data(struct video_data
*video
,
318 char *src
, unsigned int count
)
320 struct vbi_data
*vbi
= video
->vbi
;
321 unsigned int vbi_delta
= (vbi
->vbi_size
/ 2) - vbi
->copied
;
323 if (vbi_delta
>= count
) {
324 copy_vbi_data(vbi
, src
, count
);
327 copy_vbi_data(vbi
, src
, vbi_delta
);
329 /* we receive the two fields of the VBI*/
330 if (vbi
->front
&& video
->field_count
)
331 submit_frame(vbi
->front
);
333 copy_video_data(video
, src
+ vbi_delta
, count
- vbi_delta
);
337 static void urb_complete_bulk(struct urb
*urb
)
339 struct front_face
*front
= urb
->context
;
340 struct video_data
*video
= &front
->pd
->video_data
;
341 char *src
= (char *)urb
->transfer_buffer
;
342 int count
= urb
->actual_length
;
345 if (!video
->is_streaming
|| urb
->status
) {
346 if (urb
->status
== -EPROTO
)
350 if (!get_video_frame(front
, video
))
353 if (count
== urb
->transfer_buffer_length
)
354 copy_vbi_video_data(video
, src
, count
);
356 check_trailer(video
, src
, count
);
359 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
361 log(" submit failed: error %d", ret
);
364 /************************* for ISO *********************/
365 #define GET_SUCCESS (0)
366 #define GET_TRAILER (1)
367 #define GET_TOO_MUCH_BUBBLE (2)
369 static int get_chunk(int start
, struct urb
*urb
,
370 int *head
, int *tail
, int *bubble_err
)
372 struct usb_iso_packet_descriptor
*pkt
= NULL
;
373 int ret
= GET_SUCCESS
;
375 for (*head
= *tail
= -1; start
< urb
->number_of_packets
; start
++) {
376 pkt
= &urb
->iso_frame_desc
[start
];
378 /* handle the bubble of the Hub */
379 if (-EOVERFLOW
== pkt
->status
) {
380 if (++*bubble_err
> urb
->number_of_packets
/ 3)
381 return GET_TOO_MUCH_BUBBLE
;
385 /* This is the gap */
386 if (pkt
->status
|| pkt
->actual_length
<= 0
387 || pkt
->actual_length
> ISO_PKT_SIZE
) {
393 /* a good isochronous packet */
394 if (pkt
->actual_length
== ISO_PKT_SIZE
) {
401 /* trailer is here */
402 if (pkt
->actual_length
< ISO_PKT_SIZE
) {
412 if (*head
== -1 && *tail
== -1)
418 * |__|------|___|-----|_______|
423 static void urb_complete_iso(struct urb
*urb
)
425 struct front_face
*front
= urb
->context
;
426 struct video_data
*video
= &front
->pd
->video_data
;
427 int bubble_err
= 0, head
= 0, tail
= 0;
428 char *src
= (char *)urb
->transfer_buffer
;
431 if (!video
->is_streaming
)
435 if (!get_video_frame(front
, video
))
438 switch (get_chunk(head
, urb
, &head
, &tail
, &bubble_err
)) {
440 copy_vbi_video_data(video
, src
+ (head
* ISO_PKT_SIZE
),
441 (tail
- head
+ 1) * ISO_PKT_SIZE
);
444 check_trailer(video
, src
+ (head
* ISO_PKT_SIZE
),
449 case GET_TOO_MUCH_BUBBLE
:
450 log("\t We got too much bubble");
451 schedule_work(&video
->bubble_work
);
454 } while (head
= tail
+ 1, head
< urb
->number_of_packets
);
457 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
459 log("usb_submit_urb err : %d", ret
);
461 /*============================= [ end ] =====================*/
463 static int prepare_iso_urb(struct video_data
*video
)
465 struct usb_device
*udev
= video
->pd
->udev
;
468 if (video
->urb_array
[0])
471 for (i
= 0; i
< SBUF_NUM
; i
++) {
476 urb
= usb_alloc_urb(PK_PER_URB
, GFP_KERNEL
);
480 video
->urb_array
[i
] = urb
;
481 mem
= usb_alloc_coherent(udev
,
482 ISO_PKT_SIZE
* PK_PER_URB
,
486 urb
->complete
= urb_complete_iso
; /* handler */
488 urb
->context
= video
->front
;
489 urb
->pipe
= usb_rcvisocpipe(udev
,
490 video
->endpoint_addr
);
492 urb
->transfer_flags
= URB_ISO_ASAP
| URB_NO_TRANSFER_DMA_MAP
;
493 urb
->number_of_packets
= PK_PER_URB
;
494 urb
->transfer_buffer
= mem
;
495 urb
->transfer_buffer_length
= PK_PER_URB
* ISO_PKT_SIZE
;
497 for (j
= 0; j
< PK_PER_URB
; j
++) {
498 urb
->iso_frame_desc
[j
].offset
= ISO_PKT_SIZE
* j
;
499 urb
->iso_frame_desc
[j
].length
= ISO_PKT_SIZE
;
509 /* return the succeeded number of the allocation */
510 int alloc_bulk_urbs_generic(struct urb
**urb_array
, int num
,
511 struct usb_device
*udev
, u8 ep_addr
,
512 int buf_size
, gfp_t gfp_flags
,
513 usb_complete_t complete_fn
, void *context
)
519 for (i
= 0; i
< num
; i
++) {
520 urb
= usb_alloc_urb(0, gfp_flags
);
524 mem
= usb_alloc_coherent(udev
, buf_size
, gfp_flags
,
529 usb_fill_bulk_urb(urb
, udev
, usb_rcvbulkpipe(udev
, ep_addr
),
530 mem
, buf_size
, complete_fn
, context
);
531 urb
->transfer_flags
|= URB_NO_TRANSFER_DMA_MAP
;
537 void free_all_urb_generic(struct urb
**urb_array
, int num
)
542 for (i
= 0; i
< num
; i
++) {
545 usb_free_coherent(urb
->dev
,
546 urb
->transfer_buffer_length
,
547 urb
->transfer_buffer
,
555 static int prepare_bulk_urb(struct video_data
*video
)
557 if (video
->urb_array
[0])
560 alloc_bulk_urbs_generic(video
->urb_array
, SBUF_NUM
,
561 video
->pd
->udev
, video
->endpoint_addr
,
563 urb_complete_bulk
, video
->front
);
568 static void free_all_urb(struct video_data
*video
)
570 free_all_urb_generic(video
->urb_array
, SBUF_NUM
);
573 static void pd_buf_release(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
575 videobuf_vmalloc_free(vb
);
576 vb
->state
= VIDEOBUF_NEEDS_INIT
;
579 static void pd_buf_queue(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
581 struct front_face
*front
= q
->priv_data
;
582 vb
->state
= VIDEOBUF_QUEUED
;
583 list_add_tail(&vb
->queue
, &front
->active
);
586 static int pd_buf_prepare(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
,
587 enum v4l2_field field
)
589 struct front_face
*front
= q
->priv_data
;
592 switch (front
->type
) {
593 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
594 if (VIDEOBUF_NEEDS_INIT
== vb
->state
) {
595 struct v4l2_pix_format
*pix
;
597 pix
= &front
->pd
->video_data
.context
.pix
;
598 vb
->size
= pix
->sizeimage
; /* real frame size */
599 vb
->width
= pix
->width
;
600 vb
->height
= pix
->height
;
601 rc
= videobuf_iolock(q
, vb
, NULL
);
606 case V4L2_BUF_TYPE_VBI_CAPTURE
:
607 if (VIDEOBUF_NEEDS_INIT
== vb
->state
) {
608 vb
->size
= front
->pd
->vbi_data
.vbi_size
;
609 rc
= videobuf_iolock(q
, vb
, NULL
);
618 vb
->state
= VIDEOBUF_PREPARED
;
622 static int fire_all_urb(struct video_data
*video
)
626 video
->is_streaming
= 1;
628 for (i
= 0; i
< SBUF_NUM
; i
++) {
629 ret
= usb_submit_urb(video
->urb_array
[i
], GFP_KERNEL
);
631 log("(%d) failed: error %d", i
, ret
);
636 static int start_video_stream(struct poseidon
*pd
)
638 struct video_data
*video
= &pd
->video_data
;
641 send_set_req(pd
, TAKE_REQUEST
, 0, &cmd_status
);
642 send_set_req(pd
, PLAY_SERVICE
, TLG_TUNE_PLAY_SVC_START
, &cmd_status
);
644 if (pd
->cur_transfer_mode
) {
645 prepare_iso_urb(video
);
646 INIT_WORK(&video
->bubble_work
, iso_bubble_handler
);
648 /* The bulk mode does not need a bubble handler */
649 prepare_bulk_urb(video
);
655 static int pd_buf_setup(struct videobuf_queue
*q
, unsigned int *count
,
658 struct front_face
*front
= q
->priv_data
;
659 struct poseidon
*pd
= front
->pd
;
661 switch (front
->type
) {
664 case V4L2_BUF_TYPE_VIDEO_CAPTURE
: {
665 struct video_data
*video
= &pd
->video_data
;
666 struct v4l2_pix_format
*pix
= &video
->context
.pix
;
668 *size
= PAGE_ALIGN(pix
->sizeimage
);/* page aligned frame size */
672 /* same in different altersetting */
673 video
->endpoint_addr
= 0x82;
674 video
->vbi
= &pd
->vbi_data
;
675 video
->vbi
->video
= video
;
677 video
->lines_per_field
= pix
->height
/ 2;
678 video
->lines_size
= pix
->width
* 2;
679 video
->front
= front
;
681 return start_video_stream(pd
);
684 case V4L2_BUF_TYPE_VBI_CAPTURE
: {
685 struct vbi_data
*vbi
= &pd
->vbi_data
;
687 *size
= PAGE_ALIGN(vbi
->vbi_size
);
688 log("size : %d", *size
);
697 static struct videobuf_queue_ops pd_video_qops
= {
698 .buf_setup
= pd_buf_setup
,
699 .buf_prepare
= pd_buf_prepare
,
700 .buf_queue
= pd_buf_queue
,
701 .buf_release
= pd_buf_release
,
704 static int vidioc_enum_fmt(struct file
*file
, void *fh
,
705 struct v4l2_fmtdesc
*f
)
707 if (ARRAY_SIZE(poseidon_formats
) <= f
->index
)
709 f
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
711 f
->pixelformat
= poseidon_formats
[f
->index
].fourcc
;
712 strcpy(f
->description
, poseidon_formats
[f
->index
].name
);
716 static int vidioc_g_fmt(struct file
*file
, void *fh
, struct v4l2_format
*f
)
718 struct front_face
*front
= fh
;
719 struct poseidon
*pd
= front
->pd
;
722 f
->fmt
.pix
= pd
->video_data
.context
.pix
;
726 static int vidioc_try_fmt(struct file
*file
, void *fh
,
727 struct v4l2_format
*f
)
733 * VLC calls VIDIOC_S_STD before VIDIOC_S_FMT, while
734 * Mplayer calls them in the reverse order.
736 static int pd_vidioc_s_fmt(struct poseidon
*pd
, struct v4l2_pix_format
*pix
)
738 struct video_data
*video
= &pd
->video_data
;
739 struct running_context
*context
= &video
->context
;
740 struct v4l2_pix_format
*pix_def
= &context
->pix
;
741 s32 ret
= 0, cmd_status
= 0, vid_resol
;
743 /* set the pixel format to firmware */
744 if (pix
->pixelformat
== V4L2_PIX_FMT_RGB565
) {
745 vid_resol
= TLG_TUNER_VID_FORMAT_RGB_565
;
747 pix
->pixelformat
= V4L2_PIX_FMT_YUYV
;
748 vid_resol
= TLG_TUNER_VID_FORMAT_YUV
;
750 ret
= send_set_req(pd
, VIDEO_STREAM_FMT_SEL
,
751 vid_resol
, &cmd_status
);
753 /* set the resolution to firmware */
754 vid_resol
= TLG_TUNE_VID_RES_720
;
755 switch (pix
->width
) {
757 vid_resol
= TLG_TUNE_VID_RES_704
;
764 ret
|= send_set_req(pd
, VIDEO_ROSOLU_SEL
,
765 vid_resol
, &cmd_status
);
766 if (ret
|| cmd_status
) {
767 mutex_unlock(&pd
->lock
);
771 pix_def
->pixelformat
= pix
->pixelformat
; /* save it */
772 pix
->height
= (context
->tvnormid
& V4L2_STD_525_60
) ? 480 : 576;
774 /* Compare with the default setting */
775 if ((pix_def
->width
!= pix
->width
)
776 || (pix_def
->height
!= pix
->height
)) {
777 pix_def
->width
= pix
->width
;
778 pix_def
->height
= pix
->height
;
779 pix_def
->bytesperline
= pix
->width
* 2;
780 pix_def
->sizeimage
= pix
->width
* pix
->height
* 2;
787 static int vidioc_s_fmt(struct file
*file
, void *fh
, struct v4l2_format
*f
)
789 struct front_face
*front
= fh
;
790 struct poseidon
*pd
= front
->pd
;
794 if (V4L2_BUF_TYPE_VIDEO_CAPTURE
!= f
->type
)
797 mutex_lock(&pd
->lock
);
798 if (pd
->file_for_stream
== NULL
)
799 pd
->file_for_stream
= file
;
800 else if (file
!= pd
->file_for_stream
) {
801 mutex_unlock(&pd
->lock
);
805 pd_vidioc_s_fmt(pd
, &f
->fmt
.pix
);
806 mutex_unlock(&pd
->lock
);
810 static int vidioc_g_fmt_vbi(struct file
*file
, void *fh
,
811 struct v4l2_format
*v4l2_f
)
813 struct front_face
*front
= fh
;
814 struct poseidon
*pd
= front
->pd
;
815 struct v4l2_vbi_format
*vbi_fmt
= &v4l2_f
->fmt
.vbi
;
817 vbi_fmt
->samples_per_line
= 720 * 2;
818 vbi_fmt
->sampling_rate
= 6750000 * 4;
819 vbi_fmt
->sample_format
= V4L2_PIX_FMT_GREY
;
820 vbi_fmt
->offset
= 64 * 4; /*FIXME: why offset */
821 if (pd
->video_data
.context
.tvnormid
& V4L2_STD_525_60
) {
822 vbi_fmt
->start
[0] = 10;
823 vbi_fmt
->start
[1] = 264;
824 vbi_fmt
->count
[0] = V4L_NTSC_VBI_LINES
;
825 vbi_fmt
->count
[1] = V4L_NTSC_VBI_LINES
;
827 vbi_fmt
->start
[0] = 6;
828 vbi_fmt
->start
[1] = 314;
829 vbi_fmt
->count
[0] = V4L_PAL_VBI_LINES
;
830 vbi_fmt
->count
[1] = V4L_PAL_VBI_LINES
;
832 vbi_fmt
->flags
= V4L2_VBI_UNSYNC
;
837 static int set_std(struct poseidon
*pd
, v4l2_std_id
*norm
)
839 struct video_data
*video
= &pd
->video_data
;
840 struct vbi_data
*vbi
= &pd
->vbi_data
;
841 struct running_context
*context
;
842 struct v4l2_pix_format
*pix
;
843 s32 i
, ret
= 0, cmd_status
, param
;
846 for (i
= 0; i
< POSEIDON_TVNORMS
; i
++) {
847 if (*norm
& poseidon_tvnorms
[i
].v4l2_id
) {
848 param
= poseidon_tvnorms
[i
].tlg_tvnorm
;
849 log("name : %s", poseidon_tvnorms
[i
].name
);
855 mutex_lock(&pd
->lock
);
856 ret
= send_set_req(pd
, VIDEO_STD_SEL
, param
, &cmd_status
);
857 if (ret
|| cmd_status
)
860 /* Set vbi size and check the height of the frame */
861 context
= &video
->context
;
862 context
->tvnormid
= poseidon_tvnorms
[i
].v4l2_id
;
863 if (context
->tvnormid
& V4L2_STD_525_60
) {
864 vbi
->vbi_size
= V4L_NTSC_VBI_FRAMESIZE
;
867 vbi
->vbi_size
= V4L_PAL_VBI_FRAMESIZE
;
872 if (pix
->height
!= height
) {
873 pix
->height
= height
;
874 pix
->sizeimage
= pix
->width
* pix
->height
* 2;
878 mutex_unlock(&pd
->lock
);
882 static int vidioc_s_std(struct file
*file
, void *fh
, v4l2_std_id
*norm
)
884 struct front_face
*front
= fh
;
886 return set_std(front
->pd
, norm
);
889 static int vidioc_enum_input(struct file
*file
, void *fh
, struct v4l2_input
*in
)
891 struct front_face
*front
= fh
;
893 if (in
->index
< 0 || in
->index
>= POSEIDON_INPUTS
)
895 strcpy(in
->name
, pd_inputs
[in
->index
].name
);
896 in
->type
= V4L2_INPUT_TYPE_TUNER
;
899 * the audio input index mixed with this video input,
900 * Poseidon only have one audio/video, set to "0"
904 in
->std
= V4L2_STD_ALL
;
910 static int vidioc_g_input(struct file
*file
, void *fh
, unsigned int *i
)
912 struct front_face
*front
= fh
;
913 struct poseidon
*pd
= front
->pd
;
914 struct running_context
*context
= &pd
->video_data
.context
;
917 *i
= context
->sig_index
;
921 /* We can support several inputs */
922 static int vidioc_s_input(struct file
*file
, void *fh
, unsigned int i
)
924 struct front_face
*front
= fh
;
925 struct poseidon
*pd
= front
->pd
;
928 if (i
< 0 || i
>= POSEIDON_INPUTS
)
930 ret
= send_set_req(pd
, SGNL_SRC_SEL
,
931 pd_inputs
[i
].tlg_src
, &cmd_status
);
935 pd
->video_data
.context
.sig_index
= i
;
939 static struct poseidon_control
*check_control_id(__u32 id
)
941 struct poseidon_control
*control
= &controls
[0];
942 int array_size
= ARRAY_SIZE(controls
);
944 for (; control
< &controls
[array_size
]; control
++)
945 if (control
->v4l2_ctrl
.id
== id
)
950 static int vidioc_queryctrl(struct file
*file
, void *fh
,
951 struct v4l2_queryctrl
*a
)
953 struct poseidon_control
*control
= NULL
;
955 control
= check_control_id(a
->id
);
959 *a
= control
->v4l2_ctrl
;
963 static int vidioc_g_ctrl(struct file
*file
, void *fh
, struct v4l2_control
*ctrl
)
965 struct front_face
*front
= fh
;
966 struct poseidon
*pd
= front
->pd
;
967 struct poseidon_control
*control
= NULL
;
968 struct tuner_custom_parameter_s tuner_param
;
969 s32 ret
= 0, cmd_status
;
971 control
= check_control_id(ctrl
->id
);
975 mutex_lock(&pd
->lock
);
976 ret
= send_get_req(pd
, TUNER_CUSTOM_PARAMETER
, control
->vc_id
,
977 &tuner_param
, &cmd_status
, sizeof(tuner_param
));
978 mutex_unlock(&pd
->lock
);
980 if (ret
|| cmd_status
)
983 ctrl
->value
= tuner_param
.param_value
;
987 static int vidioc_s_ctrl(struct file
*file
, void *fh
, struct v4l2_control
*a
)
989 struct tuner_custom_parameter_s param
= {0};
990 struct poseidon_control
*control
= NULL
;
991 struct front_face
*front
= fh
;
992 struct poseidon
*pd
= front
->pd
;
993 s32 ret
= 0, cmd_status
, params
;
995 control
= check_control_id(a
->id
);
999 param
.param_value
= a
->value
;
1000 param
.param_id
= control
->vc_id
;
1001 params
= *(s32
*)¶m
; /* temp code */
1003 mutex_lock(&pd
->lock
);
1004 ret
= send_set_req(pd
, TUNER_CUSTOM_PARAMETER
, params
, &cmd_status
);
1005 ret
= send_set_req(pd
, TAKE_REQUEST
, 0, &cmd_status
);
1006 mutex_unlock(&pd
->lock
);
1008 set_current_state(TASK_INTERRUPTIBLE
);
1009 schedule_timeout(HZ
/4);
1014 static int vidioc_enumaudio(struct file
*file
, void *fh
, struct v4l2_audio
*a
)
1018 a
->capability
= V4L2_AUDCAP_STEREO
;
1019 strcpy(a
->name
, "USB audio in");
1020 /*Poseidon have no AVL function.*/
1025 static int vidioc_g_audio(struct file
*file
, void *fh
, struct v4l2_audio
*a
)
1028 a
->capability
= V4L2_AUDCAP_STEREO
;
1029 strcpy(a
->name
, "USB audio in");
1034 static int vidioc_s_audio(struct file
*file
, void *fh
, struct v4l2_audio
*a
)
1036 return (0 == a
->index
) ? 0 : -EINVAL
;
1040 static int vidioc_g_tuner(struct file
*file
, void *fh
, struct v4l2_tuner
*tuner
)
1042 struct front_face
*front
= fh
;
1043 struct poseidon
*pd
= front
->pd
;
1044 struct tuner_atv_sig_stat_s atv_stat
;
1045 s32 count
= 5, ret
, cmd_status
;
1048 if (0 != tuner
->index
)
1051 mutex_lock(&pd
->lock
);
1052 ret
= send_get_req(pd
, TUNER_STATUS
, TLG_MODE_ANALOG_TV
,
1053 &atv_stat
, &cmd_status
, sizeof(atv_stat
));
1055 while (atv_stat
.sig_lock_busy
&& count
-- && !ret
) {
1056 set_current_state(TASK_INTERRUPTIBLE
);
1057 schedule_timeout(HZ
);
1059 ret
= send_get_req(pd
, TUNER_STATUS
, TLG_MODE_ANALOG_TV
,
1060 &atv_stat
, &cmd_status
, sizeof(atv_stat
));
1062 mutex_unlock(&pd
->lock
);
1065 log("P:%d,S:%d", atv_stat
.sig_present
, atv_stat
.sig_strength
);
1067 if (ret
|| cmd_status
)
1069 else if (atv_stat
.sig_present
&& !atv_stat
.sig_strength
)
1070 tuner
->signal
= 0xFFFF;
1072 tuner
->signal
= (atv_stat
.sig_strength
* 255 / 10) << 8;
1074 strcpy(tuner
->name
, "Telegent Systems");
1075 tuner
->type
= V4L2_TUNER_ANALOG_TV
;
1076 tuner
->rangelow
= TUNER_FREQ_MIN
/ 62500;
1077 tuner
->rangehigh
= TUNER_FREQ_MAX
/ 62500;
1078 tuner
->capability
= V4L2_TUNER_CAP_NORM
| V4L2_TUNER_CAP_STEREO
|
1079 V4L2_TUNER_CAP_LANG1
| V4L2_TUNER_CAP_LANG2
;
1080 index
= pd
->video_data
.context
.audio_idx
;
1081 tuner
->rxsubchans
= pd_audio_modes
[index
].v4l2_audio_sub
;
1082 tuner
->audmode
= pd_audio_modes
[index
].v4l2_audio_mode
;
1088 static int pd_vidioc_s_tuner(struct poseidon
*pd
, int index
)
1090 s32 ret
= 0, cmd_status
, param
, audiomode
;
1092 mutex_lock(&pd
->lock
);
1093 param
= pd_audio_modes
[index
].tlg_audio_mode
;
1094 ret
= send_set_req(pd
, TUNER_AUD_MODE
, param
, &cmd_status
);
1095 audiomode
= get_audio_std(pd
->video_data
.context
.tvnormid
);
1096 ret
|= send_set_req(pd
, TUNER_AUD_ANA_STD
, audiomode
,
1099 pd
->video_data
.context
.audio_idx
= index
;
1100 mutex_unlock(&pd
->lock
);
1104 static int vidioc_s_tuner(struct file
*file
, void *fh
, struct v4l2_tuner
*a
)
1106 struct front_face
*front
= fh
;
1107 struct poseidon
*pd
= front
->pd
;
1113 for (index
= 0; index
< POSEIDON_AUDIOMODS
; index
++)
1114 if (a
->audmode
== pd_audio_modes
[index
].v4l2_audio_mode
)
1115 return pd_vidioc_s_tuner(pd
, index
);
1119 static int vidioc_g_frequency(struct file
*file
, void *fh
,
1120 struct v4l2_frequency
*freq
)
1122 struct front_face
*front
= fh
;
1123 struct poseidon
*pd
= front
->pd
;
1124 struct running_context
*context
= &pd
->video_data
.context
;
1126 if (0 != freq
->tuner
)
1128 freq
->frequency
= context
->freq
;
1129 freq
->type
= V4L2_TUNER_ANALOG_TV
;
1133 static int set_frequency(struct poseidon
*pd
, __u32 frequency
)
1135 s32 ret
= 0, param
, cmd_status
;
1136 struct running_context
*context
= &pd
->video_data
.context
;
1138 param
= frequency
* 62500 / 1000;
1139 if (param
< TUNER_FREQ_MIN
/1000 || param
> TUNER_FREQ_MAX
/ 1000)
1142 mutex_lock(&pd
->lock
);
1143 ret
= send_set_req(pd
, TUNE_FREQ_SELECT
, param
, &cmd_status
);
1144 ret
= send_set_req(pd
, TAKE_REQUEST
, 0, &cmd_status
);
1146 msleep(250); /* wait for a while until the hardware is ready. */
1147 context
->freq
= frequency
;
1148 mutex_unlock(&pd
->lock
);
1152 static int vidioc_s_frequency(struct file
*file
, void *fh
,
1153 struct v4l2_frequency
*freq
)
1155 struct front_face
*front
= fh
;
1156 struct poseidon
*pd
= front
->pd
;
1160 pd
->pm_suspend
= pm_video_suspend
;
1161 pd
->pm_resume
= pm_video_resume
;
1163 return set_frequency(pd
, freq
->frequency
);
1166 static int vidioc_reqbufs(struct file
*file
, void *fh
,
1167 struct v4l2_requestbuffers
*b
)
1169 struct front_face
*front
= file
->private_data
;
1171 return videobuf_reqbufs(&front
->q
, b
);
1174 static int vidioc_querybuf(struct file
*file
, void *fh
, struct v4l2_buffer
*b
)
1176 struct front_face
*front
= file
->private_data
;
1178 return videobuf_querybuf(&front
->q
, b
);
1181 static int vidioc_qbuf(struct file
*file
, void *fh
, struct v4l2_buffer
*b
)
1183 struct front_face
*front
= file
->private_data
;
1184 return videobuf_qbuf(&front
->q
, b
);
1187 static int vidioc_dqbuf(struct file
*file
, void *fh
, struct v4l2_buffer
*b
)
1189 struct front_face
*front
= file
->private_data
;
1190 return videobuf_dqbuf(&front
->q
, b
, file
->f_flags
& O_NONBLOCK
);
1193 /* Just stop the URBs, do not free the URBs */
1194 static int usb_transfer_stop(struct video_data
*video
)
1196 if (video
->is_streaming
) {
1199 struct poseidon
*pd
= video
->pd
;
1201 video
->is_streaming
= 0;
1202 for (i
= 0; i
< SBUF_NUM
; ++i
) {
1203 if (video
->urb_array
[i
])
1204 usb_kill_urb(video
->urb_array
[i
]);
1207 send_set_req(pd
, PLAY_SERVICE
, TLG_TUNE_PLAY_SVC_STOP
,
1213 int stop_all_video_stream(struct poseidon
*pd
)
1215 struct video_data
*video
= &pd
->video_data
;
1216 struct vbi_data
*vbi
= &pd
->vbi_data
;
1218 mutex_lock(&pd
->lock
);
1219 if (video
->is_streaming
) {
1220 struct front_face
*front
= video
->front
;
1223 usb_transfer_stop(video
);
1224 free_all_urb(video
);
1226 /* stop the host side of VIDEO */
1227 videobuf_stop(&front
->q
);
1228 videobuf_mmap_free(&front
->q
);
1230 /* stop the host side of VBI */
1233 videobuf_stop(&front
->q
);
1234 videobuf_mmap_free(&front
->q
);
1237 mutex_unlock(&pd
->lock
);
1242 * The bubbles can seriously damage the video's quality,
1243 * though it occurs in very rare situation.
1245 static void iso_bubble_handler(struct work_struct
*w
)
1247 struct video_data
*video
;
1248 struct poseidon
*pd
;
1250 video
= container_of(w
, struct video_data
, bubble_work
);
1253 mutex_lock(&pd
->lock
);
1254 usb_transfer_stop(video
);
1256 start_video_stream(pd
);
1257 mutex_unlock(&pd
->lock
);
1261 static int vidioc_streamon(struct file
*file
, void *fh
,
1262 enum v4l2_buf_type type
)
1264 struct front_face
*front
= fh
;
1267 if (unlikely(type
!= front
->type
))
1269 return videobuf_streamon(&front
->q
);
1272 static int vidioc_streamoff(struct file
*file
, void *fh
,
1273 enum v4l2_buf_type type
)
1275 struct front_face
*front
= file
->private_data
;
1278 if (unlikely(type
!= front
->type
))
1280 return videobuf_streamoff(&front
->q
);
1283 /* Set the firmware's default values : need altersetting */
1284 static int pd_video_checkmode(struct poseidon
*pd
)
1286 s32 ret
= 0, cmd_status
, audiomode
;
1288 set_current_state(TASK_INTERRUPTIBLE
);
1289 schedule_timeout(HZ
/2);
1291 /* choose the altersetting */
1292 ret
= usb_set_interface(pd
->udev
, 0,
1293 (pd
->cur_transfer_mode
?
1294 ISO_3K_BULK_ALTERNATE_IFACE
:
1295 BULK_ALTERNATE_IFACE
));
1299 /* set default parameters for PAL-D , with the VBI enabled*/
1300 ret
= set_tuner_mode(pd
, TLG_MODE_ANALOG_TV
);
1301 ret
|= send_set_req(pd
, SGNL_SRC_SEL
,
1302 TLG_SIG_SRC_ANTENNA
, &cmd_status
);
1303 ret
|= send_set_req(pd
, VIDEO_STD_SEL
,
1304 TLG_TUNE_VSTD_PAL_D
, &cmd_status
);
1305 ret
|= send_set_req(pd
, VIDEO_STREAM_FMT_SEL
,
1306 TLG_TUNER_VID_FORMAT_YUV
, &cmd_status
);
1307 ret
|= send_set_req(pd
, VIDEO_ROSOLU_SEL
,
1308 TLG_TUNE_VID_RES_720
, &cmd_status
);
1309 ret
|= send_set_req(pd
, TUNE_FREQ_SELECT
, TUNER_FREQ_MIN
, &cmd_status
);
1310 ret
|= send_set_req(pd
, VBI_DATA_SEL
, 1, &cmd_status
);/* enable vbi */
1313 audiomode
= get_audio_std(pd
->video_data
.context
.tvnormid
);
1314 ret
|= send_set_req(pd
, TUNER_AUD_ANA_STD
, audiomode
, &cmd_status
);
1315 ret
|= send_set_req(pd
, TUNER_AUD_MODE
,
1316 TLG_TUNE_TVAUDIO_MODE_STEREO
, &cmd_status
);
1317 ret
|= send_set_req(pd
, AUDIO_SAMPLE_RATE_SEL
,
1318 ATV_AUDIO_RATE_48K
, &cmd_status
);
1324 static int pm_video_suspend(struct poseidon
*pd
)
1327 pm_alsa_suspend(pd
);
1329 /* stop and free all the URBs */
1330 usb_transfer_stop(&pd
->video_data
);
1331 free_all_urb(&pd
->video_data
);
1333 /* reset the interface */
1334 usb_set_interface(pd
->udev
, 0, 0);
1339 static int restore_v4l2_context(struct poseidon
*pd
,
1340 struct running_context
*context
)
1342 struct front_face
*front
= pd
->video_data
.front
;
1344 pd_video_checkmode(pd
);
1346 set_std(pd
, &context
->tvnormid
);
1347 vidioc_s_input(NULL
, front
, context
->sig_index
);
1348 pd_vidioc_s_tuner(pd
, context
->audio_idx
);
1349 pd_vidioc_s_fmt(pd
, &context
->pix
);
1350 set_frequency(pd
, context
->freq
);
1354 static int pm_video_resume(struct poseidon
*pd
)
1356 struct video_data
*video
= &pd
->video_data
;
1358 /* resume the video */
1359 /* [1] restore the origin V4L2 parameters */
1360 restore_v4l2_context(pd
, &video
->context
);
1362 /* [2] initiate video copy variables */
1363 if (video
->front
->curr_frame
)
1364 init_copy(video
, 0);
1367 start_video_stream(pd
);
1369 /* resume the audio */
1375 void set_debug_mode(struct video_device
*vfd
, int debug_mode
)
1378 if (debug_mode
& 0x1)
1379 vfd
->debug
= V4L2_DEBUG_IOCTL
;
1380 if (debug_mode
& 0x2)
1381 vfd
->debug
= V4L2_DEBUG_IOCTL
| V4L2_DEBUG_IOCTL_ARG
;
1384 static void init_video_context(struct running_context
*context
)
1386 context
->sig_index
= 0;
1387 context
->audio_idx
= 1; /* stereo */
1388 context
->tvnormid
= V4L2_STD_PAL_D
;
1389 context
->pix
= (struct v4l2_pix_format
) {
1392 .pixelformat
= V4L2_PIX_FMT_YUYV
,
1393 .field
= V4L2_FIELD_INTERLACED
,
1394 .bytesperline
= 720 * 2,
1395 .sizeimage
= 720 * 576 * 2,
1396 .colorspace
= V4L2_COLORSPACE_SMPTE170M
,
1401 static int pd_video_open(struct file
*file
)
1403 struct video_device
*vfd
= video_devdata(file
);
1404 struct poseidon
*pd
= video_get_drvdata(vfd
);
1405 struct front_face
*front
= NULL
;
1408 mutex_lock(&pd
->lock
);
1409 usb_autopm_get_interface(pd
->interface
);
1411 if (vfd
->vfl_type
== VFL_TYPE_GRABBER
1412 && !(pd
->state
& POSEIDON_STATE_ANALOG
)) {
1413 front
= kzalloc(sizeof(struct front_face
), GFP_KERNEL
);
1417 pd
->cur_transfer_mode
= usb_transfer_mode
;/* bulk or iso */
1418 init_video_context(&pd
->video_data
.context
);
1420 ret
= pd_video_checkmode(pd
);
1427 pd
->state
|= POSEIDON_STATE_ANALOG
;
1428 front
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1429 pd
->video_data
.users
++;
1430 set_debug_mode(vfd
, debug_mode
);
1432 videobuf_queue_vmalloc_init(&front
->q
, &pd_video_qops
,
1433 NULL
, &front
->queue_lock
,
1434 V4L2_BUF_TYPE_VIDEO_CAPTURE
,
1435 V4L2_FIELD_INTERLACED
,/* video is interlacd */
1436 sizeof(struct videobuf_buffer
),/*it's enough*/
1438 } else if (vfd
->vfl_type
== VFL_TYPE_VBI
1439 && !(pd
->state
& POSEIDON_STATE_VBI
)) {
1440 front
= kzalloc(sizeof(struct front_face
), GFP_KERNEL
);
1444 pd
->state
|= POSEIDON_STATE_VBI
;
1445 front
->type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
1446 pd
->vbi_data
.front
= front
;
1447 pd
->vbi_data
.users
++;
1449 videobuf_queue_vmalloc_init(&front
->q
, &pd_video_qops
,
1450 NULL
, &front
->queue_lock
,
1451 V4L2_BUF_TYPE_VBI_CAPTURE
,
1452 V4L2_FIELD_NONE
, /* vbi is NONE mode */
1453 sizeof(struct videobuf_buffer
),
1456 /* maybe add FM support here */
1463 front
->curr_frame
= NULL
;
1464 INIT_LIST_HEAD(&front
->active
);
1465 spin_lock_init(&front
->queue_lock
);
1467 file
->private_data
= front
;
1468 kref_get(&pd
->kref
);
1470 mutex_unlock(&pd
->lock
);
1473 usb_autopm_put_interface(pd
->interface
);
1474 mutex_unlock(&pd
->lock
);
1478 static int pd_video_release(struct file
*file
)
1480 struct front_face
*front
= file
->private_data
;
1481 struct poseidon
*pd
= front
->pd
;
1485 mutex_lock(&pd
->lock
);
1487 if (front
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
1488 pd
->state
&= ~POSEIDON_STATE_ANALOG
;
1490 /* stop the device, and free the URBs */
1491 usb_transfer_stop(&pd
->video_data
);
1492 free_all_urb(&pd
->video_data
);
1494 /* stop the firmware */
1495 send_set_req(pd
, PLAY_SERVICE
, TLG_TUNE_PLAY_SVC_STOP
,
1498 pd
->file_for_stream
= NULL
;
1499 pd
->video_data
.users
--;
1500 } else if (front
->type
== V4L2_BUF_TYPE_VBI_CAPTURE
) {
1501 pd
->state
&= ~POSEIDON_STATE_VBI
;
1502 pd
->vbi_data
.front
= NULL
;
1503 pd
->vbi_data
.users
--;
1505 videobuf_stop(&front
->q
);
1506 videobuf_mmap_free(&front
->q
);
1508 usb_autopm_put_interface(pd
->interface
);
1509 mutex_unlock(&pd
->lock
);
1512 file
->private_data
= NULL
;
1513 kref_put(&pd
->kref
, poseidon_delete
);
1517 static int pd_video_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1519 struct front_face
*front
= file
->private_data
;
1520 return videobuf_mmap_mapper(&front
->q
, vma
);
1523 static unsigned int pd_video_poll(struct file
*file
, poll_table
*table
)
1525 struct front_face
*front
= file
->private_data
;
1526 return videobuf_poll_stream(file
, &front
->q
, table
);
1529 static ssize_t
pd_video_read(struct file
*file
, char __user
*buffer
,
1530 size_t count
, loff_t
*ppos
)
1532 struct front_face
*front
= file
->private_data
;
1533 return videobuf_read_stream(&front
->q
, buffer
, count
, ppos
,
1534 0, file
->f_flags
& O_NONBLOCK
);
1537 /* This struct works for both VIDEO and VBI */
1538 static const struct v4l2_file_operations pd_video_fops
= {
1539 .owner
= THIS_MODULE
,
1540 .open
= pd_video_open
,
1541 .release
= pd_video_release
,
1542 .read
= pd_video_read
,
1543 .poll
= pd_video_poll
,
1544 .mmap
= pd_video_mmap
,
1545 .ioctl
= video_ioctl2
, /* maybe changed in future */
1548 static const struct v4l2_ioctl_ops pd_video_ioctl_ops
= {
1549 .vidioc_querycap
= vidioc_querycap
,
1552 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt
,
1553 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt
,
1554 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt
,
1555 .vidioc_g_fmt_vbi_cap
= vidioc_g_fmt_vbi
, /* VBI */
1556 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt
,
1559 .vidioc_g_input
= vidioc_g_input
,
1560 .vidioc_s_input
= vidioc_s_input
,
1561 .vidioc_enum_input
= vidioc_enum_input
,
1564 .vidioc_enumaudio
= vidioc_enumaudio
,
1565 .vidioc_g_audio
= vidioc_g_audio
,
1566 .vidioc_s_audio
= vidioc_s_audio
,
1569 .vidioc_g_tuner
= vidioc_g_tuner
,
1570 .vidioc_s_tuner
= vidioc_s_tuner
,
1571 .vidioc_s_std
= vidioc_s_std
,
1572 .vidioc_g_frequency
= vidioc_g_frequency
,
1573 .vidioc_s_frequency
= vidioc_s_frequency
,
1575 /* Buffer handlers */
1576 .vidioc_reqbufs
= vidioc_reqbufs
,
1577 .vidioc_querybuf
= vidioc_querybuf
,
1578 .vidioc_qbuf
= vidioc_qbuf
,
1579 .vidioc_dqbuf
= vidioc_dqbuf
,
1582 .vidioc_streamon
= vidioc_streamon
,
1583 .vidioc_streamoff
= vidioc_streamoff
,
1585 /* Control handling */
1586 .vidioc_queryctrl
= vidioc_queryctrl
,
1587 .vidioc_g_ctrl
= vidioc_g_ctrl
,
1588 .vidioc_s_ctrl
= vidioc_s_ctrl
,
1591 static struct video_device pd_video_template
= {
1592 .name
= "Telegent-Video",
1593 .fops
= &pd_video_fops
,
1595 .release
= video_device_release
,
1596 .tvnorms
= V4L2_STD_ALL
,
1597 .ioctl_ops
= &pd_video_ioctl_ops
,
1600 struct video_device
*vdev_init(struct poseidon
*pd
, struct video_device
*tmp
)
1602 struct video_device
*vfd
;
1604 vfd
= video_device_alloc();
1609 vfd
->v4l2_dev
= &pd
->v4l2_dev
;
1610 /*vfd->parent = &(pd->udev->dev); */
1611 vfd
->release
= video_device_release
;
1612 video_set_drvdata(vfd
, pd
);
1616 void destroy_video_device(struct video_device
**v_dev
)
1618 struct video_device
*dev
= *v_dev
;
1623 if (video_is_registered(dev
))
1624 video_unregister_device(dev
);
1626 video_device_release(dev
);
1630 void pd_video_exit(struct poseidon
*pd
)
1632 struct video_data
*video
= &pd
->video_data
;
1633 struct vbi_data
*vbi
= &pd
->vbi_data
;
1635 destroy_video_device(&video
->v_dev
);
1636 destroy_video_device(&vbi
->v_dev
);
1640 int pd_video_init(struct poseidon
*pd
)
1642 struct video_data
*video
= &pd
->video_data
;
1643 struct vbi_data
*vbi
= &pd
->vbi_data
;
1646 video
->v_dev
= vdev_init(pd
, &pd_video_template
);
1647 if (video
->v_dev
== NULL
)
1650 ret
= video_register_device(video
->v_dev
, VFL_TYPE_GRABBER
, -1);
1654 /* VBI uses the same template as video */
1655 vbi
->v_dev
= vdev_init(pd
, &pd_video_template
);
1656 if (vbi
->v_dev
== NULL
) {
1660 ret
= video_register_device(vbi
->v_dev
, VFL_TYPE_VBI
, -1);
1663 log("register VIDEO/VBI devices");
1666 log("VIDEO/VBI devices register failed, : %d", ret
);