git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/vivi.c

   1 /*
   2  * Virtual Video driver - This code emulates a real video device with v4l2 api
   3  *
   4  * Copyright (c) 2006 by:
   5  *      Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
   6  *      Ted Walther <ted--a.t--enumera.com>
   7  *      John Sokol <sokol--a.t--videotechnology.com>
   8  *      http://v4l.videotechnology.com/
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the BSD Licence, GNU General Public License
  12  * as published by the Free Software Foundation; either version 2 of the
  13  * License, or (at your option) any later version
  14  */
  15 #include <linux/module.h>
  16 #include <linux/delay.h>
  17 #include <linux/errno.h>
  18 #include <linux/fs.h>
  19 #include <linux/kernel.h>
  20 #include <linux/slab.h>
  21 #include <linux/mm.h>
  22 #include <linux/ioport.h>
  23 #include <linux/init.h>
  24 #include <linux/sched.h>
  25 #include <linux/pci.h>
  26 #include <linux/random.h>
  27 #include <linux/version.h>
  28 #include <linux/videodev2.h>
  29 #include <linux/interrupt.h>
  30 #include <media/video-buf.h>
  31 #include <media/v4l2-common.h>
  32 #include <linux/kthread.h>
  33 #include <linux/highmem.h>
  34
  35 /* Wake up at about 30 fps */
  36 #define WAKE_NUMERATOR 30
  37 #define WAKE_DENOMINATOR 1001
  38 #define BUFFER_TIMEOUT     msecs_to_jiffies(500)  /* 0.5 seconds */
  39
  40 /* These timers are for 1 fps - used only for testing */
  41 //#define WAKE_DENOMINATOR 30 /* hack for testing purposes */
  42 //#define BUFFER_TIMEOUT     msecs_to_jiffies(5000)  /* 5 seconds */
  43
  44 #include "font.h"
  45
  46 #ifndef kzalloc
  47 #define kzalloc(size, flags)                            \
  48 ({                                                      \
  49         void *__ret = kmalloc(size, flags);             \
  50         if (__ret)                                      \
  51                 memset(__ret, 0, size);                 \
  52         __ret;                                          \
  53 })
  54 #endif
  55
  56 MODULE_DESCRIPTION("Video Technology Magazine Virtual Video Capture Board");
  57 MODULE_AUTHOR("Mauro Carvalho Chehab, Ted Walther and John Sokol");
  58 MODULE_LICENSE("Dual BSD/GPL");
  59
  60 #define VIVI_MAJOR_VERSION 0
  61 #define VIVI_MINOR_VERSION 4
  62 #define VIVI_RELEASE 0
  63 #define VIVI_VERSION KERNEL_VERSION(VIVI_MAJOR_VERSION, VIVI_MINOR_VERSION, VIVI_RELEASE)
  64
  65 static int video_nr = -1;        /* /dev/videoN, -1 for autodetect */
  66 module_param(video_nr, int, 0);
  67
  68 static int debug = 0;
  69 module_param(debug, int, 0);
  70
  71 static unsigned int vid_limit = 16;
  72 module_param(vid_limit,int,0644);
  73 MODULE_PARM_DESC(vid_limit,"capture memory limit in megabytes");
  74
  75 /* supported controls */
  76 static struct v4l2_queryctrl vivi_qctrl[] = {
  77         {
  78                 .id            = V4L2_CID_AUDIO_VOLUME,
  79                 .name          = "Volume",
  80                 .minimum       = 0,
  81                 .maximum       = 65535,
  82                 .step          = 65535/100,
  83                 .default_value = 65535,
  84                 .flags         = 0,
  85                 .type          = V4L2_CTRL_TYPE_INTEGER,
  86         },{
  87                 .id            = V4L2_CID_BRIGHTNESS,
  88                 .type          = V4L2_CTRL_TYPE_INTEGER,
  89                 .name          = "Brightness",
  90                 .minimum       = 0,
  91                 .maximum       = 255,
  92                 .step          = 1,
  93                 .default_value = 127,
  94                 .flags         = 0,
  95         }, {
  96                 .id            = V4L2_CID_CONTRAST,
  97                 .type          = V4L2_CTRL_TYPE_INTEGER,
  98                 .name          = "Contrast",
  99                 .minimum       = 0,
 100                 .maximum       = 255,
 101                 .step          = 0x1,
 102                 .default_value = 0x10,
 103                 .flags         = 0,
 104         }, {
 105                 .id            = V4L2_CID_SATURATION,
 106                 .type          = V4L2_CTRL_TYPE_INTEGER,
 107                 .name          = "Saturation",
 108                 .minimum       = 0,
 109                 .maximum       = 255,
 110                 .step          = 0x1,
 111                 .default_value = 127,
 112                 .flags         = 0,
 113         }, {
 114                 .id            = V4L2_CID_HUE,
 115                 .type          = V4L2_CTRL_TYPE_INTEGER,
 116                 .name          = "Hue",
 117                 .minimum       = -128,
 118                 .maximum       = 127,
 119                 .step          = 0x1,
 120                 .default_value = 0,
 121                 .flags         = 0,
 122         }
 123 };
 124
 125 static int qctl_regs[ARRAY_SIZE(vivi_qctrl)];
 126
 127 #define dprintk(level,fmt, arg...)                           \
 128         do {                                                 \
 129                 if (debug >= (level))                        \
 130                         printk(KERN_DEBUG "vivi: " fmt , ## arg);    \
 131         } while (0)
 132
 133 /* ------------------------------------------------------------------
 134         Basic structures
 135    ------------------------------------------------------------------*/
 136
 137 struct vivi_fmt {
 138         char  *name;
 139         u32   fourcc;          /* v4l2 format id */
 140         int   depth;
 141 };
 142
 143 static struct vivi_fmt format = {
 144         .name     = "4:2:2, packed, YUYV",
 145         .fourcc   = V4L2_PIX_FMT_YUYV,
 146         .depth    = 16,
 147 };
 148
 149 struct sg_to_addr {
 150         int pos;
 151         struct scatterlist *sg;
 152 };
 153
 154 /* buffer for one video frame */
 155 struct vivi_buffer {
 156         /* common v4l buffer stuff -- must be first */
 157         struct videobuf_buffer vb;
 158
 159         struct vivi_fmt        *fmt;
 160
 161         struct sg_to_addr      *to_addr;
 162 };
 163
 164 struct vivi_dmaqueue {
 165         struct list_head       active;
 166         struct list_head       queued;
 167         struct timer_list      timeout;
 168
 169         /* thread for generating video stream*/
 170         struct task_struct         *kthread;
 171         wait_queue_head_t          wq;
 172         /* Counters to control fps rate */
 173         int                        frame;
 174         int                        ini_jiffies;
 175 };
 176
 177 static LIST_HEAD(vivi_devlist);
 178
 179 struct vivi_dev {
 180         struct list_head           vivi_devlist;
 181
 182         struct semaphore           lock;
 183
 184         int                        users;
 185
 186         /* various device info */
 187         unsigned int               resources;
 188         struct video_device        video_dev;
 189
 190         struct vivi_dmaqueue       vidq;
 191
 192         /* Several counters */
 193         int                        h,m,s,us,jiffies;
 194         char                       timestr[13];
 195 };
 196
 197 struct vivi_fh {
 198         struct vivi_dev            *dev;
 199
 200         /* video capture */
 201         struct vivi_fmt            *fmt;
 202         unsigned int               width,height;
 203         struct videobuf_queue      vb_vidq;
 204
 205         enum v4l2_buf_type         type;
 206 };
 207
 208 /* ------------------------------------------------------------------
 209         DMA and thread functions
 210    ------------------------------------------------------------------*/
 211
 212 /* Bars and Colors should match positions */
 213
 214 enum colors {
 215         WHITE,
 216         AMBAR,
 217         CYAN,
 218         GREEN,
 219         MAGENTA,
 220         RED,
 221         BLUE
 222 };
 223
 224 static u8 bars[8][3] = {
 225         /* R   G   B */
 226         {204,204,204},  /* white */
 227         {208,208,  0},  /* ambar */
 228         {  0,206,206},  /* cyan */
 229         {  0,239,  0},  /* green */
 230         {239,  0,239},  /* magenta */
 231         {205,  0,  0},  /* red */
 232         {  0,  0,255},  /* blue */
 233         {  0,  0,  0}
 234 };
 235
 236 #define TO_Y(r,g,b) (((16829*r +33039*g +6416*b  + 32768)>>16)+16)
 237 /* RGB to  V(Cr) Color transform */
 238 #define TO_V(r,g,b) (((28784*r -24103*g -4681*b  + 32768)>>16)+128)
 239 /* RGB to  U(Cb) Color transform */
 240 #define TO_U(r,g,b) (((-9714*r -19070*g +28784*b + 32768)>>16)+128)
 241
 242 #define TSTAMP_MIN_Y 24
 243 #define TSTAMP_MAX_Y TSTAMP_MIN_Y+15
 244 #define TSTAMP_MIN_X 64
 245
 246 void prep_to_addr(struct sg_to_addr to_addr[],struct videobuf_buffer *vb)
 247 {
 248         int i, pos=0;
 249
 250         for (i=0;i<vb->dma.nr_pages;i++) {
 251                 to_addr[i].sg=&vb->dma.sglist[i];
 252                 to_addr[i].pos=pos;
 253                 pos += vb->dma.sglist[i].length;
 254         }
 255 }
 256
 257 inline int get_addr_pos(int pos, int pages, struct sg_to_addr to_addr[])
 258 {
 259         int p1=0,p2=pages-1,p3=pages/2;
 260
 261         /* Sanity test */
 262         BUG_ON (pos>=to_addr[p2].pos+to_addr[p2].sg->length);
 263
 264         while (p1+1<p2) {
 265                 if (pos < to_addr[p3].pos) {
 266                         p2=p3;
 267                 } else {
 268                         p1=p3;
 269                 }
 270                 p3=(p1+p2)/2;
 271         }
 272         if (pos >= to_addr[p2].pos)
 273                 p1=p2;
 274
 275         return (p1);
 276 }
 277
 278 void gen_line(struct sg_to_addr to_addr[],int inipos,int pages,int wmax,
 279                                         int hmax, int line, char *timestr)
 280 {
 281         int  w,i,j,pos=inipos,pgpos,oldpg,y;
 282         char *p,*s,*basep;
 283         struct page *pg;
 284         u8   chr,r,g,b,color;
 285
 286         /* Get first addr pointed to pixel position */
 287         oldpg=get_addr_pos(pos,pages,to_addr);
 288         pg=pfn_to_page(to_addr[oldpg].sg->dma_address >> PAGE_SHIFT);
 289         basep = kmap_atomic(pg, KM_BOUNCE_READ)+to_addr[oldpg].sg->offset;
 290
 291         /* We will just duplicate the second pixel at the packet */
 292         wmax/=2;
 293
 294         /* Generate a standard color bar pattern */
 295         for (w=0;w<wmax;w++) {
 296                 r=bars[w*7/wmax][0];
 297                 g=bars[w*7/wmax][1];
 298                 b=bars[w*7/wmax][2];
 299
 300                 for (color=0;color<4;color++) {
 301                         pgpos=get_addr_pos(pos,pages,to_addr);
 302                         if (pgpos!=oldpg) {
 303                                 pg=pfn_to_page(to_addr[pgpos].sg->dma_address >> PAGE_SHIFT);
 304                                 kunmap_atomic(basep, KM_BOUNCE_READ);
 305                                 basep= kmap_atomic(pg, KM_BOUNCE_READ)+to_addr[pgpos].sg->offset;
 306                                 oldpg=pgpos;
 307                         }
 308                         p=basep+pos-to_addr[pgpos].pos;
 309
 310                         switch (color) {
 311                                 case 0:
 312                                 case 2:
 313                                         *p=TO_Y(r,g,b);         /* Luminance */
 314                                         break;
 315                                 case 1:
 316                                         *p=TO_U(r,g,b);         /* Cb */
 317                                         break;
 318                                 case 3:
 319                                         *p=TO_V(r,g,b);         /* Cr */
 320                                         break;
 321                         }
 322                         pos++;
 323                 }
 324         }
 325
 326         /* Checks if it is possible to show timestamp */
 327         if (TSTAMP_MAX_Y>=hmax)
 328                 goto end;
 329         if (TSTAMP_MIN_X+strlen(timestr)>=wmax)
 330                 goto end;
 331
 332         /* Print stream time */
 333         if (line>=TSTAMP_MIN_Y && line<=TSTAMP_MAX_Y) {
 334                 j=TSTAMP_MIN_X;
 335                 for (s=timestr;*s;s++) {
 336                         chr=rom8x16_bits[(*s-0x30)*16+line-TSTAMP_MIN_Y];
 337                         for (i=0;i<7;i++) {
 338                                 if (chr&1<<(7-i)) { /* Font color*/
 339                                         r=bars[BLUE][0];
 340                                         g=bars[BLUE][1];
 341                                         b=bars[BLUE][2];
 342                                         r=g=b=0;
 343                                         g=198;
 344                                 } else { /* Background color */
 345                                         r=bars[WHITE][0];
 346                                         g=bars[WHITE][1];
 347                                         b=bars[WHITE][2];
 348                                         r=g=b=0;
 349                                 }
 350
 351                                 pos=inipos+j*2;
 352                                 for (color=0;color<4;color++) {
 353                                         pgpos=get_addr_pos(pos,pages,to_addr);
 354                                         if (pgpos!=oldpg) {
 355                                                 pg=pfn_to_page(to_addr[pgpos].
 356                                                                 sg->dma_address
 357                                                                 >> PAGE_SHIFT);
 358                                                 kunmap_atomic(basep,
 359                                                                 KM_BOUNCE_READ);
 360                                                 basep= kmap_atomic(pg,
 361                                                         KM_BOUNCE_READ)+
 362                                                         to_addr[pgpos].sg->offset;
 363                                                 oldpg=pgpos;
 364                                         }
 365                                         p=basep+pos-to_addr[pgpos].pos;
 366
 367                                         y=TO_Y(r,g,b);
 368
 369                                         switch (color) {
 370                                                 case 0:
 371                                                 case 2:
 372                                                         *p=TO_Y(r,g,b);         /* Luminance */
 373                                                         break;
 374                                                 case 1:
 375                                                         *p=TO_U(r,g,b);         /* Cb */
 376                                                         break;
 377                                                 case 3:
 378                                                         *p=TO_V(r,g,b);         /* Cr */
 379                                                         break;
 380                                         }
 381                                         pos++;
 382                                 }
 383                                 j++;
 384                         }
 385                 }
 386         }
 387
 388
 389 end:
 390         kunmap_atomic(basep, KM_BOUNCE_READ);
 391 }
 392 static void vivi_fillbuff(struct vivi_dev *dev,struct vivi_buffer *buf)
 393 {
 394         int h,pos=0;
 395         int hmax  = buf->vb.height;
 396         int wmax  = buf->vb.width;
 397         struct videobuf_buffer *vb=&buf->vb;
 398         struct sg_to_addr *to_addr=buf->to_addr;
 399         struct timeval ts;
 400
 401         /* Test if DMA mapping is ready */
 402         if (!vb->dma.sglist[0].dma_address)
 403                 return;
 404
 405         prep_to_addr(to_addr,vb);
 406
 407         /* Check if there is enough memory */
 408         BUG_ON(buf->vb.dma.nr_pages << PAGE_SHIFT < (buf->vb.width*buf->vb.height)*2);
 409
 410         for (h=0;h<hmax;h++) {
 411                 gen_line(to_addr,pos,vb->dma.nr_pages,wmax,hmax,h,dev->timestr);
 412                 pos += wmax*2;
 413         }
 414
 415         /* Updates stream time */
 416
 417         dev->us+=jiffies_to_usecs(jiffies-dev->jiffies);
 418         dev->jiffies=jiffies;
 419         if (dev->us>=1000000) {
 420                 dev->us-=1000000;
 421                 dev->s++;
 422                 if (dev->s>=60) {
 423                         dev->s-=60;
 424                         dev->m++;
 425                         if (dev->m>60) {
 426                                 dev->m-=60;
 427                                 dev->h++;
 428                                 if (dev->h>24)
 429                                         dev->h-=24;
 430                         }
 431                 }
 432         }
 433         sprintf(dev->timestr,"%02d:%02d:%02d:%03d",
 434                         dev->h,dev->m,dev->s,(dev->us+500)/1000);
 435
 436         dprintk(2,"vivifill at %s: Buffer 0x%08lx size= %d\n",dev->timestr,
 437                         (unsigned long)buf->vb.dma.vmalloc,pos);
 438
 439         /* Advice that buffer was filled */
 440         buf->vb.state = STATE_DONE;
 441         buf->vb.field_count++;
 442         do_gettimeofday(&ts);
 443         buf->vb.ts = ts;
 444
 445         list_del(&buf->vb.queue);
 446         wake_up(&buf->vb.done);
 447 }
 448
 449 static int restart_video_queue(struct vivi_dmaqueue *dma_q);
 450
 451 static void vivi_thread_tick(struct vivi_dmaqueue  *dma_q)
 452 {
 453         struct vivi_buffer    *buf;
 454         struct vivi_dev *dev= container_of(dma_q,struct vivi_dev,vidq);
 455
 456         int bc;
 457
 458         /* Announces videobuf that all went ok */
 459         for (bc = 0;; bc++) {
 460                 if (list_empty(&dma_q->active)) {
 461                         dprintk(1,"No active queue to serve\n");
 462                         break;
 463                 }
 464
 465                 buf = list_entry(dma_q->active.next,
 466                                  struct vivi_buffer, vb.queue);
 467
 468                 /* Nobody is waiting something to be done, just return */
 469                 if (!waitqueue_active(&buf->vb.done)) {
 470                         mod_timer(&dma_q->timeout, jiffies+BUFFER_TIMEOUT);
 471                         return;
 472                 }
 473
 474                 do_gettimeofday(&buf->vb.ts);
 475                 dprintk(2,"[%p/%d] wakeup\n",buf,buf->vb.i);
 476
 477                 /* Fill buffer */
 478                 vivi_fillbuff(dev,buf);
 479         }
 480         if (list_empty(&dma_q->active)) {
 481                 del_timer(&dma_q->timeout);
 482         } else {
 483                 mod_timer(&dma_q->timeout, jiffies+BUFFER_TIMEOUT);
 484         }
 485         if (bc != 1)
 486                 dprintk(1,"%s: %d buffers handled (should be 1)\n",__FUNCTION__,bc);
 487 }
 488
 489 void vivi_sleep(struct vivi_dmaqueue  *dma_q)
 490 {
 491         int timeout;
 492         DECLARE_WAITQUEUE(wait, current);
 493
 494         dprintk(1,"%s dma_q=0x%08lx\n",__FUNCTION__,(unsigned long)dma_q);
 495
 496         add_wait_queue(&dma_q->wq, &wait);
 497         if (!kthread_should_stop()) {
 498                 dma_q->frame++;
 499
 500                 /* Calculate time to wake up */
 501                 timeout=dma_q->ini_jiffies+msecs_to_jiffies((dma_q->frame*WAKE_NUMERATOR*1000)/WAKE_DENOMINATOR)-jiffies;
 502
 503                 if (timeout <= 0) {
 504                         int old=dma_q->frame;
 505                         dma_q->frame=(jiffies_to_msecs(jiffies-dma_q->ini_jiffies)*WAKE_DENOMINATOR)/(WAKE_NUMERATOR*1000)+1;
 506
 507                         timeout=dma_q->ini_jiffies+msecs_to_jiffies((dma_q->frame*WAKE_NUMERATOR*1000)/WAKE_DENOMINATOR)-jiffies;
 508
 509                         dprintk(1,"underrun, losed %d frames. "
 510                                   "Now, frame is %d. Waking on %d jiffies\n",
 511                                         dma_q->frame-old,dma_q->frame,timeout);
 512                 } else
 513                         dprintk(1,"will sleep for %i jiffies\n",timeout);
 514
 515                 vivi_thread_tick(dma_q);
 516
 517                 schedule_timeout_interruptible (timeout);
 518         }
 519
 520         remove_wait_queue(&dma_q->wq, &wait);
 521         try_to_freeze();
 522 }
 523
 524 int vivi_thread(void *data)
 525 {
 526         struct vivi_dmaqueue  *dma_q=data;
 527
 528         dprintk(1,"thread started\n");
 529
 530         for (;;) {
 531                 vivi_sleep(dma_q);
 532
 533                 if (kthread_should_stop())
 534                         break;
 535         }
 536         dprintk(1, "thread: exit\n");
 537         return 0;
 538 }
 539
 540 int vivi_start_thread(struct vivi_dmaqueue  *dma_q)
 541 {
 542         dma_q->frame=0;
 543         dma_q->ini_jiffies=jiffies;
 544
 545         dprintk(1,"%s\n",__FUNCTION__);
 546         init_waitqueue_head(&dma_q->wq);
 547
 548         dma_q->kthread = kthread_run(vivi_thread, dma_q, "vivi");
 549
 550         if (dma_q->kthread == NULL) {
 551                 printk(KERN_ERR "vivi: kernel_thread() failed\n");
 552                 return -EINVAL;
 553         }
 554         dprintk(1,"returning from %s\n",__FUNCTION__);
 555         return 0;
 556 }
 557
 558 void vivi_stop_thread(struct vivi_dmaqueue  *dma_q)
 559 {
 560         dprintk(1,"%s\n",__FUNCTION__);
 561         /* shutdown control thread */
 562         if (dma_q->kthread) {
 563                 kthread_stop(dma_q->kthread);
 564                 dma_q->kthread=NULL;
 565         }
 566 }
 567
 568 static int restart_video_queue(struct vivi_dmaqueue *dma_q)
 569 {
 570         struct vivi_buffer *buf, *prev;
 571         struct list_head *item;
 572
 573         dprintk(1,"%s dma_q=0x%08lx\n",__FUNCTION__,(unsigned long)dma_q);
 574
 575         if (!list_empty(&dma_q->active)) {
 576                 buf = list_entry(dma_q->active.next, struct vivi_buffer, vb.queue);
 577                 dprintk(2,"restart_queue [%p/%d]: restart dma\n",
 578                         buf, buf->vb.i);
 579
 580                 dprintk(1,"Restarting video dma\n");
 581                 vivi_stop_thread(dma_q);
 582 //              vivi_start_thread(dma_q);
 583
 584                 /* cancel all outstanding capture / vbi requests */
 585                 list_for_each(item,&dma_q->active) {
 586                         buf = list_entry(item, struct vivi_buffer, vb.queue);
 587
 588                         list_del(&buf->vb.queue);
 589                         buf->vb.state = STATE_ERROR;
 590                         wake_up(&buf->vb.done);
 591                 }
 592                 mod_timer(&dma_q->timeout, jiffies+BUFFER_TIMEOUT);
 593
 594                 return 0;
 595         }
 596
 597         prev = NULL;
 598         for (;;) {
 599                 if (list_empty(&dma_q->queued))
 600                         return 0;
 601                 buf = list_entry(dma_q->queued.next, struct vivi_buffer, vb.queue);
 602                 if (NULL == prev) {
 603                         list_del(&buf->vb.queue);
 604                         list_add_tail(&buf->vb.queue,&dma_q->active);
 605
 606                         dprintk(1,"Restarting video dma\n");
 607                         vivi_stop_thread(dma_q);
 608                         vivi_start_thread(dma_q);
 609
 610                         buf->vb.state = STATE_ACTIVE;
 611                         mod_timer(&dma_q->timeout, jiffies+BUFFER_TIMEOUT);
 612                         dprintk(2,"[%p/%d] restart_queue - first active\n",
 613                                 buf,buf->vb.i);
 614
 615                 } else if (prev->vb.width  == buf->vb.width  &&
 616                            prev->vb.height == buf->vb.height &&
 617                            prev->fmt       == buf->fmt) {
 618                         list_del(&buf->vb.queue);
 619                         list_add_tail(&buf->vb.queue,&dma_q->active);
 620                         buf->vb.state = STATE_ACTIVE;
 621                         dprintk(2,"[%p/%d] restart_queue - move to active\n",
 622                                 buf,buf->vb.i);
 623                 } else {
 624                         return 0;
 625                 }
 626                 prev = buf;
 627         }
 628 }
 629
 630 static void vivi_vid_timeout(unsigned long data)
 631 {
 632         struct vivi_dev      *dev  = (struct vivi_dev*)data;
 633         struct vivi_dmaqueue *vidq = &dev->vidq;
 634         struct vivi_buffer   *buf;
 635
 636         while (!list_empty(&vidq->active)) {
 637                 buf = list_entry(vidq->active.next, struct vivi_buffer, vb.queue);
 638                 list_del(&buf->vb.queue);
 639                 buf->vb.state = STATE_ERROR;
 640                 wake_up(&buf->vb.done);
 641                 printk("vivi/0: [%p/%d] timeout\n", buf, buf->vb.i);
 642         }
 643
 644         restart_video_queue(vidq);
 645 }
 646
 647 /* ------------------------------------------------------------------
 648         Videobuf operations
 649    ------------------------------------------------------------------*/
 650 static int
 651 buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
 652 {
 653         struct vivi_fh *fh = vq->priv_data;
 654
 655         *size = fh->width*fh->height*2;
 656
 657         if (0 == *count)
 658                 *count = 32;
 659         while (*size * *count > vid_limit * 1024 * 1024)
 660                 (*count)--;
 661         return 0;
 662 }
 663
 664 void
 665 free_buffer(struct videobuf_queue *vq, struct vivi_buffer *buf)
 666 {
 667         dprintk(1,"%s\n",__FUNCTION__);
 668
 669         if (in_interrupt())
 670                 BUG();
 671
 672         /*FIXME: Maybe a spinlock is required here */
 673         kfree(buf->to_addr);
 674         buf->to_addr=NULL;
 675
 676         videobuf_waiton(&buf->vb,0,0);
 677         videobuf_dma_unmap(vq, &buf->vb.dma);
 678         videobuf_dma_free(&buf->vb.dma);
 679         buf->vb.state = STATE_NEEDS_INIT;
 680 }
 681
 682 #define norm_maxw() 1024
 683 #define norm_maxh() 768
 684 static int
 685 buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
 686                                                 enum v4l2_field field)
 687 {
 688         struct vivi_fh     *fh  = vq->priv_data;
 689         struct vivi_buffer *buf = container_of(vb,struct vivi_buffer,vb);
 690         int rc, init_buffer = 0;
 691
 692 //      dprintk(1,"%s, field=%d\n",__FUNCTION__,field);
 693
 694         BUG_ON(NULL == fh->fmt);
 695         if (fh->width  < 48 || fh->width  > norm_maxw() ||
 696             fh->height < 32 || fh->height > norm_maxh())
 697                 return -EINVAL;
 698         buf->vb.size = fh->width*fh->height*2;
 699         if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
 700                 return -EINVAL;
 701
 702         if (buf->fmt       != fh->fmt    ||
 703             buf->vb.width  != fh->width  ||
 704             buf->vb.height != fh->height ||
 705         buf->vb.field  != field) {
 706                 buf->fmt       = fh->fmt;
 707                 buf->vb.width  = fh->width;
 708                 buf->vb.height = fh->height;
 709                 buf->vb.field  = field;
 710                 init_buffer = 1;
 711         }
 712
 713         if (STATE_NEEDS_INIT == buf->vb.state) {
 714                 if (0 != (rc = videobuf_iolock(vq,&buf->vb,NULL)))
 715                         goto fail;
 716         }
 717
 718         buf->vb.state = STATE_PREPARED;
 719
 720         if (NULL == (buf->to_addr = kmalloc(sizeof(*buf->to_addr) * vb->dma.nr_pages,GFP_KERNEL))) {
 721                 rc=-ENOMEM;
 722                 goto fail;
 723         }
 724
 725         return 0;
 726
 727 fail:
 728         free_buffer(vq,buf);
 729         return rc;
 730 }
 731
 732 static void
 733 buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
 734 {
 735         struct vivi_buffer    *buf     = container_of(vb,struct vivi_buffer,vb);
 736         struct vivi_fh        *fh      = vq->priv_data;
 737         struct vivi_dev       *dev     = fh->dev;
 738         struct vivi_dmaqueue  *vidq    = &dev->vidq;
 739         struct vivi_buffer    *prev;
 740
 741         if (!list_empty(&vidq->queued)) {
 742                 dprintk(1,"adding vb queue=0x%08lx\n",(unsigned long)&buf->vb.queue);
 743                 list_add_tail(&buf->vb.queue,&vidq->queued);
 744                 buf->vb.state = STATE_QUEUED;
 745                 dprintk(2,"[%p/%d] buffer_queue - append to queued\n",
 746                         buf, buf->vb.i);
 747         } else if (list_empty(&vidq->active)) {
 748                 list_add_tail(&buf->vb.queue,&vidq->active);
 749
 750                 buf->vb.state = STATE_ACTIVE;
 751                 mod_timer(&vidq->timeout, jiffies+BUFFER_TIMEOUT);
 752                 dprintk(2,"[%p/%d] buffer_queue - first active\n",
 753                         buf, buf->vb.i);
 754
 755                 vivi_start_thread(vidq);
 756         } else {
 757                 prev = list_entry(vidq->active.prev, struct vivi_buffer, vb.queue);
 758                 if (prev->vb.width  == buf->vb.width  &&
 759                     prev->vb.height == buf->vb.height &&
 760                     prev->fmt       == buf->fmt) {
 761                         list_add_tail(&buf->vb.queue,&vidq->active);
 762                         buf->vb.state = STATE_ACTIVE;
 763                         dprintk(2,"[%p/%d] buffer_queue - append to active\n",
 764                                 buf, buf->vb.i);
 765
 766                 } else {
 767                         list_add_tail(&buf->vb.queue,&vidq->queued);
 768                         buf->vb.state = STATE_QUEUED;
 769                         dprintk(2,"[%p/%d] buffer_queue - first queued\n",
 770                                 buf, buf->vb.i);
 771                 }
 772         }
 773 }
 774
 775 static void buffer_release(struct videobuf_queue *vq, struct videobuf_buffer *vb)
 776 {
 777         struct vivi_buffer   *buf  = container_of(vb,struct vivi_buffer,vb);
 778         struct vivi_fh       *fh   = vq->priv_data;
 779         struct vivi_dev      *dev  = (struct vivi_dev*)fh->dev;
 780         struct vivi_dmaqueue *vidq = &dev->vidq;
 781
 782         dprintk(1,"%s\n",__FUNCTION__);
 783
 784         vivi_stop_thread(vidq);
 785
 786         free_buffer(vq,buf);
 787 }
 788
 789 int vivi_map_sg (void *dev, struct scatterlist *sg, int nents,
 790            int direction)
 791 {
 792         int i;
 793
 794         dprintk(1,"%s, number of pages=%d\n",__FUNCTION__,nents);
 795         BUG_ON(direction == DMA_NONE);
 796
 797         for (i = 0; i < nents; i++ ) {
 798                 BUG_ON(!sg[i].page);
 799
 800                 sg[i].dma_address = page_to_phys(sg[i].page) + sg[i].offset;
 801         }
 802
 803         return nents;
 804 }
 805
 806 int vivi_unmap_sg(void *dev,struct scatterlist *sglist,int nr_pages,
 807                                         int direction)
 808 {
 809         dprintk(1,"%s\n",__FUNCTION__);
 810         return 0;
 811 }
 812
 813 int vivi_dma_sync_sg(void *dev,struct scatterlist *sglist,int nr_pages,
 814                                         int direction)
 815 {
 816 //      dprintk(1,"%s\n",__FUNCTION__);
 817
 818 //      flush_write_buffers();
 819         return 0;
 820 }
 821
 822 static struct videobuf_queue_ops vivi_video_qops = {
 823         .buf_setup      = buffer_setup,
 824         .buf_prepare    = buffer_prepare,
 825         .buf_queue      = buffer_queue,
 826         .buf_release    = buffer_release,
 827
 828         /* Non-pci handling routines */
 829         .vb_map_sg      = vivi_map_sg,
 830         .vb_dma_sync_sg = vivi_dma_sync_sg,
 831         .vb_unmap_sg    = vivi_unmap_sg,
 832 };
 833
 834 /* ------------------------------------------------------------------
 835         IOCTL handling
 836    ------------------------------------------------------------------*/
 837
 838 static int vivi_try_fmt(struct vivi_dev *dev, struct vivi_fh *fh,
 839                         struct v4l2_format *f)
 840 {
 841         struct vivi_fmt *fmt;
 842         enum v4l2_field field;
 843         unsigned int maxw, maxh;
 844
 845         if (format.fourcc != f->fmt.pix.pixelformat) {
 846                 dprintk(1,"Fourcc format invalid.\n");
 847                 return -EINVAL;
 848         }
 849         fmt=&format;
 850
 851         field = f->fmt.pix.field;
 852
 853         if (field == V4L2_FIELD_ANY) {
 854 //              field=V4L2_FIELD_INTERLACED;
 855                 field=V4L2_FIELD_SEQ_TB;
 856         } else if (V4L2_FIELD_INTERLACED != field) {
 857                 dprintk(1,"Field type invalid.\n");
 858                 return -EINVAL;
 859         }
 860
 861         maxw  = norm_maxw();
 862         maxh  = norm_maxh();
 863
 864         f->fmt.pix.field = field;
 865         if (f->fmt.pix.height < 32)
 866                 f->fmt.pix.height = 32;
 867         if (f->fmt.pix.height > maxh)
 868                 f->fmt.pix.height = maxh;
 869         if (f->fmt.pix.width < 48)
 870                 f->fmt.pix.width = 48;
 871         if (f->fmt.pix.width > maxw)
 872                 f->fmt.pix.width = maxw;
 873         f->fmt.pix.width &= ~0x03;
 874         f->fmt.pix.bytesperline =
 875                 (f->fmt.pix.width * fmt->depth) >> 3;
 876         f->fmt.pix.sizeimage =
 877                 f->fmt.pix.height * f->fmt.pix.bytesperline;
 878
 879         return 0;
 880 }
 881
 882 static int res_get(struct vivi_dev *dev, struct vivi_fh *fh)
 883 {
 884         /* is it free? */
 885         down(&dev->lock);
 886         if (dev->resources) {
 887                 /* no, someone else uses it */
 888                 up(&dev->lock);
 889                 return 0;
 890         }
 891         /* it's free, grab it */
 892         dev->resources =1;
 893         dprintk(1,"res: get\n");
 894         up(&dev->lock);
 895         return 1;
 896 }
 897
 898 static inline int res_locked(struct vivi_dev *dev)
 899 {
 900         return (dev->resources);
 901 }
 902
 903 static void res_free(struct vivi_dev *dev, struct vivi_fh *fh)
 904 {
 905         down(&dev->lock);
 906         dev->resources = 0;
 907         dprintk(1,"res: put\n");
 908         up(&dev->lock);
 909 }
 910
 911 static int vivi_do_ioctl(struct inode *inode, struct file *file, unsigned int cmd, void *arg)
 912 {
 913         struct vivi_fh  *fh     = file->private_data;
 914         struct vivi_dev *dev    = fh->dev;
 915         int ret=0;
 916
 917         if (debug) {
 918                 if (_IOC_DIR(cmd) & _IOC_WRITE)
 919                         v4l_printk_ioctl_arg("vivi(w)",cmd, arg);
 920                 else if (!_IOC_DIR(cmd) & _IOC_READ) {
 921                         v4l_print_ioctl("vivi", cmd);
 922                 }
 923         }
 924
 925         switch(cmd) {
 926         /* --- capabilities ------------------------------------------ */
 927         case VIDIOC_QUERYCAP:
 928         {
 929                 struct v4l2_capability *cap = (struct v4l2_capability*)arg;
 930
 931                 memset(cap, 0, sizeof(*cap));
 932
 933                 strcpy(cap->driver, "vivi");
 934                 strcpy(cap->card, "vivi");
 935                 cap->version = VIVI_VERSION;
 936                 cap->capabilities =
 937                                         V4L2_CAP_VIDEO_CAPTURE |
 938                                         V4L2_CAP_STREAMING     |
 939                                         V4L2_CAP_READWRITE;
 940                 break;
 941         }
 942         /* --- capture ioctls ---------------------------------------- */
 943         case VIDIOC_ENUM_FMT:
 944         {
 945                 struct v4l2_fmtdesc *f = arg;
 946                 enum v4l2_buf_type type;
 947                 unsigned int index;
 948
 949                 index = f->index;
 950                 type  = f->type;
 951
 952                 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 953                         ret=-EINVAL;
 954                         break;
 955                 }
 956
 957                 switch (type) {
 958                 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 959                         if (index > 0){
 960                                 ret=-EINVAL;
 961                                 break;
 962                         }
 963                         memset(f,0,sizeof(*f));
 964
 965                         f->index = index;
 966                         f->type  = type;
 967                         strlcpy(f->description,format.name,sizeof(f->description));
 968                         f->pixelformat = format.fourcc;
 969                         break;
 970                 default:
 971                         ret=-EINVAL;
 972                 }
 973                 break;
 974         }
 975         case VIDIOC_G_FMT:
 976         {
 977                 struct v4l2_format *f = (struct v4l2_format *)arg;
 978
 979                 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 980                         ret=-EINVAL;
 981                         break;
 982                 }
 983
 984                 memset(&f->fmt.pix,0,sizeof(f->fmt.pix));
 985                 f->fmt.pix.width        = fh->width;
 986                 f->fmt.pix.height       = fh->height;
 987                 f->fmt.pix.field        = fh->vb_vidq.field;
 988                 f->fmt.pix.pixelformat  = fh->fmt->fourcc;
 989                 f->fmt.pix.bytesperline =
 990                         (f->fmt.pix.width * fh->fmt->depth) >> 3;
 991                 f->fmt.pix.sizeimage =
 992                         f->fmt.pix.height * f->fmt.pix.bytesperline;
 993                 break;
 994         }
 995         case VIDIOC_S_FMT:
 996         {
 997                 struct v4l2_format *f = arg;
 998
 999                 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1000                         dprintk(1,"Only capture supported.\n");
1001                         ret=-EINVAL;
1002                         break;
1003                 }
1004
1005                 ret = vivi_try_fmt(dev,fh,f);
1006                 if (ret < 0)
1007                         break;
1008
1009                 fh->fmt           = &format;
1010                 fh->width         = f->fmt.pix.width;
1011                 fh->height        = f->fmt.pix.height;
1012                 fh->vb_vidq.field = f->fmt.pix.field;
1013                 fh->type          = f->type;
1014
1015                 break;
1016         }
1017         case VIDIOC_TRY_FMT:
1018         {
1019                 struct v4l2_format *f = arg;
1020                 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1021                         ret=-EINVAL;
1022                         break;
1023                 }
1024
1025                 ret=vivi_try_fmt(dev,fh,f);
1026                 break;
1027         }
1028         case VIDIOC_REQBUFS:
1029                 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1030                         ret=-EINVAL;
1031                         break;
1032                 }
1033                 ret=videobuf_reqbufs(&fh->vb_vidq, arg);
1034                 break;
1035         case VIDIOC_QUERYBUF:
1036                 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1037                         ret=-EINVAL;
1038                         break;
1039                 }
1040                 ret=videobuf_querybuf(&fh->vb_vidq, arg);
1041                 break;
1042         case VIDIOC_QBUF:
1043                 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1044                         ret=-EINVAL;
1045                         break;
1046                 }
1047                 ret=videobuf_qbuf(&fh->vb_vidq, arg);
1048                 break;
1049         case VIDIOC_DQBUF:
1050                 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1051                         ret=-EINVAL;
1052                         break;
1053                 }
1054                 ret=videobuf_dqbuf(&fh->vb_vidq, arg,
1055                                         file->f_flags & O_NONBLOCK);
1056                 break;
1057 #ifdef HAVE_V4L1
1058         /* --- streaming capture ------------------------------------- */
1059         case VIDIOCGMBUF:
1060         {
1061                 struct video_mbuf *mbuf = arg;
1062                 struct videobuf_queue *q=&fh->vb_vidq;
1063                 struct v4l2_requestbuffers req;
1064                 unsigned int i;
1065
1066                 memset(&req,0,sizeof(req));
1067                 req.type   = q->type;
1068                 req.count  = 8;
1069                 req.memory = V4L2_MEMORY_MMAP;
1070                 ret = videobuf_reqbufs(q,&req);
1071                 if (ret < 0)
1072                         break;
1073                 memset(mbuf,0,sizeof(*mbuf));
1074                 mbuf->frames = req.count;
1075                 mbuf->size   = 0;
1076                 for (i = 0; i < mbuf->frames; i++) {
1077                         mbuf->offsets[i]  = q->bufs[i]->boff;
1078                         mbuf->size       += q->bufs[i]->bsize;
1079                 }
1080                 break;
1081         }
1082 #endif
1083         case VIDIOC_STREAMON:
1084         {
1085                 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1086                         return -EINVAL;
1087                 if (!res_get(dev,fh))
1088                         return -EBUSY;
1089                 ret=videobuf_streamon(&fh->vb_vidq);
1090                 break;
1091         }
1092         case VIDIOC_STREAMOFF:
1093         {
1094                 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1095                         ret=-EINVAL;
1096                         break;
1097                 }
1098                 ret = videobuf_streamoff(&fh->vb_vidq);
1099                 if (ret < 0)
1100                         break;
1101                 res_free(dev,fh);
1102                 break;
1103         }
1104         /* ---------- tv norms ---------- */
1105         case VIDIOC_ENUMSTD:
1106         {
1107                 struct v4l2_standard *e = arg;
1108
1109                 if (e->index>0) {
1110                         ret=-EINVAL;
1111                         break;
1112                 }
1113                 ret = v4l2_video_std_construct(e, V4L2_STD_NTSC_M, "NTSC-M");
1114
1115                 /* Allows vivi to use different fps from video std */
1116                 e->frameperiod.numerator = WAKE_NUMERATOR;
1117                 e->frameperiod.denominator = WAKE_DENOMINATOR;
1118
1119                 break;
1120         }
1121         case VIDIOC_G_STD:
1122         {
1123                 v4l2_std_id *id = arg;
1124
1125                 *id = V4L2_STD_NTSC_M;
1126                 break;
1127         }
1128         case VIDIOC_S_STD:
1129         {
1130                 break;
1131         }
1132         /* ------ input switching ---------- */
1133         case VIDIOC_ENUMINPUT:
1134         { /* only one input in this sample driver */
1135                 struct v4l2_input *inp = arg;
1136
1137                 if (inp->index != 0) {
1138                         ret=-EINVAL;
1139                         break;
1140                 }
1141                 memset(inp, 0, sizeof(*inp));
1142
1143                 inp->index = 0;
1144                 inp->type = V4L2_INPUT_TYPE_CAMERA;
1145                 inp->std = V4L2_STD_NTSC_M;
1146                 strcpy(inp->name,"Camera");
1147                 break;
1148         }
1149         case VIDIOC_G_INPUT:
1150         {
1151                 unsigned int *i = arg;
1152
1153                 *i = 0;
1154                 break;
1155         }
1156         case VIDIOC_S_INPUT:
1157         {
1158                 unsigned int *i = arg;
1159
1160                 if (*i > 0)
1161                         ret=-EINVAL;
1162                 break;
1163         }
1164
1165         /* --- controls ---------------------------------------------- */
1166         case VIDIOC_QUERYCTRL:
1167         {
1168                 struct v4l2_queryctrl *qc = arg;
1169                 int i;
1170
1171                 for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1172                         if (qc->id && qc->id == vivi_qctrl[i].id) {
1173                                 memcpy(qc, &(vivi_qctrl[i]),
1174                                         sizeof(*qc));
1175                                 break;
1176                         }
1177
1178                 ret=-EINVAL;
1179                 break;
1180         }
1181         case VIDIOC_G_CTRL:
1182         {
1183                 struct v4l2_control *ctrl = arg;
1184                 int i;
1185
1186                 for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1187                         if (ctrl->id == vivi_qctrl[i].id) {
1188                                 ctrl->value=qctl_regs[i];
1189                                 break;
1190                         }
1191
1192                 ret=-EINVAL;
1193                 break;
1194         }
1195         case VIDIOC_S_CTRL:
1196         {
1197                 struct v4l2_control *ctrl = arg;
1198                 int i;
1199                 for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1200                         if (ctrl->id == vivi_qctrl[i].id) {
1201                                 if (ctrl->value <
1202                                         vivi_qctrl[i].minimum
1203                                         || ctrl->value >
1204                                         vivi_qctrl[i].maximum) {
1205                                                 ret=-ERANGE;
1206                                                 break;
1207                                         }
1208                                 qctl_regs[i]=ctrl->value;
1209                                 break;
1210                         }
1211                 ret=-EINVAL;
1212                 break;
1213         }
1214         default:
1215                 ret=v4l_compat_translate_ioctl(inode,file,cmd,arg,vivi_do_ioctl);
1216         }
1217
1218         if (debug) {
1219                 if (ret<0) {
1220                         v4l_print_ioctl("vivi(err)", cmd);
1221                         dprintk(1,"errcode=%d\n",ret);
1222                 } else if (_IOC_DIR(cmd) & _IOC_READ)
1223                         v4l_printk_ioctl_arg("vivi(r)",cmd, arg);
1224         }
1225
1226         return ret;
1227 }
1228
1229 static int vivi_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
1230 {
1231         return video_usercopy(inode, file, cmd, arg, vivi_do_ioctl);
1232 }
1233
1234 /* ------------------------------------------------------------------
1235         File operations for the device
1236    ------------------------------------------------------------------*/
1237
1238 #define line_buf_size(norm) (norm_maxw(norm)*(format.depth+7)/8)
1239
1240 static int vivi_open(struct inode *inode, struct file *file)
1241 {
1242         int minor = iminor(inode);
1243         struct vivi_dev *h,*dev = NULL;
1244         struct vivi_fh *fh;
1245         struct list_head *list;
1246         enum v4l2_buf_type type = 0;
1247         int i;
1248
1249         printk(KERN_DEBUG "vivi: open called (minor=%d)\n",minor);
1250
1251         list_for_each(list,&vivi_devlist) {
1252                 h = list_entry(list, struct vivi_dev, vivi_devlist);
1253                 if (h->video_dev.minor == minor) {
1254                         dev  = h;
1255                         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1256                 }
1257         }
1258         if (NULL == dev)
1259                 return -ENODEV;
1260
1261
1262         /* If more than one user, mutex should be added */
1263         dev->users++;
1264
1265         dprintk(1,"open minor=%d type=%s users=%d\n",
1266                                 minor,v4l2_type_names[type],dev->users);
1267
1268         /* allocate + initialize per filehandle data */
1269         fh = kzalloc(sizeof(*fh),GFP_KERNEL);
1270         if (NULL == fh) {
1271                 dev->users--;
1272                 return -ENOMEM;
1273         }
1274
1275         file->private_data = fh;
1276         fh->dev      = dev;
1277         fh->type     = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1278         fh->fmt      = &format;
1279         fh->width    = 640;
1280         fh->height   = 480;
1281
1282         /* Put all controls at a sane state */
1283         for (i = 0; i < ARRAY_SIZE(vivi_qctrl); i++)
1284                 qctl_regs[i] =vivi_qctrl[i].default_value;
1285
1286         dprintk(1,"Open: fh=0x%08lx, dev=0x%08lx, dev->vidq=0x%08lx\n",
1287                 (unsigned long)fh,(unsigned long)dev,(unsigned long)&dev->vidq);
1288         dprintk(1,"Open: list_empty queued=%d\n",list_empty(&dev->vidq.queued));
1289         dprintk(1,"Open: list_empty active=%d\n",list_empty(&dev->vidq.active));
1290
1291         /* Resets frame counters */
1292         dev->h=0;
1293         dev->m=0;
1294         dev->s=0;
1295         dev->us=0;
1296         dev->jiffies=jiffies;
1297         sprintf(dev->timestr,"%02d:%02d:%02d:%03d",
1298                         dev->h,dev->m,dev->s,(dev->us+500)/1000);
1299
1300         videobuf_queue_init(&fh->vb_vidq, &vivi_video_qops,
1301                         NULL, NULL,
1302                         fh->type,
1303                         V4L2_FIELD_INTERLACED,
1304                         sizeof(struct vivi_buffer),fh);
1305
1306         return 0;
1307 }
1308
1309 static ssize_t
1310 vivi_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1311 {
1312         struct vivi_fh *fh = file->private_data;
1313
1314         if (fh->type==V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1315                 if (res_locked(fh->dev))
1316                         return -EBUSY;
1317                 return videobuf_read_one(&fh->vb_vidq, data, count, ppos,
1318                                         file->f_flags & O_NONBLOCK);
1319         }
1320         return 0;
1321 }
1322
1323 static unsigned int
1324 vivi_poll(struct file *file, struct poll_table_struct *wait)
1325 {
1326         struct vivi_fh *fh = file->private_data;
1327         struct vivi_buffer *buf;
1328
1329         dprintk(1,"%s\n",__FUNCTION__);
1330
1331         if (V4L2_BUF_TYPE_VIDEO_CAPTURE != fh->type)
1332                 return POLLERR;
1333
1334         if (res_get(fh->dev,fh)) {
1335                 dprintk(1,"poll: mmap interface\n");
1336                 /* streaming capture */
1337                 if (list_empty(&fh->vb_vidq.stream))
1338                         return POLLERR;
1339                 buf = list_entry(fh->vb_vidq.stream.next,struct vivi_buffer,vb.stream);
1340         } else {
1341                 dprintk(1,"poll: read() interface\n");
1342                 /* read() capture */
1343                 buf = (struct vivi_buffer*)fh->vb_vidq.read_buf;
1344                 if (NULL == buf)
1345                         return POLLERR;
1346         }
1347         poll_wait(file, &buf->vb.done, wait);
1348         if (buf->vb.state == STATE_DONE ||
1349             buf->vb.state == STATE_ERROR)
1350                 return POLLIN|POLLRDNORM;
1351         return 0;
1352 }
1353
1354 static int vivi_release(struct inode *inode, struct file *file)
1355 {
1356         struct vivi_fh  *fh     = file->private_data;
1357         struct vivi_dev *dev    = fh->dev;
1358         struct vivi_dmaqueue *vidq = &dev->vidq;
1359
1360         int minor = iminor(inode);
1361
1362         vivi_stop_thread(vidq);
1363         videobuf_mmap_free(&fh->vb_vidq);
1364
1365         kfree (fh);
1366
1367         dev->users--;
1368
1369         printk(KERN_DEBUG "vivi: close called (minor=%d, users=%d)\n",minor,dev->users);
1370
1371         return 0;
1372 }
1373
1374 static int
1375 vivi_mmap(struct file *file, struct vm_area_struct * vma)
1376 {
1377         struct vivi_fh *fh = file->private_data;
1378         int ret;
1379
1380         dprintk (1,"mmap called, vma=0x%08lx\n",(unsigned long)vma);
1381
1382         ret=videobuf_mmap_mapper(&fh->vb_vidq, vma);
1383
1384         dprintk (1,"vma start=0x%08lx, size=%ld, ret=%d\n",
1385                 (unsigned long)vma->vm_start,
1386                 (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
1387                 ret);
1388
1389         return ret;
1390 }
1391
1392 static struct file_operations vivi_fops = {
1393         .owner          = THIS_MODULE,
1394         .open           = vivi_open,
1395         .release        = vivi_release,
1396         .read           = vivi_read,
1397         .poll           = vivi_poll,
1398         .ioctl          = vivi_ioctl,
1399         .mmap           = vivi_mmap,
1400         .llseek         = no_llseek,
1401 };
1402
1403 static struct video_device vivi = {
1404         .name           = "VTM Virtual Video Capture Board",
1405         .type           = VID_TYPE_CAPTURE,
1406         .hardware       = 0,
1407         .fops           = &vivi_fops,
1408         .minor          = -1,
1409 //      .release        = video_device_release,
1410 };
1411 /* ------------------------------------------------------------------
1412         Initialization and module stuff
1413    ------------------------------------------------------------------*/
1414
1415 static int __init vivi_init(void)
1416 {
1417         int ret;
1418         struct vivi_dev *dev;
1419
1420         dev = kzalloc(sizeof(*dev),GFP_KERNEL);
1421         if (NULL == dev)
1422                 return -ENOMEM;
1423         list_add_tail(&dev->vivi_devlist,&vivi_devlist);
1424
1425         /* init video dma queues */
1426         INIT_LIST_HEAD(&dev->vidq.active);
1427         INIT_LIST_HEAD(&dev->vidq.queued);
1428
1429         /* initialize locks */
1430         init_MUTEX(&dev->lock);
1431
1432         dev->vidq.timeout.function = vivi_vid_timeout;
1433         dev->vidq.timeout.data     = (unsigned long)dev;
1434         init_timer(&dev->vidq.timeout);
1435
1436         ret = video_register_device(&vivi, VFL_TYPE_GRABBER, video_nr);
1437         printk(KERN_INFO "Video Technology Magazine Virtual Video Capture Board (Load status: %d)\n", ret);
1438         return ret;
1439 }
1440
1441 static void __exit vivi_exit(void)
1442 {
1443         struct vivi_dev *h;
1444         struct list_head *list;
1445
1446         list_for_each(list,&vivi_devlist) {
1447                 h = list_entry(list, struct vivi_dev, vivi_devlist);
1448                 kfree (h);
1449         }
1450         video_unregister_device(&vivi);
1451 }
1452
1453 module_init(vivi_init);
1454 module_exit(vivi_exit);