SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/video/tlg2300/pd-video.c

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