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