?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / drivers / usb / media / konicawc.c
blob3376654ca051179cd5f044d904e7ec30dc9d5353
1 /*
2 * konicawc.c - konica webcam driver
3 *
4 * Author: Simon Evans <spse@secret.org.uk>
5 *
6 * Copyright (C) 2002 Simon Evans
7 *
8 * Licence: GPL
9 *
10 * Driver for USB webcams based on Konica chipset. This
11 * chipset is used in Intel YC76 camera.
12 *
13 */
14
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/init.h>
18 #include <linux/input.h>
19
20 #include "usbvideo.h"
21
22 #define MAX_BRIGHTNESS 108
23 #define MAX_CONTRAST 108
24 #define MAX_SATURATION 108
25 #define MAX_SHARPNESS 108
26 #define MAX_WHITEBAL 372
27 #define MAX_SPEED 6
28
29
30 #define MAX_CAMERAS 1
31
32 #define DRIVER_VERSION "v1.4"
33 #define DRIVER_DESC "Konica Webcam driver"
34
35 enum ctrl_req {
36 SetWhitebal = 0x01,
37 SetBrightness = 0x02,
38 SetSharpness = 0x03,
39 SetContrast = 0x04,
40 SetSaturation = 0x05,
41 };
42
43
44 enum frame_sizes {
45 SIZE_160X120 = 0,
46 SIZE_160X136 = 1,
47 SIZE_176X144 = 2,
48 SIZE_320X240 = 3,
49
50 };
51
52 #define MAX_FRAME_SIZE SIZE_320X240
53
54 static struct usbvideo *cams;
55
56 #ifdef CONFIG_USB_DEBUG
57 static int debug;
58 #define DEBUG(n, format, arg...) \
59 if (n <= debug) { \
60 printk(KERN_DEBUG __FILE__ ":%s(): " format "\n", __FUNCTION__ , ## arg); \
61 }
62 #else
63 #define DEBUG(n, arg...)
64 static const int debug = 0;
65 #endif
66
67
68 /* Some default values for initial camera settings,
69 can be set by modprobe */
70
71 static int size;
72 static int speed = 6; /* Speed (fps) 0 (slowest) to 6 (fastest) */
73 static int brightness = MAX_BRIGHTNESS/2;
74 static int contrast = MAX_CONTRAST/2;
75 static int saturation = MAX_SATURATION/2;
76 static int sharpness = MAX_SHARPNESS/2;
77 static int whitebal = 3*(MAX_WHITEBAL/4);
78
79 static int spd_to_iface[] = { 1, 0, 3, 2, 4, 5, 6 };
80
81 /* These FPS speeds are from the windows config box. They are
82 * indexed on size (0-2) and speed (0-6). Divide by 3 to get the
83 * real fps.
84 */
85
86 static int spd_to_fps[][7] = { { 24, 40, 48, 60, 72, 80, 100 },
87 { 24, 40, 48, 60, 72, 80, 100 },
88 { 18, 30, 36, 45, 54, 60, 75 },
89 { 6, 10, 12, 15, 18, 21, 25 } };
90
91 struct cam_size {
92 u16 width;
93 u16 height;
94 u8 cmd;
95 };
96
97 static struct cam_size camera_sizes[] = { { 160, 120, 0x7 },
98 { 160, 136, 0xa },
99 { 176, 144, 0x4 },
100 { 320, 240, 0x5 } };
101
102 struct konicawc {
103 u8 brightness; /* camera uses 0 - 9, x11 for real value */
104 u8 contrast; /* as above */
105 u8 saturation; /* as above */
106 u8 sharpness; /* as above */
107 u8 white_bal; /* 0 - 33, x11 for real value */
108 u8 speed; /* Stored as 0 - 6, used as index in spd_to_* (above) */
109 u8 size; /* Frame Size */
110 int height;
111 int width;
112 struct urb *sts_urb[USBVIDEO_NUMSBUF];
113 u8 sts_buf[USBVIDEO_NUMSBUF][FRAMES_PER_DESC];
114 struct urb *last_data_urb;
115 int lastframe;
116 int cur_frame_size; /* number of bytes in current frame size */
117 int maxline; /* number of lines per frame */
118 int yplanesz; /* Number of bytes in the Y plane */
119 unsigned int buttonsts:1;
120 #ifdef CONFIG_INPUT
121 struct input_dev input;
122 char input_physname[64];
123 #endif
124 };
125
126
127 #define konicawc_set_misc(uvd, req, value, index) konicawc_ctrl_msg(uvd, USB_DIR_OUT, req, value, index, NULL, 0)
128 #define konicawc_get_misc(uvd, req, value, index, buf, sz) konicawc_ctrl_msg(uvd, USB_DIR_IN, req, value, index, buf, sz)
129 #define konicawc_set_value(uvd, value, index) konicawc_ctrl_msg(uvd, USB_DIR_OUT, 2, value, index, NULL, 0)
130
131
132 static int konicawc_ctrl_msg(struct uvd *uvd, u8 dir, u8 request, u16 value, u16 index, void *buf, int len)
133 {
134 int retval = usb_control_msg(uvd->dev,
135 dir ? usb_rcvctrlpipe(uvd->dev, 0) : usb_sndctrlpipe(uvd->dev, 0),
136 request, 0x40 | dir, value, index, buf, len, HZ);
137 return retval < 0 ? retval : 0;
138 }
139
140
141 static inline void konicawc_camera_on(struct uvd *uvd)
142 {
143 DEBUG(0, "camera on");
144 konicawc_set_misc(uvd, 0x2, 1, 0x0b);
145 }
146
147
148 static inline void konicawc_camera_off(struct uvd *uvd)
149 {
150 DEBUG(0, "camera off");
151 konicawc_set_misc(uvd, 0x2, 0, 0x0b);
152 }
153
154
155 static void konicawc_set_camera_size(struct uvd *uvd)
156 {
157 struct konicawc *cam = (struct konicawc *)uvd->user_data;
158
159 konicawc_set_misc(uvd, 0x2, camera_sizes[cam->size].cmd, 0x08);
160 cam->width = camera_sizes[cam->size].width;
161 cam->height = camera_sizes[cam->size].height;
162 cam->yplanesz = cam->height * cam->width;
163 cam->cur_frame_size = (cam->yplanesz * 3) / 2;
164 cam->maxline = cam->yplanesz / 256;
165 uvd->videosize = VIDEOSIZE(cam->width, cam->height);
166 }
167
168
169 static int konicawc_setup_on_open(struct uvd *uvd)
170 {
171 struct konicawc *cam = (struct konicawc *)uvd->user_data;
172
173 DEBUG(1, "setting brightness to %d (%d)", cam->brightness,
174 cam->brightness * 11);
175 konicawc_set_value(uvd, cam->brightness, SetBrightness);
176 DEBUG(1, "setting white balance to %d (%d)", cam->white_bal,
177 cam->white_bal * 11);
178 konicawc_set_value(uvd, cam->white_bal, SetWhitebal);
179 DEBUG(1, "setting contrast to %d (%d)", cam->contrast,
180 cam->contrast * 11);
181 konicawc_set_value(uvd, cam->contrast, SetContrast);
182 DEBUG(1, "setting saturation to %d (%d)", cam->saturation,
183 cam->saturation * 11);
184 konicawc_set_value(uvd, cam->saturation, SetSaturation);
185 DEBUG(1, "setting sharpness to %d (%d)", cam->sharpness,
186 cam->sharpness * 11);
187 konicawc_set_value(uvd, cam->sharpness, SetSharpness);
188 konicawc_set_camera_size(uvd);
189 cam->lastframe = -2;
190 cam->buttonsts = 0;
191 return 0;
192 }
193
194
195 static void konicawc_adjust_picture(struct uvd *uvd)
196 {
197 struct konicawc *cam = (struct konicawc *)uvd->user_data;
198
199 konicawc_camera_off(uvd);
200 DEBUG(1, "new brightness: %d", uvd->vpic.brightness);
201 uvd->vpic.brightness = (uvd->vpic.brightness > MAX_BRIGHTNESS) ? MAX_BRIGHTNESS : uvd->vpic.brightness;
202 if(cam->brightness != uvd->vpic.brightness / 11) {
203 cam->brightness = uvd->vpic.brightness / 11;
204 DEBUG(1, "setting brightness to %d (%d)", cam->brightness,
205 cam->brightness * 11);
206 konicawc_set_value(uvd, cam->brightness, SetBrightness);
207 }
208
209 DEBUG(1, "new contrast: %d", uvd->vpic.contrast);
210 uvd->vpic.contrast = (uvd->vpic.contrast > MAX_CONTRAST) ? MAX_CONTRAST : uvd->vpic.contrast;
211 if(cam->contrast != uvd->vpic.contrast / 11) {
212 cam->contrast = uvd->vpic.contrast / 11;
213 DEBUG(1, "setting contrast to %d (%d)", cam->contrast,
214 cam->contrast * 11);
215 konicawc_set_value(uvd, cam->contrast, SetContrast);
216 }
217 konicawc_camera_on(uvd);
218 }
219
220
221 static int konicawc_compress_iso(struct uvd *uvd, struct urb *dataurb, struct urb *stsurb)
222 {
223 char *cdata;
224 int i, totlen = 0;
225 unsigned char *status = stsurb->transfer_buffer;
226 int keep = 0, discard = 0, bad = 0;
227 struct konicawc *cam = (struct konicawc *)uvd->user_data;
228
229 for (i = 0; i < dataurb->number_of_packets; i++) {
230 int button = cam->buttonsts;
231 unsigned char sts;
232 int n = dataurb->iso_frame_desc[i].actual_length;
233 int st = dataurb->iso_frame_desc[i].status;
234 cdata = dataurb->transfer_buffer +
235 dataurb->iso_frame_desc[i].offset;
236
237 /* Detect and ignore errored packets */
238 if (st < 0) {
239 DEBUG(1, "Data error: packet=%d. len=%d. status=%d.",
240 i, n, st);
241 uvd->stats.iso_err_count++;
242 continue;
243 }
244
245 /* Detect and ignore empty packets */
246 if (n <= 0) {
247 uvd->stats.iso_skip_count++;
248 continue;
249 }
250
251 /* See what the status data said about the packet */
252 sts = *(status+stsurb->iso_frame_desc[i].offset);
253
254 /* sts: 0x80-0xff: frame start with frame number (ie 0-7f)
255 * otherwise:
256 * bit 0 0: keep packet
257 * 1: drop packet (padding data)
258 *
259 * bit 4 0 button not clicked
260 * 1 button clicked
261 * button is used to `take a picture' (in software)
262 */
263
264 if(sts < 0x80) {
265 button = !!(sts & 0x40);
266 sts &= ~0x40;
267 }
268
269 /* work out the button status, but don't do
270 anything with it for now */
271
272 if(button != cam->buttonsts) {
273 DEBUG(2, "button: %sclicked", button ? "" : "un");
274 cam->buttonsts = button;
275 #ifdef CONFIG_INPUT
276 input_report_key(&cam->input, BTN_0, cam->buttonsts);
277 input_sync(&cam->input);
278 #endif
279 }
280
281 if(sts == 0x01) { /* drop frame */
282 discard++;
283 continue;
284 }
285
286 if((sts > 0x01) && (sts < 0x80)) {
287 info("unknown status %2.2x", sts);
288 bad++;
289 continue;
290 }
291 if(!sts && cam->lastframe == -2) {
292 DEBUG(2, "dropping frame looking for image start");
293 continue;
294 }
295
296 keep++;
297 if(sts & 0x80) { /* frame start */
298 unsigned char marker[] = { 0, 0xff, 0, 0x00 };
299
300 if(cam->lastframe == -2) {
301 DEBUG(2, "found initial image");
302 cam->lastframe = -1;
303 }
304
305 marker[3] = sts & 0x7F;
306 RingQueue_Enqueue(&uvd->dp, marker, 4);
307 totlen += 4;
308 }
309
310 totlen += n; /* Little local accounting */
311 RingQueue_Enqueue(&uvd->dp, cdata, n);
312 }
313 DEBUG(8, "finished: keep = %d discard = %d bad = %d added %d bytes",
314 keep, discard, bad, totlen);
315 return totlen;
316 }
317
318
319 static void resubmit_urb(struct uvd *uvd, struct urb *urb)
320 {
321 int i, ret;
322 for (i = 0; i < FRAMES_PER_DESC; i++) {
323 urb->iso_frame_desc[i].status = 0;
324 }
325 urb->dev = uvd->dev;
326 urb->status = 0;
327 ret = usb_submit_urb(urb, GFP_ATOMIC);
328 DEBUG(3, "submitting urb of length %d", urb->transfer_buffer_length);
329 if(ret)
330 err("usb_submit_urb error (%d)", ret);
331
332 }
333
334
335 static void konicawc_isoc_irq(struct urb *urb, struct pt_regs *regs)
336 {
337 struct uvd *uvd = urb->context;
338 struct konicawc *cam = (struct konicawc *)uvd->user_data;
339
340 /* We don't want to do anything if we are about to be removed! */
341 if (!CAMERA_IS_OPERATIONAL(uvd))
342 return;
343
344 if (!uvd->streaming) {
345 DEBUG(1, "Not streaming, but interrupt!");
346 return;
347 }
348
349 DEBUG(3, "got frame %d len = %d buflen =%d", urb->start_frame, urb->actual_length, urb->transfer_buffer_length);
350
351 uvd->stats.urb_count++;
352
353 if (urb->transfer_buffer_length > 32) {
354 cam->last_data_urb = urb;
355 return;
356 }
357 /* Copy the data received into ring queue */
358 if(cam->last_data_urb) {
359 int len = 0;
360 if(urb->start_frame != cam->last_data_urb->start_frame)
361 err("Lost sync on frames");
362 else if (!urb->status && !cam->last_data_urb->status)
363 len = konicawc_compress_iso(uvd, cam->last_data_urb, urb);
364
365 resubmit_urb(uvd, cam->last_data_urb);
366 resubmit_urb(uvd, urb);
367 cam->last_data_urb = NULL;
368 uvd->stats.urb_length = len;
369 uvd->stats.data_count += len;
370 if(len)
371 RingQueue_WakeUpInterruptible(&uvd->dp);
372 return;
373 }
374 return;
375 }
376
377
378 static int konicawc_start_data(struct uvd *uvd)
379 {
380 struct usb_device *dev = uvd->dev;
381 int i, errFlag;
382 struct konicawc *cam = (struct konicawc *)uvd->user_data;
383 int pktsz;
384 struct usb_interface *intf;
385 struct usb_host_interface *interface = NULL;
386
387 intf = usb_ifnum_to_if(dev, uvd->iface);
388 if (intf)
389 interface = usb_altnum_to_altsetting(intf,
390 spd_to_iface[cam->speed]);
391 if (!interface)
392 return -ENXIO;
393 pktsz = interface->endpoint[1].desc.wMaxPacketSize;
394 DEBUG(1, "pktsz = %d", pktsz);
395 if (!CAMERA_IS_OPERATIONAL(uvd)) {
396 err("Camera is not operational");
397 return -EFAULT;
398 }
399 uvd->curframe = -1;
400 konicawc_camera_on(uvd);
401 /* Alternate interface 1 is is the biggest frame size */
402 i = usb_set_interface(dev, uvd->iface, uvd->ifaceAltActive);
403 if (i < 0) {
404 err("usb_set_interface error");
405 uvd->last_error = i;
406 return -EBUSY;
407 }
408
409 /* We double buffer the Iso lists */
410 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
411 int j, k;
412 struct urb *urb = uvd->sbuf[i].urb;
413 urb->dev = dev;
414 urb->context = uvd;
415 urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp);
416 urb->interval = 1;
417 urb->transfer_flags = URB_ISO_ASAP;
418 urb->transfer_buffer = uvd->sbuf[i].data;
419 urb->complete = konicawc_isoc_irq;
420 urb->number_of_packets = FRAMES_PER_DESC;
421 urb->transfer_buffer_length = pktsz * FRAMES_PER_DESC;
422 for (j=k=0; j < FRAMES_PER_DESC; j++, k += pktsz) {
423 urb->iso_frame_desc[j].offset = k;
424 urb->iso_frame_desc[j].length = pktsz;
425 }
426
427 urb = cam->sts_urb[i];
428 urb->dev = dev;
429 urb->context = uvd;
430 urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp-1);
431 urb->interval = 1;
432 urb->transfer_flags = URB_ISO_ASAP;
433 urb->transfer_buffer = cam->sts_buf[i];
434 urb->complete = konicawc_isoc_irq;
435 urb->number_of_packets = FRAMES_PER_DESC;
436 urb->transfer_buffer_length = FRAMES_PER_DESC;
437 for (j=0; j < FRAMES_PER_DESC; j++) {
438 urb->iso_frame_desc[j].offset = j;
439 urb->iso_frame_desc[j].length = 1;
440 }
441 }
442
443 cam->last_data_urb = NULL;
444
445 /* Submit all URBs */
446 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
447 errFlag = usb_submit_urb(cam->sts_urb[i], GFP_KERNEL);
448 if (errFlag)
449 err("usb_submit_isoc(%d) ret %d", i, errFlag);
450
451 errFlag = usb_submit_urb(uvd->sbuf[i].urb, GFP_KERNEL);
452 if (errFlag)
453 err ("usb_submit_isoc(%d) ret %d", i, errFlag);
454 }
455
456 uvd->streaming = 1;
457 DEBUG(1, "streaming=1 video_endp=$%02x", uvd->video_endp);
458 return 0;
459 }
460
461
462 static void konicawc_stop_data(struct uvd *uvd)
463 {
464 int i, j;
465 struct konicawc *cam;
466
467 if ((uvd == NULL) || (!uvd->streaming) || (uvd->dev == NULL))
468 return;
469
470 konicawc_camera_off(uvd);
471 uvd->streaming = 0;
472 cam = (struct konicawc *)uvd->user_data;
473 cam->last_data_urb = NULL;
474
475 /* Unschedule all of the iso td's */
476 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
477 j = usb_unlink_urb(uvd->sbuf[i].urb);
478 if (j < 0)
479 err("usb_unlink_urb() error %d.", j);
480
481 j = usb_unlink_urb(cam->sts_urb[i]);
482 if (j < 0)
483 err("usb_unlink_urb() error %d.", j);
484 }
485
486 if (!uvd->remove_pending) {
487 /* Set packet size to 0 */
488 j = usb_set_interface(uvd->dev, uvd->iface, uvd->ifaceAltInactive);
489 if (j < 0) {
490 err("usb_set_interface() error %d.", j);
491 uvd->last_error = j;
492 }
493 }
494 }
495
496
497 static void konicawc_process_isoc(struct uvd *uvd, struct usbvideo_frame *frame)
498 {
499 struct konicawc *cam = (struct konicawc *)uvd->user_data;
500 int maxline = cam->maxline;
501 int yplanesz = cam->yplanesz;
502
503 assert(frame != NULL);
504
505 DEBUG(5, "maxline = %d yplanesz = %d", maxline, yplanesz);
506 DEBUG(3, "Frame state = %d", frame->scanstate);
507
508 if(frame->scanstate == ScanState_Scanning) {
509 int drop = 0;
510 int curframe;
511 int fdrops = 0;
512 DEBUG(3, "Searching for marker, queue len = %d", RingQueue_GetLength(&uvd->dp));
513 while(RingQueue_GetLength(&uvd->dp) >= 4) {
514 if ((RING_QUEUE_PEEK(&uvd->dp, 0) == 0x00) &&
515 (RING_QUEUE_PEEK(&uvd->dp, 1) == 0xff) &&
516 (RING_QUEUE_PEEK(&uvd->dp, 2) == 0x00) &&
517 (RING_QUEUE_PEEK(&uvd->dp, 3) < 0x80)) {
518 curframe = RING_QUEUE_PEEK(&uvd->dp, 3);
519 if(cam->lastframe >= 0) {
520 fdrops = (0x80 + curframe - cam->lastframe) & 0x7F;
521 fdrops--;
522 if(fdrops) {
523 info("Dropped %d frames (%d -> %d)", fdrops,
524 cam->lastframe, curframe);
525 }
526 }
527 cam->lastframe = curframe;
528 frame->curline = 0;
529 frame->scanstate = ScanState_Lines;
530 RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, 4);
531 break;
532 }
533 RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, 1);
534 drop++;
535 }
536 if(drop)
537 DEBUG(2, "dropped %d bytes looking for new frame", drop);
538 }
539
540 if(frame->scanstate == ScanState_Scanning)
541 return;
542
543 /* Try to move data from queue into frame buffer
544 * We get data in blocks of 384 bytes made up of:
545 * 256 Y, 64 U, 64 V.
546 * This needs to be written out as a Y plane, a U plane and a V plane.
547 */
548
549 while ( frame->curline < maxline && (RingQueue_GetLength(&uvd->dp) >= 384)) {
550 /* Y */
551 RingQueue_Dequeue(&uvd->dp, frame->data + (frame->curline * 256), 256);
552 /* U */
553 RingQueue_Dequeue(&uvd->dp, frame->data + yplanesz + (frame->curline * 64), 64);
554 /* V */
555 RingQueue_Dequeue(&uvd->dp, frame->data + (5 * yplanesz)/4 + (frame->curline * 64), 64);
556 frame->seqRead_Length += 384;
557 frame->curline++;
558 }
559 /* See if we filled the frame */
560 if (frame->curline == maxline) {
561 DEBUG(5, "got whole frame");
562
563 frame->frameState = FrameState_Done_Hold;
564 frame->curline = 0;
565 uvd->curframe = -1;
566 uvd->stats.frame_num++;
567 }
568 }
569
570
571 static int konicawc_find_fps(int size, int fps)
572 {
573 int i;
574
575 fps *= 3;
576 DEBUG(1, "konica_find_fps: size = %d fps = %d", size, fps);
577 if(fps <= spd_to_fps[size][0])
578 return 0;
579
580 if(fps >= spd_to_fps[size][MAX_SPEED])
581 return MAX_SPEED;
582
583 for(i = 0; i < MAX_SPEED; i++) {
584 if((fps >= spd_to_fps[size][i]) && (fps <= spd_to_fps[size][i+1])) {
585 DEBUG(2, "fps %d between %d and %d", fps, i, i+1);
586 if( (fps - spd_to_fps[size][i]) < (spd_to_fps[size][i+1] - fps))
587 return i;
588 else
589 return i+1;
590 }
591 }
592 return MAX_SPEED+1;
593 }
594
595
596 static int konicawc_set_video_mode(struct uvd *uvd, struct video_window *vw)
597 {
598 struct konicawc *cam = (struct konicawc *)uvd->user_data;
599 int newspeed = cam->speed;
600 int newsize;
601 int x = vw->width;
602 int y = vw->height;
603 int fps = vw->flags;
604
605 if(x > 0 && y > 0) {
606 DEBUG(2, "trying to find size %d,%d", x, y);
607 for(newsize = 0; newsize <= MAX_FRAME_SIZE; newsize++) {
608 if((camera_sizes[newsize].width == x) && (camera_sizes[newsize].height == y))
609 break;
610 }
611 } else {
612 newsize = cam->size;
613 }
614
615 if(newsize > MAX_FRAME_SIZE) {
616 DEBUG(1, "couldn't find size %d,%d", x, y);
617 return -EINVAL;
618 }
619
620 if(fps > 0) {
621 DEBUG(1, "trying to set fps to %d", fps);
622 newspeed = konicawc_find_fps(newsize, fps);
623 DEBUG(1, "find_fps returned %d (%d)", newspeed, spd_to_fps[newsize][newspeed]);
624 }
625
626 if(newspeed > MAX_SPEED)
627 return -EINVAL;
628
629 DEBUG(1, "setting size to %d speed to %d", newsize, newspeed);
630 if((newsize == cam->size) && (newspeed == cam->speed)) {
631 DEBUG(1, "Nothing to do");
632 return 0;
633 }
634 DEBUG(0, "setting to %dx%d @ %d fps", camera_sizes[newsize].width,
635 camera_sizes[newsize].height, spd_to_fps[newsize][newspeed]/3);
636
637 konicawc_stop_data(uvd);
638 uvd->ifaceAltActive = spd_to_iface[newspeed];
639 DEBUG(1, "new interface = %d", uvd->ifaceAltActive);
640 cam->speed = newspeed;
641
642 if(cam->size != newsize) {
643 cam->size = newsize;
644 konicawc_set_camera_size(uvd);
645 }
646
647 /* Flush the input queue and clear any current frame in progress */
648
649 RingQueue_Flush(&uvd->dp);
650 cam->lastframe = -2;
651 if(uvd->curframe != -1) {
652 uvd->frame[uvd->curframe].curline = 0;
653 uvd->frame[uvd->curframe].seqRead_Length = 0;
654 uvd->frame[uvd->curframe].seqRead_Index = 0;
655 }
656
657 konicawc_start_data(uvd);
658 return 0;
659 }
660
661
662 static int konicawc_calculate_fps(struct uvd *uvd)
663 {
664 struct konicawc *cam = uvd->user_data;
665 return spd_to_fps[cam->size][cam->speed]/3;
666 }
667
668
669 static void konicawc_configure_video(struct uvd *uvd)
670 {
671 struct konicawc *cam = (struct konicawc *)uvd->user_data;
672 u8 buf[2];
673
674 memset(&uvd->vpic, 0, sizeof(uvd->vpic));
675 memset(&uvd->vpic_old, 0x55, sizeof(uvd->vpic_old));
676
677 RESTRICT_TO_RANGE(brightness, 0, MAX_BRIGHTNESS);
678 RESTRICT_TO_RANGE(contrast, 0, MAX_CONTRAST);
679 RESTRICT_TO_RANGE(saturation, 0, MAX_SATURATION);
680 RESTRICT_TO_RANGE(sharpness, 0, MAX_SHARPNESS);
681 RESTRICT_TO_RANGE(whitebal, 0, MAX_WHITEBAL);
682
683 cam->brightness = brightness / 11;
684 cam->contrast = contrast / 11;
685 cam->saturation = saturation / 11;
686 cam->sharpness = sharpness / 11;
687 cam->white_bal = whitebal / 11;
688
689 uvd->vpic.colour = 108;
690 uvd->vpic.hue = 108;
691 uvd->vpic.brightness = brightness;
692 uvd->vpic.contrast = contrast;
693 uvd->vpic.whiteness = whitebal;
694 uvd->vpic.depth = 6;
695 uvd->vpic.palette = VIDEO_PALETTE_YUV420P;
696
697 memset(&uvd->vcap, 0, sizeof(uvd->vcap));
698 strcpy(uvd->vcap.name, "Konica Webcam");
699 uvd->vcap.type = VID_TYPE_CAPTURE;
700 uvd->vcap.channels = 1;
701 uvd->vcap.audios = 0;
702 uvd->vcap.minwidth = camera_sizes[SIZE_160X120].width;
703 uvd->vcap.minheight = camera_sizes[SIZE_160X120].height;
704 uvd->vcap.maxwidth = camera_sizes[SIZE_320X240].width;
705 uvd->vcap.maxheight = camera_sizes[SIZE_320X240].height;
706
707 memset(&uvd->vchan, 0, sizeof(uvd->vchan));
708 uvd->vchan.flags = 0 ;
709 uvd->vchan.tuners = 0;
710 uvd->vchan.channel = 0;
711 uvd->vchan.type = VIDEO_TYPE_CAMERA;
712 strcpy(uvd->vchan.name, "Camera");
713
714 /* Talk to device */
715 DEBUG(1, "device init");
716 if(!konicawc_get_misc(uvd, 0x3, 0, 0x10, buf, 2))
717 DEBUG(2, "3,10 -> %2.2x %2.2x", buf[0], buf[1]);
718 if(!konicawc_get_misc(uvd, 0x3, 0, 0x10, buf, 2))
719 DEBUG(2, "3,10 -> %2.2x %2.2x", buf[0], buf[1]);
720 if(konicawc_set_misc(uvd, 0x2, 0, 0xd))
721 DEBUG(2, "2,0,d failed");
722 DEBUG(1, "setting initial values");
723 }
724
725
726 static int konicawc_probe(struct usb_interface *intf, const struct usb_device_id *devid)
727 {
728 struct usb_device *dev = interface_to_usbdev(intf);
729 struct uvd *uvd = NULL;
730 int ix, i, nas;
731 int actInterface=-1, inactInterface=-1, maxPS=0;
732 unsigned char video_ep = 0;
733
734 DEBUG(1, "konicawc_probe(%p)", intf);
735
736 /* We don't handle multi-config cameras */
737 if (dev->descriptor.bNumConfigurations != 1)
738 return -ENODEV;
739
740 info("Konica Webcam (rev. 0x%04x)", dev->descriptor.bcdDevice);
741 RESTRICT_TO_RANGE(speed, 0, MAX_SPEED);
742
743 /* Validate found interface: must have one ISO endpoint */
744 nas = intf->num_altsetting;
745 if (nas != 8) {
746 err("Incorrect number of alternate settings (%d) for this camera!", nas);
747 return -ENODEV;
748 }
749 /* Validate all alternate settings */
750 for (ix=0; ix < nas; ix++) {
751 const struct usb_host_interface *interface;
752 const struct usb_endpoint_descriptor *endpoint;
753
754 interface = &intf->altsetting[ix];
755 i = interface->desc.bAlternateSetting;
756 if (interface->desc.bNumEndpoints != 2) {
757 err("Interface %d. has %u. endpoints!",
758 interface->desc.bInterfaceNumber,
759 (unsigned)(interface->desc.bNumEndpoints));
760 return -ENODEV;
761 }
762 endpoint = &interface->endpoint[1].desc;
763 DEBUG(1, "found endpoint: addr: 0x%2.2x maxps = 0x%4.4x",
764 endpoint->bEndpointAddress, endpoint->wMaxPacketSize);
765 if (video_ep == 0)
766 video_ep = endpoint->bEndpointAddress;
767 else if (video_ep != endpoint->bEndpointAddress) {
768 err("Alternate settings have different endpoint addresses!");
769 return -ENODEV;
770 }
771 if ((endpoint->bmAttributes & 0x03) != 0x01) {
772 err("Interface %d. has non-ISO endpoint!",
773 interface->desc.bInterfaceNumber);
774 return -ENODEV;
775 }
776 if ((endpoint->bEndpointAddress & 0x80) == 0) {
777 err("Interface %d. has ISO OUT endpoint!",
778 interface->desc.bInterfaceNumber);
779 return -ENODEV;
780 }
781 if (endpoint->wMaxPacketSize == 0) {
782 if (inactInterface < 0)
783 inactInterface = i;
784 else {
785 err("More than one inactive alt. setting!");
786 return -ENODEV;
787 }
788 } else {
789 if (i == spd_to_iface[speed]) {
790 /* This one is the requested one */
791 actInterface = i;
792 }
793 }
794 if(endpoint->wMaxPacketSize > maxPS)
795 maxPS = endpoint->wMaxPacketSize;
796 }
797 if(actInterface == -1) {
798 err("Cant find required endpoint");
799 return -ENODEV;
800 }
801
802 DEBUG(1, "Selecting requested active setting=%d. maxPS=%d.", actInterface, maxPS);
803
804 uvd = usbvideo_AllocateDevice(cams);
805 if (uvd != NULL) {
806 struct konicawc *cam = (struct konicawc *)(uvd->user_data);
807 /* Here uvd is a fully allocated uvd object */
808 for(i = 0; i < USBVIDEO_NUMSBUF; i++) {
809 cam->sts_urb[i] = usb_alloc_urb(FRAMES_PER_DESC, GFP_KERNEL);
810 if(cam->sts_urb[i] == NULL) {
811 while(i--) {
812 usb_free_urb(cam->sts_urb[i]);
813 }
814 err("can't allocate urbs");
815 return -ENOMEM;
816 }
817 }
818 cam->speed = speed;
819 RESTRICT_TO_RANGE(size, SIZE_160X120, SIZE_320X240);
820 cam->width = camera_sizes[size].width;
821 cam->height = camera_sizes[size].height;
822 cam->size = size;
823
824 uvd->flags = 0;
825 uvd->debug = debug;
826 uvd->dev = dev;
827 uvd->iface = intf->altsetting->desc.bInterfaceNumber;
828 uvd->ifaceAltInactive = inactInterface;
829 uvd->ifaceAltActive = actInterface;
830 uvd->video_endp = video_ep;
831 uvd->iso_packet_len = maxPS;
832 uvd->paletteBits = 1L << VIDEO_PALETTE_YUV420P;
833 uvd->defaultPalette = VIDEO_PALETTE_YUV420P;
834 uvd->canvas = VIDEOSIZE(320, 240);
835 uvd->videosize = VIDEOSIZE(cam->width, cam->height);
836
837 /* Initialize konicawc specific data */
838 konicawc_configure_video(uvd);
839
840 i = usbvideo_RegisterVideoDevice(uvd);
841 uvd->max_frame_size = (320 * 240 * 3)/2;
842 if (i != 0) {
843 err("usbvideo_RegisterVideoDevice() failed.");
844 uvd = NULL;
845 }
846 #ifdef CONFIG_INPUT
847 /* Register input device for button */
848 memset(&cam->input, 0, sizeof(struct input_dev));
849 cam->input.name = "Konicawc snapshot button";
850 cam->input.private = cam;
851 cam->input.evbit[0] = BIT(EV_KEY);
852 cam->input.keybit[LONG(BTN_0)] = BIT(BTN_0);
853 cam->input.id.bustype = BUS_USB;
854 cam->input.id.vendor = dev->descriptor.idVendor;
855 cam->input.id.product = dev->descriptor.idProduct;
856 cam->input.id.version = dev->descriptor.bcdDevice;
857 input_register_device(&cam->input);
858
859 usb_make_path(dev, cam->input_physname, 56);
860 strcat(cam->input_physname, "/input0");
861 cam->input.phys = cam->input_physname;
862 info("konicawc: %s on %s\n", cam->input.name, cam->input.phys);
863 #endif
864 }
865
866 if (uvd) {
867 usb_set_intfdata (intf, uvd);
868 return 0;
869 }
870 return -EIO;
871 }
872
873
874 static void konicawc_free_uvd(struct uvd *uvd)
875 {
876 int i;
877 struct konicawc *cam = (struct konicawc *)uvd->user_data;
878
879 #ifdef CONFIG_INPUT
880 input_unregister_device(&cam->input);
881 #endif
882 for (i=0; i < USBVIDEO_NUMSBUF; i++) {
883 usb_free_urb(cam->sts_urb[i]);
884 cam->sts_urb[i] = NULL;
885 }
886 }
887
888
889 static struct usb_device_id id_table[] = {
890 { USB_DEVICE(0x04c8, 0x0720) }, /* Intel YC 76 */
891 { } /* Terminating entry */
892 };
893
894
895 static int __init konicawc_init(void)
896 {
897 struct usbvideo_cb cbTbl;
898 info(DRIVER_DESC " " DRIVER_VERSION);
899 memset(&cbTbl, 0, sizeof(cbTbl));
900 cbTbl.probe = konicawc_probe;
901 cbTbl.setupOnOpen = konicawc_setup_on_open;
902 cbTbl.processData = konicawc_process_isoc;
903 cbTbl.getFPS = konicawc_calculate_fps;
904 cbTbl.setVideoMode = konicawc_set_video_mode;
905 cbTbl.startDataPump = konicawc_start_data;
906 cbTbl.stopDataPump = konicawc_stop_data;
907 cbTbl.adjustPicture = konicawc_adjust_picture;
908 cbTbl.userFree = konicawc_free_uvd;
909 return usbvideo_register(
910 &cams,
911 MAX_CAMERAS,
912 sizeof(struct konicawc),
913 "konicawc",
914 &cbTbl,
915 THIS_MODULE,
916 id_table);
917 }
918
919
920 static void __exit konicawc_cleanup(void)
921 {
922 usbvideo_Deregister(&cams);
923 }
924
925
926 MODULE_DEVICE_TABLE(usb, id_table);
927
928 MODULE_LICENSE("GPL");
929 MODULE_AUTHOR("Simon Evans <spse@secret.org.uk>");
930 MODULE_DESCRIPTION(DRIVER_DESC);
931 module_param(speed, int, 0);
932 MODULE_PARM_DESC(speed, "Initial speed: 0 (slowest) - 6 (fastest)");
933 module_param(size, int, 0);
934 MODULE_PARM_DESC(size, "Initial Size 0: 160x120 1: 160x136 2: 176x144 3: 320x240");
935 module_param(brightness, int, 0);
936 MODULE_PARM_DESC(brightness, "Initial brightness 0 - 108");
937 module_param(contrast, int, 0);
938 MODULE_PARM_DESC(contrast, "Initial contrast 0 - 108");
939 module_param(saturation, int, 0);
940 MODULE_PARM_DESC(saturation, "Initial saturation 0 - 108");
941 module_param(sharpness, int, 0);
942 MODULE_PARM_DESC(sharpness, "Initial brightness 0 - 108");
943 module_param(whitebal, int, 0);
944 MODULE_PARM_DESC(whitebal, "Initial white balance 0 - 363");
945
946 #ifdef CONFIG_USB_DEBUG
947 module_param(debug, int, S_IRUGO | S_IWUSR);
948 MODULE_PARM_DESC(debug, "Debug level: 0-9 (default=0)");
949 #endif
950
951 module_init(konicawc_init);
952 module_exit(konicawc_cleanup);
MOXA 2.6.9 from sdlinux-moxaart.tgz