?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: rename usb_buffer_alloc() and usb_buffer_free() users
[firewire-audio.git] / drivers / media / video / tlg2300 / pd-video.c
blob7bc29065e1ad81d0933986961ab2606a6f5eeeab
1 #include <linux/fs.h>
2 #include <linux/vmalloc.h>
3 #include <linux/videodev2.h>
4 #include <linux/usb.h>
5 #include <linux/mm.h>
6 #include <linux/sched.h>
7 #include <linux/slab.h>
8
9 #include <media/v4l2-ioctl.h>
10 #include <media/v4l2-dev.h>
11
12 #include "pd-common.h"
13 #include "vendorcmds.h"
14
15 static int pm_video_suspend(struct poseidon *pd);
16 static int pm_video_resume(struct poseidon *pd);
17 static void iso_bubble_handler(struct work_struct *w);
18
19 int usb_transfer_mode;
20 module_param(usb_transfer_mode, int, 0644);
21 MODULE_PARM_DESC(usb_transfer_mode, "0 = Bulk, 1 = Isochronous");
22
23 static const struct poseidon_format poseidon_formats[] = {
24 { "YUV 422", V4L2_PIX_FMT_YUYV, 16, 0},
25 { "RGB565", V4L2_PIX_FMT_RGB565, 16, 0},
26 };
27
28 static const struct poseidon_tvnorm poseidon_tvnorms[] = {
29 { V4L2_STD_PAL_D, "PAL-D", TLG_TUNE_VSTD_PAL_D },
30 { V4L2_STD_PAL_B, "PAL-B", TLG_TUNE_VSTD_PAL_B },
31 { V4L2_STD_PAL_G, "PAL-G", TLG_TUNE_VSTD_PAL_G },
32 { V4L2_STD_PAL_H, "PAL-H", TLG_TUNE_VSTD_PAL_H },
33 { V4L2_STD_PAL_I, "PAL-I", TLG_TUNE_VSTD_PAL_I },
34 { V4L2_STD_PAL_M, "PAL-M", TLG_TUNE_VSTD_PAL_M },
35 { V4L2_STD_PAL_N, "PAL-N", TLG_TUNE_VSTD_PAL_N_COMBO },
36 { V4L2_STD_PAL_Nc, "PAL-Nc", TLG_TUNE_VSTD_PAL_N_COMBO },
37 { V4L2_STD_NTSC_M, "NTSC-M", TLG_TUNE_VSTD_NTSC_M },
38 { V4L2_STD_NTSC_M_JP, "NTSC-JP", TLG_TUNE_VSTD_NTSC_M_J },
39 { V4L2_STD_SECAM_B, "SECAM-B", TLG_TUNE_VSTD_SECAM_B },
40 { V4L2_STD_SECAM_D, "SECAM-D", TLG_TUNE_VSTD_SECAM_D },
41 { V4L2_STD_SECAM_G, "SECAM-G", TLG_TUNE_VSTD_SECAM_G },
42 { V4L2_STD_SECAM_H, "SECAM-H", TLG_TUNE_VSTD_SECAM_H },
43 { V4L2_STD_SECAM_K, "SECAM-K", TLG_TUNE_VSTD_SECAM_K },
44 { V4L2_STD_SECAM_K1, "SECAM-K1", TLG_TUNE_VSTD_SECAM_K1 },
45 { V4L2_STD_SECAM_L, "SECAM-L", TLG_TUNE_VSTD_SECAM_L },
46 { V4L2_STD_SECAM_LC, "SECAM-LC", TLG_TUNE_VSTD_SECAM_L1 },
47 };
48 static const unsigned int POSEIDON_TVNORMS = ARRAY_SIZE(poseidon_tvnorms);
49
50 struct pd_audio_mode {
51 u32 tlg_audio_mode;
52 u32 v4l2_audio_sub;
53 u32 v4l2_audio_mode;
54 };
55
56 static const struct pd_audio_mode pd_audio_modes[] = {
57 { TLG_TUNE_TVAUDIO_MODE_MONO, V4L2_TUNER_SUB_MONO,
58 V4L2_TUNER_MODE_MONO },
59 { TLG_TUNE_TVAUDIO_MODE_STEREO, V4L2_TUNER_SUB_STEREO,
60 V4L2_TUNER_MODE_STEREO },
61 { TLG_TUNE_TVAUDIO_MODE_LANG_A, V4L2_TUNER_SUB_LANG1,
62 V4L2_TUNER_MODE_LANG1 },
63 { TLG_TUNE_TVAUDIO_MODE_LANG_B, V4L2_TUNER_SUB_LANG2,
64 V4L2_TUNER_MODE_LANG2 },
65 { TLG_TUNE_TVAUDIO_MODE_LANG_C, V4L2_TUNER_SUB_LANG1,
66 V4L2_TUNER_MODE_LANG1_LANG2 }
67 };
68 static const unsigned int POSEIDON_AUDIOMODS = ARRAY_SIZE(pd_audio_modes);
69
70 struct pd_input {
71 char *name;
72 uint32_t tlg_src;
73 };
74
75 static const struct pd_input pd_inputs[] = {
76 { "TV Antenna", TLG_SIG_SRC_ANTENNA },
77 { "TV Cable", TLG_SIG_SRC_CABLE },
78 { "TV SVideo", TLG_SIG_SRC_SVIDEO },
79 { "TV Composite", TLG_SIG_SRC_COMPOSITE }
80 };
81 static const unsigned int POSEIDON_INPUTS = ARRAY_SIZE(pd_inputs);
82
83 struct poseidon_control {
84 struct v4l2_queryctrl v4l2_ctrl;
85 enum cmd_custom_param_id vc_id;
86 };
87
88 static struct poseidon_control controls[] = {
89 {
90 { V4L2_CID_BRIGHTNESS, V4L2_CTRL_TYPE_INTEGER,
91 "brightness", 0, 10000, 1, 100, 0, },
92 CUST_PARM_ID_BRIGHTNESS_CTRL
93 }, {
94 { V4L2_CID_CONTRAST, V4L2_CTRL_TYPE_INTEGER,
95 "contrast", 0, 10000, 1, 100, 0, },
96 CUST_PARM_ID_CONTRAST_CTRL,
97 }, {
98 { V4L2_CID_HUE, V4L2_CTRL_TYPE_INTEGER,
99 "hue", 0, 10000, 1, 100, 0, },
100 CUST_PARM_ID_HUE_CTRL,
101 }, {
102 { V4L2_CID_SATURATION, V4L2_CTRL_TYPE_INTEGER,
103 "saturation", 0, 10000, 1, 100, 0, },
104 CUST_PARM_ID_SATURATION_CTRL,
105 },
106 };
107
108 struct video_std_to_audio_std {
109 v4l2_std_id video_std;
110 int audio_std;
111 };
112
113 static const struct video_std_to_audio_std video_to_audio_map[] = {
114 /* country : { 27, 32, 33, 34, 36, 44, 45, 46, 47, 48, 64,
115 65, 86, 351, 352, 353, 354, 358, 372, 852, 972 } */
116 { (V4L2_STD_PAL_I | V4L2_STD_PAL_B | V4L2_STD_PAL_D |
117 V4L2_STD_SECAM_L | V4L2_STD_SECAM_D), TLG_TUNE_ASTD_NICAM },
118
119 /* country : { 1, 52, 54, 55, 886 } */
120 {V4L2_STD_NTSC_M | V4L2_STD_PAL_N | V4L2_STD_PAL_M, TLG_TUNE_ASTD_BTSC},
121
122 /* country : { 81 } */
123 { V4L2_STD_NTSC_M_JP, TLG_TUNE_ASTD_EIAJ },
124
125 /* other country : TLG_TUNE_ASTD_A2 */
126 };
127 static const unsigned int map_size = ARRAY_SIZE(video_to_audio_map);
128
129 static int get_audio_std(v4l2_std_id v4l2_std)
130 {
131 int i = 0;
132
133 for (; i < map_size; i++) {
134 if (v4l2_std & video_to_audio_map[i].video_std)
135 return video_to_audio_map[i].audio_std;
136 }
137 return TLG_TUNE_ASTD_A2;
138 }
139
140 static int vidioc_querycap(struct file *file, void *fh,
141 struct v4l2_capability *cap)
142 {
143 struct front_face *front = fh;
144 struct poseidon *p = front->pd;
145
146 logs(front);
147
148 strcpy(cap->driver, "tele-video");
149 strcpy(cap->card, "Telegent Poseidon");
150 usb_make_path(p->udev, cap->bus_info, sizeof(cap->bus_info));
151 cap->version = KERNEL_VERSION(0, 0, 1);
152 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TUNER |
153 V4L2_CAP_AUDIO | V4L2_CAP_STREAMING |
154 V4L2_CAP_READWRITE | V4L2_CAP_VBI_CAPTURE;
155 return 0;
156 }
157
158 /*====================================================================*/
159 static void init_copy(struct video_data *video, bool index)
160 {
161 struct front_face *front = video->front;
162
163 video->field_count = index;
164 video->lines_copied = 0;
165 video->prev_left = 0 ;
166 video->dst = (char *)videobuf_to_vmalloc(front->curr_frame)
167 + index * video->lines_size;
168 video->vbi->copied = 0; /* set it here */
169 }
170
171 static bool get_frame(struct front_face *front, int *need_init)
172 {
173 struct videobuf_buffer *vb = front->curr_frame;
174
175 if (vb)
176 return true;
177
178 spin_lock(&front->queue_lock);
179 if (!list_empty(&front->active)) {
180 vb = list_entry(front->active.next,
181 struct videobuf_buffer, queue);
182 if (need_init)
183 *need_init = 1;
184 front->curr_frame = vb;
185 list_del_init(&vb->queue);
186 }
187 spin_unlock(&front->queue_lock);
188
189 return !!vb;
190 }
191
192 /* check if the video's buffer is ready */
193 static bool get_video_frame(struct front_face *front, struct video_data *video)
194 {
195 int need_init = 0;
196 bool ret = true;
197
198 ret = get_frame(front, &need_init);
199 if (ret && need_init)
200 init_copy(video, 0);
201 return ret;
202 }
203
204 static void submit_frame(struct front_face *front)
205 {
206 struct videobuf_buffer *vb = front->curr_frame;
207
208 if (vb == NULL)
209 return;
210
211 front->curr_frame = NULL;
212 vb->state = VIDEOBUF_DONE;
213 vb->field_count++;
214 do_gettimeofday(&vb->ts);
215
216 wake_up(&vb->done);
217 }
218
219 /*
220 * A frame is composed of two fields. If we receive all the two fields,
221 * call the submit_frame() to submit the whole frame to applications.
222 */
223 static void end_field(struct video_data *video)
224 {
225 /* logs(video->front); */
226 if (1 == video->field_count)
227 submit_frame(video->front);
228 else
229 init_copy(video, 1);
230 }
231
232 static void copy_video_data(struct video_data *video, char *src,
233 unsigned int count)
234 {
235 #define copy_data(len) \
236 do { \
237 if (++video->lines_copied > video->lines_per_field) \
238 goto overflow; \
239 memcpy(video->dst, src, len);\
240 video->dst += len + video->lines_size; \
241 src += len; \
242 count -= len; \
243 } while (0)
244
245 while (count && count >= video->lines_size) {
246 if (video->prev_left) {
247 copy_data(video->prev_left);
248 video->prev_left = 0;
249 continue;
250 }
251 copy_data(video->lines_size);
252 }
253 if (count && count < video->lines_size) {
254 memcpy(video->dst, src, count);
255
256 video->prev_left = video->lines_size - count;
257 video->dst += count;
258 }
259 return;
260
261 overflow:
262 end_field(video);
263 }
264
265 static void check_trailer(struct video_data *video, char *src, int count)
266 {
267 struct vbi_data *vbi = video->vbi;
268 int offset; /* trailer's offset */
269 char *buf;
270
271 offset = (video->context.pix.sizeimage / 2 + vbi->vbi_size / 2)
272 - (vbi->copied + video->lines_size * video->lines_copied);
273 if (video->prev_left)
274 offset -= (video->lines_size - video->prev_left);
275
276 if (offset > count || offset <= 0)
277 goto short_package;
278
279 buf = src + offset;
280
281 /* trailer : (VFHS) + U32 + U32 + field_num */
282 if (!strncmp(buf, "VFHS", 4)) {
283 int field_num = *((u32 *)(buf + 12));
284
285 if ((field_num & 1) ^ video->field_count) {
286 init_copy(video, video->field_count);
287 return;
288 }
289 copy_video_data(video, src, offset);
290 }
291 short_package:
292 end_field(video);
293 }
294
295 /* ========== Check this more carefully! =========== */
296 static inline void copy_vbi_data(struct vbi_data *vbi,
297 char *src, unsigned int count)
298 {
299 struct front_face *front = vbi->front;
300
301 if (front && get_frame(front, NULL)) {
302 char *buf = videobuf_to_vmalloc(front->curr_frame);
303
304 if (vbi->video->field_count)
305 buf += (vbi->vbi_size / 2);
306 memcpy(buf + vbi->copied, src, count);
307 }
308 vbi->copied += count;
309 }
310
311 /*
312 * Copy the normal data (VBI or VIDEO) without the trailer.
313 * VBI is not interlaced, while VIDEO is interlaced.
314 */
315 static inline void copy_vbi_video_data(struct video_data *video,
316 char *src, unsigned int count)
317 {
318 struct vbi_data *vbi = video->vbi;
319 unsigned int vbi_delta = (vbi->vbi_size / 2) - vbi->copied;
320
321 if (vbi_delta >= count) {
322 copy_vbi_data(vbi, src, count);
323 } else {
324 if (vbi_delta) {
325 copy_vbi_data(vbi, src, vbi_delta);
326
327 /* we receive the two fields of the VBI*/
328 if (vbi->front && video->field_count)
329 submit_frame(vbi->front);
330 }
331 copy_video_data(video, src + vbi_delta, count - vbi_delta);
332 }
333 }
334
335 static void urb_complete_bulk(struct urb *urb)
336 {
337 struct front_face *front = urb->context;
338 struct video_data *video = &front->pd->video_data;
339 char *src = (char *)urb->transfer_buffer;
340 int count = urb->actual_length;
341 int ret = 0;
342
343 if (!video->is_streaming || urb->status) {
344 if (urb->status == -EPROTO)
345 goto resend_it;
346 return;
347 }
348 if (!get_video_frame(front, video))
349 goto resend_it;
350
351 if (count == urb->transfer_buffer_length)
352 copy_vbi_video_data(video, src, count);
353 else
354 check_trailer(video, src, count);
355
356 resend_it:
357 ret = usb_submit_urb(urb, GFP_ATOMIC);
358 if (ret)
359 log(" submit failed: error %d", ret);
360 }
361
362 /************************* for ISO *********************/
363 #define GET_SUCCESS (0)
364 #define GET_TRAILER (1)
365 #define GET_TOO_MUCH_BUBBLE (2)
366 #define GET_NONE (3)
367 static int get_chunk(int start, struct urb *urb,
368 int *head, int *tail, int *bubble_err)
369 {
370 struct usb_iso_packet_descriptor *pkt = NULL;
371 int ret = GET_SUCCESS;
372
373 for (*head = *tail = -1; start < urb->number_of_packets; start++) {
374 pkt = &urb->iso_frame_desc[start];
375
376 /* handle the bubble of the Hub */
377 if (-EOVERFLOW == pkt->status) {
378 if (++*bubble_err > urb->number_of_packets / 3)
379 return GET_TOO_MUCH_BUBBLE;
380 continue;
381 }
382
383 /* This is the gap */
384 if (pkt->status || pkt->actual_length <= 0
385 || pkt->actual_length > ISO_PKT_SIZE) {
386 if (*head != -1)
387 break;
388 continue;
389 }
390
391 /* a good isochronous packet */
392 if (pkt->actual_length == ISO_PKT_SIZE) {
393 if (*head == -1)
394 *head = start;
395 *tail = start;
396 continue;
397 }
398
399 /* trailer is here */
400 if (pkt->actual_length < ISO_PKT_SIZE) {
401 if (*head == -1) {
402 *head = start;
403 *tail = start;
404 return GET_TRAILER;
405 }
406 break;
407 }
408 }
409
410 if (*head == -1 && *tail == -1)
411 ret = GET_NONE;
412 return ret;
413 }
414
415 /*
416 * |__|------|___|-----|_______|
417 * ^ ^
418 * | |
419 * gap gap
420 */
421 static void urb_complete_iso(struct urb *urb)
422 {
423 struct front_face *front = urb->context;
424 struct video_data *video = &front->pd->video_data;
425 int bubble_err = 0, head = 0, tail = 0;
426 char *src = (char *)urb->transfer_buffer;
427 int ret = 0;
428
429 if (!video->is_streaming)
430 return;
431
432 do {
433 if (!get_video_frame(front, video))
434 goto out;
435
436 switch (get_chunk(head, urb, &head, &tail, &bubble_err)) {
437 case GET_SUCCESS:
438 copy_vbi_video_data(video, src + (head * ISO_PKT_SIZE),
439 (tail - head + 1) * ISO_PKT_SIZE);
440 break;
441 case GET_TRAILER:
442 check_trailer(video, src + (head * ISO_PKT_SIZE),
443 ISO_PKT_SIZE);
444 break;
445 case GET_NONE:
446 goto out;
447 case GET_TOO_MUCH_BUBBLE:
448 log("\t We got too much bubble");
449 schedule_work(&video->bubble_work);
450 return;
451 }
452 } while (head = tail + 1, head < urb->number_of_packets);
453
454 out:
455 ret = usb_submit_urb(urb, GFP_ATOMIC);
456 if (ret)
457 log("usb_submit_urb err : %d", ret);
458 }
459 /*============================= [ end ] =====================*/
460
461 static int prepare_iso_urb(struct video_data *video)
462 {
463 struct usb_device *udev = video->pd->udev;
464 int i;
465
466 if (video->urb_array[0])
467 return 0;
468
469 for (i = 0; i < SBUF_NUM; i++) {
470 struct urb *urb;
471 void *mem;
472 int j;
473
474 urb = usb_alloc_urb(PK_PER_URB, GFP_KERNEL);
475 if (urb == NULL)
476 goto out;
477
478 video->urb_array[i] = urb;
479 mem = usb_alloc_coherent(udev,
480 ISO_PKT_SIZE * PK_PER_URB,
481 GFP_KERNEL,
482 &urb->transfer_dma);
483
484 urb->complete = urb_complete_iso; /* handler */
485 urb->dev = udev;
486 urb->context = video->front;
487 urb->pipe = usb_rcvisocpipe(udev,
488 video->endpoint_addr);
489 urb->interval = 1;
490 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
491 urb->number_of_packets = PK_PER_URB;
492 urb->transfer_buffer = mem;
493 urb->transfer_buffer_length = PK_PER_URB * ISO_PKT_SIZE;
494
495 for (j = 0; j < PK_PER_URB; j++) {
496 urb->iso_frame_desc[j].offset = ISO_PKT_SIZE * j;
497 urb->iso_frame_desc[j].length = ISO_PKT_SIZE;
498 }
499 }
500 return 0;
501 out:
502 for (; i > 0; i--)
503 ;
504 return -ENOMEM;
505 }
506
507 /* return the succeeded number of the allocation */
508 int alloc_bulk_urbs_generic(struct urb **urb_array, int num,
509 struct usb_device *udev, u8 ep_addr,
510 int buf_size, gfp_t gfp_flags,
511 usb_complete_t complete_fn, void *context)
512 {
513 struct urb *urb;
514 void *mem;
515 int i;
516
517 for (i = 0; i < num; i++) {
518 urb = usb_alloc_urb(0, gfp_flags);
519 if (urb == NULL)
520 return i;
521
522 mem = usb_alloc_coherent(udev, buf_size, gfp_flags,
523 &urb->transfer_dma);
524 if (mem == NULL)
525 return i;
526
527 usb_fill_bulk_urb(urb, udev, usb_rcvbulkpipe(udev, ep_addr),
528 mem, buf_size, complete_fn, context);
529 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
530 urb_array[i] = urb;
531 }
532 return i;
533 }
534
535 void free_all_urb_generic(struct urb **urb_array, int num)
536 {
537 int i;
538 struct urb *urb;
539
540 for (i = 0; i < num; i++) {
541 urb = urb_array[i];
542 if (urb) {
543 usb_free_coherent(urb->dev,
544 urb->transfer_buffer_length,
545 urb->transfer_buffer,
546 urb->transfer_dma);
547 usb_free_urb(urb);
548 urb_array[i] = NULL;
549 }
550 }
551 }
552
553 static int prepare_bulk_urb(struct video_data *video)
554 {
555 if (video->urb_array[0])
556 return 0;
557
558 alloc_bulk_urbs_generic(video->urb_array, SBUF_NUM,
559 video->pd->udev, video->endpoint_addr,
560 0x2000, GFP_KERNEL,
561 urb_complete_bulk, video->front);
562 return 0;
563 }
564
565 /* free the URBs */
566 static void free_all_urb(struct video_data *video)
567 {
568 free_all_urb_generic(video->urb_array, SBUF_NUM);
569 }
570
571 static void pd_buf_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
572 {
573 videobuf_vmalloc_free(vb);
574 vb->state = VIDEOBUF_NEEDS_INIT;
575 }
576
577 static void pd_buf_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
578 {
579 struct front_face *front = q->priv_data;
580 vb->state = VIDEOBUF_QUEUED;
581 list_add_tail(&vb->queue, &front->active);
582 }
583
584 static int pd_buf_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
585 enum v4l2_field field)
586 {
587 struct front_face *front = q->priv_data;
588 int rc;
589
590 switch (front->type) {
591 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
592 if (VIDEOBUF_NEEDS_INIT == vb->state) {
593 struct v4l2_pix_format *pix;
594
595 pix = &front->pd->video_data.context.pix;
596 vb->size = pix->sizeimage; /* real frame size */
597 vb->width = pix->width;
598 vb->height = pix->height;
599 rc = videobuf_iolock(q, vb, NULL);
600 if (rc < 0)
601 return rc;
602 }
603 break;
604 case V4L2_BUF_TYPE_VBI_CAPTURE:
605 if (VIDEOBUF_NEEDS_INIT == vb->state) {
606 vb->size = front->pd->vbi_data.vbi_size;
607 rc = videobuf_iolock(q, vb, NULL);
608 if (rc < 0)
609 return rc;
610 }
611 break;
612 default:
613 return -EINVAL;
614 }
615 vb->field = field;
616 vb->state = VIDEOBUF_PREPARED;
617 return 0;
618 }
619
620 int fire_all_urb(struct video_data *video)
621 {
622 int i, ret;
623
624 video->is_streaming = 1;
625
626 for (i = 0; i < SBUF_NUM; i++) {
627 ret = usb_submit_urb(video->urb_array[i], GFP_KERNEL);
628 if (ret)
629 log("(%d) failed: error %d", i, ret);
630 }
631 return ret;
632 }
633
634 static int start_video_stream(struct poseidon *pd)
635 {
636 struct video_data *video = &pd->video_data;
637 s32 cmd_status;
638
639 send_set_req(pd, TAKE_REQUEST, 0, &cmd_status);
640 send_set_req(pd, PLAY_SERVICE, TLG_TUNE_PLAY_SVC_START, &cmd_status);
641
642 if (pd->cur_transfer_mode) {
643 prepare_iso_urb(video);
644 INIT_WORK(&video->bubble_work, iso_bubble_handler);
645 } else {
646 /* The bulk mode does not need a bubble handler */
647 prepare_bulk_urb(video);
648 }
649 fire_all_urb(video);
650 return 0;
651 }
652
653 static int pd_buf_setup(struct videobuf_queue *q, unsigned int *count,
654 unsigned int *size)
655 {
656 struct front_face *front = q->priv_data;
657 struct poseidon *pd = front->pd;
658
659 switch (front->type) {
660 default:
661 return -EINVAL;
662 case V4L2_BUF_TYPE_VIDEO_CAPTURE: {
663 struct video_data *video = &pd->video_data;
664 struct v4l2_pix_format *pix = &video->context.pix;
665
666 *size = PAGE_ALIGN(pix->sizeimage);/* page aligned frame size */
667 if (*count < 4)
668 *count = 4;
669 if (1) {
670 /* same in different altersetting */
671 video->endpoint_addr = 0x82;
672 video->vbi = &pd->vbi_data;
673 video->vbi->video = video;
674 video->pd = pd;
675 video->lines_per_field = pix->height / 2;
676 video->lines_size = pix->width * 2;
677 video->front = front;
678 }
679 return start_video_stream(pd);
680 }
681
682 case V4L2_BUF_TYPE_VBI_CAPTURE: {
683 struct vbi_data *vbi = &pd->vbi_data;
684
685 *size = PAGE_ALIGN(vbi->vbi_size);
686 log("size : %d", *size);
687 if (*count == 0)
688 *count = 4;
689 }
690 break;
691 }
692 return 0;
693 }
694
695 static struct videobuf_queue_ops pd_video_qops = {
696 .buf_setup = pd_buf_setup,
697 .buf_prepare = pd_buf_prepare,
698 .buf_queue = pd_buf_queue,
699 .buf_release = pd_buf_release,
700 };
701
702 static int vidioc_enum_fmt(struct file *file, void *fh,
703 struct v4l2_fmtdesc *f)
704 {
705 if (ARRAY_SIZE(poseidon_formats) <= f->index)
706 return -EINVAL;
707 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
708 f->flags = 0;
709 f->pixelformat = poseidon_formats[f->index].fourcc;
710 strcpy(f->description, poseidon_formats[f->index].name);
711 return 0;
712 }
713
714 static int vidioc_g_fmt(struct file *file, void *fh, struct v4l2_format *f)
715 {
716 struct front_face *front = fh;
717 struct poseidon *pd = front->pd;
718
719 logs(front);
720 f->fmt.pix = pd->video_data.context.pix;
721 return 0;
722 }
723
724 static int vidioc_try_fmt(struct file *file, void *fh,
725 struct v4l2_format *f)
726 {
727 return 0;
728 }
729
730 /*
731 * VLC calls VIDIOC_S_STD before VIDIOC_S_FMT, while
732 * Mplayer calls them in the reverse order.
733 */
734 static int pd_vidioc_s_fmt(struct poseidon *pd, struct v4l2_pix_format *pix)
735 {
736 struct video_data *video = &pd->video_data;
737 struct running_context *context = &video->context;
738 struct v4l2_pix_format *pix_def = &context->pix;
739 s32 ret = 0, cmd_status = 0, vid_resol;
740
741 /* set the pixel format to firmware */
742 if (pix->pixelformat == V4L2_PIX_FMT_RGB565) {
743 vid_resol = TLG_TUNER_VID_FORMAT_RGB_565;
744 } else {
745 pix->pixelformat = V4L2_PIX_FMT_YUYV;
746 vid_resol = TLG_TUNER_VID_FORMAT_YUV;
747 }
748 ret = send_set_req(pd, VIDEO_STREAM_FMT_SEL,
749 vid_resol, &cmd_status);
750
751 /* set the resolution to firmware */
752 vid_resol = TLG_TUNE_VID_RES_720;
753 switch (pix->width) {
754 case 704:
755 vid_resol = TLG_TUNE_VID_RES_704;
756 break;
757 default:
758 pix->width = 720;
759 case 720:
760 break;
761 }
762 ret |= send_set_req(pd, VIDEO_ROSOLU_SEL,
763 vid_resol, &cmd_status);
764 if (ret || cmd_status) {
765 mutex_unlock(&pd->lock);
766 return -EBUSY;
767 }
768
769 pix_def->pixelformat = pix->pixelformat; /* save it */
770 pix->height = (context->tvnormid & V4L2_STD_525_60) ? 480 : 576;
771
772 /* Compare with the default setting */
773 if ((pix_def->width != pix->width)
774 || (pix_def->height != pix->height)) {
775 pix_def->width = pix->width;
776 pix_def->height = pix->height;
777 pix_def->bytesperline = pix->width * 2;
778 pix_def->sizeimage = pix->width * pix->height * 2;
779 }
780 *pix = *pix_def;
781
782 return 0;
783 }
784
785 static int vidioc_s_fmt(struct file *file, void *fh, struct v4l2_format *f)
786 {
787 struct front_face *front = fh;
788 struct poseidon *pd = front->pd;
789
790 logs(front);
791 /* stop VBI here */
792 if (V4L2_BUF_TYPE_VIDEO_CAPTURE != f->type)
793 return -EINVAL;
794
795 mutex_lock(&pd->lock);
796 if (pd->file_for_stream == NULL)
797 pd->file_for_stream = file;
798 else if (file != pd->file_for_stream) {
799 mutex_unlock(&pd->lock);
800 return -EINVAL;
801 }
802
803 pd_vidioc_s_fmt(pd, &f->fmt.pix);
804 mutex_unlock(&pd->lock);
805 return 0;
806 }
807
808 static int vidioc_g_fmt_vbi(struct file *file, void *fh,
809 struct v4l2_format *v4l2_f)
810 {
811 struct front_face *front = fh;
812 struct poseidon *pd = front->pd;
813 struct v4l2_vbi_format *vbi_fmt = &v4l2_f->fmt.vbi;
814
815 vbi_fmt->samples_per_line = 720 * 2;
816 vbi_fmt->sampling_rate = 6750000 * 4;
817 vbi_fmt->sample_format = V4L2_PIX_FMT_GREY;
818 vbi_fmt->offset = 64 * 4; /*FIXME: why offset */
819 if (pd->video_data.context.tvnormid & V4L2_STD_525_60) {
820 vbi_fmt->start[0] = 10;
821 vbi_fmt->start[1] = 264;
822 vbi_fmt->count[0] = V4L_NTSC_VBI_LINES;
823 vbi_fmt->count[1] = V4L_NTSC_VBI_LINES;
824 } else {
825 vbi_fmt->start[0] = 6;
826 vbi_fmt->start[1] = 314;
827 vbi_fmt->count[0] = V4L_PAL_VBI_LINES;
828 vbi_fmt->count[1] = V4L_PAL_VBI_LINES;
829 }
830 vbi_fmt->flags = V4L2_VBI_UNSYNC;
831 logs(front);
832 return 0;
833 }
834
835 static int set_std(struct poseidon *pd, v4l2_std_id *norm)
836 {
837 struct video_data *video = &pd->video_data;
838 struct vbi_data *vbi = &pd->vbi_data;
839 struct running_context *context;
840 struct v4l2_pix_format *pix;
841 s32 i, ret = 0, cmd_status, param;
842 int height;
843
844 for (i = 0; i < POSEIDON_TVNORMS; i++) {
845 if (*norm & poseidon_tvnorms[i].v4l2_id) {
846 param = poseidon_tvnorms[i].tlg_tvnorm;
847 log("name : %s", poseidon_tvnorms[i].name);
848 goto found;
849 }
850 }
851 return -EINVAL;
852 found:
853 mutex_lock(&pd->lock);
854 ret = send_set_req(pd, VIDEO_STD_SEL, param, &cmd_status);
855 if (ret || cmd_status)
856 goto out;
857
858 /* Set vbi size and check the height of the frame */
859 context = &video->context;
860 context->tvnormid = poseidon_tvnorms[i].v4l2_id;
861 if (context->tvnormid & V4L2_STD_525_60) {
862 vbi->vbi_size = V4L_NTSC_VBI_FRAMESIZE;
863 height = 480;
864 } else {
865 vbi->vbi_size = V4L_PAL_VBI_FRAMESIZE;
866 height = 576;
867 }
868
869 pix = &context->pix;
870 if (pix->height != height) {
871 pix->height = height;
872 pix->sizeimage = pix->width * pix->height * 2;
873 }
874
875 out:
876 mutex_unlock(&pd->lock);
877 return ret;
878 }
879
880 int vidioc_s_std(struct file *file, void *fh, v4l2_std_id *norm)
881 {
882 struct front_face *front = fh;
883 logs(front);
884 return set_std(front->pd, norm);
885 }
886
887 static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *in)
888 {
889 struct front_face *front = fh;
890
891 if (in->index < 0 || in->index >= POSEIDON_INPUTS)
892 return -EINVAL;
893 strcpy(in->name, pd_inputs[in->index].name);
894 in->type = V4L2_INPUT_TYPE_TUNER;
895
896 /*
897 * the audio input index mixed with this video input,
898 * Poseidon only have one audio/video, set to "0"
899 */
900 in->audioset = 0;
901 in->tuner = 0;
902 in->std = V4L2_STD_ALL;
903 in->status = 0;
904 logs(front);
905 return 0;
906 }
907
908 static int vidioc_g_input(struct file *file, void *fh, unsigned int *i)
909 {
910 struct front_face *front = fh;
911 struct poseidon *pd = front->pd;
912 struct running_context *context = &pd->video_data.context;
913
914 logs(front);
915 *i = context->sig_index;
916 return 0;
917 }
918
919 /* We can support several inputs */
920 static int vidioc_s_input(struct file *file, void *fh, unsigned int i)
921 {
922 struct front_face *front = fh;
923 struct poseidon *pd = front->pd;
924 s32 ret, cmd_status;
925
926 if (i < 0 || i >= POSEIDON_INPUTS)
927 return -EINVAL;
928 ret = send_set_req(pd, SGNL_SRC_SEL,
929 pd_inputs[i].tlg_src, &cmd_status);
930 if (ret)
931 return ret;
932
933 pd->video_data.context.sig_index = i;
934 return 0;
935 }
936
937 static struct poseidon_control *check_control_id(__u32 id)
938 {
939 struct poseidon_control *control = &controls[0];
940 int array_size = ARRAY_SIZE(controls);
941
942 for (; control < &controls[array_size]; control++)
943 if (control->v4l2_ctrl.id == id)
944 return control;
945 return NULL;
946 }
947
948 static int vidioc_queryctrl(struct file *file, void *fh,
949 struct v4l2_queryctrl *a)
950 {
951 struct poseidon_control *control = NULL;
952
953 control = check_control_id(a->id);
954 if (!control)
955 return -EINVAL;
956
957 *a = control->v4l2_ctrl;
958 return 0;
959 }
960
961 static int vidioc_g_ctrl(struct file *file, void *fh, struct v4l2_control *ctrl)
962 {
963 struct front_face *front = fh;
964 struct poseidon *pd = front->pd;
965 struct poseidon_control *control = NULL;
966 struct tuner_custom_parameter_s tuner_param;
967 s32 ret = 0, cmd_status;
968
969 control = check_control_id(ctrl->id);
970 if (!control)
971 return -EINVAL;
972
973 mutex_lock(&pd->lock);
974 ret = send_get_req(pd, TUNER_CUSTOM_PARAMETER, control->vc_id,
975 &tuner_param, &cmd_status, sizeof(tuner_param));
976 mutex_unlock(&pd->lock);
977
978 if (ret || cmd_status)
979 return -1;
980
981 ctrl->value = tuner_param.param_value;
982 return 0;
983 }
984
985 static int vidioc_s_ctrl(struct file *file, void *fh, struct v4l2_control *a)
986 {
987 struct tuner_custom_parameter_s param = {0};
988 struct poseidon_control *control = NULL;
989 struct front_face *front = fh;
990 struct poseidon *pd = front->pd;
991 s32 ret = 0, cmd_status, params;
992
993 control = check_control_id(a->id);
994 if (!control)
995 return -EINVAL;
996
997 param.param_value = a->value;
998 param.param_id = control->vc_id;
999 params = *(s32 *)&param; /* temp code */
1000
1001 mutex_lock(&pd->lock);
1002 ret = send_set_req(pd, TUNER_CUSTOM_PARAMETER, params, &cmd_status);
1003 ret = send_set_req(pd, TAKE_REQUEST, 0, &cmd_status);
1004 mutex_unlock(&pd->lock);
1005
1006 set_current_state(TASK_INTERRUPTIBLE);
1007 schedule_timeout(HZ/4);
1008 return ret;
1009 }
1010
1011 /* Audio ioctls */
1012 static int vidioc_enumaudio(struct file *file, void *fh, struct v4l2_audio *a)
1013 {
1014 if (0 != a->index)
1015 return -EINVAL;
1016 a->capability = V4L2_AUDCAP_STEREO;
1017 strcpy(a->name, "USB audio in");
1018 /*Poseidon have no AVL function.*/
1019 a->mode = 0;
1020 return 0;
1021 }
1022
1023 int vidioc_g_audio(struct file *file, void *fh, struct v4l2_audio *a)
1024 {
1025 a->index = 0;
1026 a->capability = V4L2_AUDCAP_STEREO;
1027 strcpy(a->name, "USB audio in");
1028 a->mode = 0;
1029 return 0;
1030 }
1031
1032 int vidioc_s_audio(struct file *file, void *fh, struct v4l2_audio *a)
1033 {
1034 return (0 == a->index) ? 0 : -EINVAL;
1035 }
1036
1037 /* Tuner ioctls */
1038 static int vidioc_g_tuner(struct file *file, void *fh, struct v4l2_tuner *tuner)
1039 {
1040 struct front_face *front = fh;
1041 struct poseidon *pd = front->pd;
1042 struct tuner_atv_sig_stat_s atv_stat;
1043 s32 count = 5, ret, cmd_status;
1044 int index;
1045
1046 if (0 != tuner->index)
1047 return -EINVAL;
1048
1049 mutex_lock(&pd->lock);
1050 ret = send_get_req(pd, TUNER_STATUS, TLG_MODE_ANALOG_TV,
1051 &atv_stat, &cmd_status, sizeof(atv_stat));
1052
1053 while (atv_stat.sig_lock_busy && count-- && !ret) {
1054 set_current_state(TASK_INTERRUPTIBLE);
1055 schedule_timeout(HZ);
1056
1057 ret = send_get_req(pd, TUNER_STATUS, TLG_MODE_ANALOG_TV,
1058 &atv_stat, &cmd_status, sizeof(atv_stat));
1059 }
1060 mutex_unlock(&pd->lock);
1061
1062 if (debug_mode)
1063 log("P:%d,S:%d", atv_stat.sig_present, atv_stat.sig_strength);
1064
1065 if (ret || cmd_status)
1066 tuner->signal = 0;
1067 else if (atv_stat.sig_present && !atv_stat.sig_strength)
1068 tuner->signal = 0xFFFF;
1069 else
1070 tuner->signal = (atv_stat.sig_strength * 255 / 10) << 8;
1071
1072 strcpy(tuner->name, "Telegent Systems");
1073 tuner->type = V4L2_TUNER_ANALOG_TV;
1074 tuner->rangelow = TUNER_FREQ_MIN / 62500;
1075 tuner->rangehigh = TUNER_FREQ_MAX / 62500;
1076 tuner->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO |
1077 V4L2_TUNER_CAP_LANG1 | V4L2_TUNER_CAP_LANG2;
1078 index = pd->video_data.context.audio_idx;
1079 tuner->rxsubchans = pd_audio_modes[index].v4l2_audio_sub;
1080 tuner->audmode = pd_audio_modes[index].v4l2_audio_mode;
1081 tuner->afc = 0;
1082 logs(front);
1083 return 0;
1084 }
1085
1086 static int pd_vidioc_s_tuner(struct poseidon *pd, int index)
1087 {
1088 s32 ret = 0, cmd_status, param, audiomode;
1089
1090 mutex_lock(&pd->lock);
1091 param = pd_audio_modes[index].tlg_audio_mode;
1092 ret = send_set_req(pd, TUNER_AUD_MODE, param, &cmd_status);
1093 audiomode = get_audio_std(pd->video_data.context.tvnormid);
1094 ret |= send_set_req(pd, TUNER_AUD_ANA_STD, audiomode,
1095 &cmd_status);
1096 if (!ret)
1097 pd->video_data.context.audio_idx = index;
1098 mutex_unlock(&pd->lock);
1099 return ret;
1100 }
1101
1102 static int vidioc_s_tuner(struct file *file, void *fh, struct v4l2_tuner *a)
1103 {
1104 struct front_face *front = fh;
1105 struct poseidon *pd = front->pd;
1106 int index;
1107
1108 if (0 != a->index)
1109 return -EINVAL;
1110 logs(front);
1111 for (index = 0; index < POSEIDON_AUDIOMODS; index++)
1112 if (a->audmode == pd_audio_modes[index].v4l2_audio_mode)
1113 return pd_vidioc_s_tuner(pd, index);
1114 return -EINVAL;
1115 }
1116
1117 static int vidioc_g_frequency(struct file *file, void *fh,
1118 struct v4l2_frequency *freq)
1119 {
1120 struct front_face *front = fh;
1121 struct poseidon *pd = front->pd;
1122 struct running_context *context = &pd->video_data.context;
1123
1124 if (0 != freq->tuner)
1125 return -EINVAL;
1126 freq->frequency = context->freq;
1127 freq->type = V4L2_TUNER_ANALOG_TV;
1128 return 0;
1129 }
1130
1131 static int set_frequency(struct poseidon *pd, __u32 frequency)
1132 {
1133 s32 ret = 0, param, cmd_status;
1134 struct running_context *context = &pd->video_data.context;
1135
1136 param = frequency * 62500 / 1000;
1137 if (param < TUNER_FREQ_MIN/1000 || param > TUNER_FREQ_MAX / 1000)
1138 return -EINVAL;
1139
1140 mutex_lock(&pd->lock);
1141 ret = send_set_req(pd, TUNE_FREQ_SELECT, param, &cmd_status);
1142 ret = send_set_req(pd, TAKE_REQUEST, 0, &cmd_status);
1143
1144 msleep(250); /* wait for a while until the hardware is ready. */
1145 context->freq = frequency;
1146 mutex_unlock(&pd->lock);
1147 return ret;
1148 }
1149
1150 static int vidioc_s_frequency(struct file *file, void *fh,
1151 struct v4l2_frequency *freq)
1152 {
1153 struct front_face *front = fh;
1154 struct poseidon *pd = front->pd;
1155
1156 logs(front);
1157 #ifdef CONFIG_PM
1158 pd->pm_suspend = pm_video_suspend;
1159 pd->pm_resume = pm_video_resume;
1160 #endif
1161 return set_frequency(pd, freq->frequency);
1162 }
1163
1164 static int vidioc_reqbufs(struct file *file, void *fh,
1165 struct v4l2_requestbuffers *b)
1166 {
1167 struct front_face *front = file->private_data;
1168 logs(front);
1169 return videobuf_reqbufs(&front->q, b);
1170 }
1171
1172 static int vidioc_querybuf(struct file *file, void *fh, struct v4l2_buffer *b)
1173 {
1174 struct front_face *front = file->private_data;
1175 logs(front);
1176 return videobuf_querybuf(&front->q, b);
1177 }
1178
1179 static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
1180 {
1181 struct front_face *front = file->private_data;
1182 return videobuf_qbuf(&front->q, b);
1183 }
1184
1185 static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
1186 {
1187 struct front_face *front = file->private_data;
1188 return videobuf_dqbuf(&front->q, b, file->f_flags & O_NONBLOCK);
1189 }
1190
1191 /* Just stop the URBs, do not free the URBs */
1192 int usb_transfer_stop(struct video_data *video)
1193 {
1194 if (video->is_streaming) {
1195 int i;
1196 s32 cmd_status;
1197 struct poseidon *pd = video->pd;
1198
1199 video->is_streaming = 0;
1200 for (i = 0; i < SBUF_NUM; ++i) {
1201 if (video->urb_array[i])
1202 usb_kill_urb(video->urb_array[i]);
1203 }
1204
1205 send_set_req(pd, PLAY_SERVICE, TLG_TUNE_PLAY_SVC_STOP,
1206 &cmd_status);
1207 }
1208 return 0;
1209 }
1210
1211 int stop_all_video_stream(struct poseidon *pd)
1212 {
1213 struct video_data *video = &pd->video_data;
1214 struct vbi_data *vbi = &pd->vbi_data;
1215
1216 mutex_lock(&pd->lock);
1217 if (video->is_streaming) {
1218 struct front_face *front = video->front;
1219
1220 /* stop the URBs */
1221 usb_transfer_stop(video);
1222 free_all_urb(video);
1223
1224 /* stop the host side of VIDEO */
1225 videobuf_stop(&front->q);
1226 videobuf_mmap_free(&front->q);
1227
1228 /* stop the host side of VBI */
1229 front = vbi->front;
1230 if (front) {
1231 videobuf_stop(&front->q);
1232 videobuf_mmap_free(&front->q);
1233 }
1234 }
1235 mutex_unlock(&pd->lock);
1236 return 0;
1237 }
1238
1239 /*
1240 * The bubbles can seriously damage the video's quality,
1241 * though it occurs in very rare situation.
1242 */
1243 static void iso_bubble_handler(struct work_struct *w)
1244 {
1245 struct video_data *video;
1246 struct poseidon *pd;
1247
1248 video = container_of(w, struct video_data, bubble_work);
1249 pd = video->pd;
1250
1251 mutex_lock(&pd->lock);
1252 usb_transfer_stop(video);
1253 msleep(500);
1254 start_video_stream(pd);
1255 mutex_unlock(&pd->lock);
1256 }
1257
1258
1259 static int vidioc_streamon(struct file *file, void *fh,
1260 enum v4l2_buf_type type)
1261 {
1262 struct front_face *front = fh;
1263
1264 logs(front);
1265 if (unlikely(type != front->type))
1266 return -EINVAL;
1267 return videobuf_streamon(&front->q);
1268 }
1269
1270 static int vidioc_streamoff(struct file *file, void *fh,
1271 enum v4l2_buf_type type)
1272 {
1273 struct front_face *front = file->private_data;
1274
1275 logs(front);
1276 if (unlikely(type != front->type))
1277 return -EINVAL;
1278 return videobuf_streamoff(&front->q);
1279 }
1280
1281 /* Set the firmware's default values : need altersetting */
1282 static int pd_video_checkmode(struct poseidon *pd)
1283 {
1284 s32 ret = 0, cmd_status, audiomode;
1285
1286 set_current_state(TASK_INTERRUPTIBLE);
1287 schedule_timeout(HZ/2);
1288
1289 /* choose the altersetting */
1290 ret = usb_set_interface(pd->udev, 0,
1291 (pd->cur_transfer_mode ?
1292 ISO_3K_BULK_ALTERNATE_IFACE :
1293 BULK_ALTERNATE_IFACE));
1294 if (ret < 0)
1295 goto error;
1296
1297 /* set default parameters for PAL-D , with the VBI enabled*/
1298 ret = set_tuner_mode(pd, TLG_MODE_ANALOG_TV);
1299 ret |= send_set_req(pd, SGNL_SRC_SEL,
1300 TLG_SIG_SRC_ANTENNA, &cmd_status);
1301 ret |= send_set_req(pd, VIDEO_STD_SEL,
1302 TLG_TUNE_VSTD_PAL_D, &cmd_status);
1303 ret |= send_set_req(pd, VIDEO_STREAM_FMT_SEL,
1304 TLG_TUNER_VID_FORMAT_YUV, &cmd_status);
1305 ret |= send_set_req(pd, VIDEO_ROSOLU_SEL,
1306 TLG_TUNE_VID_RES_720, &cmd_status);
1307 ret |= send_set_req(pd, TUNE_FREQ_SELECT, TUNER_FREQ_MIN, &cmd_status);
1308 ret |= send_set_req(pd, VBI_DATA_SEL, 1, &cmd_status);/* enable vbi */
1309
1310 /* set the audio */
1311 audiomode = get_audio_std(pd->video_data.context.tvnormid);
1312 ret |= send_set_req(pd, TUNER_AUD_ANA_STD, audiomode, &cmd_status);
1313 ret |= send_set_req(pd, TUNER_AUD_MODE,
1314 TLG_TUNE_TVAUDIO_MODE_STEREO, &cmd_status);
1315 ret |= send_set_req(pd, AUDIO_SAMPLE_RATE_SEL,
1316 ATV_AUDIO_RATE_48K, &cmd_status);
1317 error:
1318 return ret;
1319 }
1320
1321 #ifdef CONFIG_PM
1322 static int pm_video_suspend(struct poseidon *pd)
1323 {
1324 /* stop audio */
1325 pm_alsa_suspend(pd);
1326
1327 /* stop and free all the URBs */
1328 usb_transfer_stop(&pd->video_data);
1329 free_all_urb(&pd->video_data);
1330
1331 /* reset the interface */
1332 usb_set_interface(pd->udev, 0, 0);
1333 msleep(300);
1334 return 0;
1335 }
1336
1337 static int restore_v4l2_context(struct poseidon *pd,
1338 struct running_context *context)
1339 {
1340 struct front_face *front = pd->video_data.front;
1341
1342 pd_video_checkmode(pd);
1343
1344 set_std(pd, &context->tvnormid);
1345 vidioc_s_input(NULL, front, context->sig_index);
1346 pd_vidioc_s_tuner(pd, context->audio_idx);
1347 pd_vidioc_s_fmt(pd, &context->pix);
1348 set_frequency(pd, context->freq);
1349 return 0;
1350 }
1351
1352 static int pm_video_resume(struct poseidon *pd)
1353 {
1354 struct video_data *video = &pd->video_data;
1355
1356 /* resume the video */
1357 /* [1] restore the origin V4L2 parameters */
1358 restore_v4l2_context(pd, &video->context);
1359
1360 /* [2] initiate video copy variables */
1361 if (video->front->curr_frame)
1362 init_copy(video, 0);
1363
1364 /* [3] fire urbs */
1365 start_video_stream(pd);
1366
1367 /* resume the audio */
1368 pm_alsa_resume(pd);
1369 return 0;
1370 }
1371 #endif
1372
1373 void set_debug_mode(struct video_device *vfd, int debug_mode)
1374 {
1375 vfd->debug = 0;
1376 if (debug_mode & 0x1)
1377 vfd->debug = V4L2_DEBUG_IOCTL;
1378 if (debug_mode & 0x2)
1379 vfd->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
1380 }
1381
1382 static void init_video_context(struct running_context *context)
1383 {
1384 context->sig_index = 0;
1385 context->audio_idx = 1; /* stereo */
1386 context->tvnormid = V4L2_STD_PAL_D;
1387 context->pix = (struct v4l2_pix_format) {
1388 .width = 720,
1389 .height = 576,
1390 .pixelformat = V4L2_PIX_FMT_YUYV,
1391 .field = V4L2_FIELD_INTERLACED,
1392 .bytesperline = 720 * 2,
1393 .sizeimage = 720 * 576 * 2,
1394 .colorspace = V4L2_COLORSPACE_SMPTE170M,
1395 .priv = 0
1396 };
1397 }
1398
1399 static int pd_video_open(struct file *file)
1400 {
1401 struct video_device *vfd = video_devdata(file);
1402 struct poseidon *pd = video_get_drvdata(vfd);
1403 struct front_face *front = NULL;
1404 int ret = -ENOMEM;
1405
1406 mutex_lock(&pd->lock);
1407 usb_autopm_get_interface(pd->interface);
1408
1409 if (vfd->vfl_type == VFL_TYPE_GRABBER
1410 && !(pd->state & POSEIDON_STATE_ANALOG)) {
1411 front = kzalloc(sizeof(struct front_face), GFP_KERNEL);
1412 if (!front)
1413 goto out;
1414
1415 pd->cur_transfer_mode = usb_transfer_mode;/* bulk or iso */
1416 init_video_context(&pd->video_data.context);
1417
1418 ret = pd_video_checkmode(pd);
1419 if (ret < 0) {
1420 kfree(front);
1421 ret = -1;
1422 goto out;
1423 }
1424
1425 pd->state |= POSEIDON_STATE_ANALOG;
1426 front->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1427 pd->video_data.users++;
1428 set_debug_mode(vfd, debug_mode);
1429
1430 videobuf_queue_vmalloc_init(&front->q, &pd_video_qops,
1431 NULL, &front->queue_lock,
1432 V4L2_BUF_TYPE_VIDEO_CAPTURE,
1433 V4L2_FIELD_INTERLACED,/* video is interlacd */
1434 sizeof(struct videobuf_buffer),/*it's enough*/
1435 front);
1436 } else if (vfd->vfl_type == VFL_TYPE_VBI
1437 && !(pd->state & POSEIDON_STATE_VBI)) {
1438 front = kzalloc(sizeof(struct front_face), GFP_KERNEL);
1439 if (!front)
1440 goto out;
1441
1442 pd->state |= POSEIDON_STATE_VBI;
1443 front->type = V4L2_BUF_TYPE_VBI_CAPTURE;
1444 pd->vbi_data.front = front;
1445 pd->vbi_data.users++;
1446
1447 videobuf_queue_vmalloc_init(&front->q, &pd_video_qops,
1448 NULL, &front->queue_lock,
1449 V4L2_BUF_TYPE_VBI_CAPTURE,
1450 V4L2_FIELD_NONE, /* vbi is NONE mode */
1451 sizeof(struct videobuf_buffer),
1452 front);
1453 } else {
1454 /* maybe add FM support here */
1455 log("other ");
1456 ret = -EINVAL;
1457 goto out;
1458 }
1459
1460 front->pd = pd;
1461 front->curr_frame = NULL;
1462 INIT_LIST_HEAD(&front->active);
1463 spin_lock_init(&front->queue_lock);
1464
1465 file->private_data = front;
1466 kref_get(&pd->kref);
1467
1468 mutex_unlock(&pd->lock);
1469 return 0;
1470 out:
1471 usb_autopm_put_interface(pd->interface);
1472 mutex_unlock(&pd->lock);
1473 return ret;
1474 }
1475
1476 static int pd_video_release(struct file *file)
1477 {
1478 struct front_face *front = file->private_data;
1479 struct poseidon *pd = front->pd;
1480 s32 cmd_status = 0;
1481
1482 logs(front);
1483 mutex_lock(&pd->lock);
1484
1485 if (front->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1486 pd->state &= ~POSEIDON_STATE_ANALOG;
1487
1488 /* stop the device, and free the URBs */
1489 usb_transfer_stop(&pd->video_data);
1490 free_all_urb(&pd->video_data);
1491
1492 /* stop the firmware */
1493 send_set_req(pd, PLAY_SERVICE, TLG_TUNE_PLAY_SVC_STOP,
1494 &cmd_status);
1495
1496 pd->file_for_stream = NULL;
1497 pd->video_data.users--;
1498 } else if (front->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1499 pd->state &= ~POSEIDON_STATE_VBI;
1500 pd->vbi_data.front = NULL;
1501 pd->vbi_data.users--;
1502 }
1503 videobuf_stop(&front->q);
1504 videobuf_mmap_free(&front->q);
1505
1506 usb_autopm_put_interface(pd->interface);
1507 mutex_unlock(&pd->lock);
1508
1509 kfree(front);
1510 file->private_data = NULL;
1511 kref_put(&pd->kref, poseidon_delete);
1512 return 0;
1513 }
1514
1515 static int pd_video_mmap(struct file *file, struct vm_area_struct *vma)
1516 {
1517 struct front_face *front = file->private_data;
1518 return videobuf_mmap_mapper(&front->q, vma);
1519 }
1520
1521 unsigned int pd_video_poll(struct file *file, poll_table *table)
1522 {
1523 struct front_face *front = file->private_data;
1524 return videobuf_poll_stream(file, &front->q, table);
1525 }
1526
1527 ssize_t pd_video_read(struct file *file, char __user *buffer,
1528 size_t count, loff_t *ppos)
1529 {
1530 struct front_face *front = file->private_data;
1531 return videobuf_read_stream(&front->q, buffer, count, ppos,
1532 0, file->f_flags & O_NONBLOCK);
1533 }
1534
1535 /* This struct works for both VIDEO and VBI */
1536 static const struct v4l2_file_operations pd_video_fops = {
1537 .owner = THIS_MODULE,
1538 .open = pd_video_open,
1539 .release = pd_video_release,
1540 .read = pd_video_read,
1541 .poll = pd_video_poll,
1542 .mmap = pd_video_mmap,
1543 .ioctl = video_ioctl2, /* maybe changed in future */
1544 };
1545
1546 static const struct v4l2_ioctl_ops pd_video_ioctl_ops = {
1547 .vidioc_querycap = vidioc_querycap,
1548
1549 /* Video format */
1550 .vidioc_g_fmt_vid_cap = vidioc_g_fmt,
1551 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt,
1552 .vidioc_s_fmt_vid_cap = vidioc_s_fmt,
1553 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi, /* VBI */
1554 .vidioc_try_fmt_vid_cap = vidioc_try_fmt,
1555
1556 /* Input */
1557 .vidioc_g_input = vidioc_g_input,
1558 .vidioc_s_input = vidioc_s_input,
1559 .vidioc_enum_input = vidioc_enum_input,
1560
1561 /* Audio ioctls */
1562 .vidioc_enumaudio = vidioc_enumaudio,
1563 .vidioc_g_audio = vidioc_g_audio,
1564 .vidioc_s_audio = vidioc_s_audio,
1565
1566 /* Tuner ioctls */
1567 .vidioc_g_tuner = vidioc_g_tuner,
1568 .vidioc_s_tuner = vidioc_s_tuner,
1569 .vidioc_s_std = vidioc_s_std,
1570 .vidioc_g_frequency = vidioc_g_frequency,
1571 .vidioc_s_frequency = vidioc_s_frequency,
1572
1573 /* Buffer handlers */
1574 .vidioc_reqbufs = vidioc_reqbufs,
1575 .vidioc_querybuf = vidioc_querybuf,
1576 .vidioc_qbuf = vidioc_qbuf,
1577 .vidioc_dqbuf = vidioc_dqbuf,
1578
1579 /* Stream on/off */
1580 .vidioc_streamon = vidioc_streamon,
1581 .vidioc_streamoff = vidioc_streamoff,
1582
1583 /* Control handling */
1584 .vidioc_queryctrl = vidioc_queryctrl,
1585 .vidioc_g_ctrl = vidioc_g_ctrl,
1586 .vidioc_s_ctrl = vidioc_s_ctrl,
1587 };
1588
1589 static struct video_device pd_video_template = {
1590 .name = "Telegent-Video",
1591 .fops = &pd_video_fops,
1592 .minor = -1,
1593 .release = video_device_release,
1594 .tvnorms = V4L2_STD_ALL,
1595 .ioctl_ops = &pd_video_ioctl_ops,
1596 };
1597
1598 struct video_device *vdev_init(struct poseidon *pd, struct video_device *tmp)
1599 {
1600 struct video_device *vfd;
1601
1602 vfd = video_device_alloc();
1603 if (vfd == NULL)
1604 return NULL;
1605 *vfd = *tmp;
1606 vfd->minor = -1;
1607 vfd->v4l2_dev = &pd->v4l2_dev;
1608 /*vfd->parent = &(pd->udev->dev); */
1609 vfd->release = video_device_release;
1610 video_set_drvdata(vfd, pd);
1611 return vfd;
1612 }
1613
1614 void destroy_video_device(struct video_device **v_dev)
1615 {
1616 struct video_device *dev = *v_dev;
1617
1618 if (dev == NULL)
1619 return;
1620
1621 if (video_is_registered(dev))
1622 video_unregister_device(dev);
1623 else
1624 video_device_release(dev);
1625 *v_dev = NULL;
1626 }
1627
1628 void pd_video_exit(struct poseidon *pd)
1629 {
1630 struct video_data *video = &pd->video_data;
1631 struct vbi_data *vbi = &pd->vbi_data;
1632
1633 destroy_video_device(&video->v_dev);
1634 destroy_video_device(&vbi->v_dev);
1635 log();
1636 }
1637
1638 int pd_video_init(struct poseidon *pd)
1639 {
1640 struct video_data *video = &pd->video_data;
1641 struct vbi_data *vbi = &pd->vbi_data;
1642 int ret = -ENOMEM;
1643
1644 video->v_dev = vdev_init(pd, &pd_video_template);
1645 if (video->v_dev == NULL)
1646 goto out;
1647
1648 ret = video_register_device(video->v_dev, VFL_TYPE_GRABBER, -1);
1649 if (ret != 0)
1650 goto out;
1651
1652 /* VBI uses the same template as video */
1653 vbi->v_dev = vdev_init(pd, &pd_video_template);
1654 if (vbi->v_dev == NULL) {
1655 ret = -ENOMEM;
1656 goto out;
1657 }
1658 ret = video_register_device(vbi->v_dev, VFL_TYPE_VBI, -1);
1659 if (ret != 0)
1660 goto out;
1661 log("register VIDEO/VBI devices");
1662 return 0;
1663 out:
1664 log("VIDEO/VBI devices register failed, : %d", ret);
1665 pd_video_exit(pd);
1666 return ret;
1667 }
1668
AMDTP streaming driver for the Linux FireWire stack (Juju)