Merge rsync://rsync.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / drivers / media / video / cpia2 / cpia2_v4l.c
1 /****************************************************************************
2  *
3  *  Filename: cpia2_v4l.c
4  *
5  *  Copyright 2001, STMicrolectronics, Inc.
6  *      Contact:  steve.miller@st.com
7  *  Copyright 2001,2005, Scott J. Bertin <scottbertin@yahoo.com>
8  *
9  *  Description:
10  *     This is a USB driver for CPia2 based video cameras.
11  *     The infrastructure of this driver is based on the cpia usb driver by
12  *     Jochen Scharrlach and Johannes Erdfeldt.
13  *
14  *  This program is free software; you can redistribute it and/or modify
15  *  it under the terms of the GNU General Public License as published by
16  *  the Free Software Foundation; either version 2 of the License, or
17  *  (at your option) any later version.
18  *
19  *  This program is distributed in the hope that it will be useful,
20  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
21  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  *  GNU General Public License for more details.
23  *
24  *  You should have received a copy of the GNU General Public License
25  *  along with this program; if not, write to the Free Software
26  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27  *
28  *  Stripped of 2.4 stuff ready for main kernel submit by
29  *              Alan Cox <alan@redhat.com>
30  ****************************************************************************/
31
32 #include <linux/version.h>
33
34 #include <linux/config.h>
35
36 #include <linux/module.h>
37 #include <linux/time.h>
38 #include <linux/sched.h>
39 #include <linux/slab.h>
40 #include <linux/init.h>
41 #include <linux/moduleparam.h>
42
43 #include "cpia2.h"
44 #include "cpia2dev.h"
45
46
47 //#define _CPIA2_DEBUG_
48
49 #define MAKE_STRING_1(x)        #x
50 #define MAKE_STRING(x)  MAKE_STRING_1(x)
51
52 static int video_nr = -1;
53 module_param(video_nr, int, 0);
54 MODULE_PARM_DESC(video_nr,"video device to register (0=/dev/video0, etc)");
55
56 static int buffer_size = 68*1024;
57 module_param(buffer_size, int, 0);
58 MODULE_PARM_DESC(buffer_size, "Size for each frame buffer in bytes (default 68k)");
59
60 static int num_buffers = 3;
61 module_param(num_buffers, int, 0);
62 MODULE_PARM_DESC(num_buffers, "Number of frame buffers (1-"
63                  MAKE_STRING(VIDEO_MAX_FRAME) ", default 3)");
64
65 static int alternate = DEFAULT_ALT;
66 module_param(alternate, int, 0);
67 MODULE_PARM_DESC(alternate, "USB Alternate (" MAKE_STRING(USBIF_ISO_1) "-"
68                  MAKE_STRING(USBIF_ISO_6) ", default "
69                  MAKE_STRING(DEFAULT_ALT) ")");
70
71 static int flicker_freq = 60;
72 module_param(flicker_freq, int, 0);
73 MODULE_PARM_DESC(flicker_freq, "Flicker frequency (" MAKE_STRING(50) "or"
74                  MAKE_STRING(60) ", default "
75                  MAKE_STRING(60) ")");
76
77 static int flicker_mode = NEVER_FLICKER;
78 module_param(flicker_mode, int, 0);
79 MODULE_PARM_DESC(flicker_mode,
80                  "Flicker supression (" MAKE_STRING(NEVER_FLICKER) "or"
81                  MAKE_STRING(ANTI_FLICKER_ON) ", default "
82                  MAKE_STRING(NEVER_FLICKER) ")");
83
84 MODULE_AUTHOR("Steve Miller (STMicroelectronics) <steve.miller@st.com>");
85 MODULE_DESCRIPTION("V4L-driver for STMicroelectronics CPiA2 based cameras");
86 MODULE_SUPPORTED_DEVICE("video");
87 MODULE_LICENSE("GPL");
88
89 #define ABOUT "V4L-Driver for Vision CPiA2 based cameras"
90
91 #ifndef VID_HARDWARE_CPIA2
92 #error "VID_HARDWARE_CPIA2 should have been defined in linux/videodev.h"
93 #endif
94
95 struct control_menu_info {
96         int value;
97         char name[32];
98 };
99
100 static struct control_menu_info framerate_controls[] =
101 {
102         { CPIA2_VP_FRAMERATE_6_25, "6.25 fps" },
103         { CPIA2_VP_FRAMERATE_7_5,  "7.5 fps"  },
104         { CPIA2_VP_FRAMERATE_12_5, "12.5 fps" },
105         { CPIA2_VP_FRAMERATE_15,   "15 fps"   },
106         { CPIA2_VP_FRAMERATE_25,   "25 fps"   },
107         { CPIA2_VP_FRAMERATE_30,   "30 fps"   },
108 };
109 #define NUM_FRAMERATE_CONTROLS (sizeof(framerate_controls)/sizeof(framerate_controls[0]))
110
111 static struct control_menu_info flicker_controls[] =
112 {
113         { NEVER_FLICKER, "Off" },
114         { FLICKER_50,    "50 Hz" },
115         { FLICKER_60,    "60 Hz"  },
116 };
117 #define NUM_FLICKER_CONTROLS (sizeof(flicker_controls)/sizeof(flicker_controls[0]))
118
119 static struct control_menu_info lights_controls[] =
120 {
121         { 0,   "Off" },
122         { 64,  "Top" },
123         { 128, "Bottom"  },
124         { 192, "Both"  },
125 };
126 #define NUM_LIGHTS_CONTROLS (sizeof(lights_controls)/sizeof(lights_controls[0]))
127 #define GPIO_LIGHTS_MASK 192
128
129 static struct v4l2_queryctrl controls[] = {
130         {
131                 .id            = V4L2_CID_BRIGHTNESS,
132                 .type          = V4L2_CTRL_TYPE_INTEGER,
133                 .name          = "Brightness",
134                 .minimum       = 0,
135                 .maximum       = 255,
136                 .step          = 1,
137                 .default_value = DEFAULT_BRIGHTNESS,
138         },
139         {
140                 .id            = V4L2_CID_CONTRAST,
141                 .type          = V4L2_CTRL_TYPE_INTEGER,
142                 .name          = "Contrast",
143                 .minimum       = 0,
144                 .maximum       = 255,
145                 .step          = 1,
146                 .default_value = DEFAULT_CONTRAST,
147         },
148         {
149                 .id            = V4L2_CID_SATURATION,
150                 .type          = V4L2_CTRL_TYPE_INTEGER,
151                 .name          = "Saturation",
152                 .minimum       = 0,
153                 .maximum       = 255,
154                 .step          = 1,
155                 .default_value = DEFAULT_SATURATION,
156         },
157         {
158                 .id            = V4L2_CID_HFLIP,
159                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
160                 .name          = "Mirror Horizontally",
161                 .minimum       = 0,
162                 .maximum       = 1,
163                 .step          = 1,
164                 .default_value = 0,
165         },
166         {
167                 .id            = V4L2_CID_VFLIP,
168                 .type          = V4L2_CTRL_TYPE_BOOLEAN,
169                 .name          = "Flip Vertically",
170                 .minimum       = 0,
171                 .maximum       = 1,
172                 .step          = 1,
173                 .default_value = 0,
174         },
175         {
176                 .id            = CPIA2_CID_TARGET_KB,
177                 .type          = V4L2_CTRL_TYPE_INTEGER,
178                 .name          = "Target KB",
179                 .minimum       = 0,
180                 .maximum       = 255,
181                 .step          = 1,
182                 .default_value = DEFAULT_TARGET_KB,
183         },
184         {
185                 .id            = CPIA2_CID_GPIO,
186                 .type          = V4L2_CTRL_TYPE_INTEGER,
187                 .name          = "GPIO",
188                 .minimum       = 0,
189                 .maximum       = 255,
190                 .step          = 1,
191                 .default_value = 0,
192         },
193         {
194                 .id            = CPIA2_CID_FLICKER_MODE,
195                 .type          = V4L2_CTRL_TYPE_MENU,
196                 .name          = "Flicker Reduction",
197                 .minimum       = 0,
198                 .maximum       = NUM_FLICKER_CONTROLS-1,
199                 .step          = 1,
200                 .default_value = 0,
201         },
202         {
203                 .id            = CPIA2_CID_FRAMERATE,
204                 .type          = V4L2_CTRL_TYPE_MENU,
205                 .name          = "Framerate",
206                 .minimum       = 0,
207                 .maximum       = NUM_FRAMERATE_CONTROLS-1,
208                 .step          = 1,
209                 .default_value = NUM_FRAMERATE_CONTROLS-1,
210         },
211         {
212                 .id            = CPIA2_CID_USB_ALT,
213                 .type          = V4L2_CTRL_TYPE_INTEGER,
214                 .name          = "USB Alternate",
215                 .minimum       = USBIF_ISO_1,
216                 .maximum       = USBIF_ISO_6,
217                 .step          = 1,
218                 .default_value = DEFAULT_ALT,
219         },
220         {
221                 .id            = CPIA2_CID_LIGHTS,
222                 .type          = V4L2_CTRL_TYPE_MENU,
223                 .name          = "Lights",
224                 .minimum       = 0,
225                 .maximum       = NUM_LIGHTS_CONTROLS-1,
226                 .step          = 1,
227                 .default_value = 0,
228         },
229         {
230                 .id            = CPIA2_CID_RESET_CAMERA,
231                 .type          = V4L2_CTRL_TYPE_BUTTON,
232                 .name          = "Reset Camera",
233                 .minimum       = 0,
234                 .maximum       = 0,
235                 .step          = 0,
236                 .default_value = 0,
237         },
238 };
239 #define NUM_CONTROLS (sizeof(controls)/sizeof(controls[0]))
240
241
242 /******************************************************************************
243  *
244  *  cpia2_open
245  *
246  *****************************************************************************/
247 static int cpia2_open(struct inode *inode, struct file *file)
248 {
249         struct video_device *dev = video_devdata(file);
250         struct camera_data *cam = video_get_drvdata(dev);
251         int retval = 0;
252
253         if (!cam) {
254                 ERR("Internal error, camera_data not found!\n");
255                 return -ENODEV;
256         }
257
258         if(mutex_lock_interruptible(&cam->busy_lock))
259                 return -ERESTARTSYS;
260
261         if(!cam->present) {
262                 retval = -ENODEV;
263                 goto err_return;
264         }
265
266         if (cam->open_count > 0) {
267                 goto skip_init;
268         }
269
270         if (cpia2_allocate_buffers(cam)) {
271                 retval = -ENOMEM;
272                 goto err_return;
273         }
274
275         /* reset the camera */
276         if (cpia2_reset_camera(cam) < 0) {
277                 retval = -EIO;
278                 goto err_return;
279         }
280
281         cam->APP_len = 0;
282         cam->COM_len = 0;
283
284 skip_init:
285         {
286                 struct cpia2_fh *fh = kmalloc(sizeof(*fh),GFP_KERNEL);
287                 if(!fh) {
288                         retval = -ENOMEM;
289                         goto err_return;
290                 }
291                 file->private_data = fh;
292                 fh->prio = V4L2_PRIORITY_UNSET;
293                 v4l2_prio_open(&cam->prio, &fh->prio);
294                 fh->mmapped = 0;
295         }
296
297         ++cam->open_count;
298
299         cpia2_dbg_dump_registers(cam);
300
301 err_return:
302         mutex_unlock(&cam->busy_lock);
303         return retval;
304 }
305
306 /******************************************************************************
307  *
308  *  cpia2_close
309  *
310  *****************************************************************************/
311 static int cpia2_close(struct inode *inode, struct file *file)
312 {
313         struct video_device *dev = video_devdata(file);
314         struct camera_data *cam = video_get_drvdata(dev);
315         struct cpia2_fh *fh = file->private_data;
316
317         mutex_lock(&cam->busy_lock);
318
319         if (cam->present &&
320             (cam->open_count == 1
321              || fh->prio == V4L2_PRIORITY_RECORD
322             )) {
323                 cpia2_usb_stream_stop(cam);
324
325                 if(cam->open_count == 1) {
326                         /* save camera state for later open */
327                         cpia2_save_camera_state(cam);
328
329                         cpia2_set_low_power(cam);
330                         cpia2_free_buffers(cam);
331                 }
332         }
333
334         {
335                 if(fh->mmapped)
336                         cam->mmapped = 0;
337                 v4l2_prio_close(&cam->prio,&fh->prio);
338                 file->private_data = NULL;
339                 kfree(fh);
340         }
341
342         if (--cam->open_count == 0) {
343                 cpia2_free_buffers(cam);
344                 if (!cam->present) {
345                         video_unregister_device(dev);
346                         mutex_unlock(&cam->busy_lock);
347                         kfree(cam);
348                         return 0;
349                 }
350         }
351
352         mutex_unlock(&cam->busy_lock);
353
354         return 0;
355 }
356
357 /******************************************************************************
358  *
359  *  cpia2_v4l_read
360  *
361  *****************************************************************************/
362 static ssize_t cpia2_v4l_read(struct file *file, char __user *buf, size_t count,
363                               loff_t *off)
364 {
365         struct video_device *dev = video_devdata(file);
366         struct camera_data *cam = video_get_drvdata(dev);
367         int noblock = file->f_flags&O_NONBLOCK;
368
369         struct cpia2_fh *fh = file->private_data;
370
371         if(!cam)
372                 return -EINVAL;
373
374         /* Priority check */
375         if(fh->prio != V4L2_PRIORITY_RECORD) {
376                 return -EBUSY;
377         }
378
379         return cpia2_read(cam, buf, count, noblock);
380 }
381
382
383 /******************************************************************************
384  *
385  *  cpia2_v4l_poll
386  *
387  *****************************************************************************/
388 static unsigned int cpia2_v4l_poll(struct file *filp, struct poll_table_struct *wait)
389 {
390         struct video_device *dev = video_devdata(filp);
391         struct camera_data *cam = video_get_drvdata(dev);
392
393         struct cpia2_fh *fh = filp->private_data;
394
395         if(!cam)
396                 return POLLERR;
397
398         /* Priority check */
399         if(fh->prio != V4L2_PRIORITY_RECORD) {
400                 return POLLERR;
401         }
402
403         return cpia2_poll(cam, filp, wait);
404 }
405
406
407 /******************************************************************************
408  *
409  *  ioctl_cap_query
410  *
411  *****************************************************************************/
412 static int ioctl_cap_query(void *arg, struct camera_data *cam)
413 {
414         struct video_capability *vc;
415         int retval = 0;
416         vc = arg;
417
418         if (cam->params.pnp_id.product == 0x151)
419                 strcpy(vc->name, "QX5 Microscope");
420         else
421                 strcpy(vc->name, "CPiA2 Camera");
422
423         vc->type = VID_TYPE_CAPTURE | VID_TYPE_MJPEG_ENCODER;
424         vc->channels = 1;
425         vc->audios = 0;
426         vc->minwidth = 176;     /* VIDEOSIZE_QCIF */
427         vc->minheight = 144;
428         switch (cam->params.version.sensor_flags) {
429         case CPIA2_VP_SENSOR_FLAGS_500:
430                 vc->maxwidth = STV_IMAGE_VGA_COLS;
431                 vc->maxheight = STV_IMAGE_VGA_ROWS;
432                 break;
433         case CPIA2_VP_SENSOR_FLAGS_410:
434                 vc->maxwidth = STV_IMAGE_CIF_COLS;
435                 vc->maxheight = STV_IMAGE_CIF_ROWS;
436                 break;
437         default:
438                 return -EINVAL;
439         }
440
441         return retval;
442 }
443
444 /******************************************************************************
445  *
446  *  ioctl_get_channel
447  *
448  *****************************************************************************/
449 static int ioctl_get_channel(void *arg)
450 {
451         int retval = 0;
452         struct video_channel *v;
453         v = arg;
454
455         if (v->channel != 0)
456                 return -EINVAL;
457
458         v->channel = 0;
459         strcpy(v->name, "Camera");
460         v->tuners = 0;
461         v->flags = 0;
462         v->type = VIDEO_TYPE_CAMERA;
463         v->norm = 0;
464
465         return retval;
466 }
467
468 /******************************************************************************
469  *
470  *  ioctl_set_channel
471  *
472  *****************************************************************************/
473 static int ioctl_set_channel(void *arg)
474 {
475         struct video_channel *v;
476         int retval = 0;
477         v = arg;
478
479         if (retval == 0 && v->channel != 0)
480                 retval = -EINVAL;
481
482         return retval;
483 }
484
485 /******************************************************************************
486  *
487  *  ioctl_set_image_prop
488  *
489  *****************************************************************************/
490 static int ioctl_set_image_prop(void *arg, struct camera_data *cam)
491 {
492         struct video_picture *vp;
493         int retval = 0;
494         vp = arg;
495
496         /* brightness, color, contrast need no check 0-65535 */
497         memcpy(&cam->vp, vp, sizeof(*vp));
498
499         /* update cam->params.colorParams */
500         cam->params.color_params.brightness = vp->brightness / 256;
501         cam->params.color_params.saturation = vp->colour / 256;
502         cam->params.color_params.contrast = vp->contrast / 256;
503
504         DBG("Requested params: bright 0x%X, sat 0x%X, contrast 0x%X\n",
505             cam->params.color_params.brightness,
506             cam->params.color_params.saturation,
507             cam->params.color_params.contrast);
508
509         cpia2_set_color_params(cam);
510
511         return retval;
512 }
513
514 static int sync(struct camera_data *cam, int frame_nr)
515 {
516         struct framebuf *frame = &cam->buffers[frame_nr];
517
518         while (1) {
519                 if (frame->status == FRAME_READY)
520                         return 0;
521
522                 if (!cam->streaming) {
523                         frame->status = FRAME_READY;
524                         frame->length = 0;
525                         return 0;
526                 }
527
528                 mutex_unlock(&cam->busy_lock);
529                 wait_event_interruptible(cam->wq_stream,
530                                          !cam->streaming ||
531                                          frame->status == FRAME_READY);
532                 mutex_lock(&cam->busy_lock);
533                 if (signal_pending(current))
534                         return -ERESTARTSYS;
535                 if(!cam->present)
536                         return -ENOTTY;
537         }
538 }
539
540 /******************************************************************************
541  *
542  *  ioctl_set_window_size
543  *
544  *****************************************************************************/
545 static int ioctl_set_window_size(void *arg, struct camera_data *cam,
546                                  struct cpia2_fh *fh)
547 {
548         /* copy_from_user, check validity, copy to internal structure */
549         struct video_window *vw;
550         int frame, err;
551         vw = arg;
552
553         if (vw->clipcount != 0) /* clipping not supported */
554                 return -EINVAL;
555
556         if (vw->clips != NULL)  /* clipping not supported */
557                 return -EINVAL;
558
559         /* Ensure that only this process can change the format. */
560         err = v4l2_prio_change(&cam->prio, &fh->prio, V4L2_PRIORITY_RECORD);
561         if(err != 0)
562                 return err;
563
564         cam->pixelformat = V4L2_PIX_FMT_JPEG;
565
566         /* Be sure to supply the Huffman tables, this isn't MJPEG */
567         cam->params.compression.inhibit_htables = 0;
568
569         /* we set the video window to something smaller or equal to what
570          * is requested by the user???
571          */
572         DBG("Requested width = %d, height = %d\n", vw->width, vw->height);
573         if (vw->width != cam->vw.width || vw->height != cam->vw.height) {
574                 cam->vw.width = vw->width;
575                 cam->vw.height = vw->height;
576                 cam->params.roi.width = vw->width;
577                 cam->params.roi.height = vw->height;
578                 cpia2_set_format(cam);
579         }
580
581         for (frame = 0; frame < cam->num_frames; ++frame) {
582                 if (cam->buffers[frame].status == FRAME_READING)
583                         if ((err = sync(cam, frame)) < 0)
584                                 return err;
585
586                 cam->buffers[frame].status = FRAME_EMPTY;
587         }
588
589         return 0;
590 }
591
592 /******************************************************************************
593  *
594  *  ioctl_get_mbuf
595  *
596  *****************************************************************************/
597 static int ioctl_get_mbuf(void *arg, struct camera_data *cam)
598 {
599         struct video_mbuf *vm;
600         int i;
601         vm = arg;
602
603         memset(vm, 0, sizeof(*vm));
604         vm->size = cam->frame_size*cam->num_frames;
605         vm->frames = cam->num_frames;
606         for (i = 0; i < cam->num_frames; i++)
607                 vm->offsets[i] = cam->frame_size * i;
608
609         return 0;
610 }
611
612 /******************************************************************************
613  *
614  *  ioctl_mcapture
615  *
616  *****************************************************************************/
617 static int ioctl_mcapture(void *arg, struct camera_data *cam,
618                           struct cpia2_fh *fh)
619 {
620         struct video_mmap *vm;
621         int video_size, err;
622         vm = arg;
623
624         if (vm->frame < 0 || vm->frame >= cam->num_frames)
625                 return -EINVAL;
626
627         /* set video size */
628         video_size = cpia2_match_video_size(vm->width, vm->height);
629         if (cam->video_size < 0) {
630                 return -EINVAL;
631         }
632
633         /* Ensure that only this process can change the format. */
634         err = v4l2_prio_change(&cam->prio, &fh->prio, V4L2_PRIORITY_RECORD);
635         if(err != 0)
636                 return err;
637
638         if (video_size != cam->video_size) {
639                 cam->video_size = video_size;
640                 cam->params.roi.width = vm->width;
641                 cam->params.roi.height = vm->height;
642                 cpia2_set_format(cam);
643         }
644
645         if (cam->buffers[vm->frame].status == FRAME_READING)
646                 if ((err=sync(cam, vm->frame)) < 0)
647                         return err;
648
649         cam->buffers[vm->frame].status = FRAME_EMPTY;
650
651         return cpia2_usb_stream_start(cam,cam->params.camera_state.stream_mode);
652 }
653
654 /******************************************************************************
655  *
656  *  ioctl_sync
657  *
658  *****************************************************************************/
659 static int ioctl_sync(void *arg, struct camera_data *cam)
660 {
661         int frame;
662
663         frame = *(int*)arg;
664
665         if (frame < 0 || frame >= cam->num_frames)
666                 return -EINVAL;
667
668         return sync(cam, frame);
669 }
670
671
672 /******************************************************************************
673  *
674  *  ioctl_set_gpio
675  *
676  *****************************************************************************/
677
678 static int ioctl_set_gpio(void *arg, struct camera_data *cam)
679 {
680         __u32 gpio_val;
681
682         gpio_val = *(__u32*) arg;
683
684         if (gpio_val &~ 0xFFU)
685                 return -EINVAL;
686
687         return cpia2_set_gpio(cam, (unsigned char)gpio_val);
688 }
689
690 /******************************************************************************
691  *
692  *  ioctl_querycap
693  *
694  *  V4L2 device capabilities
695  *
696  *****************************************************************************/
697
698 static int ioctl_querycap(void *arg, struct camera_data *cam)
699 {
700         struct v4l2_capability *vc = arg;
701
702         memset(vc, 0, sizeof(*vc));
703         strcpy(vc->driver, "cpia2");
704
705         if (cam->params.pnp_id.product == 0x151)
706                 strcpy(vc->card, "QX5 Microscope");
707         else
708                 strcpy(vc->card, "CPiA2 Camera");
709         switch (cam->params.pnp_id.device_type) {
710         case DEVICE_STV_672:
711                 strcat(vc->card, " (672/");
712                 break;
713         case DEVICE_STV_676:
714                 strcat(vc->card, " (676/");
715                 break;
716         default:
717                 strcat(vc->card, " (???/");
718                 break;
719         }
720         switch (cam->params.version.sensor_flags) {
721         case CPIA2_VP_SENSOR_FLAGS_404:
722                 strcat(vc->card, "404)");
723                 break;
724         case CPIA2_VP_SENSOR_FLAGS_407:
725                 strcat(vc->card, "407)");
726                 break;
727         case CPIA2_VP_SENSOR_FLAGS_409:
728                 strcat(vc->card, "409)");
729                 break;
730         case CPIA2_VP_SENSOR_FLAGS_410:
731                 strcat(vc->card, "410)");
732                 break;
733         case CPIA2_VP_SENSOR_FLAGS_500:
734                 strcat(vc->card, "500)");
735                 break;
736         default:
737                 strcat(vc->card, "???)");
738                 break;
739         }
740
741         if (usb_make_path(cam->dev, vc->bus_info, sizeof(vc->bus_info)) <0)
742                 memset(vc->bus_info,0, sizeof(vc->bus_info));
743
744         vc->version = KERNEL_VERSION(CPIA2_MAJ_VER, CPIA2_MIN_VER,
745                                      CPIA2_PATCH_VER);
746
747         vc->capabilities = V4L2_CAP_VIDEO_CAPTURE |
748                            V4L2_CAP_READWRITE |
749                            V4L2_CAP_STREAMING;
750
751         return 0;
752 }
753
754 /******************************************************************************
755  *
756  *  ioctl_input
757  *
758  *  V4L2 input get/set/enumerate
759  *
760  *****************************************************************************/
761
762 static int ioctl_input(unsigned int ioclt_nr,void *arg,struct camera_data *cam)
763 {
764         struct v4l2_input *i = arg;
765
766         if(ioclt_nr  != VIDIOC_G_INPUT) {
767                 if (i->index != 0)
768                        return -EINVAL;
769         }
770
771         memset(i, 0, sizeof(*i));
772         strcpy(i->name, "Camera");
773         i->type = V4L2_INPUT_TYPE_CAMERA;
774
775         return 0;
776 }
777
778 /******************************************************************************
779  *
780  *  ioctl_enum_fmt
781  *
782  *  V4L2 format enumerate
783  *
784  *****************************************************************************/
785
786 static int ioctl_enum_fmt(void *arg,struct camera_data *cam)
787 {
788         struct v4l2_fmtdesc *f = arg;
789         int index = f->index;
790
791         if (index < 0 || index > 1)
792                return -EINVAL;
793
794         memset(f, 0, sizeof(*f));
795         f->index = index;
796         f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
797         f->flags = V4L2_FMT_FLAG_COMPRESSED;
798         switch(index) {
799         case 0:
800                 strcpy(f->description, "MJPEG");
801                 f->pixelformat = V4L2_PIX_FMT_MJPEG;
802                 break;
803         case 1:
804                 strcpy(f->description, "JPEG");
805                 f->pixelformat = V4L2_PIX_FMT_JPEG;
806                 break;
807         default:
808                 return -EINVAL;
809         }
810
811         return 0;
812 }
813
814 /******************************************************************************
815  *
816  *  ioctl_try_fmt
817  *
818  *  V4L2 format try
819  *
820  *****************************************************************************/
821
822 static int ioctl_try_fmt(void *arg,struct camera_data *cam)
823 {
824         struct v4l2_format *f = arg;
825
826         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
827                return -EINVAL;
828
829         if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_MJPEG &&
830             f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
831                return -EINVAL;
832
833         f->fmt.pix.field = V4L2_FIELD_NONE;
834         f->fmt.pix.bytesperline = 0;
835         f->fmt.pix.sizeimage = cam->frame_size;
836         f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
837         f->fmt.pix.priv = 0;
838
839         switch (cpia2_match_video_size(f->fmt.pix.width, f->fmt.pix.height)) {
840         case VIDEOSIZE_VGA:
841                 f->fmt.pix.width = 640;
842                 f->fmt.pix.height = 480;
843                 break;
844         case VIDEOSIZE_CIF:
845                 f->fmt.pix.width = 352;
846                 f->fmt.pix.height = 288;
847                 break;
848         case VIDEOSIZE_QVGA:
849                 f->fmt.pix.width = 320;
850                 f->fmt.pix.height = 240;
851                 break;
852         case VIDEOSIZE_288_216:
853                 f->fmt.pix.width = 288;
854                 f->fmt.pix.height = 216;
855                 break;
856         case VIDEOSIZE_256_192:
857                 f->fmt.pix.width = 256;
858                 f->fmt.pix.height = 192;
859                 break;
860         case VIDEOSIZE_224_168:
861                 f->fmt.pix.width = 224;
862                 f->fmt.pix.height = 168;
863                 break;
864         case VIDEOSIZE_192_144:
865                 f->fmt.pix.width = 192;
866                 f->fmt.pix.height = 144;
867                 break;
868         case VIDEOSIZE_QCIF:
869         default:
870                 f->fmt.pix.width = 176;
871                 f->fmt.pix.height = 144;
872                 break;
873         }
874
875         return 0;
876 }
877
878 /******************************************************************************
879  *
880  *  ioctl_set_fmt
881  *
882  *  V4L2 format set
883  *
884  *****************************************************************************/
885
886 static int ioctl_set_fmt(void *arg,struct camera_data *cam, struct cpia2_fh *fh)
887 {
888         struct v4l2_format *f = arg;
889         int err, frame;
890
891         err = ioctl_try_fmt(arg, cam);
892         if(err != 0)
893                 return err;
894
895         /* Ensure that only this process can change the format. */
896         err = v4l2_prio_change(&cam->prio, &fh->prio, V4L2_PRIORITY_RECORD);
897         if(err != 0) {
898                 return err;
899         }
900
901         cam->pixelformat = f->fmt.pix.pixelformat;
902
903         /* NOTE: This should be set to 1 for MJPEG, but some apps don't handle
904          * the missing Huffman table properly. */
905         cam->params.compression.inhibit_htables = 0;
906                 /*f->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG;*/
907
908         /* we set the video window to something smaller or equal to what
909          * is requested by the user???
910          */
911         DBG("Requested width = %d, height = %d\n",
912             f->fmt.pix.width, f->fmt.pix.height);
913         if (f->fmt.pix.width != cam->vw.width ||
914             f->fmt.pix.height != cam->vw.height) {
915                 cam->vw.width = f->fmt.pix.width;
916                 cam->vw.height = f->fmt.pix.height;
917                 cam->params.roi.width = f->fmt.pix.width;
918                 cam->params.roi.height = f->fmt.pix.height;
919                 cpia2_set_format(cam);
920         }
921
922         for (frame = 0; frame < cam->num_frames; ++frame) {
923                 if (cam->buffers[frame].status == FRAME_READING)
924                         if ((err = sync(cam, frame)) < 0)
925                                 return err;
926
927                 cam->buffers[frame].status = FRAME_EMPTY;
928         }
929
930         return 0;
931 }
932
933 /******************************************************************************
934  *
935  *  ioctl_get_fmt
936  *
937  *  V4L2 format get
938  *
939  *****************************************************************************/
940
941 static int ioctl_get_fmt(void *arg,struct camera_data *cam)
942 {
943         struct v4l2_format *f = arg;
944
945         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
946                return -EINVAL;
947
948         f->fmt.pix.width = cam->vw.width;
949         f->fmt.pix.height = cam->vw.height;
950         f->fmt.pix.pixelformat = cam->pixelformat;
951         f->fmt.pix.field = V4L2_FIELD_NONE;
952         f->fmt.pix.bytesperline = 0;
953         f->fmt.pix.sizeimage = cam->frame_size;
954         f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
955         f->fmt.pix.priv = 0;
956
957         return 0;
958 }
959
960 /******************************************************************************
961  *
962  *  ioctl_cropcap
963  *
964  *  V4L2 query cropping capabilities
965  *  NOTE: cropping is currently disabled
966  *
967  *****************************************************************************/
968
969 static int ioctl_cropcap(void *arg,struct camera_data *cam)
970 {
971         struct v4l2_cropcap *c = arg;
972
973         if (c->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
974                return -EINVAL;
975
976         c->bounds.left = 0;
977         c->bounds.top = 0;
978         c->bounds.width = cam->vw.width;
979         c->bounds.height = cam->vw.height;
980         c->defrect.left = 0;
981         c->defrect.top = 0;
982         c->defrect.width = cam->vw.width;
983         c->defrect.height = cam->vw.height;
984         c->pixelaspect.numerator = 1;
985         c->pixelaspect.denominator = 1;
986
987         return 0;
988 }
989
990 /******************************************************************************
991  *
992  *  ioctl_queryctrl
993  *
994  *  V4L2 query possible control variables
995  *
996  *****************************************************************************/
997
998 static int ioctl_queryctrl(void *arg,struct camera_data *cam)
999 {
1000         struct v4l2_queryctrl *c = arg;
1001         int i;
1002
1003         for(i=0; i<NUM_CONTROLS; ++i) {
1004                 if(c->id == controls[i].id) {
1005                         memcpy(c, controls+i, sizeof(*c));
1006                         break;
1007                 }
1008         }
1009
1010         if(i == NUM_CONTROLS)
1011                 return -EINVAL;
1012
1013         /* Some devices have additional limitations */
1014         switch(c->id) {
1015         case V4L2_CID_BRIGHTNESS:
1016                 /***
1017                  * Don't let the register be set to zero - bug in VP4
1018                  * flash of full brightness
1019                  ***/
1020                 if (cam->params.pnp_id.device_type == DEVICE_STV_672)
1021                         c->minimum = 1;
1022                 break;
1023         case V4L2_CID_VFLIP:
1024                 // VP5 Only
1025                 if(cam->params.pnp_id.device_type == DEVICE_STV_672)
1026                         c->flags |= V4L2_CTRL_FLAG_DISABLED;
1027                 break;
1028         case CPIA2_CID_FRAMERATE:
1029                 if(cam->params.pnp_id.device_type == DEVICE_STV_672 &&
1030                    cam->params.version.sensor_flags==CPIA2_VP_SENSOR_FLAGS_500){
1031                         // Maximum 15fps
1032                         int i;
1033                         for(i=0; i<c->maximum; ++i) {
1034                                 if(framerate_controls[i].value ==
1035                                    CPIA2_VP_FRAMERATE_15) {
1036                                         c->maximum = i;
1037                                         c->default_value = i;
1038                                 }
1039                         }
1040                 }
1041                 break;
1042         case CPIA2_CID_FLICKER_MODE:
1043                 // Flicker control only valid for 672.
1044                 if(cam->params.pnp_id.device_type != DEVICE_STV_672)
1045                         c->flags |= V4L2_CTRL_FLAG_DISABLED;
1046                 break;
1047         case CPIA2_CID_LIGHTS:
1048                 // Light control only valid for the QX5 Microscope.
1049                 if(cam->params.pnp_id.product != 0x151)
1050                         c->flags |= V4L2_CTRL_FLAG_DISABLED;
1051                 break;
1052         default:
1053                 break;
1054         }
1055
1056         return 0;
1057 }
1058
1059 /******************************************************************************
1060  *
1061  *  ioctl_querymenu
1062  *
1063  *  V4L2 query possible control variables
1064  *
1065  *****************************************************************************/
1066
1067 static int ioctl_querymenu(void *arg,struct camera_data *cam)
1068 {
1069         struct v4l2_querymenu *m = arg;
1070
1071         memset(m->name, 0, sizeof(m->name));
1072         m->reserved = 0;
1073
1074         switch(m->id) {
1075         case CPIA2_CID_FLICKER_MODE:
1076                 if(m->index < 0 || m->index >= NUM_FLICKER_CONTROLS)
1077                         return -EINVAL;
1078
1079                 strcpy(m->name, flicker_controls[m->index].name);
1080                 break;
1081         case CPIA2_CID_FRAMERATE:
1082             {
1083                 int maximum = NUM_FRAMERATE_CONTROLS - 1;
1084                 if(cam->params.pnp_id.device_type == DEVICE_STV_672 &&
1085                    cam->params.version.sensor_flags==CPIA2_VP_SENSOR_FLAGS_500){
1086                         // Maximum 15fps
1087                         int i;
1088                         for(i=0; i<maximum; ++i) {
1089                                 if(framerate_controls[i].value ==
1090                                    CPIA2_VP_FRAMERATE_15)
1091                                         maximum = i;
1092                         }
1093                 }
1094                 if(m->index < 0 || m->index > maximum)
1095                         return -EINVAL;
1096
1097                 strcpy(m->name, framerate_controls[m->index].name);
1098                 break;
1099             }
1100         case CPIA2_CID_LIGHTS:
1101                 if(m->index < 0 || m->index >= NUM_LIGHTS_CONTROLS)
1102                         return -EINVAL;
1103
1104                 strcpy(m->name, lights_controls[m->index].name);
1105                 break;
1106         default:
1107                 return -EINVAL;
1108         }
1109
1110         return 0;
1111 }
1112
1113 /******************************************************************************
1114  *
1115  *  ioctl_g_ctrl
1116  *
1117  *  V4L2 get the value of a control variable
1118  *
1119  *****************************************************************************/
1120
1121 static int ioctl_g_ctrl(void *arg,struct camera_data *cam)
1122 {
1123         struct v4l2_control *c = arg;
1124
1125         switch(c->id) {
1126         case V4L2_CID_BRIGHTNESS:
1127                 cpia2_do_command(cam, CPIA2_CMD_GET_VP_BRIGHTNESS,
1128                                  TRANSFER_READ, 0);
1129                 c->value = cam->params.color_params.brightness;
1130                 break;
1131         case V4L2_CID_CONTRAST:
1132                 cpia2_do_command(cam, CPIA2_CMD_GET_CONTRAST,
1133                                  TRANSFER_READ, 0);
1134                 c->value = cam->params.color_params.contrast;
1135                 break;
1136         case V4L2_CID_SATURATION:
1137                 cpia2_do_command(cam, CPIA2_CMD_GET_VP_SATURATION,
1138                                  TRANSFER_READ, 0);
1139                 c->value = cam->params.color_params.saturation;
1140                 break;
1141         case V4L2_CID_HFLIP:
1142                 cpia2_do_command(cam, CPIA2_CMD_GET_USER_EFFECTS,
1143                                  TRANSFER_READ, 0);
1144                 c->value = (cam->params.vp_params.user_effects &
1145                             CPIA2_VP_USER_EFFECTS_MIRROR) != 0;
1146                 break;
1147         case V4L2_CID_VFLIP:
1148                 cpia2_do_command(cam, CPIA2_CMD_GET_USER_EFFECTS,
1149                                  TRANSFER_READ, 0);
1150                 c->value = (cam->params.vp_params.user_effects &
1151                             CPIA2_VP_USER_EFFECTS_FLIP) != 0;
1152                 break;
1153         case CPIA2_CID_TARGET_KB:
1154                 c->value = cam->params.vc_params.target_kb;
1155                 break;
1156         case CPIA2_CID_GPIO:
1157                 cpia2_do_command(cam, CPIA2_CMD_GET_VP_GPIO_DATA,
1158                                  TRANSFER_READ, 0);
1159                 c->value = cam->params.vp_params.gpio_data;
1160                 break;
1161         case CPIA2_CID_FLICKER_MODE:
1162         {
1163                 int i, mode;
1164                 cpia2_do_command(cam, CPIA2_CMD_GET_FLICKER_MODES,
1165                                  TRANSFER_READ, 0);
1166                 if(cam->params.flicker_control.cam_register &
1167                    CPIA2_VP_FLICKER_MODES_NEVER_FLICKER) {
1168                         mode = NEVER_FLICKER;
1169                 } else {
1170                     if(cam->params.flicker_control.cam_register &
1171                        CPIA2_VP_FLICKER_MODES_50HZ) {
1172                         mode = FLICKER_50;
1173                     } else {
1174                         mode = FLICKER_60;
1175                     }
1176                 }
1177                 for(i=0; i<NUM_FLICKER_CONTROLS; i++) {
1178                         if(flicker_controls[i].value == mode) {
1179                                 c->value = i;
1180                                 break;
1181                         }
1182                 }
1183                 if(i == NUM_FLICKER_CONTROLS)
1184                         return -EINVAL;
1185                 break;
1186         }
1187         case CPIA2_CID_FRAMERATE:
1188         {
1189                 int maximum = NUM_FRAMERATE_CONTROLS - 1;
1190                 int i;
1191                 for(i=0; i<= maximum; i++) {
1192                         if(cam->params.vp_params.frame_rate ==
1193                            framerate_controls[i].value)
1194                                 break;
1195                 }
1196                 if(i > maximum)
1197                         return -EINVAL;
1198                 c->value = i;
1199                 break;
1200         }
1201         case CPIA2_CID_USB_ALT:
1202                 c->value = cam->params.camera_state.stream_mode;
1203                 break;
1204         case CPIA2_CID_LIGHTS:
1205         {
1206                 int i;
1207                 cpia2_do_command(cam, CPIA2_CMD_GET_VP_GPIO_DATA,
1208                                  TRANSFER_READ, 0);
1209                 for(i=0; i<NUM_LIGHTS_CONTROLS; i++) {
1210                         if((cam->params.vp_params.gpio_data&GPIO_LIGHTS_MASK) ==
1211                            lights_controls[i].value) {
1212                                 break;
1213                         }
1214                 }
1215                 if(i == NUM_LIGHTS_CONTROLS)
1216                         return -EINVAL;
1217                 c->value = i;
1218                 break;
1219         }
1220         case CPIA2_CID_RESET_CAMERA:
1221                 return -EINVAL;
1222         default:
1223                 return -EINVAL;
1224         }
1225
1226         DBG("Get control id:%d, value:%d\n", c->id, c->value);
1227
1228         return 0;
1229 }
1230
1231 /******************************************************************************
1232  *
1233  *  ioctl_s_ctrl
1234  *
1235  *  V4L2 set the value of a control variable
1236  *
1237  *****************************************************************************/
1238
1239 static int ioctl_s_ctrl(void *arg,struct camera_data *cam)
1240 {
1241         struct v4l2_control *c = arg;
1242         int i;
1243         int retval = 0;
1244
1245         DBG("Set control id:%d, value:%d\n", c->id, c->value);
1246
1247         /* Check that the value is in range */
1248         for(i=0; i<NUM_CONTROLS; i++) {
1249                 if(c->id == controls[i].id) {
1250                         if(c->value < controls[i].minimum ||
1251                            c->value > controls[i].maximum) {
1252                                 return -EINVAL;
1253                         }
1254                         break;
1255                 }
1256         }
1257         if(i == NUM_CONTROLS)
1258                 return -EINVAL;
1259
1260         switch(c->id) {
1261         case V4L2_CID_BRIGHTNESS:
1262                 cpia2_set_brightness(cam, c->value);
1263                 break;
1264         case V4L2_CID_CONTRAST:
1265                 cpia2_set_contrast(cam, c->value);
1266                 break;
1267         case V4L2_CID_SATURATION:
1268                 cpia2_set_saturation(cam, c->value);
1269                 break;
1270         case V4L2_CID_HFLIP:
1271                 cpia2_set_property_mirror(cam, c->value);
1272                 break;
1273         case V4L2_CID_VFLIP:
1274                 cpia2_set_property_flip(cam, c->value);
1275                 break;
1276         case CPIA2_CID_TARGET_KB:
1277                 retval = cpia2_set_target_kb(cam, c->value);
1278                 break;
1279         case CPIA2_CID_GPIO:
1280                 retval = cpia2_set_gpio(cam, c->value);
1281                 break;
1282         case CPIA2_CID_FLICKER_MODE:
1283                 retval = cpia2_set_flicker_mode(cam,
1284                                               flicker_controls[c->value].value);
1285                 break;
1286         case CPIA2_CID_FRAMERATE:
1287                 retval = cpia2_set_fps(cam, framerate_controls[c->value].value);
1288                 break;
1289         case CPIA2_CID_USB_ALT:
1290                 retval = cpia2_usb_change_streaming_alternate(cam, c->value);
1291                 break;
1292         case CPIA2_CID_LIGHTS:
1293                 retval = cpia2_set_gpio(cam, lights_controls[c->value].value);
1294                 break;
1295         case CPIA2_CID_RESET_CAMERA:
1296                 cpia2_usb_stream_pause(cam);
1297                 cpia2_reset_camera(cam);
1298                 cpia2_usb_stream_resume(cam);
1299                 break;
1300         default:
1301                 retval = -EINVAL;
1302         }
1303
1304         return retval;
1305 }
1306
1307 /******************************************************************************
1308  *
1309  *  ioctl_g_jpegcomp
1310  *
1311  *  V4L2 get the JPEG compression parameters
1312  *
1313  *****************************************************************************/
1314
1315 static int ioctl_g_jpegcomp(void *arg,struct camera_data *cam)
1316 {
1317         struct v4l2_jpegcompression *parms = arg;
1318
1319         memset(parms, 0, sizeof(*parms));
1320
1321         parms->quality = 80; // TODO: Can this be made meaningful?
1322
1323         parms->jpeg_markers = V4L2_JPEG_MARKER_DQT | V4L2_JPEG_MARKER_DRI;
1324         if(!cam->params.compression.inhibit_htables) {
1325                 parms->jpeg_markers |= V4L2_JPEG_MARKER_DHT;
1326         }
1327
1328         parms->APPn = cam->APPn;
1329         parms->APP_len = cam->APP_len;
1330         if(cam->APP_len > 0) {
1331                 memcpy(parms->APP_data, cam->APP_data, cam->APP_len);
1332                 parms->jpeg_markers |= V4L2_JPEG_MARKER_APP;
1333         }
1334
1335         parms->COM_len = cam->COM_len;
1336         if(cam->COM_len > 0) {
1337                 memcpy(parms->COM_data, cam->COM_data, cam->COM_len);
1338                 parms->jpeg_markers |= JPEG_MARKER_COM;
1339         }
1340
1341         DBG("G_JPEGCOMP APP_len:%d COM_len:%d\n",
1342             parms->APP_len, parms->COM_len);
1343
1344         return 0;
1345 }
1346
1347 /******************************************************************************
1348  *
1349  *  ioctl_s_jpegcomp
1350  *
1351  *  V4L2 set the JPEG compression parameters
1352  *  NOTE: quality and some jpeg_markers are ignored.
1353  *
1354  *****************************************************************************/
1355
1356 static int ioctl_s_jpegcomp(void *arg,struct camera_data *cam)
1357 {
1358         struct v4l2_jpegcompression *parms = arg;
1359
1360         DBG("S_JPEGCOMP APP_len:%d COM_len:%d\n",
1361             parms->APP_len, parms->COM_len);
1362
1363         cam->params.compression.inhibit_htables =
1364                 !(parms->jpeg_markers & V4L2_JPEG_MARKER_DHT);
1365
1366         if(parms->APP_len != 0) {
1367                 if(parms->APP_len > 0 &&
1368                    parms->APP_len <= sizeof(cam->APP_data) &&
1369                    parms->APPn >= 0 && parms->APPn <= 15) {
1370                         cam->APPn = parms->APPn;
1371                         cam->APP_len = parms->APP_len;
1372                         memcpy(cam->APP_data, parms->APP_data, parms->APP_len);
1373                 } else {
1374                         LOG("Bad APPn Params n=%d len=%d\n",
1375                             parms->APPn, parms->APP_len);
1376                         return -EINVAL;
1377                 }
1378         } else {
1379                 cam->APP_len = 0;
1380         }
1381
1382         if(parms->COM_len != 0) {
1383                 if(parms->COM_len > 0 &&
1384                    parms->COM_len <= sizeof(cam->COM_data)) {
1385                         cam->COM_len = parms->COM_len;
1386                         memcpy(cam->COM_data, parms->COM_data, parms->COM_len);
1387                 } else {
1388                         LOG("Bad COM_len=%d\n", parms->COM_len);
1389                         return -EINVAL;
1390                 }
1391         }
1392
1393         return 0;
1394 }
1395
1396 /******************************************************************************
1397  *
1398  *  ioctl_reqbufs
1399  *
1400  *  V4L2 Initiate memory mapping.
1401  *  NOTE: The user's request is ignored. For now the buffers are fixed.
1402  *
1403  *****************************************************************************/
1404
1405 static int ioctl_reqbufs(void *arg,struct camera_data *cam)
1406 {
1407         struct v4l2_requestbuffers *req = arg;
1408
1409         if(req->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
1410            req->memory != V4L2_MEMORY_MMAP)
1411                 return -EINVAL;
1412
1413         DBG("REQBUFS requested:%d returning:%d\n", req->count, cam->num_frames);
1414         req->count = cam->num_frames;
1415         memset(&req->reserved, 0, sizeof(req->reserved));
1416
1417         return 0;
1418 }
1419
1420 /******************************************************************************
1421  *
1422  *  ioctl_querybuf
1423  *
1424  *  V4L2 Query memory buffer status.
1425  *
1426  *****************************************************************************/
1427
1428 static int ioctl_querybuf(void *arg,struct camera_data *cam)
1429 {
1430         struct v4l2_buffer *buf = arg;
1431
1432         if(buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
1433            buf->index > cam->num_frames)
1434                 return -EINVAL;
1435
1436         buf->m.offset = cam->buffers[buf->index].data - cam->frame_buffer;
1437         buf->length = cam->frame_size;
1438
1439         buf->memory = V4L2_MEMORY_MMAP;
1440
1441         if(cam->mmapped)
1442                 buf->flags = V4L2_BUF_FLAG_MAPPED;
1443         else
1444                 buf->flags = 0;
1445
1446         switch (cam->buffers[buf->index].status) {
1447         case FRAME_EMPTY:
1448         case FRAME_ERROR:
1449         case FRAME_READING:
1450                 buf->bytesused = 0;
1451                 buf->flags = V4L2_BUF_FLAG_QUEUED;
1452                 break;
1453         case FRAME_READY:
1454                 buf->bytesused = cam->buffers[buf->index].length;
1455                 buf->timestamp = cam->buffers[buf->index].timestamp;
1456                 buf->sequence = cam->buffers[buf->index].seq;
1457                 buf->flags = V4L2_BUF_FLAG_DONE;
1458                 break;
1459         }
1460
1461         DBG("QUERYBUF index:%d offset:%d flags:%d seq:%d bytesused:%d\n",
1462              buf->index, buf->m.offset, buf->flags, buf->sequence,
1463              buf->bytesused);
1464
1465         return 0;
1466 }
1467
1468 /******************************************************************************
1469  *
1470  *  ioctl_qbuf
1471  *
1472  *  V4L2 User is freeing buffer
1473  *
1474  *****************************************************************************/
1475
1476 static int ioctl_qbuf(void *arg,struct camera_data *cam)
1477 {
1478         struct v4l2_buffer *buf = arg;
1479
1480         if(buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
1481            buf->memory != V4L2_MEMORY_MMAP ||
1482            buf->index > cam->num_frames)
1483                 return -EINVAL;
1484
1485         DBG("QBUF #%d\n", buf->index);
1486
1487         if(cam->buffers[buf->index].status == FRAME_READY)
1488                 cam->buffers[buf->index].status = FRAME_EMPTY;
1489
1490         return 0;
1491 }
1492
1493 /******************************************************************************
1494  *
1495  *  find_earliest_filled_buffer
1496  *
1497  *  Helper for ioctl_dqbuf. Find the next ready buffer.
1498  *
1499  *****************************************************************************/
1500
1501 static int find_earliest_filled_buffer(struct camera_data *cam)
1502 {
1503         int i;
1504         int found = -1;
1505         for (i=0; i<cam->num_frames; i++) {
1506                 if(cam->buffers[i].status == FRAME_READY) {
1507                         if(found < 0) {
1508                                 found = i;
1509                         } else {
1510                                 /* find which buffer is earlier */
1511                                 struct timeval *tv1, *tv2;
1512                                 tv1 = &cam->buffers[i].timestamp;
1513                                 tv2 = &cam->buffers[found].timestamp;
1514                                 if(tv1->tv_sec < tv2->tv_sec ||
1515                                    (tv1->tv_sec == tv2->tv_sec &&
1516                                     tv1->tv_usec < tv2->tv_usec))
1517                                         found = i;
1518                         }
1519                 }
1520         }
1521         return found;
1522 }
1523
1524 /******************************************************************************
1525  *
1526  *  ioctl_dqbuf
1527  *
1528  *  V4L2 User is asking for a filled buffer.
1529  *
1530  *****************************************************************************/
1531
1532 static int ioctl_dqbuf(void *arg,struct camera_data *cam, struct file *file)
1533 {
1534         struct v4l2_buffer *buf = arg;
1535         int frame;
1536
1537         if(buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
1538            buf->memory != V4L2_MEMORY_MMAP)
1539                 return -EINVAL;
1540
1541         frame = find_earliest_filled_buffer(cam);
1542
1543         if(frame < 0 && file->f_flags&O_NONBLOCK)
1544                 return -EAGAIN;
1545
1546         if(frame < 0) {
1547                 /* Wait for a frame to become available */
1548                 struct framebuf *cb=cam->curbuff;
1549                 mutex_unlock(&cam->busy_lock);
1550                 wait_event_interruptible(cam->wq_stream,
1551                                          !cam->present ||
1552                                          (cb=cam->curbuff)->status == FRAME_READY);
1553                 mutex_lock(&cam->busy_lock);
1554                 if (signal_pending(current))
1555                         return -ERESTARTSYS;
1556                 if(!cam->present)
1557                         return -ENOTTY;
1558                 frame = cb->num;
1559         }
1560
1561
1562         buf->index = frame;
1563         buf->bytesused = cam->buffers[buf->index].length;
1564         buf->flags = V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_DONE;
1565         buf->field = V4L2_FIELD_NONE;
1566         buf->timestamp = cam->buffers[buf->index].timestamp;
1567         buf->sequence = cam->buffers[buf->index].seq;
1568         buf->m.offset = cam->buffers[buf->index].data - cam->frame_buffer;
1569         buf->length = cam->frame_size;
1570         buf->input = 0;
1571         buf->reserved = 0;
1572         memset(&buf->timecode, 0, sizeof(buf->timecode));
1573
1574         DBG("DQBUF #%d status:%d seq:%d length:%d\n", buf->index,
1575             cam->buffers[buf->index].status, buf->sequence, buf->bytesused);
1576
1577         return 0;
1578 }
1579
1580 /******************************************************************************
1581  *
1582  *  cpia2_ioctl
1583  *
1584  *****************************************************************************/
1585 static int cpia2_do_ioctl(struct inode *inode, struct file *file,
1586                           unsigned int ioctl_nr, void *arg)
1587 {
1588         struct video_device *dev = video_devdata(file);
1589         struct camera_data *cam = video_get_drvdata(dev);
1590         int retval = 0;
1591
1592         if (!cam)
1593                 return -ENOTTY;
1594
1595         /* make this _really_ smp-safe */
1596         if (mutex_lock_interruptible(&cam->busy_lock))
1597                 return -ERESTARTSYS;
1598
1599         if (!cam->present) {
1600                 mutex_unlock(&cam->busy_lock);
1601                 return -ENODEV;
1602         }
1603
1604         /* Priority check */
1605         switch (ioctl_nr) {
1606         case VIDIOCSWIN:
1607         case VIDIOCMCAPTURE:
1608         case VIDIOC_S_FMT:
1609         {
1610                 struct cpia2_fh *fh = file->private_data;
1611                 retval = v4l2_prio_check(&cam->prio, &fh->prio);
1612                 if(retval) {
1613                         mutex_unlock(&cam->busy_lock);
1614                         return retval;
1615                 }
1616                 break;
1617         }
1618         case VIDIOCGMBUF:
1619         case VIDIOCSYNC:
1620         {
1621                 struct cpia2_fh *fh = file->private_data;
1622                 if(fh->prio != V4L2_PRIORITY_RECORD) {
1623                         mutex_unlock(&cam->busy_lock);
1624                         return -EBUSY;
1625                 }
1626                 break;
1627         }
1628         default:
1629                 break;
1630         }
1631
1632         switch (ioctl_nr) {
1633         case VIDIOCGCAP:        /* query capabilities */
1634                 retval = ioctl_cap_query(arg, cam);
1635                 break;
1636
1637         case VIDIOCGCHAN:       /* get video source - we are a camera, nothing else */
1638                 retval = ioctl_get_channel(arg);
1639                 break;
1640         case VIDIOCSCHAN:       /* set video source - we are a camera, nothing else */
1641                 retval = ioctl_set_channel(arg);
1642                 break;
1643         case VIDIOCGPICT:       /* image properties */
1644                 memcpy(arg, &cam->vp, sizeof(struct video_picture));
1645                 break;
1646         case VIDIOCSPICT:
1647                 retval = ioctl_set_image_prop(arg, cam);
1648                 break;
1649         case VIDIOCGWIN:        /* get/set capture window */
1650                 memcpy(arg, &cam->vw, sizeof(struct video_window));
1651                 break;
1652         case VIDIOCSWIN:
1653                 retval = ioctl_set_window_size(arg, cam, file->private_data);
1654                 break;
1655         case VIDIOCGMBUF:       /* mmap interface */
1656                 retval = ioctl_get_mbuf(arg, cam);
1657                 break;
1658         case VIDIOCMCAPTURE:
1659                 retval = ioctl_mcapture(arg, cam, file->private_data);
1660                 break;
1661         case VIDIOCSYNC:
1662                 retval = ioctl_sync(arg, cam);
1663                 break;
1664                 /* pointless to implement overlay with this camera */
1665         case VIDIOCCAPTURE:
1666         case VIDIOCGFBUF:
1667         case VIDIOCSFBUF:
1668         case VIDIOCKEY:
1669                 retval = -EINVAL;
1670                 break;
1671
1672                 /* tuner interface - we have none */
1673         case VIDIOCGTUNER:
1674         case VIDIOCSTUNER:
1675         case VIDIOCGFREQ:
1676         case VIDIOCSFREQ:
1677                 retval = -EINVAL;
1678                 break;
1679
1680                 /* audio interface - we have none */
1681         case VIDIOCGAUDIO:
1682         case VIDIOCSAUDIO:
1683                 retval = -EINVAL;
1684                 break;
1685
1686         /* CPIA2 extension to Video4Linux API */
1687         case CPIA2_IOC_SET_GPIO:
1688                 retval = ioctl_set_gpio(arg, cam);
1689                 break;
1690         case VIDIOC_QUERYCAP:
1691                 retval = ioctl_querycap(arg,cam);
1692                 break;
1693
1694         case VIDIOC_ENUMINPUT:
1695         case VIDIOC_G_INPUT:
1696         case VIDIOC_S_INPUT:
1697                 retval = ioctl_input(ioctl_nr, arg,cam);
1698                 break;
1699
1700         case VIDIOC_ENUM_FMT:
1701                 retval = ioctl_enum_fmt(arg,cam);
1702                 break;
1703         case VIDIOC_TRY_FMT:
1704                 retval = ioctl_try_fmt(arg,cam);
1705                 break;
1706         case VIDIOC_G_FMT:
1707                 retval = ioctl_get_fmt(arg,cam);
1708                 break;
1709         case VIDIOC_S_FMT:
1710                 retval = ioctl_set_fmt(arg,cam,file->private_data);
1711                 break;
1712
1713         case VIDIOC_CROPCAP:
1714                 retval = ioctl_cropcap(arg,cam);
1715                 break;
1716         case VIDIOC_G_CROP:
1717         case VIDIOC_S_CROP:
1718                 // TODO: I think cropping can be implemented - SJB
1719                 retval = -EINVAL;
1720                 break;
1721
1722         case VIDIOC_QUERYCTRL:
1723                 retval = ioctl_queryctrl(arg,cam);
1724                 break;
1725         case VIDIOC_QUERYMENU:
1726                 retval = ioctl_querymenu(arg,cam);
1727                 break;
1728         case VIDIOC_G_CTRL:
1729                 retval = ioctl_g_ctrl(arg,cam);
1730                 break;
1731         case VIDIOC_S_CTRL:
1732                 retval = ioctl_s_ctrl(arg,cam);
1733                 break;
1734
1735         case VIDIOC_G_JPEGCOMP:
1736                 retval = ioctl_g_jpegcomp(arg,cam);
1737                 break;
1738         case VIDIOC_S_JPEGCOMP:
1739                 retval = ioctl_s_jpegcomp(arg,cam);
1740                 break;
1741
1742         case VIDIOC_G_PRIORITY:
1743         {
1744                 struct cpia2_fh *fh = file->private_data;
1745                 *(enum v4l2_priority*)arg = fh->prio;
1746                 break;
1747         }
1748         case VIDIOC_S_PRIORITY:
1749         {
1750                 struct cpia2_fh *fh = file->private_data;
1751                 enum v4l2_priority prio;
1752                 prio = *(enum v4l2_priority*)arg;
1753                 if(cam->streaming &&
1754                    prio != fh->prio &&
1755                    fh->prio == V4L2_PRIORITY_RECORD) {
1756                         /* Can't drop record priority while streaming */
1757                         retval = -EBUSY;
1758                 } else if(prio == V4L2_PRIORITY_RECORD &&
1759                    prio != fh->prio &&
1760                    v4l2_prio_max(&cam->prio) == V4L2_PRIORITY_RECORD) {
1761                         /* Only one program can record at a time */
1762                         retval = -EBUSY;
1763                 } else {
1764                         retval = v4l2_prio_change(&cam->prio, &fh->prio, prio);
1765                 }
1766                 break;
1767         }
1768
1769         case VIDIOC_REQBUFS:
1770                 retval = ioctl_reqbufs(arg,cam);
1771                 break;
1772         case VIDIOC_QUERYBUF:
1773                 retval = ioctl_querybuf(arg,cam);
1774                 break;
1775         case VIDIOC_QBUF:
1776                 retval = ioctl_qbuf(arg,cam);
1777                 break;
1778         case VIDIOC_DQBUF:
1779                 retval = ioctl_dqbuf(arg,cam,file);
1780                 break;
1781         case VIDIOC_STREAMON:
1782         {
1783                 int type;
1784                 DBG("VIDIOC_STREAMON, streaming=%d\n", cam->streaming);
1785                 type = *(int*)arg;
1786                 if(!cam->mmapped || type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1787                         retval = -EINVAL;
1788
1789                 if(!cam->streaming) {
1790                         retval = cpia2_usb_stream_start(cam,
1791                                           cam->params.camera_state.stream_mode);
1792                 } else {
1793                         retval = -EINVAL;
1794                 }
1795
1796                 break;
1797         }
1798         case VIDIOC_STREAMOFF:
1799         {
1800                 int type;
1801                 DBG("VIDIOC_STREAMOFF, streaming=%d\n", cam->streaming);
1802                 type = *(int*)arg;
1803                 if(!cam->mmapped || type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1804                         retval = -EINVAL;
1805
1806                 if(cam->streaming) {
1807                         retval = cpia2_usb_stream_stop(cam);
1808                 } else {
1809                         retval = -EINVAL;
1810                 }
1811
1812                 break;
1813         }
1814
1815         case VIDIOC_ENUMOUTPUT:
1816         case VIDIOC_G_OUTPUT:
1817         case VIDIOC_S_OUTPUT:
1818         case VIDIOC_G_MODULATOR:
1819         case VIDIOC_S_MODULATOR:
1820
1821         case VIDIOC_ENUMAUDIO:
1822         case VIDIOC_G_AUDIO:
1823         case VIDIOC_S_AUDIO:
1824
1825         case VIDIOC_ENUMAUDOUT:
1826         case VIDIOC_G_AUDOUT:
1827         case VIDIOC_S_AUDOUT:
1828
1829         case VIDIOC_ENUMSTD:
1830         case VIDIOC_QUERYSTD:
1831         case VIDIOC_G_STD:
1832         case VIDIOC_S_STD:
1833
1834         case VIDIOC_G_TUNER:
1835         case VIDIOC_S_TUNER:
1836         case VIDIOC_G_FREQUENCY:
1837         case VIDIOC_S_FREQUENCY:
1838
1839         case VIDIOC_OVERLAY:
1840         case VIDIOC_G_FBUF:
1841         case VIDIOC_S_FBUF:
1842
1843         case VIDIOC_G_PARM:
1844         case VIDIOC_S_PARM:
1845                 retval = -EINVAL;
1846                 break;
1847         default:
1848                 retval = -ENOIOCTLCMD;
1849                 break;
1850         }
1851
1852         mutex_unlock(&cam->busy_lock);
1853         return retval;
1854 }
1855
1856 static int cpia2_ioctl(struct inode *inode, struct file *file,
1857                        unsigned int ioctl_nr, unsigned long iarg)
1858 {
1859         return video_usercopy(inode, file, ioctl_nr, iarg, cpia2_do_ioctl);
1860 }
1861
1862 /******************************************************************************
1863  *
1864  *  cpia2_mmap
1865  *
1866  *****************************************************************************/
1867 static int cpia2_mmap(struct file *file, struct vm_area_struct *area)
1868 {
1869         int retval;
1870         struct video_device *dev = video_devdata(file);
1871         struct camera_data *cam = video_get_drvdata(dev);
1872
1873         /* Priority check */
1874         struct cpia2_fh *fh = file->private_data;
1875         if(fh->prio != V4L2_PRIORITY_RECORD) {
1876                 return -EBUSY;
1877         }
1878
1879         retval = cpia2_remap_buffer(cam, area);
1880
1881         if(!retval)
1882                 fh->mmapped = 1;
1883         return retval;
1884 }
1885
1886 /******************************************************************************
1887  *
1888  *  reset_camera_struct_v4l
1889  *
1890  *  Sets all values to the defaults
1891  *****************************************************************************/
1892 static void reset_camera_struct_v4l(struct camera_data *cam)
1893 {
1894         /***
1895          * Fill in the v4l structures.  video_cap is filled in inside the VIDIOCCAP
1896          * Ioctl.  Here, just do the window and picture stucts.
1897          ***/
1898         cam->vp.palette = (u16) VIDEO_PALETTE_RGB24;    /* Is this right? */
1899         cam->vp.brightness = (u16) cam->params.color_params.brightness * 256;
1900         cam->vp.colour = (u16) cam->params.color_params.saturation * 256;
1901         cam->vp.contrast = (u16) cam->params.color_params.contrast * 256;
1902
1903         cam->vw.x = 0;
1904         cam->vw.y = 0;
1905         cam->vw.width = cam->params.roi.width;
1906         cam->vw.height = cam->params.roi.height;
1907         cam->vw.flags = 0;
1908         cam->vw.clipcount = 0;
1909
1910         cam->frame_size = buffer_size;
1911         cam->num_frames = num_buffers;
1912
1913         /* FlickerModes */
1914         cam->params.flicker_control.flicker_mode_req = flicker_mode;
1915         cam->params.flicker_control.mains_frequency = flicker_freq;
1916
1917         /* streamMode */
1918         cam->params.camera_state.stream_mode = alternate;
1919
1920         cam->pixelformat = V4L2_PIX_FMT_JPEG;
1921         v4l2_prio_init(&cam->prio);
1922         return;
1923 }
1924
1925 /***
1926  * The v4l video device structure initialized for this device
1927  ***/
1928 static struct file_operations fops_template = {
1929         .owner          = THIS_MODULE,
1930         .open           = cpia2_open,
1931         .release        = cpia2_close,
1932         .read           = cpia2_v4l_read,
1933         .poll           = cpia2_v4l_poll,
1934         .ioctl          = cpia2_ioctl,
1935         .llseek         = no_llseek,
1936         .compat_ioctl   = v4l_compat_ioctl32,
1937         .mmap           = cpia2_mmap,
1938 };
1939
1940 static struct video_device cpia2_template = {
1941         /* I could not find any place for the old .initialize initializer?? */
1942         .owner=         THIS_MODULE,
1943         .name=          "CPiA2 Camera",
1944         .type=          VID_TYPE_CAPTURE,
1945         .type2 =        V4L2_CAP_VIDEO_CAPTURE |
1946                         V4L2_CAP_STREAMING,
1947         .hardware=      VID_HARDWARE_CPIA2,
1948         .minor=         -1,
1949         .fops=          &fops_template,
1950         .release=       video_device_release,
1951 };
1952
1953 /******************************************************************************
1954  *
1955  *  cpia2_register_camera
1956  *
1957  *****************************************************************************/
1958 int cpia2_register_camera(struct camera_data *cam)
1959 {
1960         cam->vdev = video_device_alloc();
1961         if(!cam->vdev)
1962                 return -ENOMEM;
1963
1964         memcpy(cam->vdev, &cpia2_template, sizeof(cpia2_template));
1965         video_set_drvdata(cam->vdev, cam);
1966
1967         reset_camera_struct_v4l(cam);
1968
1969         /* register v4l device */
1970         if (video_register_device
1971             (cam->vdev, VFL_TYPE_GRABBER, video_nr) == -1) {
1972                 ERR("video_register_device failed\n");
1973                 video_device_release(cam->vdev);
1974                 return -ENODEV;
1975         }
1976
1977         return 0;
1978 }
1979
1980 /******************************************************************************
1981  *
1982  *  cpia2_unregister_camera
1983  *
1984  *****************************************************************************/
1985 void cpia2_unregister_camera(struct camera_data *cam)
1986 {
1987         if (!cam->open_count) {
1988                 video_unregister_device(cam->vdev);
1989         } else {
1990                 LOG("/dev/video%d removed while open, "
1991                     "deferring video_unregister_device\n",
1992                     cam->vdev->minor);
1993         }
1994 }
1995
1996 /******************************************************************************
1997  *
1998  *  check_parameters
1999  *
2000  *  Make sure that all user-supplied parameters are sensible
2001  *****************************************************************************/
2002 static void __init check_parameters(void)
2003 {
2004         if(buffer_size < PAGE_SIZE) {
2005                 buffer_size = PAGE_SIZE;
2006                 LOG("buffer_size too small, setting to %d\n", buffer_size);
2007         } else if(buffer_size > 1024*1024) {
2008                 /* arbitrary upper limiit */
2009                 buffer_size = 1024*1024;
2010                 LOG("buffer_size ridiculously large, setting to %d\n",
2011                     buffer_size);
2012         } else {
2013                 buffer_size += PAGE_SIZE-1;
2014                 buffer_size &= ~(PAGE_SIZE-1);
2015         }
2016
2017         if(num_buffers < 1) {
2018                 num_buffers = 1;
2019                 LOG("num_buffers too small, setting to %d\n", num_buffers);
2020         } else if(num_buffers > VIDEO_MAX_FRAME) {
2021                 num_buffers = VIDEO_MAX_FRAME;
2022                 LOG("num_buffers too large, setting to %d\n", num_buffers);
2023         }
2024
2025         if(alternate < USBIF_ISO_1 || alternate > USBIF_ISO_6) {
2026                 alternate = DEFAULT_ALT;
2027                 LOG("alternate specified is invalid, using %d\n", alternate);
2028         }
2029
2030         if (flicker_mode != NEVER_FLICKER && flicker_mode != ANTI_FLICKER_ON) {
2031                 flicker_mode = NEVER_FLICKER;
2032                 LOG("Flicker mode specified is invalid, using %d\n",
2033                     flicker_mode);
2034         }
2035
2036         if (flicker_freq != FLICKER_50 && flicker_freq != FLICKER_60) {
2037                 flicker_freq = FLICKER_60;
2038                 LOG("Flicker mode specified is invalid, using %d\n",
2039                     flicker_freq);
2040         }
2041
2042         if(video_nr < -1 || video_nr > 64) {
2043                 video_nr = -1;
2044                 LOG("invalid video_nr specified, must be -1 to 64\n");
2045         }
2046
2047         DBG("Using %d buffers, each %d bytes, alternate=%d\n",
2048             num_buffers, buffer_size, alternate);
2049 }
2050
2051 /************   Module Stuff ***************/
2052
2053
2054 /******************************************************************************
2055  *
2056  * cpia2_init/module_init
2057  *
2058  *****************************************************************************/
2059 static int __init cpia2_init(void)
2060 {
2061         LOG("%s v%d.%d.%d\n",
2062             ABOUT, CPIA2_MAJ_VER, CPIA2_MIN_VER, CPIA2_PATCH_VER);
2063         check_parameters();
2064         cpia2_usb_init();
2065         return 0;
2066 }
2067
2068
2069 /******************************************************************************
2070  *
2071  * cpia2_exit/module_exit
2072  *
2073  *****************************************************************************/
2074 static void __exit cpia2_exit(void)
2075 {
2076         cpia2_usb_cleanup();
2077         schedule_timeout(2 * HZ);
2078 }
2079
2080 module_init(cpia2_init);
2081 module_exit(cpia2_exit);
2082