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