?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add doxygen documentation to all functions in microdia-usb.c
[microdia.git] / microdia-v4l.c
blobe6865f329417360c20aab214278f6f87cb5850c8
1 /**
2 * @file microdia-v4l.c
3 * @author Nicolas VIVIEN
4 * @date 2008-02-01
5 *
6 * @brief V4L2 interface and functions
7 *
8 * @note Copyright (C) Nicolas VIVIEN
9 *
10 * @par Licences
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 */
26
27 #include <linux/module.h>
28 #include <linux/init.h>
29 #include <linux/kernel.h>
30 #include <linux/version.h>
31 #include <linux/errno.h>
32 #include <linux/slab.h>
33 #include <linux/kref.h>
34 #include <linux/vmalloc.h>
35 #include <linux/usb.h>
36 #include <linux/mm.h>
37 #include <media/v4l2-common.h>
38
39
40 #include "microdia.h"
41 #include "sn9c20x.h"
42
43
44 /* USER DEFINED V4L2-CONTROLS: */
45 #define V4L2_CID_SHARPNESS (V4L2_CID_PRIVATE_BASE + 0)
46 #define V4L2_CID_AUTOEXPOSURE (V4L2_CID_PRIVATE_BASE + 1)
47
48 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
49 #include <media/v4l2-ioctl.h>
50 #endif
51
52 static struct file_operations v4l_microdia_fops;
53
54 /**
55 * format list
56 */
57
58 #define NUM_V4L2_FORMATS 4
59
60 struct v4l2_pix_format microdia_fmts[] = {
61 {
62 .width = 640,
63 .height = 480,
64 .pixelformat = V4L2_PIX_FMT_YUV420,
65 .field = V4L2_FIELD_NONE,
66 .bytesperline = 960,
67 .sizeimage = 460800,
68 .colorspace = V4L2_COLORSPACE_SRGB,
69 .priv = 0
70 },
71 {
72 .width = 640,
73 .height = 480,
74 .pixelformat = V4L2_PIX_FMT_BGR24,
75 .field = V4L2_FIELD_NONE,
76 .bytesperline = 1920,
77 .sizeimage = 921600,
78 .colorspace = V4L2_COLORSPACE_SRGB,
79 .priv = 0
80 },
81 {
82 .width = 640,
83 .height = 480,
84 .pixelformat = V4L2_PIX_FMT_RGB24,
85 .field = V4L2_FIELD_NONE,
86 .bytesperline = 1920,
87 .sizeimage = 921600,
88 .colorspace = V4L2_COLORSPACE_SRGB,
89 .priv = 0
90 },
91 {
92 .width = 640,
93 .height = 480,
94 .pixelformat = V4L2_PIX_FMT_YUYV,
95 .field = V4L2_FIELD_NONE,
96 .bytesperline = 1280,
97 .sizeimage = 614400,
98 .colorspace = V4L2_COLORSPACE_SRGB,
99 .priv = 0
100 },
101 };
102
103 /**
104 * @param dev
105 * @param fmt v4l2 fmt id
106 *
107 * @returns index of requested format
108 *
109 * @brief check if v4l2 forat is supported by device.
110 *
111 * This function permits to check if v4l2 format is supported.
112 */
113 int v4l2_format_supported(struct usb_microdia *dev, __u32 fmt)
114 {
115 int i;
116 for (i = 0; i < sizeof(dev->supported_fmts) * 8; i++) {
117 if (i > (ARRAY_SIZE(microdia_fmts) - 1))
118 break;
119 if (dev->supported_fmts & (1 << i) &&
120 microdia_fmts[i].pixelformat == fmt)
121 return i;
122 }
123 return -EINVAL;
124 }
125
126 /**
127 * @param dev
128 * @param index format index
129 *
130 * @returns reference to format structure
131 *
132 * @brief enumerate supported formats
133 *
134 * This function will enumerate all supported formats.
135 */
136 struct v4l2_pix_format *v4l2_enum_supported_formats(struct usb_microdia *dev,
137 __u8 index)
138 {
139 int i, bit = 0;
140 for (i = 0; i < sizeof(dev->supported_fmts) * 8; i++) {
141 if (i > (ARRAY_SIZE(microdia_fmts) - 1))
142 break;
143 if (dev->supported_fmts & (1 << i)) {
144 if (bit == index)
145 return &microdia_fmts[i];
146 bit++;
147 }
148 }
149 return NULL;
150 }
151
152 /**
153 * @var microdia_controls
154 * List of all V4Lv2 controls supported by the driver
155 */
156 static struct v4l2_queryctrl microdia_controls[] = {
157 {
158 .id = V4L2_CID_BRIGHTNESS,
159 .type = V4L2_CTRL_TYPE_INTEGER,
160 .name = "Brightness",
161 .minimum = 0,
162 .maximum = 0xff00,
163 .step = 1,
164 .default_value = 0x7f00,
165 },
166 {
167 .id = V4L2_CID_WHITENESS,
168 .type = V4L2_CTRL_TYPE_INTEGER,
169 .name = "Whiteness",
170 .minimum = 0,
171 .maximum = 0xff00,
172 .step = 1,
173 .default_value = 0x7f00,
174 },
175 /*
176 {
177 .id = V4L2_CID_SATURATION,
178 .type = V4L2_CTRL_TYPE_INTEGER,
179 .name = "Saturation",
180 .minimum = 0,
181 .maximum = 0xff00,
182 .step = 1,
183 .default_value = 0x7f00,
184 },
185 */
186 {
187 .id = V4L2_CID_CONTRAST,
188 .type = V4L2_CTRL_TYPE_INTEGER,
189 .name = "Contrast",
190 .minimum = 0,
191 .maximum = 0xff00,
192 .step = 1,
193 .default_value = 0x0000,
194 },
195 {
196 .id = V4L2_CID_EXPOSURE,
197 .type = V4L2_CTRL_TYPE_INTEGER,
198 .name = "Exposure",
199 .minimum = 0,
200 .maximum = 0xff00,
201 .step = 1,
202 .default_value = 0x1000,
203 },
204 {
205 .id = V4L2_CID_HFLIP,
206 .type = V4L2_CTRL_TYPE_BOOLEAN,
207 .name = "Horizontal flip",
208 .minimum = 0,
209 .maximum = 1,
210 .step = 1,
211 .default_value = 0,
212 },
213 {
214 .id = V4L2_CID_VFLIP,
215 .type = V4L2_CTRL_TYPE_BOOLEAN,
216 .name = "Vertical flip",
217 .minimum = 0,
218 .maximum = 1,
219 .step = 1,
220 .default_value = 0,
221 },
222 {
223 .id = V4L2_CID_SHARPNESS,
224 .type = V4L2_CTRL_TYPE_INTEGER,
225 .name = "Sharpness",
226 .minimum = 0,
227 .maximum = 0x3f,
228 .step = 1,
229 .default_value = 0x1f,
230 },
231 {
232 .id = V4L2_CID_RED_BALANCE,
233 .type = V4L2_CTRL_TYPE_INTEGER,
234 .name = "Red Balance",
235 .minimum = 0,
236 .maximum = 0x7f,
237 .step = 1,
238 .default_value = 0x20,
239 },
240 {
241 .id = V4L2_CID_BLUE_BALANCE,
242 .type = V4L2_CTRL_TYPE_INTEGER,
243 .name = "Blue Balance",
244 .minimum = 0,
245 .maximum = 0x7f,
246 .step = 1,
247 .default_value = 0x20,
248 },
249 {
250 .id = V4L2_CID_AUTOEXPOSURE,
251 .type = V4L2_CTRL_TYPE_BOOLEAN,
252 .name = "Automatic exposure control",
253 .minimum = 0,
254 .maximum = 1,
255 .step = 1,
256 .default_value = 0,
257 },
258 {
259 .id = V4L2_CID_AUTO_WHITE_BALANCE,
260 .type = V4L2_CTRL_TYPE_BOOLEAN,
261 .name = "Automatic whitbalance control",
262 .minimum = 0,
263 .maximum = 1,
264 .step = 1,
265 .default_value = 0,
266 },
267 };
268
269 /**
270 * @brief Get V4L privileges
271 *
272 * @param file
273 *
274 * @return 0 or negative error code
275 *
276 */
277 int v4l_get_privileges(struct file *file)
278 {
279 struct usb_microdia *dev;
280 int ret = 0;
281
282 dev = video_get_drvdata(video_devdata(file));
283
284 if (dev->owner == file)
285 return 0;
286
287 mutex_lock(&open_lock);
288 if (dev->owner != NULL) {
289 ret = -EBUSY;
290 goto done;
291 }
292 dev->owner = file;
293 done:
294 mutex_unlock(&open_lock);
295 return ret;
296 }
297
298 /**
299 * @brief Check whether there are V4L privileges
300 *
301 * @param file
302 *
303 * @return 0 or 1
304 *
305 */
306 int v4l_has_privileges(struct file *file)
307 {
308 struct usb_microdia *dev;
309 int ret = 0;
310
311 dev = video_get_drvdata(video_devdata(file));
312
313 if (dev->owner == file)
314 ret = 1;
315
316 return ret;
317 }
318
319 /**
320 * @brief Drop V4L privileges
321 *
322 * @param file
323 *
324 */
325 void v4l_drop_privileges(struct file *file)
326 {
327 struct usb_microdia *dev;
328
329 dev = video_get_drvdata(video_devdata(file));
330
331 if (dev->owner == file)
332 dev->owner = NULL;
333 }
334
335 /**
336 * @brief Enable video stream
337 *
338 * @param dev Pointer to device structure
339 * @param mode Mode for video stream
340 *
341 * @returns 0 or negative error value
342 *
343 */
344 int v4l2_enable_video(struct usb_microdia *dev, int mode)
345 {
346 int ret;
347
348 if (mode == MICRODIA_MODE_IDLE) {
349 dev_microdia_stop_stream(dev);
350 usb_microdia_isoc_cleanup(dev);
351 dev_microdia_camera_off(dev);
352 microdia_queue_enable(&dev->queue, 0);
353 dev->mode = mode;
354 return 0;
355 }
356
357 if (dev->mode != MICRODIA_MODE_IDLE)
358 return -EBUSY;
359
360 if (microdia_queue_enable(&dev->queue, 1) < 0)
361 return -EBUSY;
362
363 dev_microdia_camera_on(dev);
364 ret = usb_microdia_isoc_init(dev);
365
366 if (ret)
367 return ret;
368
369 dev_microdia_start_stream(dev);
370 dev_microdia_camera_settings(dev);
371 dev->mode = mode;
372
373 return 0;
374 }
375
376 /**
377 * @param inode Pointer on an inode
378 * @param fp File pointer
379 *
380 * @returns 0 if all is OK
381 *
382 * @brief Open the video device
383 *
384 * This function permits to open a video device (/dev/videoX)
385 */
386 static int v4l_microdia_open(struct inode *inode, struct file *fp)
387 {
388 int ret = 0;
389
390 struct usb_microdia *dev;
391 struct video_device *vdev;
392
393 mutex_lock(&open_lock);
394
395 vdev = video_devdata(fp);
396 dev = video_get_drvdata(video_devdata(fp));
397
398 fp->private_data = vdev;
399
400 kref_get(&dev->vopen);
401
402 mutex_unlock(&open_lock);
403 return ret;
404 }
405
406
407 /**
408 * @param inode Pointer on inode
409 * @param fp File pointer
410 *
411 * @returns 0 if all is OK
412 *
413 * @brief Release an opened file.
414 *
415 * This function permits to release an opened file with the 'open' method.
416 */
417 static int v4l_microdia_release(struct inode *inode, struct file *fp)
418 {
419 struct usb_microdia *dev;
420 struct video_device *vdev;
421
422 mutex_lock(&open_lock);
423
424 vdev = video_devdata(fp);
425 dev = video_get_drvdata(video_devdata(fp));
426
427 if (v4l_has_privileges(fp)) {
428 v4l2_enable_video(dev, MICRODIA_MODE_IDLE);
429
430 mutex_lock(&dev->queue.mutex);
431 microdia_free_buffers(&dev->queue);
432 mutex_unlock(&dev->queue.mutex);
433 }
434
435 v4l_drop_privileges(fp);
436
437 kref_put(&dev->vopen, usb_microdia_delete);
438
439 mutex_unlock(&open_lock);
440 return 0;
441 }
442
443
444 /**
445 * @param fp File pointer
446 *
447 * @retval buf Buffer in user space
448 * @retval count
449 * @retval f_pos
450 *
451 * @returns Count value
452 *
453 * @brief Read the video device
454 *
455 * This function is called by the application is reading the video device.
456 */
457 static ssize_t v4l_microdia_read(struct file *fp, char __user *buf,
458 size_t count, loff_t *f_pos)
459 {
460 int i, ret;
461 int nbuffers;
462 struct v4l2_buffer buffer;
463 struct usb_microdia *dev;
464
465 dev = video_get_drvdata(video_devdata(fp));
466
467 ret = v4l_get_privileges(fp);
468 if (ret < 0)
469 return ret;
470
471 if (dev->mode != MICRODIA_MODE_IDLE &&
472 dev->mode != MICRODIA_MODE_READ)
473 return -EBUSY;
474
475 buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
476 buffer.memory = V4L2_MEMORY_MMAP;
477 if (dev->mode == MICRODIA_MODE_IDLE) {
478 nbuffers = microdia_alloc_buffers(&dev->queue, 2,
479 MICRODIA_FRAME_SIZE);
480 if (nbuffers < 0)
481 return nbuffers;
482
483 for (i = 0; i < nbuffers; i++) {
484 buffer = dev->queue.buffer[i].buf;
485 microdia_queue_buffer(&dev->queue, &buffer);
486 }
487
488 ret = v4l2_enable_video(dev, MICRODIA_MODE_READ);
489 if (ret < 0)
490 return ret;
491 }
492
493 if (dev->queue.read_buffer == NULL) {
494 ret = microdia_dequeue_buffer(&dev->queue, &buffer,
495 fp->f_flags & O_NONBLOCK);
496 if (ret < 0)
497 return ret;
498
499 microdia_decompress(dev, &buffer);
500 dev->queue.read_buffer = &dev->queue.buffer[buffer.index];
501 } else {
502 buffer = dev->queue.read_buffer->buf;
503 }
504
505 count = min((size_t)(buffer.bytesused - *f_pos), count);
506 if (copy_to_user(buf, dev->queue.mem + buffer.m.offset + *f_pos, count))
507 return -EFAULT;
508
509 *f_pos += count;
510 if (*f_pos >= buffer.bytesused) {
511 dev->queue.read_buffer = NULL;
512 microdia_queue_buffer(&dev->queue, &buffer);
513 *f_pos = 0;
514 }
515 return count;
516 }
517
518
519 /**
520 * @param fp File pointer
521 * @param wait
522 *
523 * @returns 0 if all is OK
524 *
525 * @brief Polling function
526 */
527 static unsigned int v4l_microdia_poll(struct file *fp, poll_table *wait)
528 {
529 struct usb_microdia *dev;
530 struct video_device *vdev;
531
532 vdev = video_devdata(fp);
533 dev = video_get_drvdata(video_devdata(fp));
534
535 UDIA_STREAM("Poll\n");
536
537 if (vdev == NULL || dev == NULL)
538 return -EFAULT;
539
540 return microdia_queue_poll(&dev->queue, fp, wait);
541 }
542
543 /**
544 * @param vma
545 *
546 */
547 static void microdia_vm_open(struct vm_area_struct *vma)
548 {
549 struct microdia_buffer *buffer = vma->vm_private_data;
550 buffer->vma_use_count++;
551
552 }
553
554 /**
555 * @param vma
556 *
557 */
558 static void microdia_vm_close(struct vm_area_struct *vma)
559 {
560 struct microdia_buffer *buffer = vma->vm_private_data;
561 buffer->vma_use_count--;
562 }
563
564 struct vm_operations_struct microdia_vm_ops = {
565 .open = microdia_vm_open,
566 .close = microdia_vm_close
567 };
568
569 /**
570 * @param fp File pointer
571 * @param vma VMA structure
572 *
573 * @returns 0 if all is OK
574 *
575 * @brief Memory map
576 *
577 * This function permits to map a memory space.
578 */
579 static int v4l_microdia_mmap(struct file *fp, struct vm_area_struct *vma)
580 {
581 struct page *page;
582 unsigned long addr, start, size;
583 unsigned int i;
584 int ret = 0;
585
586 struct usb_microdia *dev;
587 struct video_device *vdev;
588 struct microdia_buffer *buffer = NULL;
589
590 vdev = video_devdata(fp);
591 dev = video_get_drvdata(video_devdata(fp));
592
593 UDIA_STREAM("mmap\n");
594
595 start = vma->vm_start;
596 size = vma->vm_end - vma->vm_start;
597
598 mutex_lock(&dev->queue.mutex);
599
600 for (i = 0; i < dev->queue.count; ++i) {
601 buffer = &dev->queue.buffer[i];
602 if ((buffer->buf.m.offset >> PAGE_SHIFT) == vma->vm_pgoff)
603 break;
604 }
605
606 if (i == dev->queue.count || size != dev->queue.buf_size) {
607 ret = -EINVAL;
608 goto done;
609 }
610
611 vma->vm_flags |= VM_IO;
612
613 addr = (unsigned long)dev->queue.mem + buffer->buf.m.offset;
614 while (size > 0) {
615 page = vmalloc_to_page((void *)addr);
616 ret = vm_insert_page(vma, start, page);
617 if (ret < 0)
618 goto done;
619
620 start += PAGE_SIZE;
621 addr += PAGE_SIZE;
622 size -= PAGE_SIZE;
623 }
624
625 vma->vm_ops = &microdia_vm_ops;
626 vma->vm_private_data = buffer;
627 microdia_vm_open(vma);
628 done:
629 mutex_unlock(&dev->queue.mutex);
630 return ret;
631 }
632
633 /**
634 * @param file
635 * @param priv
636 * @param cap
637 *
638 * @return 0
639 *
640 */
641 int microdia_vidioc_querycap(struct file *file, void *priv,
642 struct v4l2_capability *cap)
643 {
644 struct usb_microdia *dev;
645
646 dev = video_get_drvdata(priv);
647
648 UDIA_DEBUG("VIDIOC_QUERYCAP\n");
649
650 strlcpy(cap->driver, "microdia", sizeof(cap->driver));
651 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING
652 | V4L2_CAP_READWRITE;
653 cap->version = (__u32) DRIVER_VERSION_NUM,
654 strlcpy(cap->card, dev->vdev->name, sizeof(cap->card));
655
656 if (usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info)) < 0)
657 strlcpy(cap->bus_info, dev->vdev->name, sizeof(cap->bus_info));
658 return 0;
659 }
660
661 /**
662 * @param file
663 * @param priv
664 * @param input
665 *
666 * @return 0 or negative error code
667 *
668 */
669 int microdia_vidioc_enum_input(struct file *file, void *priv,
670 struct v4l2_input *input)
671 {
672 UDIA_DEBUG("VIDIOC_ENUMINPUT %d\n", input->index);
673
674 if (input->index)
675 return -EINVAL;
676
677 strlcpy(input->name, "Webcam", sizeof(input->name));
678 input->type = V4L2_INPUT_TYPE_CAMERA;
679 input->std = 0;
680
681 return 0;
682 }
683
684 /**
685 * @param file
686 * @param priv
687 * @param index
688 *
689 * @return 0 or negative error code
690 *
691 */
692 int microdia_vidioc_g_input(struct file *file, void *priv, unsigned int *index)
693 {
694 UDIA_DEBUG("GET INPUT %d\n", *index);
695
696 if (index)
697 return -EINVAL;
698
699 return 0;
700 }
701
702 /**
703 * @param file
704 * @param priv
705 * @param index
706 *
707 * @return 0 or negative error code
708 *
709 */
710 int microdia_vidioc_s_input(struct file *file, void *priv, unsigned int index)
711 {
712 UDIA_DEBUG("SET INPUT %d\n", index);
713
714 if (v4l_get_privileges(file) < 0)
715 return -EBUSY;
716
717 if (index != 0)
718 return -EINVAL;
719
720 return 0;
721 }
722
723 /**
724 * @param file
725 * @param priv
726 * @param ctrl
727 *
728 * @return 0 or negative error code
729 *
730 */
731 int microdia_vidioc_queryctrl(struct file *file, void *priv,
732 struct v4l2_queryctrl *ctrl)
733 {
734 int i;
735 int nbr;
736
737 UDIA_DEBUG("VIDIOC_QUERYCTRL id = %d\n", ctrl->id);
738
739 nbr = sizeof(microdia_controls)/sizeof(struct v4l2_queryctrl);
740
741 for (i = 0; i < nbr; i++) {
742 if (microdia_controls[i].id == ctrl->id) {
743 UDIA_DEBUG("VIDIOC_QUERYCTRL found\n");
744 memcpy(ctrl, &microdia_controls[i],
745 sizeof(struct v4l2_queryctrl));
746 break;
747 }
748 }
749
750 if (i >= nbr)
751 return -EINVAL;
752
753 return 0;
754 }
755
756 /**
757 * @param file
758 * @param priv
759 * @param ctrl
760 *
761 * @return 0 or negative error code
762 *
763 */
764 int microdia_vidioc_g_ctrl(struct file *file, void *priv,
765 struct v4l2_control *ctrl)
766 {
767 struct usb_microdia *dev;
768
769 dev = video_get_drvdata(priv);
770
771 UDIA_DEBUG("GET CTRL id=%d\n", ctrl->id);
772
773 switch (ctrl->id) {
774 case V4L2_CID_BRIGHTNESS:
775 ctrl->value = dev->vsettings.brightness;
776 break;
777
778 case V4L2_CID_EXPOSURE:
779 ctrl->value = dev->vsettings.exposure;
780 break;
781
782 case V4L2_CID_WHITENESS:
783 ctrl->value = dev->vsettings.whiteness;
784 break;
785 /*
786 case V4L2_CID_SATURATION:
787 ctrl->value = dev->vsettings.colour;
788 break;
789 */
790 case V4L2_CID_CONTRAST:
791 ctrl->value = dev->vsettings.contrast;
792 break;
793
794 case V4L2_CID_HFLIP:
795 ctrl->value = dev->vsettings.hflip;
796 break;
797
798 case V4L2_CID_VFLIP:
799 ctrl->value = dev->vsettings.vflip;
800 break;
801
802 case V4L2_CID_SHARPNESS:
803 ctrl->value = dev->vsettings.sharpness;
804 break;
805
806 case V4L2_CID_RED_BALANCE:
807 ctrl->value = dev->vsettings.rgb_gain[0];
808 break;
809
810 case V4L2_CID_BLUE_BALANCE:
811 ctrl->value = dev->vsettings.rgb_gain[3];
812 break;
813
814 case V4L2_CID_AUTOEXPOSURE:
815 ctrl->value = dev->vsettings.auto_exposure;
816 break;
817
818 case V4L2_CID_AUTO_WHITE_BALANCE:
819 ctrl->value = dev->vsettings.auto_whitebalance;
820 break;
821
822 default:
823 return -EINVAL;
824 }
825 return 0;
826 }
827
828 /**
829 * @brief Apply v4l2 settings on camera
830 *
831 * @param file
832 * @param priv
833 * @param ctrl V4L2 control structure
834 *
835 * @returns 0 or negative error value
836 *
837 */
838 int microdia_vidioc_s_ctrl(struct file *file, void *priv,
839 struct v4l2_control *ctrl)
840 {
841 struct usb_microdia *dev;
842
843 dev = video_get_drvdata(priv);
844
845 UDIA_DEBUG("SET CTRL id=%d value=%d\n", ctrl->id, ctrl->value);
846
847 switch (ctrl->id) {
848 case V4L2_CID_BRIGHTNESS:
849 dev->vsettings.brightness = (0xff00 & ctrl->value);
850 dev_microdia_camera_set_brightness(dev);
851 break;
852
853 case V4L2_CID_EXPOSURE:
854 dev->vsettings.exposure = (0xff00 & ctrl->value);
855 dev_microdia_camera_set_exposure(dev);
856 break;
857
858 case V4L2_CID_WHITENESS:
859 dev->vsettings.whiteness = (0xff00 & ctrl->value);
860 dev_microdia_camera_set_gamma(dev);
861 break;
862 /*
863 case V4L2_CID_SATURATION:
864 dev->vsettings.colour = (0xff00 & ctrl->value);
865 break;
866 */
867 case V4L2_CID_CONTRAST:
868 dev->vsettings.contrast = (0xff00 & ctrl->value);
869 dev_microdia_camera_set_contrast(dev);
870 break;
871
872 case V4L2_CID_HFLIP:
873 dev->vsettings.hflip = ctrl->value;
874 dev_microdia_camera_set_hvflip(dev);
875 break;
876
877 case V4L2_CID_VFLIP:
878 dev->vsettings.vflip = ctrl->value;
879 dev_microdia_camera_set_hvflip(dev);
880 break;
881
882 case V4L2_CID_SHARPNESS:
883 dev->vsettings.sharpness = ctrl->value;
884 dev_microdia_camera_set_sharpness(dev);
885 break;
886
887 case V4L2_CID_RED_BALANCE:
888 dev->vsettings.rgb_gain[0] = ctrl->value;
889 dev_microdia_camera_set_rgb_gain(dev);
890 break;
891
892 case V4L2_CID_BLUE_BALANCE:
893 dev->vsettings.rgb_gain[3] = ctrl->value;
894 dev_microdia_camera_set_rgb_gain(dev);
895 break;
896
897 case V4L2_CID_AUTOEXPOSURE:
898 dev->vsettings.auto_exposure = ctrl->value;
899 dev_microdia_camera_set_auto_exposure(dev);
900 break;
901
902 case V4L2_CID_AUTO_WHITE_BALANCE:
903 dev->vsettings.auto_whitebalance = ctrl->value;
904 dev_microdia_camera_set_auto_whitebalance(dev);
905 break;
906
907 default:
908 return -EINVAL;
909 }
910
911 return 0;
912 }
913
914 /**
915 * @param file
916 * @param priv
917 * @param fmt
918 *
919 * @return 0 or negative error code
920 *
921 */
922 int microdia_vidioc_enum_fmt_cap(struct file *file, void *priv,
923 struct v4l2_fmtdesc *fmt)
924 {
925 struct usb_microdia *dev;
926 struct v4l2_pix_format *format;
927
928 dev = video_get_drvdata(priv);
929
930 UDIA_DEBUG("VIDIOC_ENUM_FMT %d\n", fmt->index);
931
932 format = v4l2_enum_supported_formats(dev, fmt->index);
933 if (format == NULL)
934 return -EINVAL;
935
936 fmt->flags = 0;
937 fmt->pixelformat = format->pixelformat;
938 fmt->description[0] = fmt->pixelformat & 0xFF;
939 fmt->description[1] = (fmt->pixelformat >> 8) & 0xFF;
940 fmt->description[2] = (fmt->pixelformat >> 16) & 0xFF;
941 fmt->description[3] = fmt->pixelformat >> 24;
942 fmt->description[4] = 0;
943
944 return 0;
945 }
946
947 /**
948 * @param file
949 * @param priv
950 * @param fmt
951 *
952 * @return 0 or negative error code
953 *
954 */
955 int microdia_vidioc_try_fmt_cap(struct file *file, void *priv,
956 struct v4l2_format *fmt)
957 {
958 struct usb_microdia *dev;
959
960 dev = video_get_drvdata(priv);
961 UDIA_DEBUG("TRY FMT %d\n", fmt->type);
962
963 /* when this code is used prevents mplayer from setting outfmt
964 if(fmt->fmt.pix.field != V4L2_FIELD_NONE)
965 return -EINVAL;
966 */
967
968 if (v4l2_format_supported(dev, fmt->fmt.pix.pixelformat) < 0)
969 return -EINVAL;
970
971 sn9c20x_get_closest_resolution(&fmt->fmt.pix.width,
972 &fmt->fmt.pix.height);
973
974 switch (fmt->fmt.pix.pixelformat) {
975 case V4L2_PIX_FMT_YUV420:
976 fmt->fmt.pix.bytesperline = (fmt->fmt.pix.width * 3)/2;
977 fmt->fmt.pix.sizeimage = fmt->fmt.pix.height *
978 fmt->fmt.pix.bytesperline;
979 break;
980 case V4L2_PIX_FMT_RGB24:
981 case V4L2_PIX_FMT_BGR24:
982 fmt->fmt.pix.bytesperline = fmt->fmt.pix.width * 3;
983 fmt->fmt.pix.sizeimage = fmt->fmt.pix.height *
984 fmt->fmt.pix.bytesperline;
985 break;
986 case V4L2_PIX_FMT_YUYV:
987 fmt->fmt.pix.bytesperline = fmt->fmt.pix.width * 2;
988 fmt->fmt.pix.sizeimage = fmt->fmt.pix.height *
989 fmt->fmt.pix.bytesperline;
990 break;
991 default:
992 return -EINVAL;
993 }
994
995 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
996 fmt->fmt.pix.priv = 0;
997
998 return 0;
999 }
1000
1001 /**
1002 * @param file
1003 * @param priv
1004 * @param fmt
1005 *
1006 * @return 0
1007 *
1008 */
1009 int microdia_vidioc_g_fmt_cap(struct file *file, void *priv,
1010 struct v4l2_format *fmt)
1011 {
1012 struct usb_microdia *dev;
1013
1014 dev = video_get_drvdata(priv);
1015
1016 UDIA_DEBUG("GET FMT %d\n", fmt->type);
1017
1018 memcpy(&(fmt->fmt.pix), &(dev->vsettings.format), sizeof(fmt->fmt.pix));
1019
1020
1021 return 0;
1022 }
1023
1024 /**
1025 * @param file
1026 * @param priv
1027 * @param fmt
1028 *
1029 * @return 0 or negative error code
1030 *
1031 */
1032 int microdia_vidioc_s_fmt_cap(struct file *file, void *priv,
1033 struct v4l2_format *fmt)
1034 {
1035 struct usb_microdia *dev;
1036 int ret;
1037
1038 dev = video_get_drvdata(priv);
1039
1040 UDIA_DEBUG("SET FMT %d : %d\n", fmt->type, fmt->fmt.pix.pixelformat);
1041
1042 if (v4l_get_privileges(file) < 0)
1043 return -EBUSY;
1044
1045 if (dev->queue.streaming)
1046 return -EBUSY;
1047
1048 ret = microdia_vidioc_try_fmt_cap(file, priv, fmt);
1049 if (ret)
1050 return -EINVAL;
1051
1052 sn9c20x_set_resolution(dev, fmt->fmt.pix.width, fmt->fmt.pix.height);
1053
1054 memcpy(&(dev->vsettings.format), &(fmt->fmt.pix), sizeof(fmt->fmt.pix));
1055
1056 return 0;
1057 }
1058
1059 /**
1060 * @param file
1061 * @param priv
1062 * @param request
1063 *
1064 * @return 0 or negative error code
1065 *
1066 */
1067 int microdia_vidioc_reqbufs(struct file *file, void *priv,
1068 struct v4l2_requestbuffers *request)
1069 {
1070 int ret = 0;
1071 struct usb_microdia *dev;
1072
1073 dev = video_get_drvdata(priv);
1074
1075 if (v4l_get_privileges(file) < 0) {
1076 ret = -EBUSY;
1077 goto done;
1078 }
1079
1080 if (request->memory != V4L2_MEMORY_MMAP ||
1081 request->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1082 ret = -EINVAL;
1083 goto done;
1084 }
1085
1086 if (dev->queue.streaming) {
1087 ret = -EBUSY;
1088 goto done;
1089 }
1090
1091 ret = microdia_alloc_buffers(&dev->queue, request->count,
1092 MICRODIA_FRAME_SIZE);
1093 if (ret < 0)
1094 goto done;
1095
1096 dev->queue.drop_incomplete = 1;
1097
1098 request->count = ret;
1099 ret = 0;
1100 UDIA_INFO("Buffers Allocated %d\n", request->count);
1101 done:
1102 return ret;
1103 }
1104
1105 /**
1106 * @param file
1107 * @param priv
1108 * @param buffer
1109 *
1110 * @return 0 or negative error code
1111 *
1112 */
1113 int microdia_vidioc_querybuf(struct file *file, void *priv,
1114 struct v4l2_buffer *buffer)
1115 {
1116 struct usb_microdia *dev;
1117
1118 dev = video_get_drvdata(priv);
1119
1120 UDIA_DEBUG("QUERY BUFFERS %d %d\n", buffer->index, dev->queue.count);
1121
1122 if (buffer->memory != V4L2_MEMORY_MMAP ||
1123 buffer->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1124 return -EINVAL;
1125
1126 if (!v4l_has_privileges(file))
1127 return -EBUSY;
1128
1129 return microdia_query_buffer(&dev->queue, buffer);
1130 }
1131
1132 /**
1133 * @param file
1134 * @param priv
1135 * @param buffer
1136 *
1137 * @return 0 or negative error code
1138 *
1139 */
1140 int microdia_vidioc_qbuf(struct file *file, void *priv,
1141 struct v4l2_buffer *buffer)
1142 {
1143 struct usb_microdia *dev;
1144
1145 dev = video_get_drvdata(priv);
1146
1147 UDIA_DEBUG("VIDIOC_QBUF\n");
1148
1149 if (!v4l_has_privileges(file))
1150 return -EBUSY;
1151
1152 return microdia_queue_buffer(&dev->queue, buffer);
1153 }
1154
1155 /**
1156 * @param file
1157 * @param priv
1158 * @param buffer
1159 *
1160 * @return 0 or negative error code
1161 *
1162 */
1163 int microdia_vidioc_dqbuf(struct file *file, void *priv,
1164 struct v4l2_buffer *buffer)
1165 {
1166 struct usb_microdia *dev;
1167 int ret = 0;
1168
1169 dev = video_get_drvdata(priv);
1170
1171 UDIA_DEBUG("VIDIOC_DQBUF\n");
1172
1173 if (!v4l_has_privileges(file))
1174 return -EBUSY;
1175
1176 ret = microdia_dequeue_buffer(&dev->queue, buffer,
1177 file->f_flags & O_NONBLOCK);
1178 if (ret < 0)
1179 return ret;
1180
1181 microdia_decompress(dev, buffer);
1182
1183 return ret;
1184 }
1185
1186 /**
1187 * @param file
1188 * @param priv
1189 * @param type
1190 *
1191 * @return 0 or negative error code
1192 *
1193 */
1194 int microdia_vidioc_streamon(struct file *file, void *priv,
1195 enum v4l2_buf_type type)
1196 {
1197 struct usb_microdia *dev;
1198
1199 dev = video_get_drvdata(priv);
1200
1201 UDIA_DEBUG("VIDIOC_STREAMON\n");
1202
1203 if (!v4l_has_privileges(file))
1204 return -EBUSY;
1205
1206 if (dev->mode != MICRODIA_MODE_IDLE)
1207 return -EBUSY;
1208
1209 return v4l2_enable_video(dev, MICRODIA_MODE_STREAM);
1210 }
1211
1212 /**
1213 * @param file
1214 * @param priv
1215 * @param type
1216 *
1217 * @return 0 or negative error code
1218 *
1219 */
1220 int microdia_vidioc_streamoff(struct file *file, void *priv,
1221 enum v4l2_buf_type type)
1222 {
1223 struct usb_microdia *dev;
1224
1225 dev = video_get_drvdata(priv);
1226
1227 UDIA_DEBUG("VIDIOC_STREAMOFF\n");
1228
1229 if (!v4l_has_privileges(file))
1230 return -EBUSY;
1231
1232 return v4l2_enable_video(dev, MICRODIA_MODE_IDLE);
1233 }
1234
1235 /**
1236 * @param file
1237 * @param priv
1238 * @param param
1239 *
1240 * @return 0 or negative error code
1241 *
1242 */
1243 int microdia_vidioc_g_param(struct file *file, void *priv,
1244 struct v4l2_streamparm *param)
1245 {
1246 struct usb_microdia *dev;
1247
1248
1249 dev = video_get_drvdata(priv);
1250
1251 if (param->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1252 return -EINVAL;
1253
1254 param->parm.capture.capability = 0;
1255 param->parm.capture.capturemode = 0;
1256 param->parm.capture.timeperframe.numerator = 1;
1257 param->parm.capture.timeperframe.denominator = 30;
1258 param->parm.capture.readbuffers = 2;
1259 param->parm.capture.extendedmode = 0;
1260
1261 return 0;
1262 }
1263
1264 /**
1265 * @param file
1266 * @param priv
1267 * @param param
1268 *
1269 * @return 0 or negative error code
1270 *
1271 */
1272 int microdia_vidioc_s_param(struct file *file, void *priv,
1273 struct v4l2_streamparm *param)
1274 {
1275 struct usb_microdia *dev;
1276
1277 dev = video_get_drvdata(priv);
1278
1279 if (v4l_get_privileges(file))
1280 return -EBUSY;
1281
1282 if (param->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1283 return -EINVAL;
1284
1285 return 0;
1286 }
1287
1288 /**
1289 * @param inode Inode pointer
1290 * @param fp File pointer
1291 * @param cmd Command
1292 * @param arg Arguements of the command
1293 *
1294 * @returns 0 if all is OK
1295 *
1296 * @brief Manage IOCTL
1297 *
1298 * This function permits to manage all the IOCTL from the application.
1299 */
1300 static int v4l_microdia_ioctl(struct inode *inode, struct file *fp,
1301 unsigned int cmd, unsigned long arg)
1302 {
1303 int err;
1304 struct usb_microdia *dev;
1305 struct video_device *vdev;
1306
1307 vdev = video_devdata(fp);
1308 dev = video_get_drvdata(video_devdata(fp));
1309
1310 UDIA_DEBUG("v4l_microdia_ioctl %02X\n", (unsigned char) cmd);
1311
1312 if (dev == NULL || vdev == NULL)
1313 return -EFAULT;
1314
1315 err = video_ioctl2(inode, fp, cmd, arg);
1316
1317 return err;
1318 }
1319
1320
1321 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27)
1322 static const struct v4l2_ioctl_ops microdia_v4l2_ioctl_ops = {
1323 .vidioc_querycap = microdia_vidioc_querycap,
1324 .vidioc_enum_fmt_vid_cap = microdia_vidioc_enum_fmt_cap,
1325 .vidioc_try_fmt_vid_cap = microdia_vidioc_try_fmt_cap,
1326 .vidioc_s_fmt_vid_cap = microdia_vidioc_s_fmt_cap,
1327 .vidioc_g_fmt_vid_cap = microdia_vidioc_g_fmt_cap,
1328 .vidioc_enum_input = microdia_vidioc_enum_input,
1329 .vidioc_g_input = microdia_vidioc_g_input,
1330 .vidioc_s_input = microdia_vidioc_s_input,
1331 .vidioc_streamon = microdia_vidioc_streamon,
1332 .vidioc_streamoff = microdia_vidioc_streamoff,
1333 .vidioc_queryctrl = microdia_vidioc_queryctrl,
1334 .vidioc_g_ctrl = microdia_vidioc_g_ctrl,
1335 .vidioc_s_ctrl = microdia_vidioc_s_ctrl,
1336 .vidioc_g_parm = microdia_vidioc_g_param,
1337 .vidioc_s_parm = microdia_vidioc_s_param,
1338 .vidioc_reqbufs = microdia_vidioc_reqbufs,
1339 .vidioc_qbuf = microdia_vidioc_qbuf,
1340 .vidioc_dqbuf = microdia_vidioc_dqbuf,
1341 .vidioc_querybuf = microdia_vidioc_querybuf,
1342 };
1343 #endif
1344
1345 /**
1346 * @param dev Device structure
1347 *
1348 * @returns 0 if all is OK
1349 *
1350 * @brief Register the video device
1351 *
1352 * This function permits to register the USB device to the video device.
1353 */
1354 int v4l_microdia_register_video_device(struct usb_microdia *dev)
1355 {
1356 int err;
1357
1358 strcpy(dev->vdev->name, DRIVER_DESC);
1359
1360 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27)
1361 dev->vdev->dev = &dev->interface->dev;
1362 dev->vdev->owner = THIS_MODULE;
1363 dev->vdev->type = VID_TYPE_CAPTURE;
1364 #else
1365 dev->vdev->dev = dev->interface->dev;
1366 #endif
1367 dev->vdev->current_norm = 0;
1368 dev->vdev->tvnorms = 0;
1369 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 24)
1370 dev->vdev->hardware = VID_HARDWARE_MICRODIA;
1371 #endif
1372 dev->vdev->fops = &v4l_microdia_fops;
1373 dev->vdev->release = video_device_release;
1374 dev->vdev->minor = -1;
1375
1376 if (log_level & MICRODIA_DEBUG)
1377 dev->vdev->debug = V4L2_DEBUG_IOCTL_ARG;
1378
1379 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27)
1380 dev->vdev->vidioc_querycap = microdia_vidioc_querycap;
1381 dev->vdev->vidioc_enum_fmt_cap = microdia_vidioc_enum_fmt_cap;
1382 dev->vdev->vidioc_try_fmt_cap = microdia_vidioc_try_fmt_cap;
1383 dev->vdev->vidioc_s_fmt_cap = microdia_vidioc_s_fmt_cap;
1384 dev->vdev->vidioc_g_fmt_cap = microdia_vidioc_g_fmt_cap;
1385 dev->vdev->vidioc_enum_input = microdia_vidioc_enum_input;
1386 dev->vdev->vidioc_g_input = microdia_vidioc_g_input;
1387 dev->vdev->vidioc_s_input = microdia_vidioc_s_input;
1388 dev->vdev->vidioc_streamon = microdia_vidioc_streamon;
1389 dev->vdev->vidioc_streamoff = microdia_vidioc_streamoff;
1390 dev->vdev->vidioc_queryctrl = microdia_vidioc_queryctrl;
1391 dev->vdev->vidioc_g_ctrl = microdia_vidioc_g_ctrl;
1392 dev->vdev->vidioc_s_ctrl = microdia_vidioc_s_ctrl;
1393 dev->vdev->vidioc_g_parm = microdia_vidioc_g_param;
1394 dev->vdev->vidioc_s_parm = microdia_vidioc_s_param;
1395 dev->vdev->vidioc_reqbufs = microdia_vidioc_reqbufs;
1396 dev->vdev->vidioc_qbuf = microdia_vidioc_qbuf;
1397 dev->vdev->vidioc_dqbuf = microdia_vidioc_dqbuf;
1398 dev->vdev->vidioc_querybuf = microdia_vidioc_querybuf;
1399 #else
1400 dev->vdev->ioctl_ops = &microdia_v4l2_ioctl_ops;
1401 #endif
1402
1403 video_set_drvdata(dev->vdev, dev);
1404
1405 microdia_queue_init(&dev->queue);
1406
1407 err = video_register_device(dev->vdev, VFL_TYPE_GRABBER, -1);
1408
1409 if (err)
1410 UDIA_ERROR("Video register fail !\n");
1411 else
1412 UDIA_INFO("Microdia USB 2.0 Webcam is now controlling "
1413 "video device /dev/video%d\n",
1414 dev->vdev->minor);
1415
1416 return err;
1417 }
1418
1419
1420 /**
1421 * @param dev Device structure
1422 *
1423 * @returns 0 if all is OK
1424 *
1425 * @brief Unregister the video device
1426 *
1427 * This function permits to unregister the video device.
1428 */
1429 int v4l_microdia_unregister_video_device(struct usb_microdia *dev)
1430 {
1431 UDIA_INFO("Microdia USB 2.0 Webcam releases control of video "
1432 "device /dev/video%d\n", dev->vdev->minor);
1433
1434 video_set_drvdata(dev->vdev, NULL);
1435 video_unregister_device(dev->vdev);
1436
1437 return 0;
1438 }
1439
1440
1441 /**
1442 * @var v4l_microdia_fops
1443 *
1444 * This variable contains some callback
1445 */
1446 static struct file_operations v4l_microdia_fops = {
1447 .owner = THIS_MODULE,
1448 .open = v4l_microdia_open,
1449 .release = v4l_microdia_release,
1450 .read = v4l_microdia_read,
1451 .poll = v4l_microdia_poll,
1452 .mmap = v4l_microdia_mmap,
1453 .ioctl = v4l_microdia_ioctl,
1454 #ifdef CONFIG_COMPAT
1455 .compat_ioctl = v4l_compat_ioctl32,
1456 #endif
1457 .llseek = no_llseek
1458 };
1459
Microdia : webcam kernel driver, for USB webcams with vendor id 0c45