1 /***************************************************************************
2 * V4L2 driver for ET61X[12]51 PC Camera Controllers *
4 * Copyright (C) 2006 by Luca Risolia <luca.risolia@studio.unibo.it> *
6 * This program is free software; you can redistribute it and/or modify *
7 * it under the terms of the GNU General Public License as published by *
8 * the Free Software Foundation; either version 2 of the License, or *
9 * (at your option) any later version. *
11 * This program is distributed in the hope that it will be useful, *
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
14 * GNU General Public License for more details. *
16 * You should have received a copy of the GNU General Public License *
17 * along with this program; if not, write to the Free Software *
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
19 ***************************************************************************/
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/kernel.h>
24 #include <linux/param.h>
25 #include <linux/moduleparam.h>
26 #include <linux/errno.h>
27 #include <linux/slab.h>
28 #include <linux/device.h>
30 #include <linux/delay.h>
31 #include <linux/compiler.h>
32 #include <linux/ioctl.h>
33 #include <linux/poll.h>
34 #include <linux/stat.h>
36 #include <linux/vmalloc.h>
37 #include <linux/page-flags.h>
38 #include <linux/byteorder/generic.h>
40 #include <asm/uaccess.h>
44 /*****************************************************************************/
46 #define ET61X251_MODULE_NAME "V4L2 driver for ET61X[12]51 " \
47 "PC Camera Controllers"
48 #define ET61X251_MODULE_AUTHOR "(C) 2006 Luca Risolia"
49 #define ET61X251_AUTHOR_EMAIL "<luca.risolia@studio.unibo.it>"
50 #define ET61X251_MODULE_LICENSE "GPL"
51 #define ET61X251_MODULE_VERSION "1:1.02"
52 #define ET61X251_MODULE_VERSION_CODE KERNEL_VERSION(1, 0, 2)
54 /*****************************************************************************/
56 MODULE_DEVICE_TABLE(usb
, et61x251_id_table
);
58 MODULE_AUTHOR(ET61X251_MODULE_AUTHOR
" " ET61X251_AUTHOR_EMAIL
);
59 MODULE_DESCRIPTION(ET61X251_MODULE_NAME
);
60 MODULE_VERSION(ET61X251_MODULE_VERSION
);
61 MODULE_LICENSE(ET61X251_MODULE_LICENSE
);
63 static short video_nr
[] = {[0 ... ET61X251_MAX_DEVICES
-1] = -1};
64 module_param_array(video_nr
, short, NULL
, 0444);
65 MODULE_PARM_DESC(video_nr
,
66 "\n<-1|n[,...]> Specify V4L2 minor mode number."
67 "\n -1 = use next available (default)"
68 "\n n = use minor number n (integer >= 0)"
69 "\nYou can specify up to "
70 __MODULE_STRING(ET61X251_MAX_DEVICES
) " cameras this way."
72 "\nvideo_nr=-1,2,-1 would assign minor number 2 to"
73 "\nthe second registered camera and use auto for the first"
74 "\none and for every other camera."
77 static short force_munmap
[] = {[0 ... ET61X251_MAX_DEVICES
-1] =
78 ET61X251_FORCE_MUNMAP
};
79 module_param_array(force_munmap
, bool, NULL
, 0444);
80 MODULE_PARM_DESC(force_munmap
,
81 "\n<0|1[,...]> Force the application to unmap previously"
82 "\nmapped buffer memory before calling any VIDIOC_S_CROP or"
83 "\nVIDIOC_S_FMT ioctl's. Not all the applications support"
84 "\nthis feature. This parameter is specific for each"
86 "\n 0 = do not force memory unmapping"
87 "\n 1 = force memory unmapping (save memory)"
88 "\nDefault value is "__MODULE_STRING(SN9C102_FORCE_MUNMAP
)"."
91 static unsigned int frame_timeout
[] = {[0 ... ET61X251_MAX_DEVICES
-1] =
92 ET61X251_FRAME_TIMEOUT
};
93 module_param_array(frame_timeout
, uint
, NULL
, 0644);
94 MODULE_PARM_DESC(frame_timeout
,
95 "\n<n[,...]> Timeout for a video frame in seconds."
96 "\nThis parameter is specific for each detected camera."
98 __MODULE_STRING(ET61X251_FRAME_TIMEOUT
)"."
101 #ifdef ET61X251_DEBUG
102 static unsigned short debug
= ET61X251_DEBUG_LEVEL
;
103 module_param(debug
, ushort
, 0644);
104 MODULE_PARM_DESC(debug
,
105 "\n<n> Debugging information level, from 0 to 3:"
106 "\n0 = none (use carefully)"
107 "\n1 = critical errors"
108 "\n2 = significant informations"
109 "\n3 = more verbose messages"
110 "\nLevel 3 is useful for testing only, when only "
111 "one device is used."
112 "\nDefault value is "__MODULE_STRING(ET61X251_DEBUG_LEVEL
)"."
116 /*****************************************************************************/
119 et61x251_request_buffers(struct et61x251_device
* cam
, u32 count
,
120 enum et61x251_io_method io
)
122 struct v4l2_pix_format
* p
= &(cam
->sensor
.pix_format
);
123 struct v4l2_rect
* r
= &(cam
->sensor
.cropcap
.bounds
);
124 const size_t imagesize
= cam
->module_param
.force_munmap
||
126 (p
->width
* p
->height
* p
->priv
) / 8 :
127 (r
->width
* r
->height
* p
->priv
) / 8;
131 if (count
> ET61X251_MAX_FRAMES
)
132 count
= ET61X251_MAX_FRAMES
;
134 cam
->nbuffers
= count
;
135 while (cam
->nbuffers
> 0) {
136 if ((buff
= vmalloc_32(cam
->nbuffers
* PAGE_ALIGN(imagesize
))))
141 for (i
= 0; i
< cam
->nbuffers
; i
++) {
142 cam
->frame
[i
].bufmem
= buff
+ i
*PAGE_ALIGN(imagesize
);
143 cam
->frame
[i
].buf
.index
= i
;
144 cam
->frame
[i
].buf
.m
.offset
= i
*PAGE_ALIGN(imagesize
);
145 cam
->frame
[i
].buf
.length
= imagesize
;
146 cam
->frame
[i
].buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
147 cam
->frame
[i
].buf
.sequence
= 0;
148 cam
->frame
[i
].buf
.field
= V4L2_FIELD_NONE
;
149 cam
->frame
[i
].buf
.memory
= V4L2_MEMORY_MMAP
;
150 cam
->frame
[i
].buf
.flags
= 0;
153 return cam
->nbuffers
;
157 static void et61x251_release_buffers(struct et61x251_device
* cam
)
160 vfree(cam
->frame
[0].bufmem
);
163 cam
->frame_current
= NULL
;
167 static void et61x251_empty_framequeues(struct et61x251_device
* cam
)
171 INIT_LIST_HEAD(&cam
->inqueue
);
172 INIT_LIST_HEAD(&cam
->outqueue
);
174 for (i
= 0; i
< ET61X251_MAX_FRAMES
; i
++) {
175 cam
->frame
[i
].state
= F_UNUSED
;
176 cam
->frame
[i
].buf
.bytesused
= 0;
181 static void et61x251_requeue_outqueue(struct et61x251_device
* cam
)
183 struct et61x251_frame_t
*i
;
185 list_for_each_entry(i
, &cam
->outqueue
, frame
) {
187 list_add(&i
->frame
, &cam
->inqueue
);
190 INIT_LIST_HEAD(&cam
->outqueue
);
194 static void et61x251_queue_unusedframes(struct et61x251_device
* cam
)
196 unsigned long lock_flags
;
199 for (i
= 0; i
< cam
->nbuffers
; i
++)
200 if (cam
->frame
[i
].state
== F_UNUSED
) {
201 cam
->frame
[i
].state
= F_QUEUED
;
202 spin_lock_irqsave(&cam
->queue_lock
, lock_flags
);
203 list_add_tail(&cam
->frame
[i
].frame
, &cam
->inqueue
);
204 spin_unlock_irqrestore(&cam
->queue_lock
, lock_flags
);
208 /*****************************************************************************/
210 int et61x251_write_reg(struct et61x251_device
* cam
, u8 value
, u16 index
)
212 struct usb_device
* udev
= cam
->usbdev
;
213 u8
* buff
= cam
->control_buffer
;
218 res
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x00, 0x41,
219 0, index
, buff
, 1, ET61X251_CTRL_TIMEOUT
);
221 DBG(3, "Failed to write a register (value 0x%02X, index "
222 "0x%02X, error %d)", value
, index
, res
);
230 int et61x251_read_reg(struct et61x251_device
* cam
, u16 index
)
232 struct usb_device
* udev
= cam
->usbdev
;
233 u8
* buff
= cam
->control_buffer
;
236 res
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0), 0x00, 0xc1,
237 0, index
, buff
, 1, ET61X251_CTRL_TIMEOUT
);
239 DBG(3, "Failed to read a register (index 0x%02X, error %d)",
242 return (res
>= 0) ? (int)(*buff
) : -1;
247 et61x251_i2c_wait(struct et61x251_device
* cam
, struct et61x251_sensor
* sensor
)
251 for (i
= 1; i
<= 8; i
++) {
252 if (sensor
->interface
== ET61X251_I2C_3WIRES
) {
253 r
= et61x251_read_reg(cam
, 0x8e);
254 if (!(r
& 0x02) && (r
>= 0))
257 r
= et61x251_read_reg(cam
, 0x8b);
258 if (!(r
& 0x01) && (r
>= 0))
263 udelay(8*8); /* minimum for sensors at 400kHz */
271 et61x251_i2c_try_read(struct et61x251_device
* cam
,
272 struct et61x251_sensor
* sensor
, u8 address
)
274 struct usb_device
* udev
= cam
->usbdev
;
275 u8
* data
= cam
->control_buffer
;
279 data
[1] = cam
->sensor
.i2c_slave_id
;
280 data
[2] = cam
->sensor
.rsta
| 0x10;
281 data
[3] = !(et61x251_read_reg(cam
, 0x8b) & 0x02);
282 res
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x00, 0x41,
283 0, 0x88, data
, 4, ET61X251_CTRL_TIMEOUT
);
287 err
+= et61x251_i2c_wait(cam
, sensor
);
289 res
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0), 0x00, 0xc1,
290 0, 0x80, data
, 8, ET61X251_CTRL_TIMEOUT
);
295 DBG(3, "I2C read failed for %s image sensor", sensor
->name
);
297 PDBGG("I2C read: address 0x%02X, value: 0x%02X", address
, data
[0]);
299 return err
? -1 : (int)data
[0];
304 et61x251_i2c_try_write(struct et61x251_device
* cam
,
305 struct et61x251_sensor
* sensor
, u8 address
, u8 value
)
307 struct usb_device
* udev
= cam
->usbdev
;
308 u8
* data
= cam
->control_buffer
;
312 data
[1] = cam
->sensor
.i2c_slave_id
;
313 data
[2] = cam
->sensor
.rsta
| 0x12;
314 res
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x00, 0x41,
315 0, 0x88, data
, 3, ET61X251_CTRL_TIMEOUT
);
320 res
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x00, 0x41,
321 0, 0x80, data
, 1, ET61X251_CTRL_TIMEOUT
);
325 err
+= et61x251_i2c_wait(cam
, sensor
);
328 DBG(3, "I2C write failed for %s image sensor", sensor
->name
);
330 PDBGG("I2C write: address 0x%02X, value: 0x%02X", address
, value
);
337 et61x251_i2c_raw_write(struct et61x251_device
* cam
, u8 n
, u8 data1
, u8 data2
,
338 u8 data3
, u8 data4
, u8 data5
, u8 data6
, u8 data7
,
339 u8 data8
, u8 address
)
341 struct usb_device
* udev
= cam
->usbdev
;
342 u8
* data
= cam
->control_buffer
;
352 res
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x00, 0x41,
353 0, 0x81, data
, n
-1, ET61X251_CTRL_TIMEOUT
);
358 data
[1] = cam
->sensor
.i2c_slave_id
;
359 data
[2] = cam
->sensor
.rsta
| 0x02 | (n
<< 4);
360 res
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x00, 0x41,
361 0, 0x88, data
, 3, ET61X251_CTRL_TIMEOUT
);
365 /* Start writing through the serial interface */
367 res
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x00, 0x41,
368 0, 0x80, data
, 1, ET61X251_CTRL_TIMEOUT
);
372 err
+= et61x251_i2c_wait(cam
, &cam
->sensor
);
375 DBG(3, "I2C raw write failed for %s image sensor",
378 PDBGG("I2C raw write: %u bytes, address = 0x%02X, data1 = 0x%02X, "
379 "data2 = 0x%02X, data3 = 0x%02X, data4 = 0x%02X, data5 = 0x%02X,"
380 " data6 = 0x%02X, data7 = 0x%02X, data8 = 0x%02X", n
, address
,
381 data1
, data2
, data3
, data4
, data5
, data6
, data7
, data8
);
388 int et61x251_i2c_read(struct et61x251_device
* cam
, u8 address
)
390 return et61x251_i2c_try_read(cam
, &cam
->sensor
, address
);
394 int et61x251_i2c_write(struct et61x251_device
* cam
, u8 address
, u8 value
)
396 return et61x251_i2c_try_write(cam
, &cam
->sensor
, address
, value
);
399 /*****************************************************************************/
401 static void et61x251_urb_complete(struct urb
*urb
)
403 struct et61x251_device
* cam
= urb
->context
;
404 struct et61x251_frame_t
** f
;
409 if (urb
->status
== -ENOENT
)
412 f
= &cam
->frame_current
;
414 if (cam
->stream
== STREAM_INTERRUPT
) {
415 cam
->stream
= STREAM_OFF
;
417 (*f
)->state
= F_QUEUED
;
418 DBG(3, "Stream interrupted");
419 wake_up(&cam
->wait_stream
);
422 if (cam
->state
& DEV_DISCONNECTED
)
425 if (cam
->state
& DEV_MISCONFIGURED
) {
426 wake_up_interruptible(&cam
->wait_frame
);
430 if (cam
->stream
== STREAM_OFF
|| list_empty(&cam
->inqueue
))
434 (*f
) = list_entry(cam
->inqueue
.next
, struct et61x251_frame_t
,
437 imagesize
= (cam
->sensor
.pix_format
.width
*
438 cam
->sensor
.pix_format
.height
*
439 cam
->sensor
.pix_format
.priv
) / 8;
441 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
442 unsigned int len
, status
;
445 const u8 VOID_BYTES
= 6;
448 len
= urb
->iso_frame_desc
[i
].actual_length
;
449 status
= urb
->iso_frame_desc
[i
].status
;
450 pos
= urb
->iso_frame_desc
[i
].offset
+ urb
->transfer_buffer
;
453 DBG(3, "Error in isochronous frame");
454 (*f
)->state
= F_ERROR
;
460 sof
= ((*b1
& 0x3f) == 63);
461 imglen
= ((*b1
& 0xc0) << 2) | *b2
;
463 PDBGG("Isochrnous frame: length %u, #%u i, image length %zu",
466 if ((*f
)->state
== F_QUEUED
|| (*f
)->state
== F_ERROR
)
469 (*f
)->state
= F_GRABBING
;
470 (*f
)->buf
.bytesused
= 0;
471 do_gettimeofday(&(*f
)->buf
.timestamp
);
473 DBG(3, "SOF detected: new video frame");
476 if ((*f
)->state
== F_GRABBING
) {
477 if (sof
&& (*f
)->buf
.bytesused
) {
478 if (cam
->sensor
.pix_format
.pixelformat
==
479 V4L2_PIX_FMT_ET61X251
)
482 DBG(3, "Not expected SOF detected "
484 (unsigned long)(*f
)->buf
.bytesused
);
485 (*f
)->state
= F_ERROR
;
490 if ((*f
)->buf
.bytesused
+ imglen
> imagesize
) {
491 DBG(3, "Video frame size exceeded");
492 (*f
)->state
= F_ERROR
;
498 memcpy((*f
)->bufmem
+(*f
)->buf
.bytesused
, pos
, imglen
);
499 (*f
)->buf
.bytesused
+= imglen
;
501 if ((*f
)->buf
.bytesused
== imagesize
) {
504 b
= (*f
)->buf
.bytesused
;
505 (*f
)->state
= F_DONE
;
506 (*f
)->buf
.sequence
= ++cam
->frame_count
;
507 spin_lock(&cam
->queue_lock
);
508 list_move_tail(&(*f
)->frame
, &cam
->outqueue
);
509 if (!list_empty(&cam
->inqueue
))
510 (*f
) = list_entry(cam
->inqueue
.next
,
511 struct et61x251_frame_t
,
515 spin_unlock(&cam
->queue_lock
);
516 DBG(3, "Video frame captured: : %lu bytes",
523 cam
->sensor
.pix_format
.pixelformat
==
524 V4L2_PIX_FMT_ET61X251
)
531 urb
->dev
= cam
->usbdev
;
532 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
533 if (err
< 0 && err
!= -EPERM
) {
534 cam
->state
|= DEV_MISCONFIGURED
;
535 DBG(1, "usb_submit_urb() failed");
538 wake_up_interruptible(&cam
->wait_frame
);
542 static int et61x251_start_transfer(struct et61x251_device
* cam
)
544 struct usb_device
*udev
= cam
->usbdev
;
546 const unsigned int wMaxPacketSize
[] = {0, 256, 384, 512, 640, 768, 832,
547 864, 896, 920, 956, 980, 1000,
549 const unsigned int psz
= wMaxPacketSize
[ET61X251_ALTERNATE_SETTING
];
553 for (i
= 0; i
< ET61X251_URBS
; i
++) {
554 cam
->transfer_buffer
[i
] = kzalloc(ET61X251_ISO_PACKETS
* psz
,
556 if (!cam
->transfer_buffer
[i
]) {
558 DBG(1, "Not enough memory");
563 for (i
= 0; i
< ET61X251_URBS
; i
++) {
564 urb
= usb_alloc_urb(ET61X251_ISO_PACKETS
, GFP_KERNEL
);
568 DBG(1, "usb_alloc_urb() failed");
573 urb
->pipe
= usb_rcvisocpipe(udev
, 1);
574 urb
->transfer_flags
= URB_ISO_ASAP
;
575 urb
->number_of_packets
= ET61X251_ISO_PACKETS
;
576 urb
->complete
= et61x251_urb_complete
;
577 urb
->transfer_buffer
= cam
->transfer_buffer
[i
];
578 urb
->transfer_buffer_length
= psz
* ET61X251_ISO_PACKETS
;
580 for (j
= 0; j
< ET61X251_ISO_PACKETS
; j
++) {
581 urb
->iso_frame_desc
[j
].offset
= psz
* j
;
582 urb
->iso_frame_desc
[j
].length
= psz
;
586 err
= et61x251_write_reg(cam
, 0x01, 0x03);
587 err
= et61x251_write_reg(cam
, 0x00, 0x03);
588 err
= et61x251_write_reg(cam
, 0x08, 0x03);
591 DBG(1, "I/O hardware error");
595 err
= usb_set_interface(udev
, 0, ET61X251_ALTERNATE_SETTING
);
597 DBG(1, "usb_set_interface() failed");
601 cam
->frame_current
= NULL
;
603 for (i
= 0; i
< ET61X251_URBS
; i
++) {
604 err
= usb_submit_urb(cam
->urb
[i
], GFP_KERNEL
);
606 for (j
= i
-1; j
>= 0; j
--)
607 usb_kill_urb(cam
->urb
[j
]);
608 DBG(1, "usb_submit_urb() failed, error %d", err
);
616 for (i
= 0; (i
< ET61X251_URBS
) && cam
->urb
[i
]; i
++)
617 usb_free_urb(cam
->urb
[i
]);
620 for (i
= 0; (i
< ET61X251_URBS
) && cam
->transfer_buffer
[i
]; i
++)
621 kfree(cam
->transfer_buffer
[i
]);
627 static int et61x251_stop_transfer(struct et61x251_device
* cam
)
629 struct usb_device
*udev
= cam
->usbdev
;
633 if (cam
->state
& DEV_DISCONNECTED
)
636 for (i
= ET61X251_URBS
-1; i
>= 0; i
--) {
637 usb_kill_urb(cam
->urb
[i
]);
638 usb_free_urb(cam
->urb
[i
]);
639 kfree(cam
->transfer_buffer
[i
]);
642 err
= usb_set_interface(udev
, 0, 0); /* 0 Mb/s */
644 DBG(3, "usb_set_interface() failed");
650 static int et61x251_stream_interrupt(struct et61x251_device
* cam
)
654 cam
->stream
= STREAM_INTERRUPT
;
655 timeout
= wait_event_timeout(cam
->wait_stream
,
656 (cam
->stream
== STREAM_OFF
) ||
657 (cam
->state
& DEV_DISCONNECTED
),
658 ET61X251_URB_TIMEOUT
);
659 if (cam
->state
& DEV_DISCONNECTED
)
661 else if (cam
->stream
!= STREAM_OFF
) {
662 cam
->state
|= DEV_MISCONFIGURED
;
663 DBG(1, "URB timeout reached. The camera is misconfigured. To "
664 "use it, close and open /dev/video%d again.",
672 /*****************************************************************************/
674 #ifdef CONFIG_VIDEO_ADV_DEBUG
675 static u8
et61x251_strtou8(const char* buff
, size_t len
, ssize_t
* count
)
682 strncpy(str
, buff
, len
);
685 strncpy(str
, buff
, 4);
689 val
= simple_strtoul(str
, &endp
, 0);
693 *count
= (ssize_t
)(endp
- str
);
694 if ((*count
) && (len
== *count
+1) && (buff
[*count
] == '\n'))
701 NOTE 1: being inside one of the following methods implies that the v4l
702 device exists for sure (see kobjects and reference counters)
703 NOTE 2: buffers are PAGE_SIZE long
706 static ssize_t
et61x251_show_reg(struct class_device
* cd
, char* buf
)
708 struct et61x251_device
* cam
;
711 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
714 cam
= video_get_drvdata(to_video_device(cd
));
716 mutex_unlock(&et61x251_sysfs_lock
);
720 count
= sprintf(buf
, "%u\n", cam
->sysfs
.reg
);
722 mutex_unlock(&et61x251_sysfs_lock
);
729 et61x251_store_reg(struct class_device
* cd
, const char* buf
, size_t len
)
731 struct et61x251_device
* cam
;
735 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
738 cam
= video_get_drvdata(to_video_device(cd
));
740 mutex_unlock(&et61x251_sysfs_lock
);
744 index
= et61x251_strtou8(buf
, len
, &count
);
745 if (index
> 0x8e || !count
) {
746 mutex_unlock(&et61x251_sysfs_lock
);
750 cam
->sysfs
.reg
= index
;
752 DBG(2, "Moved ET61X[12]51 register index to 0x%02X", cam
->sysfs
.reg
);
753 DBG(3, "Written bytes: %zd", count
);
755 mutex_unlock(&et61x251_sysfs_lock
);
761 static ssize_t
et61x251_show_val(struct class_device
* cd
, char* buf
)
763 struct et61x251_device
* cam
;
767 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
770 cam
= video_get_drvdata(to_video_device(cd
));
772 mutex_unlock(&et61x251_sysfs_lock
);
776 if ((val
= et61x251_read_reg(cam
, cam
->sysfs
.reg
)) < 0) {
777 mutex_unlock(&et61x251_sysfs_lock
);
781 count
= sprintf(buf
, "%d\n", val
);
783 DBG(3, "Read bytes: %zd", count
);
785 mutex_unlock(&et61x251_sysfs_lock
);
792 et61x251_store_val(struct class_device
* cd
, const char* buf
, size_t len
)
794 struct et61x251_device
* cam
;
799 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
802 cam
= video_get_drvdata(to_video_device(cd
));
804 mutex_unlock(&et61x251_sysfs_lock
);
808 value
= et61x251_strtou8(buf
, len
, &count
);
810 mutex_unlock(&et61x251_sysfs_lock
);
814 err
= et61x251_write_reg(cam
, value
, cam
->sysfs
.reg
);
816 mutex_unlock(&et61x251_sysfs_lock
);
820 DBG(2, "Written ET61X[12]51 reg. 0x%02X, val. 0x%02X",
821 cam
->sysfs
.reg
, value
);
822 DBG(3, "Written bytes: %zd", count
);
824 mutex_unlock(&et61x251_sysfs_lock
);
830 static ssize_t
et61x251_show_i2c_reg(struct class_device
* cd
, char* buf
)
832 struct et61x251_device
* cam
;
835 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
838 cam
= video_get_drvdata(to_video_device(cd
));
840 mutex_unlock(&et61x251_sysfs_lock
);
844 count
= sprintf(buf
, "%u\n", cam
->sysfs
.i2c_reg
);
846 DBG(3, "Read bytes: %zd", count
);
848 mutex_unlock(&et61x251_sysfs_lock
);
855 et61x251_store_i2c_reg(struct class_device
* cd
, const char* buf
, size_t len
)
857 struct et61x251_device
* cam
;
861 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
864 cam
= video_get_drvdata(to_video_device(cd
));
866 mutex_unlock(&et61x251_sysfs_lock
);
870 index
= et61x251_strtou8(buf
, len
, &count
);
872 mutex_unlock(&et61x251_sysfs_lock
);
876 cam
->sysfs
.i2c_reg
= index
;
878 DBG(2, "Moved sensor register index to 0x%02X", cam
->sysfs
.i2c_reg
);
879 DBG(3, "Written bytes: %zd", count
);
881 mutex_unlock(&et61x251_sysfs_lock
);
887 static ssize_t
et61x251_show_i2c_val(struct class_device
* cd
, char* buf
)
889 struct et61x251_device
* cam
;
893 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
896 cam
= video_get_drvdata(to_video_device(cd
));
898 mutex_unlock(&et61x251_sysfs_lock
);
902 if (!(cam
->sensor
.sysfs_ops
& ET61X251_I2C_READ
)) {
903 mutex_unlock(&et61x251_sysfs_lock
);
907 if ((val
= et61x251_i2c_read(cam
, cam
->sysfs
.i2c_reg
)) < 0) {
908 mutex_unlock(&et61x251_sysfs_lock
);
912 count
= sprintf(buf
, "%d\n", val
);
914 DBG(3, "Read bytes: %zd", count
);
916 mutex_unlock(&et61x251_sysfs_lock
);
923 et61x251_store_i2c_val(struct class_device
* cd
, const char* buf
, size_t len
)
925 struct et61x251_device
* cam
;
930 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
933 cam
= video_get_drvdata(to_video_device(cd
));
935 mutex_unlock(&et61x251_sysfs_lock
);
939 if (!(cam
->sensor
.sysfs_ops
& ET61X251_I2C_READ
)) {
940 mutex_unlock(&et61x251_sysfs_lock
);
944 value
= et61x251_strtou8(buf
, len
, &count
);
946 mutex_unlock(&et61x251_sysfs_lock
);
950 err
= et61x251_i2c_write(cam
, cam
->sysfs
.i2c_reg
, value
);
952 mutex_unlock(&et61x251_sysfs_lock
);
956 DBG(2, "Written sensor reg. 0x%02X, val. 0x%02X",
957 cam
->sysfs
.i2c_reg
, value
);
958 DBG(3, "Written bytes: %zd", count
);
960 mutex_unlock(&et61x251_sysfs_lock
);
966 static CLASS_DEVICE_ATTR(reg
, S_IRUGO
| S_IWUSR
,
967 et61x251_show_reg
, et61x251_store_reg
);
968 static CLASS_DEVICE_ATTR(val
, S_IRUGO
| S_IWUSR
,
969 et61x251_show_val
, et61x251_store_val
);
970 static CLASS_DEVICE_ATTR(i2c_reg
, S_IRUGO
| S_IWUSR
,
971 et61x251_show_i2c_reg
, et61x251_store_i2c_reg
);
972 static CLASS_DEVICE_ATTR(i2c_val
, S_IRUGO
| S_IWUSR
,
973 et61x251_show_i2c_val
, et61x251_store_i2c_val
);
976 static void et61x251_create_sysfs(struct et61x251_device
* cam
)
978 struct video_device
*v4ldev
= cam
->v4ldev
;
980 video_device_create_file(v4ldev
, &class_device_attr_reg
);
981 video_device_create_file(v4ldev
, &class_device_attr_val
);
982 if (cam
->sensor
.sysfs_ops
) {
983 video_device_create_file(v4ldev
, &class_device_attr_i2c_reg
);
984 video_device_create_file(v4ldev
, &class_device_attr_i2c_val
);
987 #endif /* CONFIG_VIDEO_ADV_DEBUG */
989 /*****************************************************************************/
992 et61x251_set_pix_format(struct et61x251_device
* cam
,
993 struct v4l2_pix_format
* pix
)
997 if ((r
= et61x251_read_reg(cam
, 0x12)) < 0)
999 if (pix
->pixelformat
== V4L2_PIX_FMT_ET61X251
)
1000 err
+= et61x251_write_reg(cam
, r
& 0xfd, 0x12);
1002 err
+= et61x251_write_reg(cam
, r
| 0x02, 0x12);
1004 return err
? -EIO
: 0;
1009 et61x251_set_compression(struct et61x251_device
* cam
,
1010 struct v4l2_jpegcompression
* compression
)
1014 if ((r
= et61x251_read_reg(cam
, 0x12)) < 0)
1016 if (compression
->quality
== 0)
1017 err
+= et61x251_write_reg(cam
, r
& 0xfb, 0x12);
1019 err
+= et61x251_write_reg(cam
, r
| 0x04, 0x12);
1021 return err
? -EIO
: 0;
1025 static int et61x251_set_scale(struct et61x251_device
* cam
, u8 scale
)
1029 r
= et61x251_read_reg(cam
, 0x12);
1034 err
+= et61x251_write_reg(cam
, r
& ~0x01, 0x12);
1035 else if (scale
== 2)
1036 err
+= et61x251_write_reg(cam
, r
| 0x01, 0x12);
1041 PDBGG("Scaling factor: %u", scale
);
1048 et61x251_set_crop(struct et61x251_device
* cam
, struct v4l2_rect
* rect
)
1050 struct et61x251_sensor
* s
= &cam
->sensor
;
1051 u16 fmw_sx
= (u16
)(rect
->left
- s
->cropcap
.bounds
.left
+
1052 s
->active_pixel
.left
),
1053 fmw_sy
= (u16
)(rect
->top
- s
->cropcap
.bounds
.top
+
1054 s
->active_pixel
.top
),
1055 fmw_length
= (u16
)(rect
->width
),
1056 fmw_height
= (u16
)(rect
->height
);
1059 err
+= et61x251_write_reg(cam
, fmw_sx
& 0xff, 0x69);
1060 err
+= et61x251_write_reg(cam
, fmw_sy
& 0xff, 0x6a);
1061 err
+= et61x251_write_reg(cam
, fmw_length
& 0xff, 0x6b);
1062 err
+= et61x251_write_reg(cam
, fmw_height
& 0xff, 0x6c);
1063 err
+= et61x251_write_reg(cam
, (fmw_sx
>> 8) | ((fmw_sy
& 0x300) >> 6)
1064 | ((fmw_length
& 0x300) >> 4)
1065 | ((fmw_height
& 0x300) >> 2), 0x6d);
1069 PDBGG("fmw_sx, fmw_sy, fmw_length, fmw_height: %u %u %u %u",
1070 fmw_sx
, fmw_sy
, fmw_length
, fmw_height
);
1076 static int et61x251_init(struct et61x251_device
* cam
)
1078 struct et61x251_sensor
* s
= &cam
->sensor
;
1079 struct v4l2_control ctrl
;
1080 struct v4l2_queryctrl
*qctrl
;
1081 struct v4l2_rect
* rect
;
1085 if (!(cam
->state
& DEV_INITIALIZED
)) {
1086 init_waitqueue_head(&cam
->open
);
1088 rect
= &(s
->cropcap
.defrect
);
1089 cam
->compression
.quality
= ET61X251_COMPRESSION_QUALITY
;
1090 } else { /* use current values */
1095 err
+= et61x251_set_scale(cam
, rect
->width
/ s
->pix_format
.width
);
1096 err
+= et61x251_set_crop(cam
, rect
);
1103 DBG(3, "Sensor initialization failed");
1108 err
+= et61x251_set_compression(cam
, &cam
->compression
);
1109 err
+= et61x251_set_pix_format(cam
, &s
->pix_format
);
1110 if (s
->set_pix_format
)
1111 err
+= s
->set_pix_format(cam
, &s
->pix_format
);
1115 if (s
->pix_format
.pixelformat
== V4L2_PIX_FMT_ET61X251
)
1116 DBG(3, "Compressed video format is active, quality %d",
1117 cam
->compression
.quality
);
1119 DBG(3, "Uncompressed video format is active");
1122 if ((err
= s
->set_crop(cam
, rect
))) {
1123 DBG(3, "set_crop() failed");
1128 for (i
= 0; i
< ARRAY_SIZE(s
->qctrl
); i
++)
1129 if (s
->qctrl
[i
].id
!= 0 &&
1130 !(s
->qctrl
[i
].flags
& V4L2_CTRL_FLAG_DISABLED
)) {
1131 ctrl
.id
= s
->qctrl
[i
].id
;
1132 ctrl
.value
= qctrl
[i
].default_value
;
1133 err
= s
->set_ctrl(cam
, &ctrl
);
1135 DBG(3, "Set %s control failed",
1139 DBG(3, "Image sensor supports '%s' control",
1144 if (!(cam
->state
& DEV_INITIALIZED
)) {
1145 mutex_init(&cam
->fileop_mutex
);
1146 spin_lock_init(&cam
->queue_lock
);
1147 init_waitqueue_head(&cam
->wait_frame
);
1148 init_waitqueue_head(&cam
->wait_stream
);
1149 cam
->nreadbuffers
= 2;
1150 memcpy(s
->_qctrl
, s
->qctrl
, sizeof(s
->qctrl
));
1151 memcpy(&(s
->_rect
), &(s
->cropcap
.defrect
),
1152 sizeof(struct v4l2_rect
));
1153 cam
->state
|= DEV_INITIALIZED
;
1156 DBG(2, "Initialization succeeded");
1161 static void et61x251_release_resources(struct et61x251_device
* cam
)
1163 mutex_lock(&et61x251_sysfs_lock
);
1165 DBG(2, "V4L2 device /dev/video%d deregistered", cam
->v4ldev
->minor
);
1166 video_set_drvdata(cam
->v4ldev
, NULL
);
1167 video_unregister_device(cam
->v4ldev
);
1169 usb_put_dev(cam
->usbdev
);
1171 mutex_unlock(&et61x251_sysfs_lock
);
1173 kfree(cam
->control_buffer
);
1176 /*****************************************************************************/
1178 static int et61x251_open(struct inode
* inode
, struct file
* filp
)
1180 struct et61x251_device
* cam
;
1184 This is the only safe way to prevent race conditions with
1187 if (!down_read_trylock(&et61x251_disconnect
))
1188 return -ERESTARTSYS
;
1190 cam
= video_get_drvdata(video_devdata(filp
));
1192 if (mutex_lock_interruptible(&cam
->dev_mutex
)) {
1193 up_read(&et61x251_disconnect
);
1194 return -ERESTARTSYS
;
1198 DBG(2, "Device /dev/video%d is busy...", cam
->v4ldev
->minor
);
1199 if ((filp
->f_flags
& O_NONBLOCK
) ||
1200 (filp
->f_flags
& O_NDELAY
)) {
1204 mutex_unlock(&cam
->dev_mutex
);
1205 err
= wait_event_interruptible_exclusive(cam
->open
,
1206 cam
->state
& DEV_DISCONNECTED
1209 up_read(&et61x251_disconnect
);
1212 if (cam
->state
& DEV_DISCONNECTED
) {
1213 up_read(&et61x251_disconnect
);
1216 mutex_lock(&cam
->dev_mutex
);
1220 if (cam
->state
& DEV_MISCONFIGURED
) {
1221 err
= et61x251_init(cam
);
1223 DBG(1, "Initialization failed again. "
1224 "I will retry on next open().");
1227 cam
->state
&= ~DEV_MISCONFIGURED
;
1230 if ((err
= et61x251_start_transfer(cam
)))
1233 filp
->private_data
= cam
;
1236 cam
->stream
= STREAM_OFF
;
1238 cam
->frame_count
= 0;
1239 et61x251_empty_framequeues(cam
);
1241 DBG(3, "Video device /dev/video%d is open", cam
->v4ldev
->minor
);
1244 mutex_unlock(&cam
->dev_mutex
);
1245 up_read(&et61x251_disconnect
);
1250 static int et61x251_release(struct inode
* inode
, struct file
* filp
)
1252 struct et61x251_device
* cam
= video_get_drvdata(video_devdata(filp
));
1254 mutex_lock(&cam
->dev_mutex
); /* prevent disconnect() to be called */
1256 et61x251_stop_transfer(cam
);
1258 et61x251_release_buffers(cam
);
1260 if (cam
->state
& DEV_DISCONNECTED
) {
1261 et61x251_release_resources(cam
);
1262 mutex_unlock(&cam
->dev_mutex
);
1268 wake_up_interruptible_nr(&cam
->open
, 1);
1270 DBG(3, "Video device /dev/video%d closed", cam
->v4ldev
->minor
);
1272 mutex_unlock(&cam
->dev_mutex
);
1279 et61x251_read(struct file
* filp
, char __user
* buf
,
1280 size_t count
, loff_t
* f_pos
)
1282 struct et61x251_device
* cam
= video_get_drvdata(video_devdata(filp
));
1283 struct et61x251_frame_t
* f
, * i
;
1284 unsigned long lock_flags
;
1288 if (mutex_lock_interruptible(&cam
->fileop_mutex
))
1289 return -ERESTARTSYS
;
1291 if (cam
->state
& DEV_DISCONNECTED
) {
1292 DBG(1, "Device not present");
1293 mutex_unlock(&cam
->fileop_mutex
);
1297 if (cam
->state
& DEV_MISCONFIGURED
) {
1298 DBG(1, "The camera is misconfigured. Close and open it "
1300 mutex_unlock(&cam
->fileop_mutex
);
1304 if (cam
->io
== IO_MMAP
) {
1305 DBG(3, "Close and open the device again to choose the read "
1307 mutex_unlock(&cam
->fileop_mutex
);
1311 if (cam
->io
== IO_NONE
) {
1312 if (!et61x251_request_buffers(cam
, cam
->nreadbuffers
,
1314 DBG(1, "read() failed, not enough memory");
1315 mutex_unlock(&cam
->fileop_mutex
);
1319 cam
->stream
= STREAM_ON
;
1322 if (list_empty(&cam
->inqueue
)) {
1323 if (!list_empty(&cam
->outqueue
))
1324 et61x251_empty_framequeues(cam
);
1325 et61x251_queue_unusedframes(cam
);
1329 mutex_unlock(&cam
->fileop_mutex
);
1333 if (list_empty(&cam
->outqueue
)) {
1334 if (filp
->f_flags
& O_NONBLOCK
) {
1335 mutex_unlock(&cam
->fileop_mutex
);
1338 timeout
= wait_event_interruptible_timeout
1340 (!list_empty(&cam
->outqueue
)) ||
1341 (cam
->state
& DEV_DISCONNECTED
) ||
1342 (cam
->state
& DEV_MISCONFIGURED
),
1343 cam
->module_param
.frame_timeout
*
1344 1000 * msecs_to_jiffies(1) );
1346 mutex_unlock(&cam
->fileop_mutex
);
1349 if (cam
->state
& DEV_DISCONNECTED
) {
1350 mutex_unlock(&cam
->fileop_mutex
);
1353 if (!timeout
|| (cam
->state
& DEV_MISCONFIGURED
)) {
1354 mutex_unlock(&cam
->fileop_mutex
);
1359 f
= list_entry(cam
->outqueue
.prev
, struct et61x251_frame_t
, frame
);
1361 if (count
> f
->buf
.bytesused
)
1362 count
= f
->buf
.bytesused
;
1364 if (copy_to_user(buf
, f
->bufmem
, count
)) {
1371 spin_lock_irqsave(&cam
->queue_lock
, lock_flags
);
1372 list_for_each_entry(i
, &cam
->outqueue
, frame
)
1373 i
->state
= F_UNUSED
;
1374 INIT_LIST_HEAD(&cam
->outqueue
);
1375 spin_unlock_irqrestore(&cam
->queue_lock
, lock_flags
);
1377 et61x251_queue_unusedframes(cam
);
1379 PDBGG("Frame #%lu, bytes read: %zu",
1380 (unsigned long)f
->buf
.index
, count
);
1382 mutex_unlock(&cam
->fileop_mutex
);
1384 return err
? err
: count
;
1388 static unsigned int et61x251_poll(struct file
*filp
, poll_table
*wait
)
1390 struct et61x251_device
* cam
= video_get_drvdata(video_devdata(filp
));
1391 struct et61x251_frame_t
* f
;
1392 unsigned long lock_flags
;
1393 unsigned int mask
= 0;
1395 if (mutex_lock_interruptible(&cam
->fileop_mutex
))
1398 if (cam
->state
& DEV_DISCONNECTED
) {
1399 DBG(1, "Device not present");
1403 if (cam
->state
& DEV_MISCONFIGURED
) {
1404 DBG(1, "The camera is misconfigured. Close and open it "
1409 if (cam
->io
== IO_NONE
) {
1410 if (!et61x251_request_buffers(cam
, cam
->nreadbuffers
,
1412 DBG(1, "poll() failed, not enough memory");
1416 cam
->stream
= STREAM_ON
;
1419 if (cam
->io
== IO_READ
) {
1420 spin_lock_irqsave(&cam
->queue_lock
, lock_flags
);
1421 list_for_each_entry(f
, &cam
->outqueue
, frame
)
1422 f
->state
= F_UNUSED
;
1423 INIT_LIST_HEAD(&cam
->outqueue
);
1424 spin_unlock_irqrestore(&cam
->queue_lock
, lock_flags
);
1425 et61x251_queue_unusedframes(cam
);
1428 poll_wait(filp
, &cam
->wait_frame
, wait
);
1430 if (!list_empty(&cam
->outqueue
))
1431 mask
|= POLLIN
| POLLRDNORM
;
1433 mutex_unlock(&cam
->fileop_mutex
);
1438 mutex_unlock(&cam
->fileop_mutex
);
1443 static void et61x251_vm_open(struct vm_area_struct
* vma
)
1445 struct et61x251_frame_t
* f
= vma
->vm_private_data
;
1450 static void et61x251_vm_close(struct vm_area_struct
* vma
)
1452 /* NOTE: buffers are not freed here */
1453 struct et61x251_frame_t
* f
= vma
->vm_private_data
;
1458 static struct vm_operations_struct et61x251_vm_ops
= {
1459 .open
= et61x251_vm_open
,
1460 .close
= et61x251_vm_close
,
1464 static int et61x251_mmap(struct file
* filp
, struct vm_area_struct
*vma
)
1466 struct et61x251_device
* cam
= video_get_drvdata(video_devdata(filp
));
1467 unsigned long size
= vma
->vm_end
- vma
->vm_start
,
1468 start
= vma
->vm_start
;
1472 if (mutex_lock_interruptible(&cam
->fileop_mutex
))
1473 return -ERESTARTSYS
;
1475 if (cam
->state
& DEV_DISCONNECTED
) {
1476 DBG(1, "Device not present");
1477 mutex_unlock(&cam
->fileop_mutex
);
1481 if (cam
->state
& DEV_MISCONFIGURED
) {
1482 DBG(1, "The camera is misconfigured. Close and open it "
1484 mutex_unlock(&cam
->fileop_mutex
);
1488 if (cam
->io
!= IO_MMAP
|| !(vma
->vm_flags
& VM_WRITE
) ||
1489 size
!= PAGE_ALIGN(cam
->frame
[0].buf
.length
)) {
1490 mutex_unlock(&cam
->fileop_mutex
);
1494 for (i
= 0; i
< cam
->nbuffers
; i
++) {
1495 if ((cam
->frame
[i
].buf
.m
.offset
>>PAGE_SHIFT
) == vma
->vm_pgoff
)
1498 if (i
== cam
->nbuffers
) {
1499 mutex_unlock(&cam
->fileop_mutex
);
1503 vma
->vm_flags
|= VM_IO
;
1504 vma
->vm_flags
|= VM_RESERVED
;
1506 pos
= cam
->frame
[i
].bufmem
;
1507 while (size
> 0) { /* size is page-aligned */
1508 if (vm_insert_page(vma
, start
, vmalloc_to_page(pos
))) {
1509 mutex_unlock(&cam
->fileop_mutex
);
1517 vma
->vm_ops
= &et61x251_vm_ops
;
1518 vma
->vm_private_data
= &cam
->frame
[i
];
1520 et61x251_vm_open(vma
);
1522 mutex_unlock(&cam
->fileop_mutex
);
1527 /*****************************************************************************/
1530 et61x251_vidioc_querycap(struct et61x251_device
* cam
, void __user
* arg
)
1532 struct v4l2_capability cap
= {
1533 .driver
= "et61x251",
1534 .version
= ET61X251_MODULE_VERSION_CODE
,
1535 .capabilities
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_READWRITE
|
1539 strlcpy(cap
.card
, cam
->v4ldev
->name
, sizeof(cap
.card
));
1540 if (usb_make_path(cam
->usbdev
, cap
.bus_info
, sizeof(cap
.bus_info
)) < 0)
1541 strlcpy(cap
.bus_info
, cam
->usbdev
->dev
.bus_id
,
1542 sizeof(cap
.bus_info
));
1544 if (copy_to_user(arg
, &cap
, sizeof(cap
)))
1552 et61x251_vidioc_enuminput(struct et61x251_device
* cam
, void __user
* arg
)
1554 struct v4l2_input i
;
1556 if (copy_from_user(&i
, arg
, sizeof(i
)))
1562 memset(&i
, 0, sizeof(i
));
1563 strcpy(i
.name
, "Camera");
1564 i
.type
= V4L2_INPUT_TYPE_CAMERA
;
1566 if (copy_to_user(arg
, &i
, sizeof(i
)))
1574 et61x251_vidioc_g_input(struct et61x251_device
* cam
, void __user
* arg
)
1578 if (copy_to_user(arg
, &index
, sizeof(index
)))
1586 et61x251_vidioc_s_input(struct et61x251_device
* cam
, void __user
* arg
)
1590 if (copy_from_user(&index
, arg
, sizeof(index
)))
1601 et61x251_vidioc_query_ctrl(struct et61x251_device
* cam
, void __user
* arg
)
1603 struct et61x251_sensor
* s
= &cam
->sensor
;
1604 struct v4l2_queryctrl qc
;
1607 if (copy_from_user(&qc
, arg
, sizeof(qc
)))
1610 for (i
= 0; i
< ARRAY_SIZE(s
->qctrl
); i
++)
1611 if (qc
.id
&& qc
.id
== s
->qctrl
[i
].id
) {
1612 memcpy(&qc
, &(s
->qctrl
[i
]), sizeof(qc
));
1613 if (copy_to_user(arg
, &qc
, sizeof(qc
)))
1623 et61x251_vidioc_g_ctrl(struct et61x251_device
* cam
, void __user
* arg
)
1625 struct et61x251_sensor
* s
= &cam
->sensor
;
1626 struct v4l2_control ctrl
;
1630 if (!s
->get_ctrl
&& !s
->set_ctrl
)
1633 if (copy_from_user(&ctrl
, arg
, sizeof(ctrl
)))
1637 for (i
= 0; i
< ARRAY_SIZE(s
->qctrl
); i
++)
1638 if (ctrl
.id
== s
->qctrl
[i
].id
) {
1639 ctrl
.value
= s
->_qctrl
[i
].default_value
;
1644 err
= s
->get_ctrl(cam
, &ctrl
);
1647 if (copy_to_user(arg
, &ctrl
, sizeof(ctrl
)))
1655 et61x251_vidioc_s_ctrl(struct et61x251_device
* cam
, void __user
* arg
)
1657 struct et61x251_sensor
* s
= &cam
->sensor
;
1658 struct v4l2_control ctrl
;
1665 if (copy_from_user(&ctrl
, arg
, sizeof(ctrl
)))
1668 for (i
= 0; i
< ARRAY_SIZE(s
->qctrl
); i
++)
1669 if (ctrl
.id
== s
->qctrl
[i
].id
) {
1670 if (s
->qctrl
[i
].flags
& V4L2_CTRL_FLAG_DISABLED
)
1672 if (ctrl
.value
< s
->qctrl
[i
].minimum
||
1673 ctrl
.value
> s
->qctrl
[i
].maximum
)
1675 ctrl
.value
-= ctrl
.value
% s
->qctrl
[i
].step
;
1679 if ((err
= s
->set_ctrl(cam
, &ctrl
)))
1682 s
->_qctrl
[i
].default_value
= ctrl
.value
;
1689 et61x251_vidioc_cropcap(struct et61x251_device
* cam
, void __user
* arg
)
1691 struct v4l2_cropcap
* cc
= &(cam
->sensor
.cropcap
);
1693 cc
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1694 cc
->pixelaspect
.numerator
= 1;
1695 cc
->pixelaspect
.denominator
= 1;
1697 if (copy_to_user(arg
, cc
, sizeof(*cc
)))
1705 et61x251_vidioc_g_crop(struct et61x251_device
* cam
, void __user
* arg
)
1707 struct et61x251_sensor
* s
= &cam
->sensor
;
1708 struct v4l2_crop crop
= {
1709 .type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
,
1712 memcpy(&(crop
.c
), &(s
->_rect
), sizeof(struct v4l2_rect
));
1714 if (copy_to_user(arg
, &crop
, sizeof(crop
)))
1722 et61x251_vidioc_s_crop(struct et61x251_device
* cam
, void __user
* arg
)
1724 struct et61x251_sensor
* s
= &cam
->sensor
;
1725 struct v4l2_crop crop
;
1726 struct v4l2_rect
* rect
;
1727 struct v4l2_rect
* bounds
= &(s
->cropcap
.bounds
);
1728 struct v4l2_pix_format
* pix_format
= &(s
->pix_format
);
1730 const enum et61x251_stream_state stream
= cam
->stream
;
1731 const u32 nbuffers
= cam
->nbuffers
;
1735 if (copy_from_user(&crop
, arg
, sizeof(crop
)))
1740 if (crop
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1743 if (cam
->module_param
.force_munmap
)
1744 for (i
= 0; i
< cam
->nbuffers
; i
++)
1745 if (cam
->frame
[i
].vma_use_count
) {
1746 DBG(3, "VIDIOC_S_CROP failed. "
1747 "Unmap the buffers first.");
1751 /* Preserve R,G or B origin */
1752 rect
->left
= (s
->_rect
.left
& 1L) ? rect
->left
| 1L : rect
->left
& ~1L;
1753 rect
->top
= (s
->_rect
.top
& 1L) ? rect
->top
| 1L : rect
->top
& ~1L;
1755 if (rect
->width
< 4)
1757 if (rect
->height
< 4)
1759 if (rect
->width
> bounds
->width
)
1760 rect
->width
= bounds
->width
;
1761 if (rect
->height
> bounds
->height
)
1762 rect
->height
= bounds
->height
;
1763 if (rect
->left
< bounds
->left
)
1764 rect
->left
= bounds
->left
;
1765 if (rect
->top
< bounds
->top
)
1766 rect
->top
= bounds
->top
;
1767 if (rect
->left
+ rect
->width
> bounds
->left
+ bounds
->width
)
1768 rect
->left
= bounds
->left
+bounds
->width
- rect
->width
;
1769 if (rect
->top
+ rect
->height
> bounds
->top
+ bounds
->height
)
1770 rect
->top
= bounds
->top
+bounds
->height
- rect
->height
;
1773 rect
->height
&= ~3L;
1775 if (ET61X251_PRESERVE_IMGSCALE
) {
1776 /* Calculate the actual scaling factor */
1778 a
= rect
->width
* rect
->height
;
1779 b
= pix_format
->width
* pix_format
->height
;
1780 scale
= b
? (u8
)((a
/ b
) < 4 ? 1 : 2) : 1;
1784 if (cam
->stream
== STREAM_ON
)
1785 if ((err
= et61x251_stream_interrupt(cam
)))
1788 if (copy_to_user(arg
, &crop
, sizeof(crop
))) {
1789 cam
->stream
= stream
;
1793 if (cam
->module_param
.force_munmap
|| cam
->io
== IO_READ
)
1794 et61x251_release_buffers(cam
);
1796 err
= et61x251_set_crop(cam
, rect
);
1798 err
+= s
->set_crop(cam
, rect
);
1799 err
+= et61x251_set_scale(cam
, scale
);
1801 if (err
) { /* atomic, no rollback in ioctl() */
1802 cam
->state
|= DEV_MISCONFIGURED
;
1803 DBG(1, "VIDIOC_S_CROP failed because of hardware problems. To "
1804 "use the camera, close and open /dev/video%d again.",
1805 cam
->v4ldev
->minor
);
1809 s
->pix_format
.width
= rect
->width
/scale
;
1810 s
->pix_format
.height
= rect
->height
/scale
;
1811 memcpy(&(s
->_rect
), rect
, sizeof(*rect
));
1813 if ((cam
->module_param
.force_munmap
|| cam
->io
== IO_READ
) &&
1814 nbuffers
!= et61x251_request_buffers(cam
, nbuffers
, cam
->io
)) {
1815 cam
->state
|= DEV_MISCONFIGURED
;
1816 DBG(1, "VIDIOC_S_CROP failed because of not enough memory. To "
1817 "use the camera, close and open /dev/video%d again.",
1818 cam
->v4ldev
->minor
);
1822 if (cam
->io
== IO_READ
)
1823 et61x251_empty_framequeues(cam
);
1824 else if (cam
->module_param
.force_munmap
)
1825 et61x251_requeue_outqueue(cam
);
1827 cam
->stream
= stream
;
1834 et61x251_vidioc_enum_fmt(struct et61x251_device
* cam
, void __user
* arg
)
1836 struct v4l2_fmtdesc fmtd
;
1838 if (copy_from_user(&fmtd
, arg
, sizeof(fmtd
)))
1841 if (fmtd
.index
== 0) {
1842 strcpy(fmtd
.description
, "bayer rgb");
1843 fmtd
.pixelformat
= V4L2_PIX_FMT_SBGGR8
;
1844 } else if (fmtd
.index
== 1) {
1845 strcpy(fmtd
.description
, "compressed");
1846 fmtd
.pixelformat
= V4L2_PIX_FMT_ET61X251
;
1847 fmtd
.flags
= V4L2_FMT_FLAG_COMPRESSED
;
1851 fmtd
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1852 memset(&fmtd
.reserved
, 0, sizeof(fmtd
.reserved
));
1854 if (copy_to_user(arg
, &fmtd
, sizeof(fmtd
)))
1862 et61x251_vidioc_g_fmt(struct et61x251_device
* cam
, void __user
* arg
)
1864 struct v4l2_format format
;
1865 struct v4l2_pix_format
* pfmt
= &(cam
->sensor
.pix_format
);
1867 if (copy_from_user(&format
, arg
, sizeof(format
)))
1870 if (format
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1873 pfmt
->bytesperline
= (pfmt
->pixelformat
==V4L2_PIX_FMT_ET61X251
)
1874 ? 0 : (pfmt
->width
* pfmt
->priv
) / 8;
1875 pfmt
->sizeimage
= pfmt
->height
* ((pfmt
->width
*pfmt
->priv
)/8);
1876 pfmt
->field
= V4L2_FIELD_NONE
;
1877 memcpy(&(format
.fmt
.pix
), pfmt
, sizeof(*pfmt
));
1879 if (copy_to_user(arg
, &format
, sizeof(format
)))
1887 et61x251_vidioc_try_s_fmt(struct et61x251_device
* cam
, unsigned int cmd
,
1890 struct et61x251_sensor
* s
= &cam
->sensor
;
1891 struct v4l2_format format
;
1892 struct v4l2_pix_format
* pix
;
1893 struct v4l2_pix_format
* pfmt
= &(s
->pix_format
);
1894 struct v4l2_rect
* bounds
= &(s
->cropcap
.bounds
);
1895 struct v4l2_rect rect
;
1897 const enum et61x251_stream_state stream
= cam
->stream
;
1898 const u32 nbuffers
= cam
->nbuffers
;
1902 if (copy_from_user(&format
, arg
, sizeof(format
)))
1905 pix
= &(format
.fmt
.pix
);
1907 if (format
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1910 memcpy(&rect
, &(s
->_rect
), sizeof(rect
));
1912 { /* calculate the actual scaling factor */
1914 a
= rect
.width
* rect
.height
;
1915 b
= pix
->width
* pix
->height
;
1916 scale
= b
? (u8
)((a
/ b
) < 4 ? 1 : 2) : 1;
1919 rect
.width
= scale
* pix
->width
;
1920 rect
.height
= scale
* pix
->height
;
1924 if (rect
.height
< 4)
1926 if (rect
.width
> bounds
->left
+ bounds
->width
- rect
.left
)
1927 rect
.width
= bounds
->left
+ bounds
->width
- rect
.left
;
1928 if (rect
.height
> bounds
->top
+ bounds
->height
- rect
.top
)
1929 rect
.height
= bounds
->top
+ bounds
->height
- rect
.top
;
1934 { /* adjust the scaling factor */
1936 a
= rect
.width
* rect
.height
;
1937 b
= pix
->width
* pix
->height
;
1938 scale
= b
? (u8
)((a
/ b
) < 4 ? 1 : 2) : 1;
1941 pix
->width
= rect
.width
/ scale
;
1942 pix
->height
= rect
.height
/ scale
;
1944 if (pix
->pixelformat
!= V4L2_PIX_FMT_ET61X251
&&
1945 pix
->pixelformat
!= V4L2_PIX_FMT_SBGGR8
)
1946 pix
->pixelformat
= pfmt
->pixelformat
;
1947 pix
->priv
= pfmt
->priv
; /* bpp */
1948 pix
->colorspace
= pfmt
->colorspace
;
1949 pix
->bytesperline
= (pix
->pixelformat
== V4L2_PIX_FMT_ET61X251
)
1950 ? 0 : (pix
->width
* pix
->priv
) / 8;
1951 pix
->sizeimage
= pix
->height
* ((pix
->width
* pix
->priv
) / 8);
1952 pix
->field
= V4L2_FIELD_NONE
;
1954 if (cmd
== VIDIOC_TRY_FMT
) {
1955 if (copy_to_user(arg
, &format
, sizeof(format
)))
1960 if (cam
->module_param
.force_munmap
)
1961 for (i
= 0; i
< cam
->nbuffers
; i
++)
1962 if (cam
->frame
[i
].vma_use_count
) {
1963 DBG(3, "VIDIOC_S_FMT failed. "
1964 "Unmap the buffers first.");
1968 if (cam
->stream
== STREAM_ON
)
1969 if ((err
= et61x251_stream_interrupt(cam
)))
1972 if (copy_to_user(arg
, &format
, sizeof(format
))) {
1973 cam
->stream
= stream
;
1977 if (cam
->module_param
.force_munmap
|| cam
->io
== IO_READ
)
1978 et61x251_release_buffers(cam
);
1980 err
+= et61x251_set_pix_format(cam
, pix
);
1981 err
+= et61x251_set_crop(cam
, &rect
);
1982 if (s
->set_pix_format
)
1983 err
+= s
->set_pix_format(cam
, pix
);
1985 err
+= s
->set_crop(cam
, &rect
);
1986 err
+= et61x251_set_scale(cam
, scale
);
1988 if (err
) { /* atomic, no rollback in ioctl() */
1989 cam
->state
|= DEV_MISCONFIGURED
;
1990 DBG(1, "VIDIOC_S_FMT failed because of hardware problems. To "
1991 "use the camera, close and open /dev/video%d again.",
1992 cam
->v4ldev
->minor
);
1996 memcpy(pfmt
, pix
, sizeof(*pix
));
1997 memcpy(&(s
->_rect
), &rect
, sizeof(rect
));
1999 if ((cam
->module_param
.force_munmap
|| cam
->io
== IO_READ
) &&
2000 nbuffers
!= et61x251_request_buffers(cam
, nbuffers
, cam
->io
)) {
2001 cam
->state
|= DEV_MISCONFIGURED
;
2002 DBG(1, "VIDIOC_S_FMT failed because of not enough memory. To "
2003 "use the camera, close and open /dev/video%d again.",
2004 cam
->v4ldev
->minor
);
2008 if (cam
->io
== IO_READ
)
2009 et61x251_empty_framequeues(cam
);
2010 else if (cam
->module_param
.force_munmap
)
2011 et61x251_requeue_outqueue(cam
);
2013 cam
->stream
= stream
;
2020 et61x251_vidioc_g_jpegcomp(struct et61x251_device
* cam
, void __user
* arg
)
2022 if (copy_to_user(arg
, &cam
->compression
,
2023 sizeof(cam
->compression
)))
2031 et61x251_vidioc_s_jpegcomp(struct et61x251_device
* cam
, void __user
* arg
)
2033 struct v4l2_jpegcompression jc
;
2034 const enum et61x251_stream_state stream
= cam
->stream
;
2037 if (copy_from_user(&jc
, arg
, sizeof(jc
)))
2040 if (jc
.quality
!= 0 && jc
.quality
!= 1)
2043 if (cam
->stream
== STREAM_ON
)
2044 if ((err
= et61x251_stream_interrupt(cam
)))
2047 err
+= et61x251_set_compression(cam
, &jc
);
2048 if (err
) { /* atomic, no rollback in ioctl() */
2049 cam
->state
|= DEV_MISCONFIGURED
;
2050 DBG(1, "VIDIOC_S_JPEGCOMP failed because of hardware "
2051 "problems. To use the camera, close and open "
2052 "/dev/video%d again.", cam
->v4ldev
->minor
);
2056 cam
->compression
.quality
= jc
.quality
;
2058 cam
->stream
= stream
;
2065 et61x251_vidioc_reqbufs(struct et61x251_device
* cam
, void __user
* arg
)
2067 struct v4l2_requestbuffers rb
;
2071 if (copy_from_user(&rb
, arg
, sizeof(rb
)))
2074 if (rb
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
2075 rb
.memory
!= V4L2_MEMORY_MMAP
)
2078 if (cam
->io
== IO_READ
) {
2079 DBG(3, "Close and open the device again to choose the mmap "
2084 for (i
= 0; i
< cam
->nbuffers
; i
++)
2085 if (cam
->frame
[i
].vma_use_count
) {
2086 DBG(3, "VIDIOC_REQBUFS failed. "
2087 "Previous buffers are still mapped.");
2091 if (cam
->stream
== STREAM_ON
)
2092 if ((err
= et61x251_stream_interrupt(cam
)))
2095 et61x251_empty_framequeues(cam
);
2097 et61x251_release_buffers(cam
);
2099 rb
.count
= et61x251_request_buffers(cam
, rb
.count
, IO_MMAP
);
2101 if (copy_to_user(arg
, &rb
, sizeof(rb
))) {
2102 et61x251_release_buffers(cam
);
2107 cam
->io
= rb
.count
? IO_MMAP
: IO_NONE
;
2114 et61x251_vidioc_querybuf(struct et61x251_device
* cam
, void __user
* arg
)
2116 struct v4l2_buffer b
;
2118 if (copy_from_user(&b
, arg
, sizeof(b
)))
2121 if (b
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
2122 b
.index
>= cam
->nbuffers
|| cam
->io
!= IO_MMAP
)
2125 memcpy(&b
, &cam
->frame
[b
.index
].buf
, sizeof(b
));
2127 if (cam
->frame
[b
.index
].vma_use_count
)
2128 b
.flags
|= V4L2_BUF_FLAG_MAPPED
;
2130 if (cam
->frame
[b
.index
].state
== F_DONE
)
2131 b
.flags
|= V4L2_BUF_FLAG_DONE
;
2132 else if (cam
->frame
[b
.index
].state
!= F_UNUSED
)
2133 b
.flags
|= V4L2_BUF_FLAG_QUEUED
;
2135 if (copy_to_user(arg
, &b
, sizeof(b
)))
2143 et61x251_vidioc_qbuf(struct et61x251_device
* cam
, void __user
* arg
)
2145 struct v4l2_buffer b
;
2146 unsigned long lock_flags
;
2148 if (copy_from_user(&b
, arg
, sizeof(b
)))
2151 if (b
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
2152 b
.index
>= cam
->nbuffers
|| cam
->io
!= IO_MMAP
)
2155 if (cam
->frame
[b
.index
].state
!= F_UNUSED
)
2158 cam
->frame
[b
.index
].state
= F_QUEUED
;
2160 spin_lock_irqsave(&cam
->queue_lock
, lock_flags
);
2161 list_add_tail(&cam
->frame
[b
.index
].frame
, &cam
->inqueue
);
2162 spin_unlock_irqrestore(&cam
->queue_lock
, lock_flags
);
2164 PDBGG("Frame #%lu queued", (unsigned long)b
.index
);
2171 et61x251_vidioc_dqbuf(struct et61x251_device
* cam
, struct file
* filp
,
2174 struct v4l2_buffer b
;
2175 struct et61x251_frame_t
*f
;
2176 unsigned long lock_flags
;
2179 if (copy_from_user(&b
, arg
, sizeof(b
)))
2182 if (b
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
|| cam
->io
!= IO_MMAP
)
2185 if (list_empty(&cam
->outqueue
)) {
2186 if (cam
->stream
== STREAM_OFF
)
2188 if (filp
->f_flags
& O_NONBLOCK
)
2190 timeout
= wait_event_interruptible_timeout
2192 (!list_empty(&cam
->outqueue
)) ||
2193 (cam
->state
& DEV_DISCONNECTED
) ||
2194 (cam
->state
& DEV_MISCONFIGURED
),
2195 cam
->module_param
.frame_timeout
*
2196 1000 * msecs_to_jiffies(1) );
2199 if (cam
->state
& DEV_DISCONNECTED
)
2201 if (!timeout
|| (cam
->state
& DEV_MISCONFIGURED
))
2205 spin_lock_irqsave(&cam
->queue_lock
, lock_flags
);
2206 f
= list_entry(cam
->outqueue
.next
, struct et61x251_frame_t
, frame
);
2207 list_del(cam
->outqueue
.next
);
2208 spin_unlock_irqrestore(&cam
->queue_lock
, lock_flags
);
2210 f
->state
= F_UNUSED
;
2212 memcpy(&b
, &f
->buf
, sizeof(b
));
2213 if (f
->vma_use_count
)
2214 b
.flags
|= V4L2_BUF_FLAG_MAPPED
;
2216 if (copy_to_user(arg
, &b
, sizeof(b
)))
2219 PDBGG("Frame #%lu dequeued", (unsigned long)f
->buf
.index
);
2226 et61x251_vidioc_streamon(struct et61x251_device
* cam
, void __user
* arg
)
2230 if (copy_from_user(&type
, arg
, sizeof(type
)))
2233 if (type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
|| cam
->io
!= IO_MMAP
)
2236 if (list_empty(&cam
->inqueue
))
2239 cam
->stream
= STREAM_ON
;
2241 DBG(3, "Stream on");
2248 et61x251_vidioc_streamoff(struct et61x251_device
* cam
, void __user
* arg
)
2252 if (copy_from_user(&type
, arg
, sizeof(type
)))
2255 if (type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
|| cam
->io
!= IO_MMAP
)
2258 if (cam
->stream
== STREAM_ON
)
2259 if ((err
= et61x251_stream_interrupt(cam
)))
2262 et61x251_empty_framequeues(cam
);
2264 DBG(3, "Stream off");
2271 et61x251_vidioc_g_parm(struct et61x251_device
* cam
, void __user
* arg
)
2273 struct v4l2_streamparm sp
;
2275 if (copy_from_user(&sp
, arg
, sizeof(sp
)))
2278 if (sp
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
2281 sp
.parm
.capture
.extendedmode
= 0;
2282 sp
.parm
.capture
.readbuffers
= cam
->nreadbuffers
;
2284 if (copy_to_user(arg
, &sp
, sizeof(sp
)))
2292 et61x251_vidioc_s_parm(struct et61x251_device
* cam
, void __user
* arg
)
2294 struct v4l2_streamparm sp
;
2296 if (copy_from_user(&sp
, arg
, sizeof(sp
)))
2299 if (sp
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
2302 sp
.parm
.capture
.extendedmode
= 0;
2304 if (sp
.parm
.capture
.readbuffers
== 0)
2305 sp
.parm
.capture
.readbuffers
= cam
->nreadbuffers
;
2307 if (sp
.parm
.capture
.readbuffers
> ET61X251_MAX_FRAMES
)
2308 sp
.parm
.capture
.readbuffers
= ET61X251_MAX_FRAMES
;
2310 if (copy_to_user(arg
, &sp
, sizeof(sp
)))
2313 cam
->nreadbuffers
= sp
.parm
.capture
.readbuffers
;
2319 static int et61x251_ioctl_v4l2(struct inode
* inode
, struct file
* filp
,
2320 unsigned int cmd
, void __user
* arg
)
2322 struct et61x251_device
* cam
= video_get_drvdata(video_devdata(filp
));
2326 case VIDIOC_QUERYCAP
:
2327 return et61x251_vidioc_querycap(cam
, arg
);
2329 case VIDIOC_ENUMINPUT
:
2330 return et61x251_vidioc_enuminput(cam
, arg
);
2332 case VIDIOC_G_INPUT
:
2333 return et61x251_vidioc_g_input(cam
, arg
);
2335 case VIDIOC_S_INPUT
:
2336 return et61x251_vidioc_s_input(cam
, arg
);
2338 case VIDIOC_QUERYCTRL
:
2339 return et61x251_vidioc_query_ctrl(cam
, arg
);
2342 return et61x251_vidioc_g_ctrl(cam
, arg
);
2345 return et61x251_vidioc_s_ctrl(cam
, arg
);
2347 case VIDIOC_CROPCAP
:
2348 return et61x251_vidioc_cropcap(cam
, arg
);
2351 return et61x251_vidioc_g_crop(cam
, arg
);
2354 return et61x251_vidioc_s_crop(cam
, arg
);
2356 case VIDIOC_ENUM_FMT
:
2357 return et61x251_vidioc_enum_fmt(cam
, arg
);
2360 return et61x251_vidioc_g_fmt(cam
, arg
);
2362 case VIDIOC_TRY_FMT
:
2364 return et61x251_vidioc_try_s_fmt(cam
, cmd
, arg
);
2366 case VIDIOC_G_JPEGCOMP
:
2367 return et61x251_vidioc_g_jpegcomp(cam
, arg
);
2369 case VIDIOC_S_JPEGCOMP
:
2370 return et61x251_vidioc_s_jpegcomp(cam
, arg
);
2372 case VIDIOC_REQBUFS
:
2373 return et61x251_vidioc_reqbufs(cam
, arg
);
2375 case VIDIOC_QUERYBUF
:
2376 return et61x251_vidioc_querybuf(cam
, arg
);
2379 return et61x251_vidioc_qbuf(cam
, arg
);
2382 return et61x251_vidioc_dqbuf(cam
, filp
, arg
);
2384 case VIDIOC_STREAMON
:
2385 return et61x251_vidioc_streamon(cam
, arg
);
2387 case VIDIOC_STREAMOFF
:
2388 return et61x251_vidioc_streamoff(cam
, arg
);
2391 return et61x251_vidioc_g_parm(cam
, arg
);
2394 return et61x251_vidioc_s_parm(cam
, arg
);
2398 case VIDIOC_QUERYSTD
:
2399 case VIDIOC_ENUMSTD
:
2400 case VIDIOC_QUERYMENU
:
2410 static int et61x251_ioctl(struct inode
* inode
, struct file
* filp
,
2411 unsigned int cmd
, unsigned long arg
)
2413 struct et61x251_device
* cam
= video_get_drvdata(video_devdata(filp
));
2416 if (mutex_lock_interruptible(&cam
->fileop_mutex
))
2417 return -ERESTARTSYS
;
2419 if (cam
->state
& DEV_DISCONNECTED
) {
2420 DBG(1, "Device not present");
2421 mutex_unlock(&cam
->fileop_mutex
);
2425 if (cam
->state
& DEV_MISCONFIGURED
) {
2426 DBG(1, "The camera is misconfigured. Close and open it "
2428 mutex_unlock(&cam
->fileop_mutex
);
2432 V4LDBG(3, "et61x251", cmd
);
2434 err
= et61x251_ioctl_v4l2(inode
, filp
, cmd
, (void __user
*)arg
);
2436 mutex_unlock(&cam
->fileop_mutex
);
2442 static struct file_operations et61x251_fops
= {
2443 .owner
= THIS_MODULE
,
2444 .open
= et61x251_open
,
2445 .release
= et61x251_release
,
2446 .ioctl
= et61x251_ioctl
,
2447 .read
= et61x251_read
,
2448 .poll
= et61x251_poll
,
2449 .mmap
= et61x251_mmap
,
2450 .llseek
= no_llseek
,
2453 /*****************************************************************************/
2455 /* It exists a single interface only. We do not need to validate anything. */
2457 et61x251_usb_probe(struct usb_interface
* intf
, const struct usb_device_id
* id
)
2459 struct usb_device
*udev
= interface_to_usbdev(intf
);
2460 struct et61x251_device
* cam
;
2461 static unsigned int dev_nr
= 0;
2465 if (!(cam
= kzalloc(sizeof(struct et61x251_device
), GFP_KERNEL
)))
2470 if (!(cam
->control_buffer
= kzalloc(8, GFP_KERNEL
))) {
2471 DBG(1, "kmalloc() failed");
2476 if (!(cam
->v4ldev
= video_device_alloc())) {
2477 DBG(1, "video_device_alloc() failed");
2482 mutex_init(&cam
->dev_mutex
);
2484 DBG(2, "ET61X[12]51 PC Camera Controller detected "
2485 "(vid/pid 0x%04X/0x%04X)",id
->idVendor
, id
->idProduct
);
2487 for (i
= 0; et61x251_sensor_table
[i
]; i
++) {
2488 err
= et61x251_sensor_table
[i
](cam
);
2494 DBG(2, "%s image sensor detected", cam
->sensor
.name
);
2496 DBG(1, "No supported image sensor detected");
2501 if (et61x251_init(cam
)) {
2502 DBG(1, "Initialization failed. I will retry on open().");
2503 cam
->state
|= DEV_MISCONFIGURED
;
2506 strcpy(cam
->v4ldev
->name
, "ET61X[12]51 PC Camera");
2507 cam
->v4ldev
->owner
= THIS_MODULE
;
2508 cam
->v4ldev
->type
= VID_TYPE_CAPTURE
| VID_TYPE_SCALES
;
2509 cam
->v4ldev
->hardware
= 0;
2510 cam
->v4ldev
->fops
= &et61x251_fops
;
2511 cam
->v4ldev
->minor
= video_nr
[dev_nr
];
2512 cam
->v4ldev
->release
= video_device_release
;
2513 video_set_drvdata(cam
->v4ldev
, cam
);
2515 mutex_lock(&cam
->dev_mutex
);
2517 err
= video_register_device(cam
->v4ldev
, VFL_TYPE_GRABBER
,
2520 DBG(1, "V4L2 device registration failed");
2521 if (err
== -ENFILE
&& video_nr
[dev_nr
] == -1)
2522 DBG(1, "Free /dev/videoX node not found");
2523 video_nr
[dev_nr
] = -1;
2524 dev_nr
= (dev_nr
< ET61X251_MAX_DEVICES
-1) ? dev_nr
+1 : 0;
2525 mutex_unlock(&cam
->dev_mutex
);
2529 DBG(2, "V4L2 device registered as /dev/video%d", cam
->v4ldev
->minor
);
2531 cam
->module_param
.force_munmap
= force_munmap
[dev_nr
];
2532 cam
->module_param
.frame_timeout
= frame_timeout
[dev_nr
];
2534 dev_nr
= (dev_nr
< ET61X251_MAX_DEVICES
-1) ? dev_nr
+1 : 0;
2536 #ifdef CONFIG_VIDEO_ADV_DEBUG
2537 et61x251_create_sysfs(cam
);
2538 DBG(2, "Optional device control through 'sysfs' interface ready");
2541 usb_set_intfdata(intf
, cam
);
2543 mutex_unlock(&cam
->dev_mutex
);
2549 kfree(cam
->control_buffer
);
2551 video_device_release(cam
->v4ldev
);
2558 static void et61x251_usb_disconnect(struct usb_interface
* intf
)
2560 struct et61x251_device
* cam
= usb_get_intfdata(intf
);
2565 down_write(&et61x251_disconnect
);
2567 mutex_lock(&cam
->dev_mutex
);
2569 DBG(2, "Disconnecting %s...", cam
->v4ldev
->name
);
2571 wake_up_interruptible_all(&cam
->open
);
2574 DBG(2, "Device /dev/video%d is open! Deregistration and "
2575 "memory deallocation are deferred on close.",
2576 cam
->v4ldev
->minor
);
2577 cam
->state
|= DEV_MISCONFIGURED
;
2578 et61x251_stop_transfer(cam
);
2579 cam
->state
|= DEV_DISCONNECTED
;
2580 wake_up_interruptible(&cam
->wait_frame
);
2581 wake_up(&cam
->wait_stream
);
2582 usb_get_dev(cam
->usbdev
);
2584 cam
->state
|= DEV_DISCONNECTED
;
2585 et61x251_release_resources(cam
);
2588 mutex_unlock(&cam
->dev_mutex
);
2593 up_write(&et61x251_disconnect
);
2597 static struct usb_driver et61x251_usb_driver
= {
2599 .id_table
= et61x251_id_table
,
2600 .probe
= et61x251_usb_probe
,
2601 .disconnect
= et61x251_usb_disconnect
,
2604 /*****************************************************************************/
2606 static int __init
et61x251_module_init(void)
2610 KDBG(2, ET61X251_MODULE_NAME
" v" ET61X251_MODULE_VERSION
);
2611 KDBG(3, ET61X251_MODULE_AUTHOR
);
2613 if ((err
= usb_register(&et61x251_usb_driver
)))
2614 KDBG(1, "usb_register() failed");
2620 static void __exit
et61x251_module_exit(void)
2622 usb_deregister(&et61x251_usb_driver
);
2626 module_init(et61x251_module_init
);
2627 module_exit(et61x251_module_exit
);