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