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