1 /***************************************************************************
2 * Video4Linux2 driver for ZC0301 Image Processor and Control Chip *
4 * Copyright (C) 2006 by Luca Risolia <luca.risolia@studio.unibo.it> *
6 * Informations about the chip internals to enable the I2C protocol have *
7 * been taken from the documentation of the ZC030x Video4Linux1 driver *
8 * written by Andrew Birkett <andy@nobugs.org> *
10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License as published by *
12 * the Free Software Foundation; either version 2 of the License, or *
13 * (at your option) any later version. *
15 * This program is distributed in the hope that it will be useful, *
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
18 * GNU General Public License for more details. *
20 * You should have received a copy of the GNU General Public License *
21 * along with this program; if not, write to the Free Software *
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
23 ***************************************************************************/
25 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <linux/kernel.h>
28 #include <linux/param.h>
29 #include <linux/moduleparam.h>
30 #include <linux/errno.h>
31 #include <linux/slab.h>
32 #include <linux/string.h>
33 #include <linux/device.h>
35 #include <linux/delay.h>
36 #include <linux/stddef.h>
37 #include <linux/compiler.h>
38 #include <linux/ioctl.h>
39 #include <linux/poll.h>
40 #include <linux/stat.h>
42 #include <linux/vmalloc.h>
43 #include <linux/page-flags.h>
44 #include <linux/byteorder/generic.h>
46 #include <asm/uaccess.h>
50 /*****************************************************************************/
52 #define ZC0301_MODULE_NAME "V4L2 driver for ZC0301 " \
53 "Image Processor and Control Chip"
54 #define ZC0301_MODULE_AUTHOR "(C) 2006 Luca Risolia"
55 #define ZC0301_AUTHOR_EMAIL "<luca.risolia@studio.unibo.it>"
56 #define ZC0301_MODULE_LICENSE "GPL"
57 #define ZC0301_MODULE_VERSION "1:1.00"
58 #define ZC0301_MODULE_VERSION_CODE KERNEL_VERSION(1, 0, 0)
60 /*****************************************************************************/
62 MODULE_DEVICE_TABLE(usb
, zc0301_id_table
);
64 MODULE_AUTHOR(ZC0301_MODULE_AUTHOR
" " ZC0301_AUTHOR_EMAIL
);
65 MODULE_DESCRIPTION(ZC0301_MODULE_NAME
);
66 MODULE_VERSION(ZC0301_MODULE_VERSION
);
67 MODULE_LICENSE(ZC0301_MODULE_LICENSE
);
69 static short video_nr
[] = {[0 ... ZC0301_MAX_DEVICES
-1] = -1};
70 module_param_array(video_nr
, short, NULL
, 0444);
71 MODULE_PARM_DESC(video_nr
,
72 "\n<-1|n[,...]> Specify V4L2 minor mode number."
73 "\n -1 = use next available (default)"
74 "\n n = use minor number n (integer >= 0)"
75 "\nYou can specify up to "
76 __MODULE_STRING(ZC0301_MAX_DEVICES
) " cameras this way."
78 "\nvideo_nr=-1,2,-1 would assign minor number 2 to"
79 "\nthe second registered camera and use auto for the first"
80 "\none and for every other camera."
83 static short force_munmap
[] = {[0 ... ZC0301_MAX_DEVICES
-1] =
85 module_param_array(force_munmap
, bool, NULL
, 0444);
86 MODULE_PARM_DESC(force_munmap
,
87 "\n<0|1[,...]> Force the application to unmap previously"
88 "\nmapped buffer memory before calling any VIDIOC_S_CROP or"
89 "\nVIDIOC_S_FMT ioctl's. Not all the applications support"
90 "\nthis feature. This parameter is specific for each"
92 "\n 0 = do not force memory unmapping"
93 "\n 1 = force memory unmapping (save memory)"
94 "\nDefault value is "__MODULE_STRING(SN9C102_FORCE_MUNMAP
)"."
98 static unsigned short debug
= ZC0301_DEBUG_LEVEL
;
99 module_param(debug
, ushort
, 0644);
100 MODULE_PARM_DESC(debug
,
101 "\n<n> Debugging information level, from 0 to 3:"
102 "\n0 = none (use carefully)"
103 "\n1 = critical errors"
104 "\n2 = significant informations"
105 "\n3 = more verbose messages"
106 "\nLevel 3 is useful for testing only, when only "
107 "one device is used."
108 "\nDefault value is "__MODULE_STRING(ZC0301_DEBUG_LEVEL
)"."
112 /*****************************************************************************/
115 zc0301_request_buffers(struct zc0301_device
* cam
, u32 count
,
116 enum zc0301_io_method io
)
118 struct v4l2_pix_format
* p
= &(cam
->sensor
->pix_format
);
119 struct v4l2_rect
* r
= &(cam
->sensor
->cropcap
.bounds
);
120 const size_t imagesize
= cam
->module_param
.force_munmap
||
122 (p
->width
* p
->height
* p
->priv
) / 8 :
123 (r
->width
* r
->height
* p
->priv
) / 8;
127 if (count
> ZC0301_MAX_FRAMES
)
128 count
= ZC0301_MAX_FRAMES
;
130 cam
->nbuffers
= count
;
131 while (cam
->nbuffers
> 0) {
132 if ((buff
= vmalloc_32(cam
->nbuffers
* PAGE_ALIGN(imagesize
))))
137 for (i
= 0; i
< cam
->nbuffers
; i
++) {
138 cam
->frame
[i
].bufmem
= buff
+ i
*PAGE_ALIGN(imagesize
);
139 cam
->frame
[i
].buf
.index
= i
;
140 cam
->frame
[i
].buf
.m
.offset
= i
*PAGE_ALIGN(imagesize
);
141 cam
->frame
[i
].buf
.length
= imagesize
;
142 cam
->frame
[i
].buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
143 cam
->frame
[i
].buf
.sequence
= 0;
144 cam
->frame
[i
].buf
.field
= V4L2_FIELD_NONE
;
145 cam
->frame
[i
].buf
.memory
= V4L2_MEMORY_MMAP
;
146 cam
->frame
[i
].buf
.flags
= 0;
149 return cam
->nbuffers
;
153 static void zc0301_release_buffers(struct zc0301_device
* cam
)
156 vfree(cam
->frame
[0].bufmem
);
159 cam
->frame_current
= NULL
;
163 static void zc0301_empty_framequeues(struct zc0301_device
* cam
)
167 INIT_LIST_HEAD(&cam
->inqueue
);
168 INIT_LIST_HEAD(&cam
->outqueue
);
170 for (i
= 0; i
< ZC0301_MAX_FRAMES
; i
++) {
171 cam
->frame
[i
].state
= F_UNUSED
;
172 cam
->frame
[i
].buf
.bytesused
= 0;
177 static void zc0301_requeue_outqueue(struct zc0301_device
* cam
)
179 struct zc0301_frame_t
*i
;
181 list_for_each_entry(i
, &cam
->outqueue
, frame
) {
183 list_add(&i
->frame
, &cam
->inqueue
);
186 INIT_LIST_HEAD(&cam
->outqueue
);
190 static void zc0301_queue_unusedframes(struct zc0301_device
* cam
)
192 unsigned long lock_flags
;
195 for (i
= 0; i
< cam
->nbuffers
; i
++)
196 if (cam
->frame
[i
].state
== F_UNUSED
) {
197 cam
->frame
[i
].state
= F_QUEUED
;
198 spin_lock_irqsave(&cam
->queue_lock
, lock_flags
);
199 list_add_tail(&cam
->frame
[i
].frame
, &cam
->inqueue
);
200 spin_unlock_irqrestore(&cam
->queue_lock
, lock_flags
);
204 /*****************************************************************************/
206 int zc0301_write_reg(struct zc0301_device
* cam
, u16 index
, u16 value
)
208 struct usb_device
* udev
= cam
->usbdev
;
211 res
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0xa0, 0x40,
212 value
, index
, NULL
, 0, ZC0301_CTRL_TIMEOUT
);
214 DBG(3, "Failed to write a register (index 0x%04X, "
215 "value 0x%02X, error %d)",index
, value
, res
);
223 int zc0301_read_reg(struct zc0301_device
* cam
, u16 index
)
225 struct usb_device
* udev
= cam
->usbdev
;
226 u8
* buff
= cam
->control_buffer
;
229 res
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0), 0xa1, 0xc0,
230 0x0001, index
, buff
, 1, ZC0301_CTRL_TIMEOUT
);
232 DBG(3, "Failed to read a register (index 0x%04X, error %d)",
235 PDBGG("Read: index 0x%04X, value: 0x%04X", index
, (int)(*buff
));
237 return (res
>= 0) ? (int)(*buff
) : -1;
241 int zc0301_i2c_read(struct zc0301_device
* cam
, u16 address
, u8 length
)
243 int err
= 0, res
, r0
, r1
;
245 err
+= zc0301_write_reg(cam
, 0x0092, address
);
246 err
+= zc0301_write_reg(cam
, 0x0090, 0x02);
250 res
= zc0301_read_reg(cam
, 0x0091);
253 r0
= zc0301_read_reg(cam
, 0x0095);
256 r1
= zc0301_read_reg(cam
, 0x0096);
260 res
= (length
<= 1) ? r0
: r0
| (r1
<< 8);
263 DBG(3, "I2C read failed at address 0x%04X, value: 0x%04X",
267 PDBGG("I2C read: address 0x%04X, value: 0x%04X", address
, res
);
269 return err
? -1 : res
;
273 int zc0301_i2c_write(struct zc0301_device
* cam
, u16 address
, u16 value
)
277 err
+= zc0301_write_reg(cam
, 0x0092, address
);
278 err
+= zc0301_write_reg(cam
, 0x0093, value
& 0xff);
279 err
+= zc0301_write_reg(cam
, 0x0094, value
>> 8);
280 err
+= zc0301_write_reg(cam
, 0x0090, 0x01);
284 res
= zc0301_read_reg(cam
, 0x0091);
289 DBG(3, "I2C write failed at address 0x%04X, value: 0x%04X",
292 PDBGG("I2C write: address 0x%04X, value: 0x%04X", address
, value
);
297 /*****************************************************************************/
299 static void zc0301_urb_complete(struct urb
*urb
, struct pt_regs
* regs
)
301 struct zc0301_device
* cam
= urb
->context
;
302 struct zc0301_frame_t
** f
;
307 if (urb
->status
== -ENOENT
)
310 f
= &cam
->frame_current
;
312 if (cam
->stream
== STREAM_INTERRUPT
) {
313 cam
->stream
= STREAM_OFF
;
315 (*f
)->state
= F_QUEUED
;
316 DBG(3, "Stream interrupted");
317 wake_up_interruptible(&cam
->wait_stream
);
320 if (cam
->state
& DEV_DISCONNECTED
)
323 if (cam
->state
& DEV_MISCONFIGURED
) {
324 wake_up_interruptible(&cam
->wait_frame
);
328 if (cam
->stream
== STREAM_OFF
|| list_empty(&cam
->inqueue
))
332 (*f
) = list_entry(cam
->inqueue
.next
, struct zc0301_frame_t
,
335 imagesize
= (cam
->sensor
->pix_format
.width
*
336 cam
->sensor
->pix_format
.height
*
337 cam
->sensor
->pix_format
.priv
) / 8;
339 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
340 unsigned int len
, status
;
345 len
= urb
->iso_frame_desc
[i
].actual_length
;
346 status
= urb
->iso_frame_desc
[i
].status
;
347 pos
= urb
->iso_frame_desc
[i
].offset
+ urb
->transfer_buffer
;
350 DBG(3, "Error in isochronous frame");
351 (*f
)->state
= F_ERROR
;
355 sof
= (*(soi
= pos
) == 0xd8ff);
357 PDBGG("Isochrnous frame: length %u, #%u i,", len
, i
);
359 if ((*f
)->state
== F_QUEUED
|| (*f
)->state
== F_ERROR
)
362 (*f
)->state
= F_GRABBING
;
363 (*f
)->buf
.bytesused
= 0;
364 do_gettimeofday(&(*f
)->buf
.timestamp
);
365 DBG(3, "SOF detected: new video frame");
368 if ((*f
)->state
== F_GRABBING
) {
369 if (sof
&& (*f
)->buf
.bytesused
)
372 if ((*f
)->buf
.bytesused
+ len
> imagesize
) {
373 DBG(3, "Video frame size exceeded");
374 (*f
)->state
= F_ERROR
;
378 memcpy((*f
)->bufmem
+(*f
)->buf
.bytesused
, pos
, len
);
379 (*f
)->buf
.bytesused
+= len
;
381 if ((*f
)->buf
.bytesused
== imagesize
) {
384 b
= (*f
)->buf
.bytesused
;
385 (*f
)->state
= F_DONE
;
386 (*f
)->buf
.sequence
= ++cam
->frame_count
;
387 spin_lock(&cam
->queue_lock
);
388 list_move_tail(&(*f
)->frame
, &cam
->outqueue
);
389 if (!list_empty(&cam
->inqueue
))
390 (*f
) = list_entry(cam
->inqueue
.next
,
391 struct zc0301_frame_t
,
395 spin_unlock(&cam
->queue_lock
);
396 DBG(3, "Video frame captured: : %lu bytes",
409 urb
->dev
= cam
->usbdev
;
410 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
411 if (err
< 0 && err
!= -EPERM
) {
412 cam
->state
|= DEV_MISCONFIGURED
;
413 DBG(1, "usb_submit_urb() failed");
416 wake_up_interruptible(&cam
->wait_frame
);
420 static int zc0301_start_transfer(struct zc0301_device
* cam
)
422 struct usb_device
*udev
= cam
->usbdev
;
424 const unsigned int wMaxPacketSize
[] = {0, 128, 192, 256, 384,
426 const unsigned int psz
= wMaxPacketSize
[ZC0301_ALTERNATE_SETTING
];
430 for (i
= 0; i
< ZC0301_URBS
; i
++) {
431 cam
->transfer_buffer
[i
] = kzalloc(ZC0301_ISO_PACKETS
* psz
,
433 if (!cam
->transfer_buffer
[i
]) {
435 DBG(1, "Not enough memory");
440 for (i
= 0; i
< ZC0301_URBS
; i
++) {
441 urb
= usb_alloc_urb(ZC0301_ISO_PACKETS
, GFP_KERNEL
);
445 DBG(1, "usb_alloc_urb() failed");
450 urb
->pipe
= usb_rcvisocpipe(udev
, 1);
451 urb
->transfer_flags
= URB_ISO_ASAP
;
452 urb
->number_of_packets
= ZC0301_ISO_PACKETS
;
453 urb
->complete
= zc0301_urb_complete
;
454 urb
->transfer_buffer
= cam
->transfer_buffer
[i
];
455 urb
->transfer_buffer_length
= psz
* ZC0301_ISO_PACKETS
;
457 for (j
= 0; j
< ZC0301_ISO_PACKETS
; j
++) {
458 urb
->iso_frame_desc
[j
].offset
= psz
* j
;
459 urb
->iso_frame_desc
[j
].length
= psz
;
463 err
= usb_set_interface(udev
, 0, ZC0301_ALTERNATE_SETTING
);
465 DBG(1, "usb_set_interface() failed");
469 cam
->frame_current
= NULL
;
471 for (i
= 0; i
< ZC0301_URBS
; i
++) {
472 err
= usb_submit_urb(cam
->urb
[i
], GFP_KERNEL
);
474 for (j
= i
-1; j
>= 0; j
--)
475 usb_kill_urb(cam
->urb
[j
]);
476 DBG(1, "usb_submit_urb() failed, error %d", err
);
484 for (i
= 0; (i
< ZC0301_URBS
) && cam
->urb
[i
]; i
++)
485 usb_free_urb(cam
->urb
[i
]);
488 for (i
= 0; (i
< ZC0301_URBS
) && cam
->transfer_buffer
[i
]; i
++)
489 kfree(cam
->transfer_buffer
[i
]);
495 static int zc0301_stop_transfer(struct zc0301_device
* cam
)
497 struct usb_device
*udev
= cam
->usbdev
;
501 if (cam
->state
& DEV_DISCONNECTED
)
504 for (i
= ZC0301_URBS
-1; i
>= 0; i
--) {
505 usb_kill_urb(cam
->urb
[i
]);
506 usb_free_urb(cam
->urb
[i
]);
507 kfree(cam
->transfer_buffer
[i
]);
510 err
= usb_set_interface(udev
, 0, 0); /* 0 Mb/s */
512 DBG(3, "usb_set_interface() failed");
518 static int zc0301_stream_interrupt(struct zc0301_device
* cam
)
522 cam
->stream
= STREAM_INTERRUPT
;
523 timeout
= wait_event_timeout(cam
->wait_stream
,
524 (cam
->stream
== STREAM_OFF
) ||
525 (cam
->state
& DEV_DISCONNECTED
),
527 if (cam
->state
& DEV_DISCONNECTED
)
530 cam
->state
|= DEV_MISCONFIGURED
;
531 DBG(1, "URB timeout reached. The camera is misconfigured. To "
532 "use it, close and open /dev/video%d again.",
540 /*****************************************************************************/
543 zc0301_set_compression(struct zc0301_device
* cam
,
544 struct v4l2_jpegcompression
* compression
)
548 if ((r
= zc0301_read_reg(cam
, 0x0008)) < 0)
550 err
+= zc0301_write_reg(cam
, 0x0008,
551 r
| 0x11 | (compression
->quality
>> 1));
553 return err
? -EIO
: 0;
557 static int zc0301_init(struct zc0301_device
* cam
)
559 struct zc0301_sensor
* s
= cam
->sensor
;
560 struct v4l2_control ctrl
;
561 struct v4l2_queryctrl
*qctrl
;
562 struct v4l2_rect
* rect
;
566 if (!(cam
->state
& DEV_INITIALIZED
)) {
567 init_waitqueue_head(&cam
->open
);
569 rect
= &(s
->cropcap
.defrect
);
570 cam
->compression
.quality
= ZC0301_COMPRESSION_QUALITY
;
571 } else { /* use current values */
579 DBG(3, "Sensor initialization failed");
584 if ((err
= zc0301_set_compression(cam
, &cam
->compression
))) {
585 DBG(3, "set_compression() failed");
590 if ((err
= s
->set_crop(cam
, rect
))) {
591 DBG(3, "set_crop() failed");
596 for (i
= 0; i
< ARRAY_SIZE(s
->qctrl
); i
++)
597 if (s
->qctrl
[i
].id
!= 0 &&
598 !(s
->qctrl
[i
].flags
& V4L2_CTRL_FLAG_DISABLED
)) {
599 ctrl
.id
= s
->qctrl
[i
].id
;
600 ctrl
.value
= qctrl
[i
].default_value
;
601 err
= s
->set_ctrl(cam
, &ctrl
);
603 DBG(3, "Set %s control failed",
607 DBG(3, "Image sensor supports '%s' control",
612 if (!(cam
->state
& DEV_INITIALIZED
)) {
613 mutex_init(&cam
->fileop_mutex
);
614 spin_lock_init(&cam
->queue_lock
);
615 init_waitqueue_head(&cam
->wait_frame
);
616 init_waitqueue_head(&cam
->wait_stream
);
617 cam
->nreadbuffers
= 2;
618 memcpy(s
->_qctrl
, s
->qctrl
, sizeof(s
->qctrl
));
619 memcpy(&(s
->_rect
), &(s
->cropcap
.defrect
),
620 sizeof(struct v4l2_rect
));
621 cam
->state
|= DEV_INITIALIZED
;
624 DBG(2, "Initialization succeeded");
629 static void zc0301_release_resources(struct zc0301_device
* cam
)
631 DBG(2, "V4L2 device /dev/video%d deregistered", cam
->v4ldev
->minor
);
632 video_set_drvdata(cam
->v4ldev
, NULL
);
633 video_unregister_device(cam
->v4ldev
);
634 kfree(cam
->control_buffer
);
637 /*****************************************************************************/
639 static int zc0301_open(struct inode
* inode
, struct file
* filp
)
641 struct zc0301_device
* cam
;
645 This is the only safe way to prevent race conditions with
648 if (!down_read_trylock(&zc0301_disconnect
))
651 cam
= video_get_drvdata(video_devdata(filp
));
653 if (mutex_lock_interruptible(&cam
->dev_mutex
)) {
654 up_read(&zc0301_disconnect
);
659 DBG(2, "Device /dev/video%d is busy...", cam
->v4ldev
->minor
);
660 if ((filp
->f_flags
& O_NONBLOCK
) ||
661 (filp
->f_flags
& O_NDELAY
)) {
665 mutex_unlock(&cam
->dev_mutex
);
666 err
= wait_event_interruptible_exclusive(cam
->open
,
667 cam
->state
& DEV_DISCONNECTED
670 up_read(&zc0301_disconnect
);
673 if (cam
->state
& DEV_DISCONNECTED
) {
674 up_read(&zc0301_disconnect
);
677 mutex_lock(&cam
->dev_mutex
);
681 if (cam
->state
& DEV_MISCONFIGURED
) {
682 err
= zc0301_init(cam
);
684 DBG(1, "Initialization failed again. "
685 "I will retry on next open().");
688 cam
->state
&= ~DEV_MISCONFIGURED
;
691 if ((err
= zc0301_start_transfer(cam
)))
694 filp
->private_data
= cam
;
697 cam
->stream
= STREAM_OFF
;
699 cam
->frame_count
= 0;
700 zc0301_empty_framequeues(cam
);
702 DBG(3, "Video device /dev/video%d is open", cam
->v4ldev
->minor
);
705 mutex_unlock(&cam
->dev_mutex
);
706 up_read(&zc0301_disconnect
);
711 static int zc0301_release(struct inode
* inode
, struct file
* filp
)
713 struct zc0301_device
* cam
= video_get_drvdata(video_devdata(filp
));
715 mutex_lock(&cam
->dev_mutex
); /* prevent disconnect() to be called */
717 zc0301_stop_transfer(cam
);
719 zc0301_release_buffers(cam
);
721 if (cam
->state
& DEV_DISCONNECTED
) {
722 zc0301_release_resources(cam
);
723 mutex_unlock(&cam
->dev_mutex
);
729 wake_up_interruptible_nr(&cam
->open
, 1);
731 DBG(3, "Video device /dev/video%d closed", cam
->v4ldev
->minor
);
733 mutex_unlock(&cam
->dev_mutex
);
740 zc0301_read(struct file
* filp
, char __user
* buf
,
741 size_t count
, loff_t
* f_pos
)
743 struct zc0301_device
* cam
= video_get_drvdata(video_devdata(filp
));
744 struct zc0301_frame_t
* f
, * i
;
745 unsigned long lock_flags
;
749 if (mutex_lock_interruptible(&cam
->fileop_mutex
))
752 if (cam
->state
& DEV_DISCONNECTED
) {
753 DBG(1, "Device not present");
754 mutex_unlock(&cam
->fileop_mutex
);
758 if (cam
->state
& DEV_MISCONFIGURED
) {
759 DBG(1, "The camera is misconfigured. Close and open it "
761 mutex_unlock(&cam
->fileop_mutex
);
765 if (cam
->io
== IO_MMAP
) {
766 DBG(3, "Close and open the device again to choose the read "
768 mutex_unlock(&cam
->fileop_mutex
);
772 if (cam
->io
== IO_NONE
) {
773 if (!zc0301_request_buffers(cam
, cam
->nreadbuffers
, IO_READ
)) {
774 DBG(1, "read() failed, not enough memory");
775 mutex_unlock(&cam
->fileop_mutex
);
779 cam
->stream
= STREAM_ON
;
782 if (list_empty(&cam
->inqueue
)) {
783 if (!list_empty(&cam
->outqueue
))
784 zc0301_empty_framequeues(cam
);
785 zc0301_queue_unusedframes(cam
);
789 mutex_unlock(&cam
->fileop_mutex
);
793 if (list_empty(&cam
->outqueue
)) {
794 if (filp
->f_flags
& O_NONBLOCK
) {
795 mutex_unlock(&cam
->fileop_mutex
);
798 timeout
= wait_event_interruptible_timeout
800 (!list_empty(&cam
->outqueue
)) ||
801 (cam
->state
& DEV_DISCONNECTED
) ||
802 (cam
->state
& DEV_MISCONFIGURED
),
803 ZC0301_FRAME_TIMEOUT
);
805 mutex_unlock(&cam
->fileop_mutex
);
808 if (cam
->state
& DEV_DISCONNECTED
) {
809 mutex_unlock(&cam
->fileop_mutex
);
812 if (!timeout
|| (cam
->state
& DEV_MISCONFIGURED
)) {
813 mutex_unlock(&cam
->fileop_mutex
);
818 f
= list_entry(cam
->outqueue
.prev
, struct zc0301_frame_t
, frame
);
820 if (count
> f
->buf
.bytesused
)
821 count
= f
->buf
.bytesused
;
823 if (copy_to_user(buf
, f
->bufmem
, count
)) {
830 spin_lock_irqsave(&cam
->queue_lock
, lock_flags
);
831 list_for_each_entry(i
, &cam
->outqueue
, frame
)
833 INIT_LIST_HEAD(&cam
->outqueue
);
834 spin_unlock_irqrestore(&cam
->queue_lock
, lock_flags
);
836 zc0301_queue_unusedframes(cam
);
838 PDBGG("Frame #%lu, bytes read: %zu",
839 (unsigned long)f
->buf
.index
, count
);
841 mutex_unlock(&cam
->fileop_mutex
);
843 return err
? err
: count
;
847 static unsigned int zc0301_poll(struct file
*filp
, poll_table
*wait
)
849 struct zc0301_device
* cam
= video_get_drvdata(video_devdata(filp
));
850 struct zc0301_frame_t
* f
;
851 unsigned long lock_flags
;
852 unsigned int mask
= 0;
854 if (mutex_lock_interruptible(&cam
->fileop_mutex
))
857 if (cam
->state
& DEV_DISCONNECTED
) {
858 DBG(1, "Device not present");
862 if (cam
->state
& DEV_MISCONFIGURED
) {
863 DBG(1, "The camera is misconfigured. Close and open it "
868 if (cam
->io
== IO_NONE
) {
869 if (!zc0301_request_buffers(cam
, cam
->nreadbuffers
, IO_READ
)) {
870 DBG(1, "poll() failed, not enough memory");
874 cam
->stream
= STREAM_ON
;
877 if (cam
->io
== IO_READ
) {
878 spin_lock_irqsave(&cam
->queue_lock
, lock_flags
);
879 list_for_each_entry(f
, &cam
->outqueue
, frame
)
881 INIT_LIST_HEAD(&cam
->outqueue
);
882 spin_unlock_irqrestore(&cam
->queue_lock
, lock_flags
);
883 zc0301_queue_unusedframes(cam
);
886 poll_wait(filp
, &cam
->wait_frame
, wait
);
888 if (!list_empty(&cam
->outqueue
))
889 mask
|= POLLIN
| POLLRDNORM
;
891 mutex_unlock(&cam
->fileop_mutex
);
896 mutex_unlock(&cam
->fileop_mutex
);
901 static void zc0301_vm_open(struct vm_area_struct
* vma
)
903 struct zc0301_frame_t
* f
= vma
->vm_private_data
;
908 static void zc0301_vm_close(struct vm_area_struct
* vma
)
910 /* NOTE: buffers are not freed here */
911 struct zc0301_frame_t
* f
= vma
->vm_private_data
;
916 static struct vm_operations_struct zc0301_vm_ops
= {
917 .open
= zc0301_vm_open
,
918 .close
= zc0301_vm_close
,
922 static int zc0301_mmap(struct file
* filp
, struct vm_area_struct
*vma
)
924 struct zc0301_device
* cam
= video_get_drvdata(video_devdata(filp
));
925 unsigned long size
= vma
->vm_end
- vma
->vm_start
,
926 start
= vma
->vm_start
;
930 if (mutex_lock_interruptible(&cam
->fileop_mutex
))
933 if (cam
->state
& DEV_DISCONNECTED
) {
934 DBG(1, "Device not present");
935 mutex_unlock(&cam
->fileop_mutex
);
939 if (cam
->state
& DEV_MISCONFIGURED
) {
940 DBG(1, "The camera is misconfigured. Close and open it "
942 mutex_unlock(&cam
->fileop_mutex
);
946 if (cam
->io
!= IO_MMAP
|| !(vma
->vm_flags
& VM_WRITE
) ||
947 size
!= PAGE_ALIGN(cam
->frame
[0].buf
.length
)) {
948 mutex_unlock(&cam
->fileop_mutex
);
952 for (i
= 0; i
< cam
->nbuffers
; i
++) {
953 if ((cam
->frame
[i
].buf
.m
.offset
>>PAGE_SHIFT
) == vma
->vm_pgoff
)
956 if (i
== cam
->nbuffers
) {
957 mutex_unlock(&cam
->fileop_mutex
);
961 vma
->vm_flags
|= VM_IO
;
962 vma
->vm_flags
|= VM_RESERVED
;
964 pos
= cam
->frame
[i
].bufmem
;
965 while (size
> 0) { /* size is page-aligned */
966 if (vm_insert_page(vma
, start
, vmalloc_to_page(pos
))) {
967 mutex_unlock(&cam
->fileop_mutex
);
975 vma
->vm_ops
= &zc0301_vm_ops
;
976 vma
->vm_private_data
= &cam
->frame
[i
];
980 mutex_unlock(&cam
->fileop_mutex
);
985 /*****************************************************************************/
988 zc0301_vidioc_querycap(struct zc0301_device
* cam
, void __user
* arg
)
990 struct v4l2_capability cap
= {
992 .version
= ZC0301_MODULE_VERSION_CODE
,
993 .capabilities
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_READWRITE
|
997 strlcpy(cap
.card
, cam
->v4ldev
->name
, sizeof(cap
.card
));
998 if (usb_make_path(cam
->usbdev
, cap
.bus_info
, sizeof(cap
.bus_info
)) < 0)
999 strlcpy(cap
.bus_info
, cam
->usbdev
->dev
.bus_id
,
1000 sizeof(cap
.bus_info
));
1002 if (copy_to_user(arg
, &cap
, sizeof(cap
)))
1010 zc0301_vidioc_enuminput(struct zc0301_device
* cam
, void __user
* arg
)
1012 struct v4l2_input i
;
1014 if (copy_from_user(&i
, arg
, sizeof(i
)))
1020 memset(&i
, 0, sizeof(i
));
1021 strcpy(i
.name
, "Camera");
1023 if (copy_to_user(arg
, &i
, sizeof(i
)))
1031 zc0301_vidioc_gs_input(struct zc0301_device
* cam
, void __user
* arg
)
1035 if (copy_from_user(&index
, arg
, sizeof(index
)))
1046 zc0301_vidioc_query_ctrl(struct zc0301_device
* cam
, void __user
* arg
)
1048 struct zc0301_sensor
* s
= cam
->sensor
;
1049 struct v4l2_queryctrl qc
;
1052 if (copy_from_user(&qc
, arg
, sizeof(qc
)))
1055 for (i
= 0; i
< ARRAY_SIZE(s
->qctrl
); i
++)
1056 if (qc
.id
&& qc
.id
== s
->qctrl
[i
].id
) {
1057 memcpy(&qc
, &(s
->qctrl
[i
]), sizeof(qc
));
1058 if (copy_to_user(arg
, &qc
, sizeof(qc
)))
1068 zc0301_vidioc_g_ctrl(struct zc0301_device
* cam
, void __user
* arg
)
1070 struct zc0301_sensor
* s
= cam
->sensor
;
1071 struct v4l2_control ctrl
;
1075 if (!s
->get_ctrl
&& !s
->set_ctrl
)
1078 if (copy_from_user(&ctrl
, arg
, sizeof(ctrl
)))
1082 for (i
= 0; i
< ARRAY_SIZE(s
->qctrl
); i
++)
1083 if (ctrl
.id
== s
->qctrl
[i
].id
) {
1084 ctrl
.value
= s
->_qctrl
[i
].default_value
;
1089 err
= s
->get_ctrl(cam
, &ctrl
);
1092 if (copy_to_user(arg
, &ctrl
, sizeof(ctrl
)))
1100 zc0301_vidioc_s_ctrl(struct zc0301_device
* cam
, void __user
* arg
)
1102 struct zc0301_sensor
* s
= cam
->sensor
;
1103 struct v4l2_control ctrl
;
1110 if (copy_from_user(&ctrl
, arg
, sizeof(ctrl
)))
1113 for (i
= 0; i
< ARRAY_SIZE(s
->qctrl
); i
++)
1114 if (ctrl
.id
== s
->qctrl
[i
].id
) {
1115 if (ctrl
.value
< s
->qctrl
[i
].minimum
||
1116 ctrl
.value
> s
->qctrl
[i
].maximum
)
1118 ctrl
.value
-= ctrl
.value
% s
->qctrl
[i
].step
;
1122 if ((err
= s
->set_ctrl(cam
, &ctrl
)))
1125 s
->_qctrl
[i
].default_value
= ctrl
.value
;
1132 zc0301_vidioc_cropcap(struct zc0301_device
* cam
, void __user
* arg
)
1134 struct v4l2_cropcap
* cc
= &(cam
->sensor
->cropcap
);
1136 cc
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1137 cc
->pixelaspect
.numerator
= 1;
1138 cc
->pixelaspect
.denominator
= 1;
1140 if (copy_to_user(arg
, cc
, sizeof(*cc
)))
1148 zc0301_vidioc_g_crop(struct zc0301_device
* cam
, void __user
* arg
)
1150 struct zc0301_sensor
* s
= cam
->sensor
;
1151 struct v4l2_crop crop
= {
1152 .type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
,
1155 memcpy(&(crop
.c
), &(s
->_rect
), sizeof(struct v4l2_rect
));
1157 if (copy_to_user(arg
, &crop
, sizeof(crop
)))
1165 zc0301_vidioc_s_crop(struct zc0301_device
* cam
, void __user
* arg
)
1167 struct zc0301_sensor
* s
= cam
->sensor
;
1168 struct v4l2_crop crop
;
1169 struct v4l2_rect
* rect
;
1170 struct v4l2_rect
* bounds
= &(s
->cropcap
.bounds
);
1171 const enum zc0301_stream_state stream
= cam
->stream
;
1172 const u32 nbuffers
= cam
->nbuffers
;
1176 if (copy_from_user(&crop
, arg
, sizeof(crop
)))
1181 if (crop
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1184 if (cam
->module_param
.force_munmap
)
1185 for (i
= 0; i
< cam
->nbuffers
; i
++)
1186 if (cam
->frame
[i
].vma_use_count
) {
1187 DBG(3, "VIDIOC_S_CROP failed. "
1188 "Unmap the buffers first.");
1193 memcpy(rect
, &(s
->_rect
), sizeof(*rect
));
1194 if (copy_to_user(arg
, &crop
, sizeof(crop
)))
1201 if (rect
->width
< 8)
1203 if (rect
->height
< 8)
1205 if (rect
->width
> bounds
->width
)
1206 rect
->width
= bounds
->width
;
1207 if (rect
->height
> bounds
->height
)
1208 rect
->height
= bounds
->height
;
1209 if (rect
->left
< bounds
->left
)
1210 rect
->left
= bounds
->left
;
1211 if (rect
->top
< bounds
->top
)
1212 rect
->top
= bounds
->top
;
1213 if (rect
->left
+ rect
->width
> bounds
->left
+ bounds
->width
)
1214 rect
->left
= bounds
->left
+bounds
->width
- rect
->width
;
1215 if (rect
->top
+ rect
->height
> bounds
->top
+ bounds
->height
)
1216 rect
->top
= bounds
->top
+bounds
->height
- rect
->height
;
1218 rect
->height
&= ~7L;
1220 if (cam
->stream
== STREAM_ON
)
1221 if ((err
= zc0301_stream_interrupt(cam
)))
1224 if (copy_to_user(arg
, &crop
, sizeof(crop
))) {
1225 cam
->stream
= stream
;
1229 if (cam
->module_param
.force_munmap
|| cam
->io
== IO_READ
)
1230 zc0301_release_buffers(cam
);
1233 err
+= s
->set_crop(cam
, rect
);
1235 if (err
) { /* atomic, no rollback in ioctl() */
1236 cam
->state
|= DEV_MISCONFIGURED
;
1237 DBG(1, "VIDIOC_S_CROP failed because of hardware problems. To "
1238 "use the camera, close and open /dev/video%d again.",
1239 cam
->v4ldev
->minor
);
1243 s
->pix_format
.width
= rect
->width
;
1244 s
->pix_format
.height
= rect
->height
;
1245 memcpy(&(s
->_rect
), rect
, sizeof(*rect
));
1247 if ((cam
->module_param
.force_munmap
|| cam
->io
== IO_READ
) &&
1248 nbuffers
!= zc0301_request_buffers(cam
, nbuffers
, cam
->io
)) {
1249 cam
->state
|= DEV_MISCONFIGURED
;
1250 DBG(1, "VIDIOC_S_CROP failed because of not enough memory. To "
1251 "use the camera, close and open /dev/video%d again.",
1252 cam
->v4ldev
->minor
);
1256 if (cam
->io
== IO_READ
)
1257 zc0301_empty_framequeues(cam
);
1258 else if (cam
->module_param
.force_munmap
)
1259 zc0301_requeue_outqueue(cam
);
1261 cam
->stream
= stream
;
1268 zc0301_vidioc_enum_fmt(struct zc0301_device
* cam
, void __user
* arg
)
1270 struct v4l2_fmtdesc fmtd
;
1272 if (copy_from_user(&fmtd
, arg
, sizeof(fmtd
)))
1275 if (fmtd
.index
== 0) {
1276 strcpy(fmtd
.description
, "JPEG");
1277 fmtd
.pixelformat
= V4L2_PIX_FMT_JPEG
;
1278 fmtd
.flags
= V4L2_FMT_FLAG_COMPRESSED
;
1282 fmtd
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1283 memset(&fmtd
.reserved
, 0, sizeof(fmtd
.reserved
));
1285 if (copy_to_user(arg
, &fmtd
, sizeof(fmtd
)))
1293 zc0301_vidioc_g_fmt(struct zc0301_device
* cam
, void __user
* arg
)
1295 struct v4l2_format format
;
1296 struct v4l2_pix_format
* pfmt
= &(cam
->sensor
->pix_format
);
1298 if (copy_from_user(&format
, arg
, sizeof(format
)))
1301 if (format
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1304 pfmt
->bytesperline
= 0;
1305 pfmt
->sizeimage
= pfmt
->height
* ((pfmt
->width
*pfmt
->priv
)/8);
1306 pfmt
->field
= V4L2_FIELD_NONE
;
1307 memcpy(&(format
.fmt
.pix
), pfmt
, sizeof(*pfmt
));
1309 if (copy_to_user(arg
, &format
, sizeof(format
)))
1317 zc0301_vidioc_try_s_fmt(struct zc0301_device
* cam
, unsigned int cmd
,
1320 struct zc0301_sensor
* s
= cam
->sensor
;
1321 struct v4l2_format format
;
1322 struct v4l2_pix_format
* pix
;
1323 struct v4l2_pix_format
* pfmt
= &(s
->pix_format
);
1324 struct v4l2_rect
* bounds
= &(s
->cropcap
.bounds
);
1325 struct v4l2_rect rect
;
1326 const enum zc0301_stream_state stream
= cam
->stream
;
1327 const u32 nbuffers
= cam
->nbuffers
;
1331 if (copy_from_user(&format
, arg
, sizeof(format
)))
1334 pix
= &(format
.fmt
.pix
);
1336 if (format
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1339 memcpy(&rect
, &(s
->_rect
), sizeof(rect
));
1342 pix
->width
= rect
.width
;
1343 pix
->height
= rect
.height
;
1345 rect
.width
= pix
->width
;
1346 rect
.height
= pix
->height
;
1351 if (rect
.height
< 8)
1353 if (rect
.width
> bounds
->left
+ bounds
->width
- rect
.left
)
1354 rect
.width
= bounds
->left
+ bounds
->width
- rect
.left
;
1355 if (rect
.height
> bounds
->top
+ bounds
->height
- rect
.top
)
1356 rect
.height
= bounds
->top
+ bounds
->height
- rect
.top
;
1360 pix
->width
= rect
.width
;
1361 pix
->height
= rect
.height
;
1362 pix
->pixelformat
= pfmt
->pixelformat
;
1363 pix
->priv
= pfmt
->priv
;
1364 pix
->colorspace
= pfmt
->colorspace
;
1365 pix
->bytesperline
= 0;
1366 pix
->sizeimage
= pix
->height
* ((pix
->width
* pix
->priv
) / 8);
1367 pix
->field
= V4L2_FIELD_NONE
;
1369 if (cmd
== VIDIOC_TRY_FMT
) {
1370 if (copy_to_user(arg
, &format
, sizeof(format
)))
1375 if (cam
->module_param
.force_munmap
)
1376 for (i
= 0; i
< cam
->nbuffers
; i
++)
1377 if (cam
->frame
[i
].vma_use_count
) {
1378 DBG(3, "VIDIOC_S_FMT failed. "
1379 "Unmap the buffers first.");
1383 if (cam
->stream
== STREAM_ON
)
1384 if ((err
= zc0301_stream_interrupt(cam
)))
1387 if (copy_to_user(arg
, &format
, sizeof(format
))) {
1388 cam
->stream
= stream
;
1392 if (cam
->module_param
.force_munmap
|| cam
->io
== IO_READ
)
1393 zc0301_release_buffers(cam
);
1396 err
+= s
->set_crop(cam
, &rect
);
1398 if (err
) { /* atomic, no rollback in ioctl() */
1399 cam
->state
|= DEV_MISCONFIGURED
;
1400 DBG(1, "VIDIOC_S_FMT failed because of hardware problems. To "
1401 "use the camera, close and open /dev/video%d again.",
1402 cam
->v4ldev
->minor
);
1406 memcpy(pfmt
, pix
, sizeof(*pix
));
1407 memcpy(&(s
->_rect
), &rect
, sizeof(rect
));
1409 if ((cam
->module_param
.force_munmap
|| cam
->io
== IO_READ
) &&
1410 nbuffers
!= zc0301_request_buffers(cam
, nbuffers
, cam
->io
)) {
1411 cam
->state
|= DEV_MISCONFIGURED
;
1412 DBG(1, "VIDIOC_S_FMT failed because of not enough memory. To "
1413 "use the camera, close and open /dev/video%d again.",
1414 cam
->v4ldev
->minor
);
1418 if (cam
->io
== IO_READ
)
1419 zc0301_empty_framequeues(cam
);
1420 else if (cam
->module_param
.force_munmap
)
1421 zc0301_requeue_outqueue(cam
);
1423 cam
->stream
= stream
;
1430 zc0301_vidioc_g_jpegcomp(struct zc0301_device
* cam
, void __user
* arg
)
1432 if (copy_to_user(arg
, &cam
->compression
, sizeof(cam
->compression
)))
1440 zc0301_vidioc_s_jpegcomp(struct zc0301_device
* cam
, void __user
* arg
)
1442 struct v4l2_jpegcompression jc
;
1443 const enum zc0301_stream_state stream
= cam
->stream
;
1446 if (copy_from_user(&jc
, arg
, sizeof(jc
)))
1449 if (jc
.quality
< 0 || jc
.quality
> 3)
1452 if (cam
->stream
== STREAM_ON
)
1453 if ((err
= zc0301_stream_interrupt(cam
)))
1456 err
+= zc0301_set_compression(cam
, &jc
);
1457 if (err
) { /* atomic, no rollback in ioctl() */
1458 cam
->state
|= DEV_MISCONFIGURED
;
1459 DBG(1, "VIDIOC_S_JPEGCOMP failed because of hardware "
1460 "problems. To use the camera, close and open "
1461 "/dev/video%d again.", cam
->v4ldev
->minor
);
1465 cam
->compression
.quality
= jc
.quality
;
1467 cam
->stream
= stream
;
1474 zc0301_vidioc_reqbufs(struct zc0301_device
* cam
, void __user
* arg
)
1476 struct v4l2_requestbuffers rb
;
1480 if (copy_from_user(&rb
, arg
, sizeof(rb
)))
1483 if (rb
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
1484 rb
.memory
!= V4L2_MEMORY_MMAP
)
1487 if (cam
->io
== IO_READ
) {
1488 DBG(3, "Close and open the device again to choose the mmap "
1493 for (i
= 0; i
< cam
->nbuffers
; i
++)
1494 if (cam
->frame
[i
].vma_use_count
) {
1495 DBG(3, "VIDIOC_REQBUFS failed. "
1496 "Previous buffers are still mapped.");
1500 if (cam
->stream
== STREAM_ON
)
1501 if ((err
= zc0301_stream_interrupt(cam
)))
1504 zc0301_empty_framequeues(cam
);
1506 zc0301_release_buffers(cam
);
1508 rb
.count
= zc0301_request_buffers(cam
, rb
.count
, IO_MMAP
);
1510 if (copy_to_user(arg
, &rb
, sizeof(rb
))) {
1511 zc0301_release_buffers(cam
);
1516 cam
->io
= rb
.count
? IO_MMAP
: IO_NONE
;
1523 zc0301_vidioc_querybuf(struct zc0301_device
* cam
, void __user
* arg
)
1525 struct v4l2_buffer b
;
1527 if (copy_from_user(&b
, arg
, sizeof(b
)))
1530 if (b
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
1531 b
.index
>= cam
->nbuffers
|| cam
->io
!= IO_MMAP
)
1534 memcpy(&b
, &cam
->frame
[b
.index
].buf
, sizeof(b
));
1536 if (cam
->frame
[b
.index
].vma_use_count
)
1537 b
.flags
|= V4L2_BUF_FLAG_MAPPED
;
1539 if (cam
->frame
[b
.index
].state
== F_DONE
)
1540 b
.flags
|= V4L2_BUF_FLAG_DONE
;
1541 else if (cam
->frame
[b
.index
].state
!= F_UNUSED
)
1542 b
.flags
|= V4L2_BUF_FLAG_QUEUED
;
1544 if (copy_to_user(arg
, &b
, sizeof(b
)))
1552 zc0301_vidioc_qbuf(struct zc0301_device
* cam
, void __user
* arg
)
1554 struct v4l2_buffer b
;
1555 unsigned long lock_flags
;
1557 if (copy_from_user(&b
, arg
, sizeof(b
)))
1560 if (b
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
1561 b
.index
>= cam
->nbuffers
|| cam
->io
!= IO_MMAP
)
1564 if (cam
->frame
[b
.index
].state
!= F_UNUSED
)
1567 cam
->frame
[b
.index
].state
= F_QUEUED
;
1569 spin_lock_irqsave(&cam
->queue_lock
, lock_flags
);
1570 list_add_tail(&cam
->frame
[b
.index
].frame
, &cam
->inqueue
);
1571 spin_unlock_irqrestore(&cam
->queue_lock
, lock_flags
);
1573 PDBGG("Frame #%lu queued", (unsigned long)b
.index
);
1580 zc0301_vidioc_dqbuf(struct zc0301_device
* cam
, struct file
* filp
,
1583 struct v4l2_buffer b
;
1584 struct zc0301_frame_t
*f
;
1585 unsigned long lock_flags
;
1588 if (copy_from_user(&b
, arg
, sizeof(b
)))
1591 if (b
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
|| cam
->io
!= IO_MMAP
)
1594 if (list_empty(&cam
->outqueue
)) {
1595 if (cam
->stream
== STREAM_OFF
)
1597 if (filp
->f_flags
& O_NONBLOCK
)
1599 timeout
= wait_event_interruptible_timeout
1601 (!list_empty(&cam
->outqueue
)) ||
1602 (cam
->state
& DEV_DISCONNECTED
) ||
1603 (cam
->state
& DEV_MISCONFIGURED
),
1604 ZC0301_FRAME_TIMEOUT
);
1607 if (cam
->state
& DEV_DISCONNECTED
)
1609 if (!timeout
|| (cam
->state
& DEV_MISCONFIGURED
))
1613 spin_lock_irqsave(&cam
->queue_lock
, lock_flags
);
1614 f
= list_entry(cam
->outqueue
.next
, struct zc0301_frame_t
, frame
);
1615 list_del(cam
->outqueue
.next
);
1616 spin_unlock_irqrestore(&cam
->queue_lock
, lock_flags
);
1618 f
->state
= F_UNUSED
;
1620 memcpy(&b
, &f
->buf
, sizeof(b
));
1621 if (f
->vma_use_count
)
1622 b
.flags
|= V4L2_BUF_FLAG_MAPPED
;
1624 if (copy_to_user(arg
, &b
, sizeof(b
)))
1627 PDBGG("Frame #%lu dequeued", (unsigned long)f
->buf
.index
);
1634 zc0301_vidioc_streamon(struct zc0301_device
* cam
, void __user
* arg
)
1638 if (copy_from_user(&type
, arg
, sizeof(type
)))
1641 if (type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
|| cam
->io
!= IO_MMAP
)
1644 if (list_empty(&cam
->inqueue
))
1647 cam
->stream
= STREAM_ON
;
1649 DBG(3, "Stream on");
1656 zc0301_vidioc_streamoff(struct zc0301_device
* cam
, void __user
* arg
)
1660 if (copy_from_user(&type
, arg
, sizeof(type
)))
1663 if (type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
|| cam
->io
!= IO_MMAP
)
1666 if (cam
->stream
== STREAM_ON
)
1667 if ((err
= zc0301_stream_interrupt(cam
)))
1670 zc0301_empty_framequeues(cam
);
1672 DBG(3, "Stream off");
1679 zc0301_vidioc_g_parm(struct zc0301_device
* cam
, void __user
* arg
)
1681 struct v4l2_streamparm sp
;
1683 if (copy_from_user(&sp
, arg
, sizeof(sp
)))
1686 if (sp
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1689 sp
.parm
.capture
.extendedmode
= 0;
1690 sp
.parm
.capture
.readbuffers
= cam
->nreadbuffers
;
1692 if (copy_to_user(arg
, &sp
, sizeof(sp
)))
1700 zc0301_vidioc_s_parm(struct zc0301_device
* cam
, void __user
* arg
)
1702 struct v4l2_streamparm sp
;
1704 if (copy_from_user(&sp
, arg
, sizeof(sp
)))
1707 if (sp
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1710 sp
.parm
.capture
.extendedmode
= 0;
1712 if (sp
.parm
.capture
.readbuffers
== 0)
1713 sp
.parm
.capture
.readbuffers
= cam
->nreadbuffers
;
1715 if (sp
.parm
.capture
.readbuffers
> ZC0301_MAX_FRAMES
)
1716 sp
.parm
.capture
.readbuffers
= ZC0301_MAX_FRAMES
;
1718 if (copy_to_user(arg
, &sp
, sizeof(sp
)))
1721 cam
->nreadbuffers
= sp
.parm
.capture
.readbuffers
;
1727 static int zc0301_ioctl_v4l2(struct inode
* inode
, struct file
* filp
,
1728 unsigned int cmd
, void __user
* arg
)
1730 struct zc0301_device
* cam
= video_get_drvdata(video_devdata(filp
));
1734 case VIDIOC_QUERYCAP
:
1735 return zc0301_vidioc_querycap(cam
, arg
);
1737 case VIDIOC_ENUMINPUT
:
1738 return zc0301_vidioc_enuminput(cam
, arg
);
1740 case VIDIOC_G_INPUT
:
1741 case VIDIOC_S_INPUT
:
1742 return zc0301_vidioc_gs_input(cam
, arg
);
1744 case VIDIOC_QUERYCTRL
:
1745 return zc0301_vidioc_query_ctrl(cam
, arg
);
1748 return zc0301_vidioc_g_ctrl(cam
, arg
);
1750 case VIDIOC_S_CTRL_OLD
:
1752 return zc0301_vidioc_s_ctrl(cam
, arg
);
1754 case VIDIOC_CROPCAP_OLD
:
1755 case VIDIOC_CROPCAP
:
1756 return zc0301_vidioc_cropcap(cam
, arg
);
1759 return zc0301_vidioc_g_crop(cam
, arg
);
1762 return zc0301_vidioc_s_crop(cam
, arg
);
1764 case VIDIOC_ENUM_FMT
:
1765 return zc0301_vidioc_enum_fmt(cam
, arg
);
1768 return zc0301_vidioc_g_fmt(cam
, arg
);
1770 case VIDIOC_TRY_FMT
:
1772 return zc0301_vidioc_try_s_fmt(cam
, cmd
, arg
);
1774 case VIDIOC_G_JPEGCOMP
:
1775 return zc0301_vidioc_g_jpegcomp(cam
, arg
);
1777 case VIDIOC_S_JPEGCOMP
:
1778 return zc0301_vidioc_s_jpegcomp(cam
, arg
);
1780 case VIDIOC_REQBUFS
:
1781 return zc0301_vidioc_reqbufs(cam
, arg
);
1783 case VIDIOC_QUERYBUF
:
1784 return zc0301_vidioc_querybuf(cam
, arg
);
1787 return zc0301_vidioc_qbuf(cam
, arg
);
1790 return zc0301_vidioc_dqbuf(cam
, filp
, arg
);
1792 case VIDIOC_STREAMON
:
1793 return zc0301_vidioc_streamon(cam
, arg
);
1795 case VIDIOC_STREAMOFF
:
1796 return zc0301_vidioc_streamoff(cam
, arg
);
1799 return zc0301_vidioc_g_parm(cam
, arg
);
1801 case VIDIOC_S_PARM_OLD
:
1803 return zc0301_vidioc_s_parm(cam
, arg
);
1807 case VIDIOC_QUERYSTD
:
1808 case VIDIOC_ENUMSTD
:
1809 case VIDIOC_QUERYMENU
:
1819 static int zc0301_ioctl(struct inode
* inode
, struct file
* filp
,
1820 unsigned int cmd
, unsigned long arg
)
1822 struct zc0301_device
* cam
= video_get_drvdata(video_devdata(filp
));
1825 if (mutex_lock_interruptible(&cam
->fileop_mutex
))
1826 return -ERESTARTSYS
;
1828 if (cam
->state
& DEV_DISCONNECTED
) {
1829 DBG(1, "Device not present");
1830 mutex_unlock(&cam
->fileop_mutex
);
1834 if (cam
->state
& DEV_MISCONFIGURED
) {
1835 DBG(1, "The camera is misconfigured. Close and open it "
1837 mutex_unlock(&cam
->fileop_mutex
);
1841 V4LDBG(3, "zc0301", cmd
);
1843 err
= zc0301_ioctl_v4l2(inode
, filp
, cmd
, (void __user
*)arg
);
1845 mutex_unlock(&cam
->fileop_mutex
);
1851 static struct file_operations zc0301_fops
= {
1852 .owner
= THIS_MODULE
,
1853 .open
= zc0301_open
,
1854 .release
= zc0301_release
,
1855 .ioctl
= zc0301_ioctl
,
1856 .read
= zc0301_read
,
1857 .poll
= zc0301_poll
,
1858 .mmap
= zc0301_mmap
,
1859 .llseek
= no_llseek
,
1862 /*****************************************************************************/
1865 zc0301_usb_probe(struct usb_interface
* intf
, const struct usb_device_id
* id
)
1867 struct usb_device
*udev
= interface_to_usbdev(intf
);
1868 struct zc0301_device
* cam
;
1869 static unsigned int dev_nr
= 0;
1873 if (!(cam
= kzalloc(sizeof(struct zc0301_device
), GFP_KERNEL
)))
1878 if (!(cam
->control_buffer
= kzalloc(4, GFP_KERNEL
))) {
1879 DBG(1, "kmalloc() failed");
1884 if (!(cam
->v4ldev
= video_device_alloc())) {
1885 DBG(1, "video_device_alloc() failed");
1890 mutex_init(&cam
->dev_mutex
);
1892 DBG(2, "ZC0301 Image Processor and Control Chip detected "
1893 "(vid/pid 0x%04X/0x%04X)",id
->idVendor
, id
->idProduct
);
1895 for (i
= 0; zc0301_sensor_table
[i
]; i
++) {
1896 err
= zc0301_sensor_table
[i
](cam
);
1901 if (!err
&& cam
->sensor
)
1902 DBG(2, "%s image sensor detected", cam
->sensor
->name
);
1904 DBG(1, "No supported image sensor detected");
1909 if (zc0301_init(cam
)) {
1910 DBG(1, "Initialization failed. I will retry on open().");
1911 cam
->state
|= DEV_MISCONFIGURED
;
1914 strcpy(cam
->v4ldev
->name
, "ZC0301 PC Camera");
1915 cam
->v4ldev
->owner
= THIS_MODULE
;
1916 cam
->v4ldev
->type
= VID_TYPE_CAPTURE
| VID_TYPE_SCALES
;
1917 cam
->v4ldev
->hardware
= 0;
1918 cam
->v4ldev
->fops
= &zc0301_fops
;
1919 cam
->v4ldev
->minor
= video_nr
[dev_nr
];
1920 cam
->v4ldev
->release
= video_device_release
;
1921 video_set_drvdata(cam
->v4ldev
, cam
);
1923 mutex_lock(&cam
->dev_mutex
);
1925 err
= video_register_device(cam
->v4ldev
, VFL_TYPE_GRABBER
,
1928 DBG(1, "V4L2 device registration failed");
1929 if (err
== -ENFILE
&& video_nr
[dev_nr
] == -1)
1930 DBG(1, "Free /dev/videoX node not found");
1931 video_nr
[dev_nr
] = -1;
1932 dev_nr
= (dev_nr
< ZC0301_MAX_DEVICES
-1) ? dev_nr
+1 : 0;
1933 mutex_unlock(&cam
->dev_mutex
);
1937 DBG(2, "V4L2 device registered as /dev/video%d", cam
->v4ldev
->minor
);
1939 cam
->module_param
.force_munmap
= force_munmap
[dev_nr
];
1941 dev_nr
= (dev_nr
< ZC0301_MAX_DEVICES
-1) ? dev_nr
+1 : 0;
1943 usb_set_intfdata(intf
, cam
);
1945 mutex_unlock(&cam
->dev_mutex
);
1951 kfree(cam
->control_buffer
);
1953 video_device_release(cam
->v4ldev
);
1960 static void zc0301_usb_disconnect(struct usb_interface
* intf
)
1962 struct zc0301_device
* cam
= usb_get_intfdata(intf
);
1967 down_write(&zc0301_disconnect
);
1969 mutex_lock(&cam
->dev_mutex
);
1971 DBG(2, "Disconnecting %s...", cam
->v4ldev
->name
);
1973 wake_up_interruptible_all(&cam
->open
);
1976 DBG(2, "Device /dev/video%d is open! Deregistration and "
1977 "memory deallocation are deferred on close.",
1978 cam
->v4ldev
->minor
);
1979 cam
->state
|= DEV_MISCONFIGURED
;
1980 zc0301_stop_transfer(cam
);
1981 cam
->state
|= DEV_DISCONNECTED
;
1982 wake_up_interruptible(&cam
->wait_frame
);
1983 wake_up_interruptible(&cam
->wait_stream
);
1985 cam
->state
|= DEV_DISCONNECTED
;
1986 zc0301_release_resources(cam
);
1989 mutex_unlock(&cam
->dev_mutex
);
1994 up_write(&zc0301_disconnect
);
1998 static struct usb_driver zc0301_usb_driver
= {
2000 .id_table
= zc0301_id_table
,
2001 .probe
= zc0301_usb_probe
,
2002 .disconnect
= zc0301_usb_disconnect
,
2005 /*****************************************************************************/
2007 static int __init
zc0301_module_init(void)
2011 KDBG(2, ZC0301_MODULE_NAME
" v" ZC0301_MODULE_VERSION
);
2012 KDBG(3, ZC0301_MODULE_AUTHOR
);
2014 if ((err
= usb_register(&zc0301_usb_driver
)))
2015 KDBG(1, "usb_register() failed");
2021 static void __exit
zc0301_module_exit(void)
2023 usb_deregister(&zc0301_usb_driver
);
2027 module_init(zc0301_module_init
);
2028 module_exit(zc0301_module_exit
);