Merge branch 'x86-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6] / drivers / media / video / usbvideo / konicawc.c
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/usb/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", __func__ , ## arg); \
61         }
62 #else
63 #define DEBUG(n, arg...)
64 static const int debug;
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 const 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 const 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 const 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, 1000);
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 #ifdef CONFIG_INPUT
221
222 static void konicawc_register_input(struct konicawc *cam, struct usb_device *dev)
223 {
224         struct input_dev *input_dev;
225         int error;
226
227         usb_make_path(dev, cam->input_physname, sizeof(cam->input_physname));
228         strncat(cam->input_physname, "/input0", sizeof(cam->input_physname));
229
230         cam->input = input_dev = input_allocate_device();
231         if (!input_dev) {
232                 warn("Not enough memory for camera's input device\n");
233                 return;
234         }
235
236         input_dev->name = "Konicawc snapshot button";
237         input_dev->phys = cam->input_physname;
238         usb_to_input_id(dev, &input_dev->id);
239         input_dev->dev.parent = &dev->dev;
240
241         input_dev->evbit[0] = BIT_MASK(EV_KEY);
242         input_dev->keybit[BIT_WORD(BTN_0)] = BIT_MASK(BTN_0);
243
244         error = input_register_device(cam->input);
245         if (error) {
246                 warn("Failed to register camera's input device, err: %d\n",
247                      error);
248                 input_free_device(cam->input);
249                 cam->input = NULL;
250         }
251 }
252
253 static void konicawc_unregister_input(struct konicawc *cam)
254 {
255         if (cam->input) {
256                 input_unregister_device(cam->input);
257                 cam->input = NULL;
258         }
259 }
260
261 static void konicawc_report_buttonstat(struct konicawc *cam)
262 {
263         if (cam->input) {
264                 input_report_key(cam->input, BTN_0, cam->buttonsts);
265                 input_sync(cam->input);
266         }
267 }
268
269 #else
270
271 static inline void konicawc_register_input(struct konicawc *cam, struct usb_device *dev) { }
272 static inline void konicawc_unregister_input(struct konicawc *cam) { }
273 static inline void konicawc_report_buttonstat(struct konicawc *cam) { }
274
275 #endif /* CONFIG_INPUT */
276
277 static int konicawc_compress_iso(struct uvd *uvd, struct urb *dataurb, struct urb *stsurb)
278 {
279         char *cdata;
280         int i, totlen = 0;
281         unsigned char *status = stsurb->transfer_buffer;
282         int keep = 0, discard = 0, bad = 0;
283         struct konicawc *cam = (struct konicawc *)uvd->user_data;
284
285         for (i = 0; i < dataurb->number_of_packets; i++) {
286                 int button = cam->buttonsts;
287                 unsigned char sts;
288                 int n = dataurb->iso_frame_desc[i].actual_length;
289                 int st = dataurb->iso_frame_desc[i].status;
290                 cdata = dataurb->transfer_buffer +
291                         dataurb->iso_frame_desc[i].offset;
292
293                 /* Detect and ignore errored packets */
294                 if (st < 0) {
295                         DEBUG(1, "Data error: packet=%d. len=%d. status=%d.",
296                               i, n, st);
297                         uvd->stats.iso_err_count++;
298                         continue;
299                 }
300
301                 /* Detect and ignore empty packets */
302                 if (n <= 0) {
303                         uvd->stats.iso_skip_count++;
304                         continue;
305                 }
306
307                 /* See what the status data said about the packet */
308                 sts = *(status+stsurb->iso_frame_desc[i].offset);
309
310                 /* sts: 0x80-0xff: frame start with frame number (ie 0-7f)
311                  * otherwise:
312                  * bit 0 0: keep packet
313                  *       1: drop packet (padding data)
314                  *
315                  * bit 4 0 button not clicked
316                  *       1 button clicked
317                  * button is used to `take a picture' (in software)
318                  */
319
320                 if(sts < 0x80) {
321                         button = !!(sts & 0x40);
322                         sts &= ~0x40;
323                 }
324
325                 /* work out the button status, but don't do
326                    anything with it for now */
327
328                 if(button != cam->buttonsts) {
329                         DEBUG(2, "button: %sclicked", button ? "" : "un");
330                         cam->buttonsts = button;
331                         konicawc_report_buttonstat(cam);
332                 }
333
334                 if(sts == 0x01) { /* drop frame */
335                         discard++;
336                         continue;
337                 }
338
339                 if((sts > 0x01) && (sts < 0x80)) {
340                         dev_info(&uvd->dev->dev, "unknown status %2.2x\n",
341                                  sts);
342                         bad++;
343                         continue;
344                 }
345                 if(!sts && cam->lastframe == -2) {
346                         DEBUG(2, "dropping frame looking for image start");
347                         continue;
348                 }
349
350                 keep++;
351                 if(sts & 0x80) { /* frame start */
352                         unsigned char marker[] = { 0, 0xff, 0, 0x00 };
353
354                         if(cam->lastframe == -2) {
355                                 DEBUG(2, "found initial image");
356                                 cam->lastframe = -1;
357                         }
358
359                         marker[3] = sts & 0x7F;
360                         RingQueue_Enqueue(&uvd->dp, marker, 4);
361                         totlen += 4;
362                 }
363
364                 totlen += n;    /* Little local accounting */
365                 RingQueue_Enqueue(&uvd->dp, cdata, n);
366         }
367         DEBUG(8, "finished: keep = %d discard = %d bad = %d added %d bytes",
368                     keep, discard, bad, totlen);
369         return totlen;
370 }
371
372
373 static void resubmit_urb(struct uvd *uvd, struct urb *urb)
374 {
375         int i, ret;
376         for (i = 0; i < FRAMES_PER_DESC; i++) {
377                 urb->iso_frame_desc[i].status = 0;
378         }
379         urb->dev = uvd->dev;
380         urb->status = 0;
381         ret = usb_submit_urb(urb, GFP_ATOMIC);
382         DEBUG(3, "submitting urb of length %d", urb->transfer_buffer_length);
383         if(ret)
384                 err("usb_submit_urb error (%d)", ret);
385
386 }
387
388
389 static void konicawc_isoc_irq(struct urb *urb)
390 {
391         struct uvd *uvd = urb->context;
392         struct konicawc *cam = (struct konicawc *)uvd->user_data;
393
394         /* We don't want to do anything if we are about to be removed! */
395         if (!CAMERA_IS_OPERATIONAL(uvd))
396                 return;
397
398         if (!uvd->streaming) {
399                 DEBUG(1, "Not streaming, but interrupt!");
400                 return;
401         }
402
403         DEBUG(3, "got frame %d len = %d buflen =%d", urb->start_frame, urb->actual_length, urb->transfer_buffer_length);
404
405         uvd->stats.urb_count++;
406
407         if (urb->transfer_buffer_length > 32) {
408                 cam->last_data_urb = urb;
409                 return;
410         }
411         /* Copy the data received into ring queue */
412         if(cam->last_data_urb) {
413                 int len = 0;
414                 if(urb->start_frame != cam->last_data_urb->start_frame)
415                         err("Lost sync on frames");
416                 else if (!urb->status && !cam->last_data_urb->status)
417                         len = konicawc_compress_iso(uvd, cam->last_data_urb, urb);
418
419                 resubmit_urb(uvd, cam->last_data_urb);
420                 resubmit_urb(uvd, urb);
421                 cam->last_data_urb = NULL;
422                 uvd->stats.urb_length = len;
423                 uvd->stats.data_count += len;
424                 if(len)
425                         RingQueue_WakeUpInterruptible(&uvd->dp);
426                 return;
427         }
428         return;
429 }
430
431
432 static int konicawc_start_data(struct uvd *uvd)
433 {
434         struct usb_device *dev = uvd->dev;
435         int i, errFlag;
436         struct konicawc *cam = (struct konicawc *)uvd->user_data;
437         int pktsz;
438         struct usb_interface *intf;
439         struct usb_host_interface *interface = NULL;
440
441         intf = usb_ifnum_to_if(dev, uvd->iface);
442         if (intf)
443                 interface = usb_altnum_to_altsetting(intf,
444                                 spd_to_iface[cam->speed]);
445         if (!interface)
446                 return -ENXIO;
447         pktsz = le16_to_cpu(interface->endpoint[1].desc.wMaxPacketSize);
448         DEBUG(1, "pktsz = %d", pktsz);
449         if (!CAMERA_IS_OPERATIONAL(uvd)) {
450                 err("Camera is not operational");
451                 return -EFAULT;
452         }
453         uvd->curframe = -1;
454         konicawc_camera_on(uvd);
455         /* Alternate interface 1 is is the biggest frame size */
456         i = usb_set_interface(dev, uvd->iface, uvd->ifaceAltActive);
457         if (i < 0) {
458                 err("usb_set_interface error");
459                 uvd->last_error = i;
460                 return -EBUSY;
461         }
462
463         /* We double buffer the Iso lists */
464         for (i=0; i < USBVIDEO_NUMSBUF; i++) {
465                 int j, k;
466                 struct urb *urb = uvd->sbuf[i].urb;
467                 urb->dev = dev;
468                 urb->context = uvd;
469                 urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp);
470                 urb->interval = 1;
471                 urb->transfer_flags = URB_ISO_ASAP;
472                 urb->transfer_buffer = uvd->sbuf[i].data;
473                 urb->complete = konicawc_isoc_irq;
474                 urb->number_of_packets = FRAMES_PER_DESC;
475                 urb->transfer_buffer_length = pktsz * FRAMES_PER_DESC;
476                 for (j=k=0; j < FRAMES_PER_DESC; j++, k += pktsz) {
477                         urb->iso_frame_desc[j].offset = k;
478                         urb->iso_frame_desc[j].length = pktsz;
479                 }
480
481                 urb = cam->sts_urb[i];
482                 urb->dev = dev;
483                 urb->context = uvd;
484                 urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp-1);
485                 urb->interval = 1;
486                 urb->transfer_flags = URB_ISO_ASAP;
487                 urb->transfer_buffer = cam->sts_buf[i];
488                 urb->complete = konicawc_isoc_irq;
489                 urb->number_of_packets = FRAMES_PER_DESC;
490                 urb->transfer_buffer_length = FRAMES_PER_DESC;
491                 for (j=0; j < FRAMES_PER_DESC; j++) {
492                         urb->iso_frame_desc[j].offset = j;
493                         urb->iso_frame_desc[j].length = 1;
494                 }
495         }
496
497         cam->last_data_urb = NULL;
498
499         /* Submit all URBs */
500         for (i=0; i < USBVIDEO_NUMSBUF; i++) {
501                 errFlag = usb_submit_urb(cam->sts_urb[i], GFP_KERNEL);
502                 if (errFlag)
503                         err("usb_submit_isoc(%d) ret %d", i, errFlag);
504
505                 errFlag = usb_submit_urb(uvd->sbuf[i].urb, GFP_KERNEL);
506                 if (errFlag)
507                         err ("usb_submit_isoc(%d) ret %d", i, errFlag);
508         }
509
510         uvd->streaming = 1;
511         DEBUG(1, "streaming=1 video_endp=$%02x", uvd->video_endp);
512         return 0;
513 }
514
515
516 static void konicawc_stop_data(struct uvd *uvd)
517 {
518         int i, j;
519         struct konicawc *cam;
520
521         if ((uvd == NULL) || (!uvd->streaming) || (uvd->dev == NULL))
522                 return;
523
524         konicawc_camera_off(uvd);
525         uvd->streaming = 0;
526         cam = (struct konicawc *)uvd->user_data;
527         cam->last_data_urb = NULL;
528
529         /* Unschedule all of the iso td's */
530         for (i=0; i < USBVIDEO_NUMSBUF; i++) {
531                 usb_kill_urb(uvd->sbuf[i].urb);
532                 usb_kill_urb(cam->sts_urb[i]);
533         }
534
535         if (!uvd->remove_pending) {
536                 /* Set packet size to 0 */
537                 j = usb_set_interface(uvd->dev, uvd->iface, uvd->ifaceAltInactive);
538                 if (j < 0) {
539                         err("usb_set_interface() error %d.", j);
540                         uvd->last_error = j;
541                 }
542         }
543 }
544
545
546 static void konicawc_process_isoc(struct uvd *uvd, struct usbvideo_frame *frame)
547 {
548         struct konicawc *cam = (struct konicawc *)uvd->user_data;
549         int maxline = cam->maxline;
550         int yplanesz = cam->yplanesz;
551
552         assert(frame != NULL);
553
554         DEBUG(5, "maxline = %d yplanesz = %d", maxline, yplanesz);
555         DEBUG(3, "Frame state = %d", frame->scanstate);
556
557         if(frame->scanstate == ScanState_Scanning) {
558                 int drop = 0;
559                 int curframe;
560                 int fdrops = 0;
561                 DEBUG(3, "Searching for marker, queue len = %d", RingQueue_GetLength(&uvd->dp));
562                 while(RingQueue_GetLength(&uvd->dp) >= 4) {
563                         if ((RING_QUEUE_PEEK(&uvd->dp, 0) == 0x00) &&
564                             (RING_QUEUE_PEEK(&uvd->dp, 1) == 0xff) &&
565                             (RING_QUEUE_PEEK(&uvd->dp, 2) == 0x00) &&
566                             (RING_QUEUE_PEEK(&uvd->dp, 3) < 0x80)) {
567                                 curframe = RING_QUEUE_PEEK(&uvd->dp, 3);
568                                 if(cam->lastframe >= 0) {
569                                         fdrops = (0x80 + curframe - cam->lastframe) & 0x7F;
570                                         fdrops--;
571                                         if(fdrops) {
572                                                 dev_info(&uvd->dev->dev,
573                                                          "Dropped %d frames "
574                                                          "(%d -> %d)\n",
575                                                          fdrops,
576                                                          cam->lastframe,
577                                                          curframe);
578                                         }
579                                 }
580                                 cam->lastframe = curframe;
581                                 frame->curline = 0;
582                                 frame->scanstate = ScanState_Lines;
583                                 RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, 4);
584                                 break;
585                         }
586                         RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, 1);
587                         drop++;
588                 }
589                 if(drop)
590                         DEBUG(2, "dropped %d bytes looking for new frame", drop);
591         }
592
593         if(frame->scanstate == ScanState_Scanning)
594                 return;
595
596         /* Try to move data from queue into frame buffer
597          * We get data in blocks of 384 bytes made up of:
598          * 256 Y, 64 U, 64 V.
599          * This needs to be written out as a Y plane, a U plane and a V plane.
600          */
601
602         while ( frame->curline < maxline && (RingQueue_GetLength(&uvd->dp) >= 384)) {
603                 /* Y */
604                 RingQueue_Dequeue(&uvd->dp, frame->data + (frame->curline * 256), 256);
605                 /* U */
606                 RingQueue_Dequeue(&uvd->dp, frame->data + yplanesz + (frame->curline * 64), 64);
607                 /* V */
608                 RingQueue_Dequeue(&uvd->dp, frame->data + (5 * yplanesz)/4 + (frame->curline * 64), 64);
609                 frame->seqRead_Length += 384;
610                 frame->curline++;
611         }
612         /* See if we filled the frame */
613         if (frame->curline == maxline) {
614                 DEBUG(5, "got whole frame");
615
616                 frame->frameState = FrameState_Done_Hold;
617                 frame->curline = 0;
618                 uvd->curframe = -1;
619                 uvd->stats.frame_num++;
620         }
621 }
622
623
624 static int konicawc_find_fps(int size, int fps)
625 {
626         int i;
627
628         fps *= 3;
629         DEBUG(1, "konica_find_fps: size = %d fps = %d", size, fps);
630         if(fps <= spd_to_fps[size][0])
631                 return 0;
632
633         if(fps >= spd_to_fps[size][MAX_SPEED])
634                 return MAX_SPEED;
635
636         for(i = 0; i < MAX_SPEED; i++) {
637                 if((fps >= spd_to_fps[size][i]) && (fps <= spd_to_fps[size][i+1])) {
638                         DEBUG(2, "fps %d between %d and %d", fps, i, i+1);
639                         if( (fps - spd_to_fps[size][i]) < (spd_to_fps[size][i+1] - fps))
640                                 return i;
641                         else
642                                 return i+1;
643                 }
644         }
645         return MAX_SPEED+1;
646 }
647
648
649 static int konicawc_set_video_mode(struct uvd *uvd, struct video_window *vw)
650 {
651         struct konicawc *cam = (struct konicawc *)uvd->user_data;
652         int newspeed = cam->speed;
653         int newsize;
654         int x = vw->width;
655         int y = vw->height;
656         int fps = vw->flags;
657
658         if(x > 0 && y > 0) {
659                 DEBUG(2, "trying to find size %d,%d", x, y);
660                 for(newsize = 0; newsize <= MAX_FRAME_SIZE; newsize++) {
661                         if((camera_sizes[newsize].width == x) && (camera_sizes[newsize].height == y))
662                                 break;
663                 }
664         } else {
665                 newsize = cam->size;
666         }
667
668         if(newsize > MAX_FRAME_SIZE) {
669                 DEBUG(1, "couldn't find size %d,%d", x, y);
670                 return -EINVAL;
671         }
672
673         if(fps > 0) {
674                 DEBUG(1, "trying to set fps to %d", fps);
675                 newspeed = konicawc_find_fps(newsize, fps);
676                 DEBUG(1, "find_fps returned %d (%d)", newspeed, spd_to_fps[newsize][newspeed]);
677         }
678
679         if(newspeed > MAX_SPEED)
680                 return -EINVAL;
681
682         DEBUG(1, "setting size to %d speed to %d", newsize, newspeed);
683         if((newsize == cam->size) && (newspeed == cam->speed)) {
684                 DEBUG(1, "Nothing to do");
685                 return 0;
686         }
687         DEBUG(0, "setting to  %dx%d @ %d fps", camera_sizes[newsize].width,
688              camera_sizes[newsize].height, spd_to_fps[newsize][newspeed]/3);
689
690         konicawc_stop_data(uvd);
691         uvd->ifaceAltActive = spd_to_iface[newspeed];
692         DEBUG(1, "new interface = %d", uvd->ifaceAltActive);
693         cam->speed = newspeed;
694
695         if(cam->size != newsize) {
696                 cam->size = newsize;
697                 konicawc_set_camera_size(uvd);
698         }
699
700         /* Flush the input queue and clear any current frame in progress */
701
702         RingQueue_Flush(&uvd->dp);
703         cam->lastframe = -2;
704         if(uvd->curframe != -1) {
705                 uvd->frame[uvd->curframe].curline = 0;
706                 uvd->frame[uvd->curframe].seqRead_Length = 0;
707                 uvd->frame[uvd->curframe].seqRead_Index = 0;
708         }
709
710         konicawc_start_data(uvd);
711         return 0;
712 }
713
714
715 static int konicawc_calculate_fps(struct uvd *uvd)
716 {
717         struct konicawc *cam = uvd->user_data;
718         return spd_to_fps[cam->size][cam->speed]/3;
719 }
720
721
722 static void konicawc_configure_video(struct uvd *uvd)
723 {
724         struct konicawc *cam = (struct konicawc *)uvd->user_data;
725         u8 buf[2];
726
727         memset(&uvd->vpic, 0, sizeof(uvd->vpic));
728         memset(&uvd->vpic_old, 0x55, sizeof(uvd->vpic_old));
729
730         RESTRICT_TO_RANGE(brightness, 0, MAX_BRIGHTNESS);
731         RESTRICT_TO_RANGE(contrast, 0, MAX_CONTRAST);
732         RESTRICT_TO_RANGE(saturation, 0, MAX_SATURATION);
733         RESTRICT_TO_RANGE(sharpness, 0, MAX_SHARPNESS);
734         RESTRICT_TO_RANGE(whitebal, 0, MAX_WHITEBAL);
735
736         cam->brightness = brightness / 11;
737         cam->contrast = contrast / 11;
738         cam->saturation = saturation / 11;
739         cam->sharpness = sharpness / 11;
740         cam->white_bal = whitebal / 11;
741
742         uvd->vpic.colour = 108;
743         uvd->vpic.hue = 108;
744         uvd->vpic.brightness = brightness;
745         uvd->vpic.contrast = contrast;
746         uvd->vpic.whiteness = whitebal;
747         uvd->vpic.depth = 6;
748         uvd->vpic.palette = VIDEO_PALETTE_YUV420P;
749
750         memset(&uvd->vcap, 0, sizeof(uvd->vcap));
751         strcpy(uvd->vcap.name, "Konica Webcam");
752         uvd->vcap.type = VID_TYPE_CAPTURE;
753         uvd->vcap.channels = 1;
754         uvd->vcap.audios = 0;
755         uvd->vcap.minwidth = camera_sizes[SIZE_160X120].width;
756         uvd->vcap.minheight = camera_sizes[SIZE_160X120].height;
757         uvd->vcap.maxwidth = camera_sizes[SIZE_320X240].width;
758         uvd->vcap.maxheight = camera_sizes[SIZE_320X240].height;
759
760         memset(&uvd->vchan, 0, sizeof(uvd->vchan));
761         uvd->vchan.flags = 0 ;
762         uvd->vchan.tuners = 0;
763         uvd->vchan.channel = 0;
764         uvd->vchan.type = VIDEO_TYPE_CAMERA;
765         strcpy(uvd->vchan.name, "Camera");
766
767         /* Talk to device */
768         DEBUG(1, "device init");
769         if(!konicawc_get_misc(uvd, 0x3, 0, 0x10, buf, 2))
770                 DEBUG(2, "3,10 -> %2.2x %2.2x", buf[0], buf[1]);
771         if(!konicawc_get_misc(uvd, 0x3, 0, 0x10, buf, 2))
772                 DEBUG(2, "3,10 -> %2.2x %2.2x", buf[0], buf[1]);
773         if(konicawc_set_misc(uvd, 0x2, 0, 0xd))
774                 DEBUG(2, "2,0,d failed");
775         DEBUG(1, "setting initial values");
776 }
777
778 static int konicawc_probe(struct usb_interface *intf, const struct usb_device_id *devid)
779 {
780         struct usb_device *dev = interface_to_usbdev(intf);
781         struct uvd *uvd = NULL;
782         int ix, i, nas;
783         int actInterface=-1, inactInterface=-1, maxPS=0;
784         unsigned char video_ep = 0;
785
786         DEBUG(1, "konicawc_probe(%p)", intf);
787
788         /* We don't handle multi-config cameras */
789         if (dev->descriptor.bNumConfigurations != 1)
790                 return -ENODEV;
791
792         dev_info(&intf->dev, "Konica Webcam (rev. 0x%04x)\n",
793                  le16_to_cpu(dev->descriptor.bcdDevice));
794         RESTRICT_TO_RANGE(speed, 0, MAX_SPEED);
795
796         /* Validate found interface: must have one ISO endpoint */
797         nas = intf->num_altsetting;
798         if (nas != 8) {
799                 err("Incorrect number of alternate settings (%d) for this camera!", nas);
800                 return -ENODEV;
801         }
802         /* Validate all alternate settings */
803         for (ix=0; ix < nas; ix++) {
804                 const struct usb_host_interface *interface;
805                 const struct usb_endpoint_descriptor *endpoint;
806
807                 interface = &intf->altsetting[ix];
808                 i = interface->desc.bAlternateSetting;
809                 if (interface->desc.bNumEndpoints != 2) {
810                         err("Interface %d. has %u. endpoints!",
811                             interface->desc.bInterfaceNumber,
812                             (unsigned)(interface->desc.bNumEndpoints));
813                         return -ENODEV;
814                 }
815                 endpoint = &interface->endpoint[1].desc;
816                 DEBUG(1, "found endpoint: addr: 0x%2.2x maxps = 0x%4.4x",
817                     endpoint->bEndpointAddress, le16_to_cpu(endpoint->wMaxPacketSize));
818                 if (video_ep == 0)
819                         video_ep = endpoint->bEndpointAddress;
820                 else if (video_ep != endpoint->bEndpointAddress) {
821                         err("Alternate settings have different endpoint addresses!");
822                         return -ENODEV;
823                 }
824                 if ((endpoint->bmAttributes & 0x03) != 0x01) {
825                         err("Interface %d. has non-ISO endpoint!",
826                             interface->desc.bInterfaceNumber);
827                         return -ENODEV;
828                 }
829                 if ((endpoint->bEndpointAddress & 0x80) == 0) {
830                         err("Interface %d. has ISO OUT endpoint!",
831                             interface->desc.bInterfaceNumber);
832                         return -ENODEV;
833                 }
834                 if (le16_to_cpu(endpoint->wMaxPacketSize) == 0) {
835                         if (inactInterface < 0)
836                                 inactInterface = i;
837                         else {
838                                 err("More than one inactive alt. setting!");
839                                 return -ENODEV;
840                         }
841                 } else {
842                         if (i == spd_to_iface[speed]) {
843                                 /* This one is the requested one */
844                                 actInterface = i;
845                         }
846                 }
847                 if (le16_to_cpu(endpoint->wMaxPacketSize) > maxPS)
848                         maxPS = le16_to_cpu(endpoint->wMaxPacketSize);
849         }
850         if(actInterface == -1) {
851                 err("Cant find required endpoint");
852                 return -ENODEV;
853         }
854
855         DEBUG(1, "Selecting requested active setting=%d. maxPS=%d.", actInterface, maxPS);
856
857         uvd = usbvideo_AllocateDevice(cams);
858         if (uvd != NULL) {
859                 struct konicawc *cam = (struct konicawc *)(uvd->user_data);
860                 /* Here uvd is a fully allocated uvd object */
861                 for(i = 0; i < USBVIDEO_NUMSBUF; i++) {
862                         cam->sts_urb[i] = usb_alloc_urb(FRAMES_PER_DESC, GFP_KERNEL);
863                         if(cam->sts_urb[i] == NULL) {
864                                 while(i--) {
865                                         usb_free_urb(cam->sts_urb[i]);
866                                 }
867                                 err("can't allocate urbs");
868                                 return -ENOMEM;
869                         }
870                 }
871                 cam->speed = speed;
872                 RESTRICT_TO_RANGE(size, SIZE_160X120, SIZE_320X240);
873                 cam->width = camera_sizes[size].width;
874                 cam->height = camera_sizes[size].height;
875                 cam->size = size;
876
877                 uvd->flags = 0;
878                 uvd->debug = debug;
879                 uvd->dev = dev;
880                 uvd->iface = intf->altsetting->desc.bInterfaceNumber;
881                 uvd->ifaceAltInactive = inactInterface;
882                 uvd->ifaceAltActive = actInterface;
883                 uvd->video_endp = video_ep;
884                 uvd->iso_packet_len = maxPS;
885                 uvd->paletteBits = 1L << VIDEO_PALETTE_YUV420P;
886                 uvd->defaultPalette = VIDEO_PALETTE_YUV420P;
887                 uvd->canvas = VIDEOSIZE(320, 240);
888                 uvd->videosize = VIDEOSIZE(cam->width, cam->height);
889
890                 /* Initialize konicawc specific data */
891                 konicawc_configure_video(uvd);
892
893                 i = usbvideo_RegisterVideoDevice(uvd);
894                 uvd->max_frame_size = (320 * 240 * 3)/2;
895                 if (i != 0) {
896                         err("usbvideo_RegisterVideoDevice() failed.");
897                         uvd = NULL;
898                 }
899
900                 konicawc_register_input(cam, dev);
901         }
902
903         if (uvd) {
904                 usb_set_intfdata (intf, uvd);
905                 return 0;
906         }
907         return -EIO;
908 }
909
910
911 static void konicawc_free_uvd(struct uvd *uvd)
912 {
913         int i;
914         struct konicawc *cam = (struct konicawc *)uvd->user_data;
915
916         konicawc_unregister_input(cam);
917
918         for (i = 0; i < USBVIDEO_NUMSBUF; i++) {
919                 usb_free_urb(cam->sts_urb[i]);
920                 cam->sts_urb[i] = NULL;
921         }
922 }
923
924
925 static struct usb_device_id id_table[] = {
926         { USB_DEVICE(0x04c8, 0x0720) }, /* Intel YC 76 */
927         { }  /* Terminating entry */
928 };
929
930
931 static int __init konicawc_init(void)
932 {
933         struct usbvideo_cb cbTbl;
934         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
935                DRIVER_DESC "\n");
936         memset(&cbTbl, 0, sizeof(cbTbl));
937         cbTbl.probe = konicawc_probe;
938         cbTbl.setupOnOpen = konicawc_setup_on_open;
939         cbTbl.processData = konicawc_process_isoc;
940         cbTbl.getFPS = konicawc_calculate_fps;
941         cbTbl.setVideoMode = konicawc_set_video_mode;
942         cbTbl.startDataPump = konicawc_start_data;
943         cbTbl.stopDataPump = konicawc_stop_data;
944         cbTbl.adjustPicture = konicawc_adjust_picture;
945         cbTbl.userFree = konicawc_free_uvd;
946         return usbvideo_register(
947                 &cams,
948                 MAX_CAMERAS,
949                 sizeof(struct konicawc),
950                 "konicawc",
951                 &cbTbl,
952                 THIS_MODULE,
953                 id_table);
954 }
955
956
957 static void __exit konicawc_cleanup(void)
958 {
959         usbvideo_Deregister(&cams);
960 }
961
962
963 MODULE_DEVICE_TABLE(usb, id_table);
964
965 MODULE_LICENSE("GPL");
966 MODULE_AUTHOR("Simon Evans <spse@secret.org.uk>");
967 MODULE_DESCRIPTION(DRIVER_DESC);
968 module_param(speed, int, 0);
969 MODULE_PARM_DESC(speed, "Initial speed: 0 (slowest) - 6 (fastest)");
970 module_param(size, int, 0);
971 MODULE_PARM_DESC(size, "Initial Size 0: 160x120 1: 160x136 2: 176x144 3: 320x240");
972 module_param(brightness, int, 0);
973 MODULE_PARM_DESC(brightness, "Initial brightness 0 - 108");
974 module_param(contrast, int, 0);
975 MODULE_PARM_DESC(contrast, "Initial contrast 0 - 108");
976 module_param(saturation, int, 0);
977 MODULE_PARM_DESC(saturation, "Initial saturation 0 - 108");
978 module_param(sharpness, int, 0);
979 MODULE_PARM_DESC(sharpness, "Initial brightness 0 - 108");
980 module_param(whitebal, int, 0);
981 MODULE_PARM_DESC(whitebal, "Initial white balance 0 - 363");
982
983 #ifdef CONFIG_USB_DEBUG
984 module_param(debug, int, S_IRUGO | S_IWUSR);
985 MODULE_PARM_DESC(debug, "Debug level: 0-9 (default=0)");
986 #endif
987
988 module_init(konicawc_init);
989 module_exit(konicawc_cleanup);