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

   1 /*
   2  * Endpoints (formerly known as AOX) se401 USB Camera Driver
   3  *
   4  * Copyright (c) 2000 Jeroen B. Vreeken (pe1rxq@amsat.org)
   5  *
   6  * Still somewhat based on the Linux ov511 driver.
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; either version 2 of the License, or (at your
  11  * option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  15  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16  * for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  *
  22  *
  23  * Thanks to Endpoints Inc. (www.endpoints.com) for making documentation on
  24  * their chipset available and supporting me while writing this driver.
  25  *      - Jeroen Vreeken
  26  */
  27
  28 static const char version[] = "0.24";
  29
  30 #include <linux/module.h>
  31 #include <linux/init.h>
  32 #include <linux/vmalloc.h>
  33 #include <linux/slab.h>
  34 #include <linux/pagemap.h>
  35 #include <linux/usb.h>
  36 #include "se401.h"
  37
  38 static int flickerless;
  39 static int video_nr = -1;
  40
  41 static struct usb_device_id device_table [] = {
  42         { USB_DEVICE(0x03e8, 0x0004) },/* Endpoints/Aox SE401 */
  43         { USB_DEVICE(0x0471, 0x030b) },/* Philips PCVC665K */
  44         { USB_DEVICE(0x047d, 0x5001) },/* Kensington 67014 */
  45         { USB_DEVICE(0x047d, 0x5002) },/* Kensington 6701(5/7) */
  46         { USB_DEVICE(0x047d, 0x5003) },/* Kensington 67016 */
  47         { }
  48 };
  49
  50 MODULE_DEVICE_TABLE(usb, device_table);
  51
  52 MODULE_AUTHOR("Jeroen Vreeken <pe1rxq@amsat.org>");
  53 MODULE_DESCRIPTION("SE401 USB Camera Driver");
  54 MODULE_LICENSE("GPL");
  55 module_param(flickerless, int, 0);
  56 MODULE_PARM_DESC(flickerless, "Net frequency to adjust exposure time to (0/50/60)");
  57 module_param(video_nr, int, 0);
  58
  59 static struct usb_driver se401_driver;
  60
  61
  62 /**********************************************************************
  63  *
  64  * Memory management
  65  *
  66  **********************************************************************/
  67 static void *rvmalloc(unsigned long size)
  68 {
  69         void *mem;
  70         unsigned long adr;
  71
  72         size = PAGE_ALIGN(size);
  73         mem = vmalloc_32(size);
  74         if (!mem)
  75                 return NULL;
  76
  77         memset(mem, 0, size); /* Clear the ram out, no junk to the user */
  78         adr = (unsigned long) mem;
  79         while (size > 0) {
  80                 SetPageReserved(vmalloc_to_page((void *)adr));
  81                 adr += PAGE_SIZE;
  82                 size -= PAGE_SIZE;
  83         }
  84
  85         return mem;
  86 }
  87
  88 static void rvfree(void *mem, unsigned long size)
  89 {
  90         unsigned long adr;
  91
  92         if (!mem)
  93                 return;
  94
  95         adr = (unsigned long) mem;
  96         while ((long) size > 0) {
  97                 ClearPageReserved(vmalloc_to_page((void *)adr));
  98                 adr += PAGE_SIZE;
  99                 size -= PAGE_SIZE;
 100         }
 101         vfree(mem);
 102 }
 103
 104
 105
 106 /****************************************************************************
 107  *
 108  * se401 register read/write functions
 109  *
 110  ***************************************************************************/
 111
 112 static int se401_sndctrl(int set, struct usb_se401 *se401, unsigned short req,
 113                          unsigned short value, unsigned char *cp, int size)
 114 {
 115         return usb_control_msg (
 116                 se401->dev,
 117                 set ? usb_sndctrlpipe(se401->dev, 0) : usb_rcvctrlpipe(se401->dev, 0),
 118                 req,
 119                 (set ? USB_DIR_OUT : USB_DIR_IN) | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 120                 value,
 121                 0,
 122                 cp,
 123                 size,
 124                 1000
 125         );
 126 }
 127
 128 static int se401_set_feature(struct usb_se401 *se401, unsigned short selector,
 129                              unsigned short param)
 130 {
 131         /* specs say that the selector (address) should go in the value field
 132            and the param in index, but in the logs of the windows driver they do
 133            this the other way around...
 134          */
 135         return usb_control_msg (
 136                 se401->dev,
 137                 usb_sndctrlpipe(se401->dev, 0),
 138                 SE401_REQ_SET_EXT_FEATURE,
 139                 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 140                 param,
 141                 selector,
 142                 NULL,
 143                 0,
 144                 1000
 145         );
 146 }
 147
 148 static unsigned short se401_get_feature(struct usb_se401 *se401,
 149                                         unsigned short selector)
 150 {
 151         /* For 'set' the selecetor should be in index, not sure if the spec is
 152            wrong here to....
 153          */
 154         unsigned char cp[2];
 155         usb_control_msg (
 156                 se401->dev,
 157                 usb_rcvctrlpipe(se401->dev, 0),
 158                 SE401_REQ_GET_EXT_FEATURE,
 159                 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 160                 0,
 161                 selector,
 162                 cp,
 163                 2,
 164                 1000
 165         );
 166         return cp[0]+cp[1]*256;
 167 }
 168
 169 /****************************************************************************
 170  *
 171  * Camera control
 172  *
 173  ***************************************************************************/
 174
 175
 176 static int se401_send_pict(struct usb_se401 *se401)
 177 {
 178         se401_set_feature(se401, HV7131_REG_TITL, se401->expose_l);/* integration time low */
 179         se401_set_feature(se401, HV7131_REG_TITM, se401->expose_m);/* integration time mid */
 180         se401_set_feature(se401, HV7131_REG_TITU, se401->expose_h);/* integration time mid */
 181         se401_set_feature(se401, HV7131_REG_ARLV, se401->resetlevel);/* reset level value */
 182         se401_set_feature(se401, HV7131_REG_ARCG, se401->rgain);/* red color gain */
 183         se401_set_feature(se401, HV7131_REG_AGCG, se401->ggain);/* green color gain */
 184         se401_set_feature(se401, HV7131_REG_ABCG, se401->bgain);/* blue color gain */
 185
 186         return 0;
 187 }
 188
 189 static void se401_set_exposure(struct usb_se401 *se401, int brightness)
 190 {
 191         int integration=brightness<<5;
 192
 193         if (flickerless==50) {
 194                 integration=integration-integration%106667;
 195         }
 196         if (flickerless==60) {
 197                 integration=integration-integration%88889;
 198         }
 199         se401->brightness=integration>>5;
 200         se401->expose_h=(integration>>16)&0xff;
 201         se401->expose_m=(integration>>8)&0xff;
 202         se401->expose_l=integration&0xff;
 203 }
 204
 205 static int se401_get_pict(struct usb_se401 *se401, struct video_picture *p)
 206 {
 207         p->brightness=se401->brightness;
 208         if (se401->enhance) {
 209                 p->whiteness=32768;
 210         } else {
 211                 p->whiteness=0;
 212         }
 213         p->colour=65535;
 214         p->contrast=65535;
 215         p->hue=se401->rgain<<10;
 216         p->palette=se401->palette;
 217         p->depth=3; /* rgb24 */
 218         return 0;
 219 }
 220
 221
 222 static int se401_set_pict(struct usb_se401 *se401, struct video_picture *p)
 223 {
 224         if (p->palette != VIDEO_PALETTE_RGB24)
 225                 return 1;
 226         se401->palette=p->palette;
 227         if (p->hue!=se401->hue) {
 228                 se401->rgain= p->hue>>10;
 229                 se401->bgain= 0x40-(p->hue>>10);
 230                 se401->hue=p->hue;
 231         }
 232         if (p->brightness!=se401->brightness) {
 233                 se401_set_exposure(se401, p->brightness);
 234         }
 235         if (p->whiteness>=32768) {
 236                 se401->enhance=1;
 237         } else {
 238                 se401->enhance=0;
 239         }
 240         se401_send_pict(se401);
 241         se401_send_pict(se401);
 242         return 0;
 243 }
 244
 245 /*
 246         Hyundai have some really nice docs about this and other sensor related
 247         stuff on their homepage: www.hei.co.kr
 248 */
 249 static void se401_auto_resetlevel(struct usb_se401 *se401)
 250 {
 251         unsigned int ahrc, alrc;
 252         int oldreset=se401->resetlevel;
 253
 254         /* For some reason this normally read-only register doesn't get reset
 255            to zero after reading them just once...
 256          */
 257         se401_get_feature(se401, HV7131_REG_HIREFNOH);
 258         se401_get_feature(se401, HV7131_REG_HIREFNOL);
 259         se401_get_feature(se401, HV7131_REG_LOREFNOH);
 260         se401_get_feature(se401, HV7131_REG_LOREFNOL);
 261         ahrc=256*se401_get_feature(se401, HV7131_REG_HIREFNOH) +
 262             se401_get_feature(se401, HV7131_REG_HIREFNOL);
 263         alrc=256*se401_get_feature(se401, HV7131_REG_LOREFNOH) +
 264             se401_get_feature(se401, HV7131_REG_LOREFNOL);
 265
 266         /* Not an exact science, but it seems to work pretty well... */
 267         if (alrc > 10) {
 268                 while (alrc>=10 && se401->resetlevel < 63) {
 269                         se401->resetlevel++;
 270                         alrc /=2;
 271                 }
 272         } else if (ahrc > 20) {
 273                 while (ahrc>=20 && se401->resetlevel > 0) {
 274                         se401->resetlevel--;
 275                         ahrc /=2;
 276                 }
 277         }
 278         if (se401->resetlevel!=oldreset)
 279                 se401_set_feature(se401, HV7131_REG_ARLV, se401->resetlevel);
 280
 281         return;
 282 }
 283
 284 /* irq handler for snapshot button */
 285 static void se401_button_irq(struct urb *urb)
 286 {
 287         struct usb_se401 *se401 = urb->context;
 288         int status;
 289
 290         if (!se401->dev) {
 291                 dev_info(&urb->dev->dev, "device vapourished\n");
 292                 return;
 293         }
 294
 295         switch (urb->status) {
 296         case 0:
 297                 /* success */
 298                 break;
 299         case -ECONNRESET:
 300         case -ENOENT:
 301         case -ESHUTDOWN:
 302                 /* this urb is terminated, clean up */
 303                 dbg("%s - urb shutting down with status: %d", __func__, urb->status);
 304                 return;
 305         default:
 306                 dbg("%s - nonzero urb status received: %d", __func__, urb->status);
 307                 goto exit;
 308         }
 309
 310         if (urb->actual_length >=2) {
 311                 if (se401->button)
 312                         se401->buttonpressed=1;
 313         }
 314 exit:
 315         status = usb_submit_urb (urb, GFP_ATOMIC);
 316         if (status)
 317                 err ("%s - usb_submit_urb failed with result %d",
 318                      __func__, status);
 319 }
 320
 321 static void se401_video_irq(struct urb *urb)
 322 {
 323         struct usb_se401 *se401 = urb->context;
 324         int length = urb->actual_length;
 325
 326         /* ohoh... */
 327         if (!se401->streaming)
 328                 return;
 329
 330         if (!se401->dev) {
 331                 dev_info(&urb->dev->dev, "device vapourished\n");
 332                 return;
 333         }
 334
 335         /* 0 sized packets happen if we are to fast, but sometimes the camera
 336            keeps sending them forever...
 337          */
 338         if (length && !urb->status) {
 339                 se401->nullpackets=0;
 340                 switch(se401->scratch[se401->scratch_next].state) {
 341                         case BUFFER_READY:
 342                         case BUFFER_BUSY: {
 343                                 se401->dropped++;
 344                                 break;
 345                         }
 346                         case BUFFER_UNUSED: {
 347                                 memcpy(se401->scratch[se401->scratch_next].data, (unsigned char *)urb->transfer_buffer, length);
 348                                 se401->scratch[se401->scratch_next].state=BUFFER_READY;
 349                                 se401->scratch[se401->scratch_next].offset=se401->bayeroffset;
 350                                 se401->scratch[se401->scratch_next].length=length;
 351                                 if (waitqueue_active(&se401->wq)) {
 352                                         wake_up_interruptible(&se401->wq);
 353                                 }
 354                                 se401->scratch_overflow=0;
 355                                 se401->scratch_next++;
 356                                 if (se401->scratch_next>=SE401_NUMSCRATCH)
 357                                         se401->scratch_next=0;
 358                                 break;
 359                         }
 360                 }
 361                 se401->bayeroffset+=length;
 362                 if (se401->bayeroffset>=se401->cheight*se401->cwidth) {
 363                         se401->bayeroffset=0;
 364                 }
 365         } else {
 366                 se401->nullpackets++;
 367                 if (se401->nullpackets > SE401_MAX_NULLPACKETS) {
 368                         if (waitqueue_active(&se401->wq)) {
 369                                 wake_up_interruptible(&se401->wq);
 370                         }
 371                 }
 372         }
 373
 374         /* Resubmit urb for new data */
 375         urb->status=0;
 376         urb->dev=se401->dev;
 377         if(usb_submit_urb(urb, GFP_KERNEL))
 378                 dev_info(&urb->dev->dev, "urb burned down\n");
 379         return;
 380 }
 381
 382 static void se401_send_size(struct usb_se401 *se401, int width, int height)
 383 {
 384         int i=0;
 385         int mode=0x03; /* No compression */
 386         int sendheight=height;
 387         int sendwidth=width;
 388
 389         /* JangGu compression can only be used with the camera supported sizes,
 390            but bayer seems to work with any size that fits on the sensor.
 391            We check if we can use compression with the current size with either
 392            4 or 16 times subcapturing, if not we use uncompressed bayer data
 393            but this will result in cutouts of the maximum size....
 394          */
 395         while (i<se401->sizes && !(se401->width[i]==width && se401->height[i]==height))
 396                 i++;
 397         while (i<se401->sizes) {
 398                 if (se401->width[i]==width*2 && se401->height[i]==height*2) {
 399                         sendheight=se401->height[i];
 400                         sendwidth=se401->width[i];
 401                         mode=0x40;
 402                 }
 403                 if (se401->width[i]==width*4 && se401->height[i]==height*4) {
 404                         sendheight=se401->height[i];
 405                         sendwidth=se401->width[i];
 406                         mode=0x42;
 407                 }
 408                 i++;
 409         }
 410
 411         se401_sndctrl(1, se401, SE401_REQ_SET_WIDTH, sendwidth, NULL, 0);
 412         se401_sndctrl(1, se401, SE401_REQ_SET_HEIGHT, sendheight, NULL, 0);
 413         se401_set_feature(se401, SE401_OPERATINGMODE, mode);
 414
 415         if (mode==0x03) {
 416                 se401->format=FMT_BAYER;
 417         } else {
 418                 se401->format=FMT_JANGGU;
 419         }
 420
 421         return;
 422 }
 423
 424 /*
 425         In this function se401_send_pict is called several times,
 426         for some reason (depending on the state of the sensor and the phase of
 427         the moon :) doing this only in either place doesn't always work...
 428 */
 429 static int se401_start_stream(struct usb_se401 *se401)
 430 {
 431         struct urb *urb;
 432         int err=0, i;
 433         se401->streaming=1;
 434
 435         se401_sndctrl(1, se401, SE401_REQ_CAMERA_POWER, 1, NULL, 0);
 436         se401_sndctrl(1, se401, SE401_REQ_LED_CONTROL, 1, NULL, 0);
 437
 438         /* Set picture settings */
 439         se401_set_feature(se401, HV7131_REG_MODE_B, 0x05);/*windowed + pix intg */
 440         se401_send_pict(se401);
 441
 442         se401_send_size(se401, se401->cwidth, se401->cheight);
 443
 444         se401_sndctrl(1, se401, SE401_REQ_START_CONTINUOUS_CAPTURE, 0, NULL, 0);
 445
 446         /* Do some memory allocation */
 447         for (i=0; i<SE401_NUMFRAMES; i++) {
 448                 se401->frame[i].data=se401->fbuf + i * se401->maxframesize;
 449                 se401->frame[i].curpix=0;
 450         }
 451         for (i=0; i<SE401_NUMSBUF; i++) {
 452                 se401->sbuf[i].data=kmalloc(SE401_PACKETSIZE, GFP_KERNEL);
 453                 if (!se401->sbuf[i].data) {
 454                         for(i = i - 1; i >= 0; i--) {
 455                                 kfree(se401->sbuf[i].data);
 456                                 se401->sbuf[i].data = NULL;
 457                         }
 458                         return -ENOMEM;
 459                 }
 460         }
 461
 462         se401->bayeroffset=0;
 463         se401->scratch_next=0;
 464         se401->scratch_use=0;
 465         se401->scratch_overflow=0;
 466         for (i=0; i<SE401_NUMSCRATCH; i++) {
 467                 se401->scratch[i].data=kmalloc(SE401_PACKETSIZE, GFP_KERNEL);
 468                 if (!se401->scratch[i].data) {
 469                         for(i = i - 1; i >= 0; i--) {
 470                                 kfree(se401->scratch[i].data);
 471                                 se401->scratch[i].data = NULL;
 472                         }
 473                         goto nomem_sbuf;
 474                 }
 475                 se401->scratch[i].state=BUFFER_UNUSED;
 476         }
 477
 478         for (i=0; i<SE401_NUMSBUF; i++) {
 479                 urb=usb_alloc_urb(0, GFP_KERNEL);
 480                 if(!urb) {
 481                         for(i = i - 1; i >= 0; i--) {
 482                                 usb_kill_urb(se401->urb[i]);
 483                                 usb_free_urb(se401->urb[i]);
 484                                 se401->urb[i] = NULL;
 485                         }
 486                         goto nomem_scratch;
 487                 }
 488
 489                 usb_fill_bulk_urb(urb, se401->dev,
 490                         usb_rcvbulkpipe(se401->dev, SE401_VIDEO_ENDPOINT),
 491                         se401->sbuf[i].data, SE401_PACKETSIZE,
 492                         se401_video_irq,
 493                         se401);
 494
 495                 se401->urb[i]=urb;
 496
 497                 err=usb_submit_urb(se401->urb[i], GFP_KERNEL);
 498                 if(err)
 499                         err("urb burned down");
 500         }
 501
 502         se401->framecount=0;
 503
 504         return 0;
 505
 506  nomem_scratch:
 507         for (i=0; i<SE401_NUMSCRATCH; i++) {
 508                 kfree(se401->scratch[i].data);
 509                 se401->scratch[i].data = NULL;
 510         }
 511  nomem_sbuf:
 512         for (i=0; i<SE401_NUMSBUF; i++) {
 513                 kfree(se401->sbuf[i].data);
 514                 se401->sbuf[i].data = NULL;
 515         }
 516         return -ENOMEM;
 517 }
 518
 519 static int se401_stop_stream(struct usb_se401 *se401)
 520 {
 521         int i;
 522
 523         if (!se401->streaming || !se401->dev)
 524                 return 1;
 525
 526         se401->streaming=0;
 527
 528         se401_sndctrl(1, se401, SE401_REQ_STOP_CONTINUOUS_CAPTURE, 0, NULL, 0);
 529
 530         se401_sndctrl(1, se401, SE401_REQ_LED_CONTROL, 0, NULL, 0);
 531         se401_sndctrl(1, se401, SE401_REQ_CAMERA_POWER, 0, NULL, 0);
 532
 533         for (i=0; i<SE401_NUMSBUF; i++) if (se401->urb[i]) {
 534                 usb_kill_urb(se401->urb[i]);
 535                 usb_free_urb(se401->urb[i]);
 536                 se401->urb[i]=NULL;
 537                 kfree(se401->sbuf[i].data);
 538         }
 539         for (i=0; i<SE401_NUMSCRATCH; i++) {
 540                 kfree(se401->scratch[i].data);
 541                 se401->scratch[i].data=NULL;
 542         }
 543
 544         return 0;
 545 }
 546
 547 static int se401_set_size(struct usb_se401 *se401, int width, int height)
 548 {
 549         int wasstreaming=se401->streaming;
 550         /* Check to see if we need to change */
 551         if (se401->cwidth==width && se401->cheight==height)
 552                 return 0;
 553
 554         /* Check for a valid mode */
 555         if (!width || !height)
 556                 return 1;
 557         if ((width & 1) || (height & 1))
 558                 return 1;
 559         if (width>se401->width[se401->sizes-1])
 560                 return 1;
 561         if (height>se401->height[se401->sizes-1])
 562                 return 1;
 563
 564         /* Stop a current stream and start it again at the new size */
 565         if (wasstreaming)
 566                 se401_stop_stream(se401);
 567         se401->cwidth=width;
 568         se401->cheight=height;
 569         if (wasstreaming)
 570                 se401_start_stream(se401);
 571         return 0;
 572 }
 573
 574
 575 /****************************************************************************
 576  *
 577  * Video Decoding
 578  *
 579  ***************************************************************************/
 580
 581 /*
 582         This shouldn't really be done in a v4l driver....
 583         But it does make the image look a lot more usable.
 584         Basically it lifts the dark pixels more than the light pixels.
 585 */
 586 static inline void enhance_picture(unsigned char *frame, int len)
 587 {
 588         while (len--) {
 589                 *frame=(((*frame^255)*(*frame^255))/255)^255;
 590                 frame++;
 591         }
 592 }
 593
 594 static inline void decode_JangGu_integrate(struct usb_se401 *se401, int data)
 595 {
 596         struct se401_frame *frame=&se401->frame[se401->curframe];
 597         int linelength=se401->cwidth*3;
 598
 599         if (frame->curlinepix >= linelength) {
 600                 frame->curlinepix=0;
 601                 frame->curline+=linelength;
 602         }
 603
 604         /* First three are absolute, all others relative.
 605          * Format is rgb from right to left (mirrorred image),
 606          * we flip it to get bgr from left to right. */
 607         if (frame->curlinepix < 3) {
 608                 *(frame->curline-frame->curlinepix)=1+data*4;
 609         } else {
 610                 *(frame->curline-frame->curlinepix)=
 611                     *(frame->curline-frame->curlinepix+3)+data*4;
 612         }
 613         frame->curlinepix++;
 614 }
 615
 616 static inline void decode_JangGu_vlc (struct usb_se401 *se401, unsigned char *data, int bit_exp, int packetlength)
 617 {
 618         int pos=0;
 619         int vlc_cod=0;
 620         int vlc_size=0;
 621         int vlc_data=0;
 622         int bit_cur;
 623         int bit;
 624         data+=4;
 625         while (pos < packetlength) {
 626                 bit_cur=8;
 627                 while (bit_cur && bit_exp) {
 628                         bit=((*data)>>(bit_cur-1))&1;
 629                         if (!vlc_cod) {
 630                                 if (bit) {
 631                                         vlc_size++;
 632                                 } else {
 633                                         if (!vlc_size) {
 634                                                 decode_JangGu_integrate(se401, 0);
 635                                         } else {
 636                                                 vlc_cod=2;
 637                                                 vlc_data=0;
 638                                         }
 639                                 }
 640                         } else {
 641                                 if (vlc_cod==2) {
 642                                         if (!bit)
 643                                                 vlc_data =  -(1<<vlc_size) + 1;
 644                                         vlc_cod--;
 645                                 }
 646                                 vlc_size--;
 647                                 vlc_data+=bit<<vlc_size;
 648                                 if (!vlc_size) {
 649                                         decode_JangGu_integrate(se401, vlc_data);
 650                                         vlc_cod=0;
 651                                 }
 652                         }
 653                         bit_cur--;
 654                         bit_exp--;
 655                 }
 656                 pos++;
 657                 data++;
 658         }
 659 }
 660
 661 static inline void decode_JangGu (struct usb_se401 *se401, struct se401_scratch *buffer)
 662 {
 663         unsigned char *data=buffer->data;
 664         int len=buffer->length;
 665         int bit_exp=0, pix_exp=0, frameinfo=0, packetlength=0, size;
 666         int datapos=0;
 667
 668         /* New image? */
 669         if (!se401->frame[se401->curframe].curpix) {
 670                 se401->frame[se401->curframe].curlinepix=0;
 671                 se401->frame[se401->curframe].curline=
 672                     se401->frame[se401->curframe].data+
 673                     se401->cwidth*3-1;
 674                 if (se401->frame[se401->curframe].grabstate==FRAME_READY)
 675                         se401->frame[se401->curframe].grabstate=FRAME_GRABBING;
 676                 se401->vlcdatapos=0;
 677         }
 678         while (datapos < len) {
 679                 size=1024-se401->vlcdatapos;
 680                 if (size+datapos > len)
 681                         size=len-datapos;
 682                 memcpy(se401->vlcdata+se401->vlcdatapos, data+datapos, size);
 683                 se401->vlcdatapos+=size;
 684                 packetlength=0;
 685                 if (se401->vlcdatapos >= 4) {
 686                         bit_exp=se401->vlcdata[3]+(se401->vlcdata[2]<<8);
 687                         pix_exp=se401->vlcdata[1]+((se401->vlcdata[0]&0x3f)<<8);
 688                         frameinfo=se401->vlcdata[0]&0xc0;
 689                         packetlength=((bit_exp+47)>>4)<<1;
 690                         if (packetlength > 1024) {
 691                                 se401->vlcdatapos=0;
 692                                 datapos=len;
 693                                 packetlength=0;
 694                                 se401->error++;
 695                                 se401->frame[se401->curframe].curpix=0;
 696                         }
 697                 }
 698                 if (packetlength && se401->vlcdatapos >= packetlength) {
 699                         decode_JangGu_vlc(se401, se401->vlcdata, bit_exp, packetlength);
 700                         se401->frame[se401->curframe].curpix+=pix_exp*3;
 701                         datapos+=size-(se401->vlcdatapos-packetlength);
 702                         se401->vlcdatapos=0;
 703                         if (se401->frame[se401->curframe].curpix>=se401->cwidth*se401->cheight*3) {
 704                                 if (se401->frame[se401->curframe].curpix==se401->cwidth*se401->cheight*3) {
 705                                         if (se401->frame[se401->curframe].grabstate==FRAME_GRABBING) {
 706                                                 se401->frame[se401->curframe].grabstate=FRAME_DONE;
 707                                                 se401->framecount++;
 708                                                 se401->readcount++;
 709                                         }
 710                                         if (se401->frame[(se401->curframe+1)&(SE401_NUMFRAMES-1)].grabstate==FRAME_READY) {
 711                                                 se401->curframe=(se401->curframe+1) & (SE401_NUMFRAMES-1);
 712                                         }
 713                                 } else {
 714                                         se401->error++;
 715                                 }
 716                                 se401->frame[se401->curframe].curpix=0;
 717                                 datapos=len;
 718                         }
 719                 } else {
 720                         datapos+=size;
 721                 }
 722         }
 723 }
 724
 725 static inline void decode_bayer (struct usb_se401 *se401, struct se401_scratch *buffer)
 726 {
 727         unsigned char *data=buffer->data;
 728         int len=buffer->length;
 729         int offset=buffer->offset;
 730         int datasize=se401->cwidth*se401->cheight;
 731         struct se401_frame *frame=&se401->frame[se401->curframe];
 732
 733         unsigned char *framedata=frame->data, *curline, *nextline;
 734         int width=se401->cwidth;
 735         int blineoffset=0, bline;
 736         int linelength=width*3, i;
 737
 738
 739         if (frame->curpix==0) {
 740                 if (frame->grabstate==FRAME_READY) {
 741                         frame->grabstate=FRAME_GRABBING;
 742                 }
 743                 frame->curline=framedata+linelength;
 744                 frame->curlinepix=0;
 745         }
 746
 747         if (offset!=frame->curpix) {
 748                 /* Regard frame as lost :( */
 749                 frame->curpix=0;
 750                 se401->error++;
 751                 return;
 752         }
 753
 754         /* Check if we have to much data */
 755         if (frame->curpix+len > datasize) {
 756                 len=datasize-frame->curpix;
 757         }
 758         if (se401->cheight%4)
 759                 blineoffset=1;
 760         bline=frame->curpix/se401->cwidth+blineoffset;
 761
 762         curline=frame->curline;
 763         nextline=curline+linelength;
 764         if (nextline >= framedata+datasize*3)
 765                 nextline=curline;
 766         while (len) {
 767                 if (frame->curlinepix>=width) {
 768                         frame->curlinepix-=width;
 769                         bline=frame->curpix/width+blineoffset;
 770                         curline+=linelength*2;
 771                         nextline+=linelength*2;
 772                         if (curline >= framedata+datasize*3) {
 773                                 frame->curlinepix++;
 774                                 curline-=3;
 775                                 nextline-=3;
 776                                 len--;
 777                                 data++;
 778                                 frame->curpix++;
 779                         }
 780                         if (nextline >= framedata+datasize*3)
 781                                 nextline=curline;
 782                 }
 783                 if ((bline&1)) {
 784                         if ((frame->curlinepix&1)) {
 785                                 *(curline+2)=*data;
 786                                 *(curline-1)=*data;
 787                                 *(nextline+2)=*data;
 788                                 *(nextline-1)=*data;
 789                         } else {
 790                                 *(curline+1)=
 791                                         (*(curline+1)+*data)/2;
 792                                 *(curline-2)=
 793                                         (*(curline-2)+*data)/2;
 794                                 *(nextline+1)=*data;
 795                                 *(nextline-2)=*data;
 796                         }
 797                 } else {
 798                         if ((frame->curlinepix&1)) {
 799                                 *(curline+1)=
 800                                         (*(curline+1)+*data)/2;
 801                                 *(curline-2)=
 802                                         (*(curline-2)+*data)/2;
 803                                 *(nextline+1)=*data;
 804                                 *(nextline-2)=*data;
 805                         } else {
 806                                 *curline=*data;
 807                                 *(curline-3)=*data;
 808                                 *nextline=*data;
 809                                 *(nextline-3)=*data;
 810                         }
 811                 }
 812                 frame->curlinepix++;
 813                 curline-=3;
 814                 nextline-=3;
 815                 len--;
 816                 data++;
 817                 frame->curpix++;
 818         }
 819         frame->curline=curline;
 820
 821         if (frame->curpix>=datasize) {
 822                 /* Fix the top line */
 823                 framedata+=linelength;
 824                 for (i=0; i<linelength; i++) {
 825                         framedata--;
 826                         *framedata=*(framedata+linelength);
 827                 }
 828                 /* Fix the left side (green is already present) */
 829                 for (i=0; i<se401->cheight; i++) {
 830                         *framedata=*(framedata+3);
 831                         *(framedata+1)=*(framedata+4);
 832                         *(framedata+2)=*(framedata+5);
 833                         framedata+=linelength;
 834                 }
 835                 frame->curpix=0;
 836                 frame->grabstate=FRAME_DONE;
 837                 se401->framecount++;
 838                 se401->readcount++;
 839                 if (se401->frame[(se401->curframe+1)&(SE401_NUMFRAMES-1)].grabstate==FRAME_READY) {
 840                         se401->curframe=(se401->curframe+1) & (SE401_NUMFRAMES-1);
 841                 }
 842         }
 843 }
 844
 845 static int se401_newframe(struct usb_se401 *se401, int framenr)
 846 {
 847         DECLARE_WAITQUEUE(wait, current);
 848         int errors=0;
 849
 850         while (se401->streaming &&
 851             (se401->frame[framenr].grabstate==FRAME_READY ||
 852              se401->frame[framenr].grabstate==FRAME_GRABBING) ) {
 853                 if(!se401->frame[framenr].curpix) {
 854                         errors++;
 855                 }
 856                 wait_interruptible(
 857                     se401->scratch[se401->scratch_use].state!=BUFFER_READY,
 858                     &se401->wq,
 859                     &wait
 860                 );
 861                 if (se401->nullpackets > SE401_MAX_NULLPACKETS) {
 862                         se401->nullpackets=0;
 863                         dev_info(&se401->dev->dev,
 864                                  "too many null length packets, restarting capture\n");
 865                         se401_stop_stream(se401);
 866                         se401_start_stream(se401);
 867                 } else {
 868                         if (se401->scratch[se401->scratch_use].state!=BUFFER_READY) {
 869                                 se401->frame[framenr].grabstate=FRAME_ERROR;
 870                                 return -EIO;
 871                         }
 872                         se401->scratch[se401->scratch_use].state=BUFFER_BUSY;
 873                         if (se401->format==FMT_JANGGU) {
 874                                 decode_JangGu(se401, &se401->scratch[se401->scratch_use]);
 875                         } else {
 876                                 decode_bayer(se401, &se401->scratch[se401->scratch_use]);
 877                         }
 878                         se401->scratch[se401->scratch_use].state=BUFFER_UNUSED;
 879                         se401->scratch_use++;
 880                         if (se401->scratch_use>=SE401_NUMSCRATCH)
 881                                 se401->scratch_use=0;
 882                         if (errors > SE401_MAX_ERRORS) {
 883                                 errors=0;
 884                                 dev_info(&se401->dev->dev,
 885                                          "too many errors, restarting capture\n");
 886                                 se401_stop_stream(se401);
 887                                 se401_start_stream(se401);
 888                         }
 889                 }
 890         }
 891
 892         if (se401->frame[framenr].grabstate==FRAME_DONE)
 893                 if (se401->enhance)
 894                         enhance_picture(se401->frame[framenr].data, se401->cheight*se401->cwidth*3);
 895         return 0;
 896 }
 897
 898 static void usb_se401_remove_disconnected (struct usb_se401 *se401)
 899 {
 900         int i;
 901
 902         se401->dev = NULL;
 903
 904         for (i=0; i<SE401_NUMSBUF; i++)
 905                 if (se401->urb[i]) {
 906                         usb_kill_urb(se401->urb[i]);
 907                         usb_free_urb(se401->urb[i]);
 908                         se401->urb[i] = NULL;
 909                         kfree(se401->sbuf[i].data);
 910                 }
 911         for (i=0; i<SE401_NUMSCRATCH; i++) {
 912                 kfree(se401->scratch[i].data);
 913         }
 914         if (se401->inturb) {
 915                 usb_kill_urb(se401->inturb);
 916                 usb_free_urb(se401->inturb);
 917         }
 918         dev_info(&se401->dev->dev, "%s disconnected", se401->camera_name);
 919
 920         /* Free the memory */
 921         kfree(se401->width);
 922         kfree(se401->height);
 923         kfree(se401);
 924 }
 925
 926
 927
 928 /****************************************************************************
 929  *
 930  * Video4Linux
 931  *
 932  ***************************************************************************/
 933
 934
 935 static int se401_open(struct inode *inode, struct file *file)
 936 {
 937         struct video_device *dev = video_devdata(file);
 938         struct usb_se401 *se401 = (struct usb_se401 *)dev;
 939         int err = 0;
 940
 941         lock_kernel();
 942         if (se401->user) {
 943                 unlock_kernel();
 944                 return -EBUSY;
 945         }
 946         se401->fbuf = rvmalloc(se401->maxframesize * SE401_NUMFRAMES);
 947         if (se401->fbuf)
 948                 file->private_data = dev;
 949         else
 950                 err = -ENOMEM;
 951         se401->user = !err;
 952         unlock_kernel();
 953
 954         return err;
 955 }
 956
 957 static int se401_close(struct inode *inode, struct file *file)
 958 {
 959         struct video_device *dev = file->private_data;
 960         struct usb_se401 *se401 = (struct usb_se401 *)dev;
 961         int i;
 962
 963         rvfree(se401->fbuf, se401->maxframesize * SE401_NUMFRAMES);
 964         if (se401->removed) {
 965                 dev_info(&se401->dev->dev, "device unregistered\n");
 966                 usb_se401_remove_disconnected(se401);
 967         } else {
 968                 for (i=0; i<SE401_NUMFRAMES; i++)
 969                         se401->frame[i].grabstate=FRAME_UNUSED;
 970                 if (se401->streaming)
 971                         se401_stop_stream(se401);
 972                 se401->user=0;
 973         }
 974         file->private_data = NULL;
 975         return 0;
 976 }
 977
 978 static int se401_do_ioctl(struct inode *inode, struct file *file,
 979                           unsigned int cmd, void *arg)
 980 {
 981         struct video_device *vdev = file->private_data;
 982         struct usb_se401 *se401 = (struct usb_se401 *)vdev;
 983
 984         if (!se401->dev)
 985                 return -EIO;
 986
 987         switch (cmd) {
 988         case VIDIOCGCAP:
 989         {
 990                 struct video_capability *b = arg;
 991                 strcpy(b->name, se401->camera_name);
 992                 b->type = VID_TYPE_CAPTURE;
 993                 b->channels = 1;
 994                 b->audios = 0;
 995                 b->maxwidth = se401->width[se401->sizes-1];
 996                 b->maxheight = se401->height[se401->sizes-1];
 997                 b->minwidth = se401->width[0];
 998                 b->minheight = se401->height[0];
 999                 return 0;
1000         }
1001         case VIDIOCGCHAN:
1002         {
1003                 struct video_channel *v = arg;
1004
1005                 if (v->channel != 0)
1006                         return -EINVAL;
1007                 v->flags = 0;
1008                 v->tuners = 0;
1009                 v->type = VIDEO_TYPE_CAMERA;
1010                 strcpy(v->name, "Camera");
1011                 return 0;
1012         }
1013         case VIDIOCSCHAN:
1014         {
1015                 struct video_channel *v = arg;
1016
1017                 if (v->channel != 0)
1018                         return -EINVAL;
1019                 return 0;
1020         }
1021         case VIDIOCGPICT:
1022         {
1023                 struct video_picture *p = arg;
1024
1025                 se401_get_pict(se401, p);
1026                 return 0;
1027         }
1028         case VIDIOCSPICT:
1029         {
1030                 struct video_picture *p = arg;
1031
1032                 if (se401_set_pict(se401, p))
1033                         return -EINVAL;
1034                 return 0;
1035         }
1036         case VIDIOCSWIN:
1037         {
1038                 struct video_window *vw = arg;
1039
1040                 if (vw->flags)
1041                         return -EINVAL;
1042                 if (vw->clipcount)
1043                         return -EINVAL;
1044                 if (se401_set_size(se401, vw->width, vw->height))
1045                         return -EINVAL;
1046                 return 0;
1047         }
1048         case VIDIOCGWIN:
1049         {
1050                 struct video_window *vw = arg;
1051
1052                 vw->x = 0;               /* FIXME */
1053                 vw->y = 0;
1054                 vw->chromakey = 0;
1055                 vw->flags = 0;
1056                 vw->clipcount = 0;
1057                 vw->width = se401->cwidth;
1058                 vw->height = se401->cheight;
1059                 return 0;
1060         }
1061         case VIDIOCGMBUF:
1062         {
1063                 struct video_mbuf *vm = arg;
1064                 int i;
1065
1066                 memset(vm, 0, sizeof(*vm));
1067                 vm->size = SE401_NUMFRAMES * se401->maxframesize;
1068                 vm->frames = SE401_NUMFRAMES;
1069                 for (i=0; i<SE401_NUMFRAMES; i++)
1070                         vm->offsets[i] = se401->maxframesize * i;
1071                 return 0;
1072         }
1073         case VIDIOCMCAPTURE:
1074         {
1075                 struct video_mmap *vm = arg;
1076
1077                 if (vm->format != VIDEO_PALETTE_RGB24)
1078                         return -EINVAL;
1079                 if (vm->frame >= SE401_NUMFRAMES)
1080                         return -EINVAL;
1081                 if (se401->frame[vm->frame].grabstate != FRAME_UNUSED)
1082                         return -EBUSY;
1083
1084                 /* Is this according to the v4l spec??? */
1085                 if (se401_set_size(se401, vm->width, vm->height))
1086                         return -EINVAL;
1087                 se401->frame[vm->frame].grabstate=FRAME_READY;
1088
1089                 if (!se401->streaming)
1090                         se401_start_stream(se401);
1091
1092                 /* Set the picture properties */
1093                 if (se401->framecount==0)
1094                         se401_send_pict(se401);
1095                 /* Calibrate the reset level after a few frames. */
1096                 if (se401->framecount%20==1)
1097                         se401_auto_resetlevel(se401);
1098
1099                 return 0;
1100         }
1101         case VIDIOCSYNC:
1102         {
1103                 int *frame = arg;
1104                 int ret=0;
1105
1106                 if(*frame <0 || *frame >= SE401_NUMFRAMES)
1107                         return -EINVAL;
1108
1109                 ret=se401_newframe(se401, *frame);
1110                 se401->frame[*frame].grabstate=FRAME_UNUSED;
1111                 return ret;
1112         }
1113         case VIDIOCGFBUF:
1114         {
1115                 struct video_buffer *vb = arg;
1116
1117                 memset(vb, 0, sizeof(*vb));
1118                 return 0;
1119         }
1120         case VIDIOCKEY:
1121                 return 0;
1122         case VIDIOCCAPTURE:
1123                 return -EINVAL;
1124         case VIDIOCSFBUF:
1125                 return -EINVAL;
1126         case VIDIOCGTUNER:
1127         case VIDIOCSTUNER:
1128                 return -EINVAL;
1129         case VIDIOCGFREQ:
1130         case VIDIOCSFREQ:
1131                 return -EINVAL;
1132         case VIDIOCGAUDIO:
1133         case VIDIOCSAUDIO:
1134                 return -EINVAL;
1135         default:
1136                 return -ENOIOCTLCMD;
1137         } /* end switch */
1138
1139         return 0;
1140 }
1141
1142 static int se401_ioctl(struct inode *inode, struct file *file,
1143                        unsigned int cmd, unsigned long arg)
1144 {
1145         return video_usercopy(inode, file, cmd, arg, se401_do_ioctl);
1146 }
1147
1148 static ssize_t se401_read(struct file *file, char __user *buf,
1149                      size_t count, loff_t *ppos)
1150 {
1151         int realcount=count, ret=0;
1152         struct video_device *dev = file->private_data;
1153         struct usb_se401 *se401 = (struct usb_se401 *)dev;
1154
1155
1156         if (se401->dev == NULL)
1157                 return -EIO;
1158         if (realcount > se401->cwidth*se401->cheight*3)
1159                 realcount=se401->cwidth*se401->cheight*3;
1160
1161         /* Shouldn't happen: */
1162         if (se401->frame[0].grabstate==FRAME_GRABBING)
1163                 return -EBUSY;
1164         se401->frame[0].grabstate=FRAME_READY;
1165         se401->frame[1].grabstate=FRAME_UNUSED;
1166         se401->curframe=0;
1167
1168         if (!se401->streaming)
1169                 se401_start_stream(se401);
1170
1171         /* Set the picture properties */
1172         if (se401->framecount==0)
1173                 se401_send_pict(se401);
1174         /* Calibrate the reset level after a few frames. */
1175         if (se401->framecount%20==1)
1176                 se401_auto_resetlevel(se401);
1177
1178         ret=se401_newframe(se401, 0);
1179
1180         se401->frame[0].grabstate=FRAME_UNUSED;
1181         if (ret)
1182                 return ret;
1183         if (copy_to_user(buf, se401->frame[0].data, realcount))
1184                 return -EFAULT;
1185
1186         return realcount;
1187 }
1188
1189 static int se401_mmap(struct file *file, struct vm_area_struct *vma)
1190 {
1191         struct video_device *dev = file->private_data;
1192         struct usb_se401 *se401 = (struct usb_se401 *)dev;
1193         unsigned long start = vma->vm_start;
1194         unsigned long size  = vma->vm_end-vma->vm_start;
1195         unsigned long page, pos;
1196
1197         mutex_lock(&se401->lock);
1198
1199         if (se401->dev == NULL) {
1200                 mutex_unlock(&se401->lock);
1201                 return -EIO;
1202         }
1203         if (size > (((SE401_NUMFRAMES * se401->maxframesize) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))) {
1204                 mutex_unlock(&se401->lock);
1205                 return -EINVAL;
1206         }
1207         pos = (unsigned long)se401->fbuf;
1208         while (size > 0) {
1209                 page = vmalloc_to_pfn((void *)pos);
1210                 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
1211                         mutex_unlock(&se401->lock);
1212                         return -EAGAIN;
1213                 }
1214                 start += PAGE_SIZE;
1215                 pos += PAGE_SIZE;
1216                 if (size > PAGE_SIZE)
1217                         size -= PAGE_SIZE;
1218                 else
1219                         size = 0;
1220         }
1221         mutex_unlock(&se401->lock);
1222
1223         return 0;
1224 }
1225
1226 static const struct file_operations se401_fops = {
1227         .owner =        THIS_MODULE,
1228         .open =         se401_open,
1229         .release =      se401_close,
1230         .read =         se401_read,
1231         .mmap =         se401_mmap,
1232         .ioctl =        se401_ioctl,
1233 #ifdef CONFIG_COMPAT
1234         .compat_ioctl = v4l_compat_ioctl32,
1235 #endif
1236         .llseek =       no_llseek,
1237 };
1238 static struct video_device se401_template = {
1239         .name =         "se401 USB camera",
1240         .fops =         &se401_fops,
1241         .release = video_device_release_empty,
1242 };
1243
1244
1245
1246 /***************************/
1247 static int se401_init(struct usb_se401 *se401, int button)
1248 {
1249         int i=0, rc;
1250         unsigned char cp[0x40];
1251         char temp[200];
1252
1253         /* led on */
1254         se401_sndctrl(1, se401, SE401_REQ_LED_CONTROL, 1, NULL, 0);
1255
1256         /* get camera descriptor */
1257         rc=se401_sndctrl(0, se401, SE401_REQ_GET_CAMERA_DESCRIPTOR, 0, cp, sizeof(cp));
1258         if (cp[1]!=0x41) {
1259                 err("Wrong descriptor type");
1260                 return 1;
1261         }
1262         sprintf (temp, "ExtraFeatures: %d", cp[3]);
1263
1264         se401->sizes=cp[4]+cp[5]*256;
1265         se401->width=kmalloc(se401->sizes*sizeof(int), GFP_KERNEL);
1266         if (!se401->width)
1267                 return 1;
1268         se401->height=kmalloc(se401->sizes*sizeof(int), GFP_KERNEL);
1269         if (!se401->height) {
1270                 kfree(se401->width);
1271                 return 1;
1272         }
1273         for (i=0; i<se401->sizes; i++) {
1274                     se401->width[i]=cp[6+i*4+0]+cp[6+i*4+1]*256;
1275                     se401->height[i]=cp[6+i*4+2]+cp[6+i*4+3]*256;
1276         }
1277         sprintf (temp, "%s Sizes:", temp);
1278         for (i=0; i<se401->sizes; i++) {
1279                 sprintf(temp, "%s %dx%d", temp, se401->width[i], se401->height[i]);
1280         }
1281         dev_info(&se401->dev->dev, "%s\n", temp);
1282         se401->maxframesize=se401->width[se401->sizes-1]*se401->height[se401->sizes-1]*3;
1283
1284         rc=se401_sndctrl(0, se401, SE401_REQ_GET_WIDTH, 0, cp, sizeof(cp));
1285         se401->cwidth=cp[0]+cp[1]*256;
1286         rc=se401_sndctrl(0, se401, SE401_REQ_GET_HEIGHT, 0, cp, sizeof(cp));
1287         se401->cheight=cp[0]+cp[1]*256;
1288
1289         if (!(cp[2] & SE401_FORMAT_BAYER)) {
1290                 err("Bayer format not supported!");
1291                 return 1;
1292         }
1293         /* set output mode (BAYER) */
1294         se401_sndctrl(1, se401, SE401_REQ_SET_OUTPUT_MODE, SE401_FORMAT_BAYER, NULL, 0);
1295
1296         rc=se401_sndctrl(0, se401, SE401_REQ_GET_BRT, 0, cp, sizeof(cp));
1297         se401->brightness=cp[0]+cp[1]*256;
1298         /* some default values */
1299         se401->resetlevel=0x2d;
1300         se401->rgain=0x20;
1301         se401->ggain=0x20;
1302         se401->bgain=0x20;
1303         se401_set_exposure(se401, 20000);
1304         se401->palette=VIDEO_PALETTE_RGB24;
1305         se401->enhance=1;
1306         se401->dropped=0;
1307         se401->error=0;
1308         se401->framecount=0;
1309         se401->readcount=0;
1310
1311         /* Start interrupt transfers for snapshot button */
1312         if (button) {
1313                 se401->inturb=usb_alloc_urb(0, GFP_KERNEL);
1314                 if (!se401->inturb) {
1315                         dev_info(&se401->dev->dev,
1316                                  "Allocation of inturb failed\n");
1317                         return 1;
1318                 }
1319                 usb_fill_int_urb(se401->inturb, se401->dev,
1320                     usb_rcvintpipe(se401->dev, SE401_BUTTON_ENDPOINT),
1321                     &se401->button, sizeof(se401->button),
1322                     se401_button_irq,
1323                     se401,
1324                     8
1325                 );
1326                 if (usb_submit_urb(se401->inturb, GFP_KERNEL)) {
1327                         dev_info(&se401->dev->dev, "int urb burned down\n");
1328                         return 1;
1329                 }
1330         } else
1331                 se401->inturb=NULL;
1332
1333         /* Flash the led */
1334         se401_sndctrl(1, se401, SE401_REQ_CAMERA_POWER, 1, NULL, 0);
1335         se401_sndctrl(1, se401, SE401_REQ_LED_CONTROL, 1, NULL, 0);
1336         se401_sndctrl(1, se401, SE401_REQ_CAMERA_POWER, 0, NULL, 0);
1337         se401_sndctrl(1, se401, SE401_REQ_LED_CONTROL, 0, NULL, 0);
1338
1339         return 0;
1340 }
1341
1342 static int se401_probe(struct usb_interface *intf,
1343         const struct usb_device_id *id)
1344 {
1345         struct usb_device *dev = interface_to_usbdev(intf);
1346         struct usb_interface_descriptor *interface;
1347         struct usb_se401 *se401;
1348         char *camera_name=NULL;
1349         int button=1;
1350
1351         /* We don't handle multi-config cameras */
1352         if (dev->descriptor.bNumConfigurations != 1)
1353                 return -ENODEV;
1354
1355         interface = &intf->cur_altsetting->desc;
1356
1357         /* Is it an se401? */
1358         if (le16_to_cpu(dev->descriptor.idVendor) == 0x03e8 &&
1359             le16_to_cpu(dev->descriptor.idProduct) == 0x0004) {
1360                 camera_name="Endpoints/Aox SE401";
1361         } else if (le16_to_cpu(dev->descriptor.idVendor) == 0x0471 &&
1362             le16_to_cpu(dev->descriptor.idProduct) == 0x030b) {
1363                 camera_name="Philips PCVC665K";
1364         } else if (le16_to_cpu(dev->descriptor.idVendor) == 0x047d &&
1365             le16_to_cpu(dev->descriptor.idProduct) == 0x5001) {
1366                 camera_name="Kensington VideoCAM 67014";
1367         } else if (le16_to_cpu(dev->descriptor.idVendor) == 0x047d &&
1368             le16_to_cpu(dev->descriptor.idProduct) == 0x5002) {
1369                 camera_name="Kensington VideoCAM 6701(5/7)";
1370         } else if (le16_to_cpu(dev->descriptor.idVendor) == 0x047d &&
1371             le16_to_cpu(dev->descriptor.idProduct) == 0x5003) {
1372                 camera_name="Kensington VideoCAM 67016";
1373                 button=0;
1374         } else
1375                 return -ENODEV;
1376
1377         /* Checking vendor/product should be enough, but what the hell */
1378         if (interface->bInterfaceClass != 0x00)
1379                 return -ENODEV;
1380         if (interface->bInterfaceSubClass != 0x00)
1381                 return -ENODEV;
1382
1383         /* We found one */
1384         dev_info(&intf->dev, "SE401 camera found: %s\n", camera_name);
1385
1386         if ((se401 = kzalloc(sizeof(*se401), GFP_KERNEL)) == NULL) {
1387                 err("couldn't kmalloc se401 struct");
1388                 return -ENOMEM;
1389         }
1390
1391         se401->dev = dev;
1392         se401->iface = interface->bInterfaceNumber;
1393         se401->camera_name = camera_name;
1394
1395         dev_info(&intf->dev, "firmware version: %02x\n",
1396                  le16_to_cpu(dev->descriptor.bcdDevice) & 255);
1397
1398         if (se401_init(se401, button)) {
1399                 kfree(se401);
1400                 return -EIO;
1401         }
1402
1403         memcpy(&se401->vdev, &se401_template, sizeof(se401_template));
1404         memcpy(se401->vdev.name, se401->camera_name, strlen(se401->camera_name));
1405         init_waitqueue_head(&se401->wq);
1406         mutex_init(&se401->lock);
1407         wmb();
1408
1409         if (video_register_device(&se401->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
1410                 kfree(se401);
1411                 err("video_register_device failed");
1412                 return -EIO;
1413         }
1414         dev_info(&intf->dev, "registered new video device: video%d\n",
1415                  se401->vdev.num);
1416
1417         usb_set_intfdata (intf, se401);
1418         return 0;
1419 }
1420
1421 static void se401_disconnect(struct usb_interface *intf)
1422 {
1423         struct usb_se401 *se401 = usb_get_intfdata (intf);
1424
1425         usb_set_intfdata (intf, NULL);
1426         if (se401) {
1427                 video_unregister_device(&se401->vdev);
1428                 if (!se401->user){
1429                         usb_se401_remove_disconnected(se401);
1430                 } else {
1431                         se401->frame[0].grabstate = FRAME_ERROR;
1432                         se401->frame[0].grabstate = FRAME_ERROR;
1433
1434                         se401->streaming = 0;
1435
1436                         wake_up_interruptible(&se401->wq);
1437                         se401->removed = 1;
1438                 }
1439         }
1440 }
1441
1442 static struct usb_driver se401_driver = {
1443         .name           = "se401",
1444         .id_table       = device_table,
1445         .probe          = se401_probe,
1446         .disconnect     = se401_disconnect,
1447 };
1448
1449
1450
1451 /****************************************************************************
1452  *
1453  *  Module routines
1454  *
1455  ***************************************************************************/
1456
1457 static int __init usb_se401_init(void)
1458 {
1459         printk(KERN_INFO "SE401 usb camera driver version %s registering\n", version);
1460         if (flickerless)
1461                 if (flickerless!=50 && flickerless!=60) {
1462                         printk(KERN_ERR "Invallid flickerless value, use 0, 50 or 60.\n");
1463                         return -1;
1464         }
1465         return usb_register(&se401_driver);
1466 }
1467
1468 static void __exit usb_se401_exit(void)
1469 {
1470         usb_deregister(&se401_driver);
1471         printk(KERN_INFO "SE401 driver deregistered\frame");
1472 }
1473
1474 module_init(usb_se401_init);
1475 module_exit(usb_se401_exit);