1 /***************************************************************************
2 * V4L2 driver for ET61X[12]51 PC Camera Controllers *
4 * Copyright (C) 2006-2007 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/errno.h>
26 #include <linux/slab.h>
27 #include <linux/device.h>
29 #include <linux/delay.h>
30 #include <linux/compiler.h>
31 #include <linux/ioctl.h>
32 #include <linux/poll.h>
33 #include <linux/stat.h>
35 #include <linux/vmalloc.h>
36 #include <linux/page-flags.h>
37 #include <media/v4l2-ioctl.h>
38 #include <asm/byteorder.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-2007 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.09"
52 #define ET61X251_MODULE_VERSION_CODE KERNEL_VERSION(1, 1, 9)
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(ET61X251_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_user(cam
->nbuffers
*
137 PAGE_ALIGN(imagesize
))))
142 for (i
= 0; i
< cam
->nbuffers
; i
++) {
143 cam
->frame
[i
].bufmem
= buff
+ i
*PAGE_ALIGN(imagesize
);
144 cam
->frame
[i
].buf
.index
= i
;
145 cam
->frame
[i
].buf
.m
.offset
= i
*PAGE_ALIGN(imagesize
);
146 cam
->frame
[i
].buf
.length
= imagesize
;
147 cam
->frame
[i
].buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
148 cam
->frame
[i
].buf
.sequence
= 0;
149 cam
->frame
[i
].buf
.field
= V4L2_FIELD_NONE
;
150 cam
->frame
[i
].buf
.memory
= V4L2_MEMORY_MMAP
;
151 cam
->frame
[i
].buf
.flags
= 0;
154 return cam
->nbuffers
;
158 static void et61x251_release_buffers(struct et61x251_device
* cam
)
161 vfree(cam
->frame
[0].bufmem
);
164 cam
->frame_current
= NULL
;
168 static void et61x251_empty_framequeues(struct et61x251_device
* cam
)
172 INIT_LIST_HEAD(&cam
->inqueue
);
173 INIT_LIST_HEAD(&cam
->outqueue
);
175 for (i
= 0; i
< ET61X251_MAX_FRAMES
; i
++) {
176 cam
->frame
[i
].state
= F_UNUSED
;
177 cam
->frame
[i
].buf
.bytesused
= 0;
182 static void et61x251_requeue_outqueue(struct et61x251_device
* cam
)
184 struct et61x251_frame_t
*i
;
186 list_for_each_entry(i
, &cam
->outqueue
, frame
) {
188 list_add(&i
->frame
, &cam
->inqueue
);
191 INIT_LIST_HEAD(&cam
->outqueue
);
195 static void et61x251_queue_unusedframes(struct et61x251_device
* cam
)
197 unsigned long lock_flags
;
200 for (i
= 0; i
< cam
->nbuffers
; i
++)
201 if (cam
->frame
[i
].state
== F_UNUSED
) {
202 cam
->frame
[i
].state
= F_QUEUED
;
203 spin_lock_irqsave(&cam
->queue_lock
, lock_flags
);
204 list_add_tail(&cam
->frame
[i
].frame
, &cam
->inqueue
);
205 spin_unlock_irqrestore(&cam
->queue_lock
, lock_flags
);
209 /*****************************************************************************/
211 int et61x251_write_reg(struct et61x251_device
* cam
, u8 value
, u16 index
)
213 struct usb_device
* udev
= cam
->usbdev
;
214 u8
* buff
= cam
->control_buffer
;
219 res
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x00, 0x41,
220 0, index
, buff
, 1, ET61X251_CTRL_TIMEOUT
);
222 DBG(3, "Failed to write a register (value 0x%02X, index "
223 "0x%02X, error %d)", value
, index
, res
);
231 static int et61x251_read_reg(struct et61x251_device
* cam
, u16 index
)
233 struct usb_device
* udev
= cam
->usbdev
;
234 u8
* buff
= cam
->control_buffer
;
237 res
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0), 0x00, 0xc1,
238 0, index
, buff
, 1, ET61X251_CTRL_TIMEOUT
);
240 DBG(3, "Failed to read a register (index 0x%02X, error %d)",
243 return (res
>= 0) ? (int)(*buff
) : -1;
248 et61x251_i2c_wait(struct et61x251_device
* cam
,
249 const struct et61x251_sensor
* sensor
)
253 for (i
= 1; i
<= 8; i
++) {
254 if (sensor
->interface
== ET61X251_I2C_3WIRES
) {
255 r
= et61x251_read_reg(cam
, 0x8e);
256 if (!(r
& 0x02) && (r
>= 0))
259 r
= et61x251_read_reg(cam
, 0x8b);
260 if (!(r
& 0x01) && (r
>= 0))
265 udelay(8*8); /* minimum for sensors at 400kHz */
273 et61x251_i2c_raw_write(struct et61x251_device
* cam
, u8 n
, u8 data1
, u8 data2
,
274 u8 data3
, u8 data4
, u8 data5
, u8 data6
, u8 data7
,
275 u8 data8
, u8 address
)
277 struct usb_device
* udev
= cam
->usbdev
;
278 u8
* data
= cam
->control_buffer
;
288 res
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x00, 0x41,
289 0, 0x81, data
, n
-1, ET61X251_CTRL_TIMEOUT
);
294 data
[1] = cam
->sensor
.i2c_slave_id
;
295 data
[2] = cam
->sensor
.rsta
| 0x02 | (n
<< 4);
296 res
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x00, 0x41,
297 0, 0x88, data
, 3, ET61X251_CTRL_TIMEOUT
);
301 /* Start writing through the serial interface */
303 res
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x00, 0x41,
304 0, 0x80, data
, 1, ET61X251_CTRL_TIMEOUT
);
308 err
+= et61x251_i2c_wait(cam
, &cam
->sensor
);
311 DBG(3, "I2C raw write failed for %s image sensor",
314 PDBGG("I2C raw write: %u bytes, address = 0x%02X, data1 = 0x%02X, "
315 "data2 = 0x%02X, data3 = 0x%02X, data4 = 0x%02X, data5 = 0x%02X,"
316 " data6 = 0x%02X, data7 = 0x%02X, data8 = 0x%02X", n
, address
,
317 data1
, data2
, data3
, data4
, data5
, data6
, data7
, data8
);
324 /*****************************************************************************/
326 static void et61x251_urb_complete(struct urb
*urb
)
328 struct et61x251_device
* cam
= urb
->context
;
329 struct et61x251_frame_t
** f
;
334 if (urb
->status
== -ENOENT
)
337 f
= &cam
->frame_current
;
339 if (cam
->stream
== STREAM_INTERRUPT
) {
340 cam
->stream
= STREAM_OFF
;
342 (*f
)->state
= F_QUEUED
;
343 DBG(3, "Stream interrupted");
344 wake_up(&cam
->wait_stream
);
347 if (cam
->state
& DEV_DISCONNECTED
)
350 if (cam
->state
& DEV_MISCONFIGURED
) {
351 wake_up_interruptible(&cam
->wait_frame
);
355 if (cam
->stream
== STREAM_OFF
|| list_empty(&cam
->inqueue
))
359 (*f
) = list_entry(cam
->inqueue
.next
, struct et61x251_frame_t
,
362 imagesize
= (cam
->sensor
.pix_format
.width
*
363 cam
->sensor
.pix_format
.height
*
364 cam
->sensor
.pix_format
.priv
) / 8;
366 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
367 unsigned int len
, status
;
370 const u8 VOID_BYTES
= 6;
373 len
= urb
->iso_frame_desc
[i
].actual_length
;
374 status
= urb
->iso_frame_desc
[i
].status
;
375 pos
= urb
->iso_frame_desc
[i
].offset
+ urb
->transfer_buffer
;
378 DBG(3, "Error in isochronous frame");
379 (*f
)->state
= F_ERROR
;
385 sof
= ((*b1
& 0x3f) == 63);
386 imglen
= ((*b1
& 0xc0) << 2) | *b2
;
388 PDBGG("Isochrnous frame: length %u, #%u i, image length %zu",
391 if ((*f
)->state
== F_QUEUED
|| (*f
)->state
== F_ERROR
)
394 (*f
)->state
= F_GRABBING
;
395 (*f
)->buf
.bytesused
= 0;
396 do_gettimeofday(&(*f
)->buf
.timestamp
);
398 DBG(3, "SOF detected: new video frame");
401 if ((*f
)->state
== F_GRABBING
) {
402 if (sof
&& (*f
)->buf
.bytesused
) {
403 if (cam
->sensor
.pix_format
.pixelformat
==
404 V4L2_PIX_FMT_ET61X251
)
407 DBG(3, "Not expected SOF detected "
409 (unsigned long)(*f
)->buf
.bytesused
);
410 (*f
)->state
= F_ERROR
;
415 if ((*f
)->buf
.bytesused
+ imglen
> imagesize
) {
416 DBG(3, "Video frame size exceeded");
417 (*f
)->state
= F_ERROR
;
423 memcpy((*f
)->bufmem
+(*f
)->buf
.bytesused
, pos
, imglen
);
424 (*f
)->buf
.bytesused
+= imglen
;
426 if ((*f
)->buf
.bytesused
== imagesize
) {
429 b
= (*f
)->buf
.bytesused
;
430 (*f
)->state
= F_DONE
;
431 (*f
)->buf
.sequence
= ++cam
->frame_count
;
432 spin_lock(&cam
->queue_lock
);
433 list_move_tail(&(*f
)->frame
, &cam
->outqueue
);
434 if (!list_empty(&cam
->inqueue
))
435 (*f
) = list_entry(cam
->inqueue
.next
,
436 struct et61x251_frame_t
,
440 spin_unlock(&cam
->queue_lock
);
441 DBG(3, "Video frame captured: : %lu bytes",
448 cam
->sensor
.pix_format
.pixelformat
==
449 V4L2_PIX_FMT_ET61X251
)
456 urb
->dev
= cam
->usbdev
;
457 err
= usb_submit_urb(urb
, GFP_ATOMIC
);
458 if (err
< 0 && err
!= -EPERM
) {
459 cam
->state
|= DEV_MISCONFIGURED
;
460 DBG(1, "usb_submit_urb() failed");
463 wake_up_interruptible(&cam
->wait_frame
);
467 static int et61x251_start_transfer(struct et61x251_device
* cam
)
469 struct usb_device
*udev
= cam
->usbdev
;
471 struct usb_host_interface
* altsetting
= usb_altnum_to_altsetting(
472 usb_ifnum_to_if(udev
, 0),
473 ET61X251_ALTERNATE_SETTING
);
474 const unsigned int psz
= le16_to_cpu(altsetting
->
475 endpoint
[0].desc
.wMaxPacketSize
);
479 for (i
= 0; i
< ET61X251_URBS
; i
++) {
480 cam
->transfer_buffer
[i
] = kzalloc(ET61X251_ISO_PACKETS
* psz
,
482 if (!cam
->transfer_buffer
[i
]) {
484 DBG(1, "Not enough memory");
489 for (i
= 0; i
< ET61X251_URBS
; i
++) {
490 urb
= usb_alloc_urb(ET61X251_ISO_PACKETS
, GFP_KERNEL
);
494 DBG(1, "usb_alloc_urb() failed");
499 urb
->pipe
= usb_rcvisocpipe(udev
, 1);
500 urb
->transfer_flags
= URB_ISO_ASAP
;
501 urb
->number_of_packets
= ET61X251_ISO_PACKETS
;
502 urb
->complete
= et61x251_urb_complete
;
503 urb
->transfer_buffer
= cam
->transfer_buffer
[i
];
504 urb
->transfer_buffer_length
= psz
* ET61X251_ISO_PACKETS
;
506 for (j
= 0; j
< ET61X251_ISO_PACKETS
; j
++) {
507 urb
->iso_frame_desc
[j
].offset
= psz
* j
;
508 urb
->iso_frame_desc
[j
].length
= psz
;
512 err
= et61x251_write_reg(cam
, 0x01, 0x03);
513 err
= et61x251_write_reg(cam
, 0x00, 0x03);
514 err
= et61x251_write_reg(cam
, 0x08, 0x03);
517 DBG(1, "I/O hardware error");
521 err
= usb_set_interface(udev
, 0, ET61X251_ALTERNATE_SETTING
);
523 DBG(1, "usb_set_interface() failed");
527 cam
->frame_current
= NULL
;
529 for (i
= 0; i
< ET61X251_URBS
; i
++) {
530 err
= usb_submit_urb(cam
->urb
[i
], GFP_KERNEL
);
532 for (j
= i
-1; j
>= 0; j
--)
533 usb_kill_urb(cam
->urb
[j
]);
534 DBG(1, "usb_submit_urb() failed, error %d", err
);
542 for (i
= 0; (i
< ET61X251_URBS
) && cam
->urb
[i
]; i
++)
543 usb_free_urb(cam
->urb
[i
]);
546 for (i
= 0; (i
< ET61X251_URBS
) && cam
->transfer_buffer
[i
]; i
++)
547 kfree(cam
->transfer_buffer
[i
]);
553 static int et61x251_stop_transfer(struct et61x251_device
* cam
)
555 struct usb_device
*udev
= cam
->usbdev
;
559 if (cam
->state
& DEV_DISCONNECTED
)
562 for (i
= ET61X251_URBS
-1; i
>= 0; i
--) {
563 usb_kill_urb(cam
->urb
[i
]);
564 usb_free_urb(cam
->urb
[i
]);
565 kfree(cam
->transfer_buffer
[i
]);
568 err
= usb_set_interface(udev
, 0, 0); /* 0 Mb/s */
570 DBG(3, "usb_set_interface() failed");
576 static int et61x251_stream_interrupt(struct et61x251_device
* cam
)
580 cam
->stream
= STREAM_INTERRUPT
;
581 timeout
= wait_event_timeout(cam
->wait_stream
,
582 (cam
->stream
== STREAM_OFF
) ||
583 (cam
->state
& DEV_DISCONNECTED
),
584 ET61X251_URB_TIMEOUT
);
585 if (cam
->state
& DEV_DISCONNECTED
)
587 else if (cam
->stream
!= STREAM_OFF
) {
588 cam
->state
|= DEV_MISCONFIGURED
;
589 DBG(1, "URB timeout reached. The camera is misconfigured. To "
590 "use it, close and open %s again.",
591 video_device_node_name(cam
->v4ldev
));
598 /*****************************************************************************/
600 #ifdef CONFIG_VIDEO_ADV_DEBUG
602 static int et61x251_i2c_try_read(struct et61x251_device
* cam
,
603 const struct et61x251_sensor
* sensor
,
606 struct usb_device
* udev
= cam
->usbdev
;
607 u8
* data
= cam
->control_buffer
;
611 data
[1] = cam
->sensor
.i2c_slave_id
;
612 data
[2] = cam
->sensor
.rsta
| 0x10;
613 data
[3] = !(et61x251_read_reg(cam
, 0x8b) & 0x02);
614 res
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x00, 0x41,
615 0, 0x88, data
, 4, ET61X251_CTRL_TIMEOUT
);
619 err
+= et61x251_i2c_wait(cam
, sensor
);
621 res
= usb_control_msg(udev
, usb_rcvctrlpipe(udev
, 0), 0x00, 0xc1,
622 0, 0x80, data
, 8, ET61X251_CTRL_TIMEOUT
);
627 DBG(3, "I2C read failed for %s image sensor", sensor
->name
);
629 PDBGG("I2C read: address 0x%02X, value: 0x%02X", address
, data
[0]);
631 return err
? -1 : (int)data
[0];
635 static int et61x251_i2c_try_write(struct et61x251_device
* cam
,
636 const struct et61x251_sensor
* sensor
,
637 u8 address
, u8 value
)
639 struct usb_device
* udev
= cam
->usbdev
;
640 u8
* data
= cam
->control_buffer
;
644 data
[1] = cam
->sensor
.i2c_slave_id
;
645 data
[2] = cam
->sensor
.rsta
| 0x12;
646 res
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x00, 0x41,
647 0, 0x88, data
, 3, ET61X251_CTRL_TIMEOUT
);
652 res
= usb_control_msg(udev
, usb_sndctrlpipe(udev
, 0), 0x00, 0x41,
653 0, 0x80, data
, 1, ET61X251_CTRL_TIMEOUT
);
657 err
+= et61x251_i2c_wait(cam
, sensor
);
660 DBG(3, "I2C write failed for %s image sensor", sensor
->name
);
662 PDBGG("I2C write: address 0x%02X, value: 0x%02X", address
, value
);
667 static int et61x251_i2c_read(struct et61x251_device
* cam
, u8 address
)
669 return et61x251_i2c_try_read(cam
, &cam
->sensor
, address
);
672 static int et61x251_i2c_write(struct et61x251_device
* cam
,
673 u8 address
, u8 value
)
675 return et61x251_i2c_try_write(cam
, &cam
->sensor
, address
, value
);
678 static u8
et61x251_strtou8(const char* buff
, size_t len
, ssize_t
* count
)
685 strncpy(str
, buff
, len
);
688 strncpy(str
, buff
, 4);
692 val
= simple_strtoul(str
, &endp
, 0);
696 *count
= (ssize_t
)(endp
- str
);
697 if ((*count
) && (len
== *count
+1) && (buff
[*count
] == '\n'))
704 NOTE 1: being inside one of the following methods implies that the v4l
705 device exists for sure (see kobjects and reference counters)
706 NOTE 2: buffers are PAGE_SIZE long
709 static ssize_t
et61x251_show_reg(struct device
* cd
,
710 struct device_attribute
*attr
, char* buf
)
712 struct et61x251_device
* cam
;
715 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
718 cam
= video_get_drvdata(to_video_device(cd
));
720 mutex_unlock(&et61x251_sysfs_lock
);
724 count
= sprintf(buf
, "%u\n", cam
->sysfs
.reg
);
726 mutex_unlock(&et61x251_sysfs_lock
);
733 et61x251_store_reg(struct device
* cd
,
734 struct device_attribute
*attr
, const char* buf
, size_t len
)
736 struct et61x251_device
* cam
;
740 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
743 cam
= video_get_drvdata(to_video_device(cd
));
745 mutex_unlock(&et61x251_sysfs_lock
);
749 index
= et61x251_strtou8(buf
, len
, &count
);
750 if (index
> 0x8e || !count
) {
751 mutex_unlock(&et61x251_sysfs_lock
);
755 cam
->sysfs
.reg
= index
;
757 DBG(2, "Moved ET61X[12]51 register index to 0x%02X", cam
->sysfs
.reg
);
758 DBG(3, "Written bytes: %zd", count
);
760 mutex_unlock(&et61x251_sysfs_lock
);
766 static ssize_t
et61x251_show_val(struct device
* cd
,
767 struct device_attribute
*attr
, char* buf
)
769 struct et61x251_device
* cam
;
773 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
776 cam
= video_get_drvdata(to_video_device(cd
));
778 mutex_unlock(&et61x251_sysfs_lock
);
782 if ((val
= et61x251_read_reg(cam
, cam
->sysfs
.reg
)) < 0) {
783 mutex_unlock(&et61x251_sysfs_lock
);
787 count
= sprintf(buf
, "%d\n", val
);
789 DBG(3, "Read bytes: %zd", count
);
791 mutex_unlock(&et61x251_sysfs_lock
);
798 et61x251_store_val(struct device
* cd
, struct device_attribute
*attr
,
799 const char* buf
, size_t len
)
801 struct et61x251_device
* cam
;
806 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
809 cam
= video_get_drvdata(to_video_device(cd
));
811 mutex_unlock(&et61x251_sysfs_lock
);
815 value
= et61x251_strtou8(buf
, len
, &count
);
817 mutex_unlock(&et61x251_sysfs_lock
);
821 err
= et61x251_write_reg(cam
, value
, cam
->sysfs
.reg
);
823 mutex_unlock(&et61x251_sysfs_lock
);
827 DBG(2, "Written ET61X[12]51 reg. 0x%02X, val. 0x%02X",
828 cam
->sysfs
.reg
, value
);
829 DBG(3, "Written bytes: %zd", count
);
831 mutex_unlock(&et61x251_sysfs_lock
);
837 static ssize_t
et61x251_show_i2c_reg(struct device
* cd
,
838 struct device_attribute
*attr
, char* buf
)
840 struct et61x251_device
* cam
;
843 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
846 cam
= video_get_drvdata(to_video_device(cd
));
848 mutex_unlock(&et61x251_sysfs_lock
);
852 count
= sprintf(buf
, "%u\n", cam
->sysfs
.i2c_reg
);
854 DBG(3, "Read bytes: %zd", count
);
856 mutex_unlock(&et61x251_sysfs_lock
);
863 et61x251_store_i2c_reg(struct device
* cd
, struct device_attribute
*attr
,
864 const char* buf
, size_t len
)
866 struct et61x251_device
* cam
;
870 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
873 cam
= video_get_drvdata(to_video_device(cd
));
875 mutex_unlock(&et61x251_sysfs_lock
);
879 index
= et61x251_strtou8(buf
, len
, &count
);
881 mutex_unlock(&et61x251_sysfs_lock
);
885 cam
->sysfs
.i2c_reg
= index
;
887 DBG(2, "Moved sensor register index to 0x%02X", cam
->sysfs
.i2c_reg
);
888 DBG(3, "Written bytes: %zd", count
);
890 mutex_unlock(&et61x251_sysfs_lock
);
896 static ssize_t
et61x251_show_i2c_val(struct device
* cd
,
897 struct device_attribute
*attr
, char* buf
)
899 struct et61x251_device
* cam
;
903 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
906 cam
= video_get_drvdata(to_video_device(cd
));
908 mutex_unlock(&et61x251_sysfs_lock
);
912 if (!(cam
->sensor
.sysfs_ops
& ET61X251_I2C_READ
)) {
913 mutex_unlock(&et61x251_sysfs_lock
);
917 if ((val
= et61x251_i2c_read(cam
, cam
->sysfs
.i2c_reg
)) < 0) {
918 mutex_unlock(&et61x251_sysfs_lock
);
922 count
= sprintf(buf
, "%d\n", val
);
924 DBG(3, "Read bytes: %zd", count
);
926 mutex_unlock(&et61x251_sysfs_lock
);
933 et61x251_store_i2c_val(struct device
* cd
, struct device_attribute
*attr
,
934 const char* buf
, size_t len
)
936 struct et61x251_device
* cam
;
941 if (mutex_lock_interruptible(&et61x251_sysfs_lock
))
944 cam
= video_get_drvdata(to_video_device(cd
));
946 mutex_unlock(&et61x251_sysfs_lock
);
950 if (!(cam
->sensor
.sysfs_ops
& ET61X251_I2C_READ
)) {
951 mutex_unlock(&et61x251_sysfs_lock
);
955 value
= et61x251_strtou8(buf
, len
, &count
);
957 mutex_unlock(&et61x251_sysfs_lock
);
961 err
= et61x251_i2c_write(cam
, cam
->sysfs
.i2c_reg
, value
);
963 mutex_unlock(&et61x251_sysfs_lock
);
967 DBG(2, "Written sensor reg. 0x%02X, val. 0x%02X",
968 cam
->sysfs
.i2c_reg
, value
);
969 DBG(3, "Written bytes: %zd", count
);
971 mutex_unlock(&et61x251_sysfs_lock
);
977 static DEVICE_ATTR(reg
, S_IRUGO
| S_IWUSR
,
978 et61x251_show_reg
, et61x251_store_reg
);
979 static DEVICE_ATTR(val
, S_IRUGO
| S_IWUSR
,
980 et61x251_show_val
, et61x251_store_val
);
981 static DEVICE_ATTR(i2c_reg
, S_IRUGO
| S_IWUSR
,
982 et61x251_show_i2c_reg
, et61x251_store_i2c_reg
);
983 static DEVICE_ATTR(i2c_val
, S_IRUGO
| S_IWUSR
,
984 et61x251_show_i2c_val
, et61x251_store_i2c_val
);
987 static int et61x251_create_sysfs(struct et61x251_device
* cam
)
989 struct device
*classdev
= &(cam
->v4ldev
->dev
);
992 if ((err
= device_create_file(classdev
, &dev_attr_reg
)))
994 if ((err
= device_create_file(classdev
, &dev_attr_val
)))
997 if (cam
->sensor
.sysfs_ops
) {
998 if ((err
= device_create_file(classdev
, &dev_attr_i2c_reg
)))
1000 if ((err
= device_create_file(classdev
, &dev_attr_i2c_val
)))
1005 if (cam
->sensor
.sysfs_ops
)
1006 device_remove_file(classdev
, &dev_attr_i2c_reg
);
1008 device_remove_file(classdev
, &dev_attr_val
);
1010 device_remove_file(classdev
, &dev_attr_reg
);
1014 #endif /* CONFIG_VIDEO_ADV_DEBUG */
1016 /*****************************************************************************/
1019 et61x251_set_pix_format(struct et61x251_device
* cam
,
1020 struct v4l2_pix_format
* pix
)
1024 if ((r
= et61x251_read_reg(cam
, 0x12)) < 0)
1026 if (pix
->pixelformat
== V4L2_PIX_FMT_ET61X251
)
1027 err
+= et61x251_write_reg(cam
, r
& 0xfd, 0x12);
1029 err
+= et61x251_write_reg(cam
, r
| 0x02, 0x12);
1031 return err
? -EIO
: 0;
1036 et61x251_set_compression(struct et61x251_device
* cam
,
1037 struct v4l2_jpegcompression
* compression
)
1041 if ((r
= et61x251_read_reg(cam
, 0x12)) < 0)
1043 if (compression
->quality
== 0)
1044 err
+= et61x251_write_reg(cam
, r
& 0xfb, 0x12);
1046 err
+= et61x251_write_reg(cam
, r
| 0x04, 0x12);
1048 return err
? -EIO
: 0;
1052 static int et61x251_set_scale(struct et61x251_device
* cam
, u8 scale
)
1056 r
= et61x251_read_reg(cam
, 0x12);
1061 err
+= et61x251_write_reg(cam
, r
& ~0x01, 0x12);
1062 else if (scale
== 2)
1063 err
+= et61x251_write_reg(cam
, r
| 0x01, 0x12);
1068 PDBGG("Scaling factor: %u", scale
);
1075 et61x251_set_crop(struct et61x251_device
* cam
, struct v4l2_rect
* rect
)
1077 struct et61x251_sensor
* s
= &cam
->sensor
;
1078 u16 fmw_sx
= (u16
)(rect
->left
- s
->cropcap
.bounds
.left
+
1079 s
->active_pixel
.left
),
1080 fmw_sy
= (u16
)(rect
->top
- s
->cropcap
.bounds
.top
+
1081 s
->active_pixel
.top
),
1082 fmw_length
= (u16
)(rect
->width
),
1083 fmw_height
= (u16
)(rect
->height
);
1086 err
+= et61x251_write_reg(cam
, fmw_sx
& 0xff, 0x69);
1087 err
+= et61x251_write_reg(cam
, fmw_sy
& 0xff, 0x6a);
1088 err
+= et61x251_write_reg(cam
, fmw_length
& 0xff, 0x6b);
1089 err
+= et61x251_write_reg(cam
, fmw_height
& 0xff, 0x6c);
1090 err
+= et61x251_write_reg(cam
, (fmw_sx
>> 8) | ((fmw_sy
& 0x300) >> 6)
1091 | ((fmw_length
& 0x300) >> 4)
1092 | ((fmw_height
& 0x300) >> 2), 0x6d);
1096 PDBGG("fmw_sx, fmw_sy, fmw_length, fmw_height: %u %u %u %u",
1097 fmw_sx
, fmw_sy
, fmw_length
, fmw_height
);
1103 static int et61x251_init(struct et61x251_device
* cam
)
1105 struct et61x251_sensor
* s
= &cam
->sensor
;
1106 struct v4l2_control ctrl
;
1107 struct v4l2_queryctrl
*qctrl
;
1108 struct v4l2_rect
* rect
;
1112 if (!(cam
->state
& DEV_INITIALIZED
)) {
1113 mutex_init(&cam
->open_mutex
);
1114 init_waitqueue_head(&cam
->wait_open
);
1116 rect
= &(s
->cropcap
.defrect
);
1117 cam
->compression
.quality
= ET61X251_COMPRESSION_QUALITY
;
1118 } else { /* use current values */
1123 err
+= et61x251_set_scale(cam
, rect
->width
/ s
->pix_format
.width
);
1124 err
+= et61x251_set_crop(cam
, rect
);
1131 DBG(3, "Sensor initialization failed");
1136 err
+= et61x251_set_compression(cam
, &cam
->compression
);
1137 err
+= et61x251_set_pix_format(cam
, &s
->pix_format
);
1138 if (s
->set_pix_format
)
1139 err
+= s
->set_pix_format(cam
, &s
->pix_format
);
1143 if (s
->pix_format
.pixelformat
== V4L2_PIX_FMT_ET61X251
)
1144 DBG(3, "Compressed video format is active, quality %d",
1145 cam
->compression
.quality
);
1147 DBG(3, "Uncompressed video format is active");
1150 if ((err
= s
->set_crop(cam
, rect
))) {
1151 DBG(3, "set_crop() failed");
1156 for (i
= 0; i
< ARRAY_SIZE(s
->qctrl
); i
++)
1157 if (s
->qctrl
[i
].id
!= 0 &&
1158 !(s
->qctrl
[i
].flags
& V4L2_CTRL_FLAG_DISABLED
)) {
1159 ctrl
.id
= s
->qctrl
[i
].id
;
1160 ctrl
.value
= qctrl
[i
].default_value
;
1161 err
= s
->set_ctrl(cam
, &ctrl
);
1163 DBG(3, "Set %s control failed",
1167 DBG(3, "Image sensor supports '%s' control",
1172 if (!(cam
->state
& DEV_INITIALIZED
)) {
1173 mutex_init(&cam
->fileop_mutex
);
1174 spin_lock_init(&cam
->queue_lock
);
1175 init_waitqueue_head(&cam
->wait_frame
);
1176 init_waitqueue_head(&cam
->wait_stream
);
1177 cam
->nreadbuffers
= 2;
1178 memcpy(s
->_qctrl
, s
->qctrl
, sizeof(s
->qctrl
));
1179 memcpy(&(s
->_rect
), &(s
->cropcap
.defrect
),
1180 sizeof(struct v4l2_rect
));
1181 cam
->state
|= DEV_INITIALIZED
;
1184 DBG(2, "Initialization succeeded");
1188 /*****************************************************************************/
1190 static void et61x251_release_resources(struct kref
*kref
)
1192 struct et61x251_device
*cam
;
1194 mutex_lock(&et61x251_sysfs_lock
);
1196 cam
= container_of(kref
, struct et61x251_device
, kref
);
1198 DBG(2, "V4L2 device %s deregistered",
1199 video_device_node_name(cam
->v4ldev
));
1200 video_set_drvdata(cam
->v4ldev
, NULL
);
1201 video_unregister_device(cam
->v4ldev
);
1202 usb_put_dev(cam
->usbdev
);
1203 kfree(cam
->control_buffer
);
1206 mutex_unlock(&et61x251_sysfs_lock
);
1210 static int et61x251_open(struct file
*filp
)
1212 struct et61x251_device
* cam
;
1215 if (!down_read_trylock(&et61x251_dev_lock
))
1216 return -ERESTARTSYS
;
1218 cam
= video_drvdata(filp
);
1220 if (wait_for_completion_interruptible(&cam
->probe
)) {
1221 up_read(&et61x251_dev_lock
);
1222 return -ERESTARTSYS
;
1225 kref_get(&cam
->kref
);
1227 if (mutex_lock_interruptible(&cam
->open_mutex
)) {
1228 kref_put(&cam
->kref
, et61x251_release_resources
);
1229 up_read(&et61x251_dev_lock
);
1230 return -ERESTARTSYS
;
1233 if (cam
->state
& DEV_DISCONNECTED
) {
1234 DBG(1, "Device not present");
1240 DBG(2, "Device %s is already in use",
1241 video_device_node_name(cam
->v4ldev
));
1242 DBG(3, "Simultaneous opens are not supported");
1243 if ((filp
->f_flags
& O_NONBLOCK
) ||
1244 (filp
->f_flags
& O_NDELAY
)) {
1248 DBG(2, "A blocking open() has been requested. Wait for the "
1249 "device to be released...");
1250 up_read(&et61x251_dev_lock
);
1251 err
= wait_event_interruptible_exclusive(cam
->wait_open
,
1252 (cam
->state
& DEV_DISCONNECTED
)
1254 down_read(&et61x251_dev_lock
);
1257 if (cam
->state
& DEV_DISCONNECTED
) {
1263 if (cam
->state
& DEV_MISCONFIGURED
) {
1264 err
= et61x251_init(cam
);
1266 DBG(1, "Initialization failed again. "
1267 "I will retry on next open().");
1270 cam
->state
&= ~DEV_MISCONFIGURED
;
1273 if ((err
= et61x251_start_transfer(cam
)))
1276 filp
->private_data
= cam
;
1279 cam
->stream
= STREAM_OFF
;
1281 cam
->frame_count
= 0;
1282 et61x251_empty_framequeues(cam
);
1284 DBG(3, "Video device %s is open",
1285 video_device_node_name(cam
->v4ldev
));
1288 mutex_unlock(&cam
->open_mutex
);
1290 kref_put(&cam
->kref
, et61x251_release_resources
);
1291 up_read(&et61x251_dev_lock
);
1296 static int et61x251_release(struct file
*filp
)
1298 struct et61x251_device
* cam
;
1300 down_write(&et61x251_dev_lock
);
1302 cam
= video_drvdata(filp
);
1304 et61x251_stop_transfer(cam
);
1305 et61x251_release_buffers(cam
);
1307 wake_up_interruptible_nr(&cam
->wait_open
, 1);
1309 DBG(3, "Video device %s closed",
1310 video_device_node_name(cam
->v4ldev
));
1312 kref_put(&cam
->kref
, et61x251_release_resources
);
1314 up_write(&et61x251_dev_lock
);
1321 et61x251_read(struct file
* filp
, char __user
* buf
,
1322 size_t count
, loff_t
* f_pos
)
1324 struct et61x251_device
*cam
= video_drvdata(filp
);
1325 struct et61x251_frame_t
* f
, * i
;
1326 unsigned long lock_flags
;
1330 if (mutex_lock_interruptible(&cam
->fileop_mutex
))
1331 return -ERESTARTSYS
;
1333 if (cam
->state
& DEV_DISCONNECTED
) {
1334 DBG(1, "Device not present");
1335 mutex_unlock(&cam
->fileop_mutex
);
1339 if (cam
->state
& DEV_MISCONFIGURED
) {
1340 DBG(1, "The camera is misconfigured. Close and open it "
1342 mutex_unlock(&cam
->fileop_mutex
);
1346 if (cam
->io
== IO_MMAP
) {
1347 DBG(3, "Close and open the device again to choose the read "
1349 mutex_unlock(&cam
->fileop_mutex
);
1353 if (cam
->io
== IO_NONE
) {
1354 if (!et61x251_request_buffers(cam
, cam
->nreadbuffers
,
1356 DBG(1, "read() failed, not enough memory");
1357 mutex_unlock(&cam
->fileop_mutex
);
1361 cam
->stream
= STREAM_ON
;
1364 if (list_empty(&cam
->inqueue
)) {
1365 if (!list_empty(&cam
->outqueue
))
1366 et61x251_empty_framequeues(cam
);
1367 et61x251_queue_unusedframes(cam
);
1371 mutex_unlock(&cam
->fileop_mutex
);
1375 if (list_empty(&cam
->outqueue
)) {
1376 if (filp
->f_flags
& O_NONBLOCK
) {
1377 mutex_unlock(&cam
->fileop_mutex
);
1380 timeout
= wait_event_interruptible_timeout
1382 (!list_empty(&cam
->outqueue
)) ||
1383 (cam
->state
& DEV_DISCONNECTED
) ||
1384 (cam
->state
& DEV_MISCONFIGURED
),
1386 cam
->module_param
.frame_timeout
* 1000
1390 mutex_unlock(&cam
->fileop_mutex
);
1393 if (cam
->state
& DEV_DISCONNECTED
) {
1394 mutex_unlock(&cam
->fileop_mutex
);
1397 if (!timeout
|| (cam
->state
& DEV_MISCONFIGURED
)) {
1398 mutex_unlock(&cam
->fileop_mutex
);
1403 f
= list_entry(cam
->outqueue
.prev
, struct et61x251_frame_t
, frame
);
1405 if (count
> f
->buf
.bytesused
)
1406 count
= f
->buf
.bytesused
;
1408 if (copy_to_user(buf
, f
->bufmem
, count
)) {
1415 spin_lock_irqsave(&cam
->queue_lock
, lock_flags
);
1416 list_for_each_entry(i
, &cam
->outqueue
, frame
)
1417 i
->state
= F_UNUSED
;
1418 INIT_LIST_HEAD(&cam
->outqueue
);
1419 spin_unlock_irqrestore(&cam
->queue_lock
, lock_flags
);
1421 et61x251_queue_unusedframes(cam
);
1423 PDBGG("Frame #%lu, bytes read: %zu",
1424 (unsigned long)f
->buf
.index
, count
);
1426 mutex_unlock(&cam
->fileop_mutex
);
1428 return err
? err
: count
;
1432 static unsigned int et61x251_poll(struct file
*filp
, poll_table
*wait
)
1434 struct et61x251_device
*cam
= video_drvdata(filp
);
1435 struct et61x251_frame_t
* f
;
1436 unsigned long lock_flags
;
1437 unsigned int mask
= 0;
1439 if (mutex_lock_interruptible(&cam
->fileop_mutex
))
1442 if (cam
->state
& DEV_DISCONNECTED
) {
1443 DBG(1, "Device not present");
1447 if (cam
->state
& DEV_MISCONFIGURED
) {
1448 DBG(1, "The camera is misconfigured. Close and open it "
1453 if (cam
->io
== IO_NONE
) {
1454 if (!et61x251_request_buffers(cam
, cam
->nreadbuffers
,
1456 DBG(1, "poll() failed, not enough memory");
1460 cam
->stream
= STREAM_ON
;
1463 if (cam
->io
== IO_READ
) {
1464 spin_lock_irqsave(&cam
->queue_lock
, lock_flags
);
1465 list_for_each_entry(f
, &cam
->outqueue
, frame
)
1466 f
->state
= F_UNUSED
;
1467 INIT_LIST_HEAD(&cam
->outqueue
);
1468 spin_unlock_irqrestore(&cam
->queue_lock
, lock_flags
);
1469 et61x251_queue_unusedframes(cam
);
1472 poll_wait(filp
, &cam
->wait_frame
, wait
);
1474 if (!list_empty(&cam
->outqueue
))
1475 mask
|= POLLIN
| POLLRDNORM
;
1477 mutex_unlock(&cam
->fileop_mutex
);
1482 mutex_unlock(&cam
->fileop_mutex
);
1487 static void et61x251_vm_open(struct vm_area_struct
* vma
)
1489 struct et61x251_frame_t
* f
= vma
->vm_private_data
;
1494 static void et61x251_vm_close(struct vm_area_struct
* vma
)
1496 /* NOTE: buffers are not freed here */
1497 struct et61x251_frame_t
* f
= vma
->vm_private_data
;
1502 static const struct vm_operations_struct et61x251_vm_ops
= {
1503 .open
= et61x251_vm_open
,
1504 .close
= et61x251_vm_close
,
1508 static int et61x251_mmap(struct file
* filp
, struct vm_area_struct
*vma
)
1510 struct et61x251_device
*cam
= video_drvdata(filp
);
1511 unsigned long size
= vma
->vm_end
- vma
->vm_start
,
1512 start
= vma
->vm_start
;
1516 if (mutex_lock_interruptible(&cam
->fileop_mutex
))
1517 return -ERESTARTSYS
;
1519 if (cam
->state
& DEV_DISCONNECTED
) {
1520 DBG(1, "Device not present");
1521 mutex_unlock(&cam
->fileop_mutex
);
1525 if (cam
->state
& DEV_MISCONFIGURED
) {
1526 DBG(1, "The camera is misconfigured. Close and open it "
1528 mutex_unlock(&cam
->fileop_mutex
);
1532 if (!(vma
->vm_flags
& (VM_WRITE
| VM_READ
))) {
1533 mutex_unlock(&cam
->fileop_mutex
);
1537 if (cam
->io
!= IO_MMAP
||
1538 size
!= PAGE_ALIGN(cam
->frame
[0].buf
.length
)) {
1539 mutex_unlock(&cam
->fileop_mutex
);
1543 for (i
= 0; i
< cam
->nbuffers
; i
++) {
1544 if ((cam
->frame
[i
].buf
.m
.offset
>>PAGE_SHIFT
) == vma
->vm_pgoff
)
1547 if (i
== cam
->nbuffers
) {
1548 mutex_unlock(&cam
->fileop_mutex
);
1552 vma
->vm_flags
|= VM_IO
;
1553 vma
->vm_flags
|= VM_RESERVED
;
1555 pos
= cam
->frame
[i
].bufmem
;
1556 while (size
> 0) { /* size is page-aligned */
1557 if (vm_insert_page(vma
, start
, vmalloc_to_page(pos
))) {
1558 mutex_unlock(&cam
->fileop_mutex
);
1566 vma
->vm_ops
= &et61x251_vm_ops
;
1567 vma
->vm_private_data
= &cam
->frame
[i
];
1568 et61x251_vm_open(vma
);
1570 mutex_unlock(&cam
->fileop_mutex
);
1575 /*****************************************************************************/
1578 et61x251_vidioc_querycap(struct et61x251_device
* cam
, void __user
* arg
)
1580 struct v4l2_capability cap
= {
1581 .driver
= "et61x251",
1582 .version
= ET61X251_MODULE_VERSION_CODE
,
1583 .capabilities
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_READWRITE
|
1587 strlcpy(cap
.card
, cam
->v4ldev
->name
, sizeof(cap
.card
));
1588 if (usb_make_path(cam
->usbdev
, cap
.bus_info
, sizeof(cap
.bus_info
)) < 0)
1589 strlcpy(cap
.bus_info
, dev_name(&cam
->usbdev
->dev
),
1590 sizeof(cap
.bus_info
));
1592 if (copy_to_user(arg
, &cap
, sizeof(cap
)))
1600 et61x251_vidioc_enuminput(struct et61x251_device
* cam
, void __user
* arg
)
1602 struct v4l2_input i
;
1604 if (copy_from_user(&i
, arg
, sizeof(i
)))
1610 memset(&i
, 0, sizeof(i
));
1611 strcpy(i
.name
, "Camera");
1612 i
.type
= V4L2_INPUT_TYPE_CAMERA
;
1614 if (copy_to_user(arg
, &i
, sizeof(i
)))
1622 et61x251_vidioc_g_input(struct et61x251_device
* cam
, void __user
* arg
)
1626 if (copy_to_user(arg
, &index
, sizeof(index
)))
1634 et61x251_vidioc_s_input(struct et61x251_device
* cam
, void __user
* arg
)
1638 if (copy_from_user(&index
, arg
, sizeof(index
)))
1649 et61x251_vidioc_query_ctrl(struct et61x251_device
* cam
, void __user
* arg
)
1651 struct et61x251_sensor
* s
= &cam
->sensor
;
1652 struct v4l2_queryctrl qc
;
1655 if (copy_from_user(&qc
, arg
, sizeof(qc
)))
1658 for (i
= 0; i
< ARRAY_SIZE(s
->qctrl
); i
++)
1659 if (qc
.id
&& qc
.id
== s
->qctrl
[i
].id
) {
1660 memcpy(&qc
, &(s
->qctrl
[i
]), sizeof(qc
));
1661 if (copy_to_user(arg
, &qc
, sizeof(qc
)))
1671 et61x251_vidioc_g_ctrl(struct et61x251_device
* cam
, void __user
* arg
)
1673 struct et61x251_sensor
* s
= &cam
->sensor
;
1674 struct v4l2_control ctrl
;
1678 if (!s
->get_ctrl
&& !s
->set_ctrl
)
1681 if (copy_from_user(&ctrl
, arg
, sizeof(ctrl
)))
1685 for (i
= 0; i
< ARRAY_SIZE(s
->qctrl
); i
++)
1686 if (ctrl
.id
== s
->qctrl
[i
].id
) {
1687 ctrl
.value
= s
->_qctrl
[i
].default_value
;
1692 err
= s
->get_ctrl(cam
, &ctrl
);
1695 if (copy_to_user(arg
, &ctrl
, sizeof(ctrl
)))
1703 et61x251_vidioc_s_ctrl(struct et61x251_device
* cam
, void __user
* arg
)
1705 struct et61x251_sensor
* s
= &cam
->sensor
;
1706 struct v4l2_control ctrl
;
1713 if (copy_from_user(&ctrl
, arg
, sizeof(ctrl
)))
1716 for (i
= 0; i
< ARRAY_SIZE(s
->qctrl
); i
++) {
1717 if (ctrl
.id
== s
->qctrl
[i
].id
) {
1718 if (s
->qctrl
[i
].flags
& V4L2_CTRL_FLAG_DISABLED
)
1720 if (ctrl
.value
< s
->qctrl
[i
].minimum
||
1721 ctrl
.value
> s
->qctrl
[i
].maximum
)
1723 ctrl
.value
-= ctrl
.value
% s
->qctrl
[i
].step
;
1727 if (i
== ARRAY_SIZE(s
->qctrl
))
1729 if ((err
= s
->set_ctrl(cam
, &ctrl
)))
1732 s
->_qctrl
[i
].default_value
= ctrl
.value
;
1739 et61x251_vidioc_cropcap(struct et61x251_device
* cam
, void __user
* arg
)
1741 struct v4l2_cropcap
* cc
= &(cam
->sensor
.cropcap
);
1743 cc
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1744 cc
->pixelaspect
.numerator
= 1;
1745 cc
->pixelaspect
.denominator
= 1;
1747 if (copy_to_user(arg
, cc
, sizeof(*cc
)))
1755 et61x251_vidioc_g_crop(struct et61x251_device
* cam
, void __user
* arg
)
1757 struct et61x251_sensor
* s
= &cam
->sensor
;
1758 struct v4l2_crop crop
= {
1759 .type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
,
1762 memcpy(&(crop
.c
), &(s
->_rect
), sizeof(struct v4l2_rect
));
1764 if (copy_to_user(arg
, &crop
, sizeof(crop
)))
1772 et61x251_vidioc_s_crop(struct et61x251_device
* cam
, void __user
* arg
)
1774 struct et61x251_sensor
* s
= &cam
->sensor
;
1775 struct v4l2_crop crop
;
1776 struct v4l2_rect
* rect
;
1777 struct v4l2_rect
* bounds
= &(s
->cropcap
.bounds
);
1778 struct v4l2_pix_format
* pix_format
= &(s
->pix_format
);
1780 const enum et61x251_stream_state stream
= cam
->stream
;
1781 const u32 nbuffers
= cam
->nbuffers
;
1785 if (copy_from_user(&crop
, arg
, sizeof(crop
)))
1790 if (crop
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1793 if (cam
->module_param
.force_munmap
)
1794 for (i
= 0; i
< cam
->nbuffers
; i
++)
1795 if (cam
->frame
[i
].vma_use_count
) {
1796 DBG(3, "VIDIOC_S_CROP failed. "
1797 "Unmap the buffers first.");
1801 /* Preserve R,G or B origin */
1802 rect
->left
= (s
->_rect
.left
& 1L) ? rect
->left
| 1L : rect
->left
& ~1L;
1803 rect
->top
= (s
->_rect
.top
& 1L) ? rect
->top
| 1L : rect
->top
& ~1L;
1805 if (rect
->width
< 16)
1807 if (rect
->height
< 16)
1809 if (rect
->width
> bounds
->width
)
1810 rect
->width
= bounds
->width
;
1811 if (rect
->height
> bounds
->height
)
1812 rect
->height
= bounds
->height
;
1813 if (rect
->left
< bounds
->left
)
1814 rect
->left
= bounds
->left
;
1815 if (rect
->top
< bounds
->top
)
1816 rect
->top
= bounds
->top
;
1817 if (rect
->left
+ rect
->width
> bounds
->left
+ bounds
->width
)
1818 rect
->left
= bounds
->left
+bounds
->width
- rect
->width
;
1819 if (rect
->top
+ rect
->height
> bounds
->top
+ bounds
->height
)
1820 rect
->top
= bounds
->top
+bounds
->height
- rect
->height
;
1822 rect
->width
&= ~15L;
1823 rect
->height
&= ~15L;
1825 if (ET61X251_PRESERVE_IMGSCALE
) {
1826 /* Calculate the actual scaling factor */
1828 a
= rect
->width
* rect
->height
;
1829 b
= pix_format
->width
* pix_format
->height
;
1830 scale
= b
? (u8
)((a
/ b
) < 4 ? 1 : 2) : 1;
1834 if (cam
->stream
== STREAM_ON
)
1835 if ((err
= et61x251_stream_interrupt(cam
)))
1838 if (copy_to_user(arg
, &crop
, sizeof(crop
))) {
1839 cam
->stream
= stream
;
1843 if (cam
->module_param
.force_munmap
|| cam
->io
== IO_READ
)
1844 et61x251_release_buffers(cam
);
1846 err
= et61x251_set_crop(cam
, rect
);
1848 err
+= s
->set_crop(cam
, rect
);
1849 err
+= et61x251_set_scale(cam
, scale
);
1851 if (err
) { /* atomic, no rollback in ioctl() */
1852 cam
->state
|= DEV_MISCONFIGURED
;
1853 DBG(1, "VIDIOC_S_CROP failed because of hardware problems. To "
1854 "use the camera, close and open %s again.",
1855 video_device_node_name(cam
->v4ldev
));
1859 s
->pix_format
.width
= rect
->width
/scale
;
1860 s
->pix_format
.height
= rect
->height
/scale
;
1861 memcpy(&(s
->_rect
), rect
, sizeof(*rect
));
1863 if ((cam
->module_param
.force_munmap
|| cam
->io
== IO_READ
) &&
1864 nbuffers
!= et61x251_request_buffers(cam
, nbuffers
, cam
->io
)) {
1865 cam
->state
|= DEV_MISCONFIGURED
;
1866 DBG(1, "VIDIOC_S_CROP failed because of not enough memory. To "
1867 "use the camera, close and open %s again.",
1868 video_device_node_name(cam
->v4ldev
));
1872 if (cam
->io
== IO_READ
)
1873 et61x251_empty_framequeues(cam
);
1874 else if (cam
->module_param
.force_munmap
)
1875 et61x251_requeue_outqueue(cam
);
1877 cam
->stream
= stream
;
1884 et61x251_vidioc_enum_framesizes(struct et61x251_device
* cam
, void __user
* arg
)
1886 struct v4l2_frmsizeenum frmsize
;
1888 if (copy_from_user(&frmsize
, arg
, sizeof(frmsize
)))
1891 if (frmsize
.index
!= 0)
1894 if (frmsize
.pixel_format
!= V4L2_PIX_FMT_ET61X251
&&
1895 frmsize
.pixel_format
!= V4L2_PIX_FMT_SBGGR8
)
1898 frmsize
.type
= V4L2_FRMSIZE_TYPE_STEPWISE
;
1899 frmsize
.stepwise
.min_width
= frmsize
.stepwise
.step_width
= 16;
1900 frmsize
.stepwise
.min_height
= frmsize
.stepwise
.step_height
= 16;
1901 frmsize
.stepwise
.max_width
= cam
->sensor
.cropcap
.bounds
.width
;
1902 frmsize
.stepwise
.max_height
= cam
->sensor
.cropcap
.bounds
.height
;
1903 memset(&frmsize
.reserved
, 0, sizeof(frmsize
.reserved
));
1905 if (copy_to_user(arg
, &frmsize
, sizeof(frmsize
)))
1913 et61x251_vidioc_enum_fmt(struct et61x251_device
* cam
, void __user
* arg
)
1915 struct v4l2_fmtdesc fmtd
;
1917 if (copy_from_user(&fmtd
, arg
, sizeof(fmtd
)))
1920 if (fmtd
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1923 if (fmtd
.index
== 0) {
1924 strcpy(fmtd
.description
, "bayer rgb");
1925 fmtd
.pixelformat
= V4L2_PIX_FMT_SBGGR8
;
1926 } else if (fmtd
.index
== 1) {
1927 strcpy(fmtd
.description
, "compressed");
1928 fmtd
.pixelformat
= V4L2_PIX_FMT_ET61X251
;
1929 fmtd
.flags
= V4L2_FMT_FLAG_COMPRESSED
;
1933 fmtd
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1934 memset(&fmtd
.reserved
, 0, sizeof(fmtd
.reserved
));
1936 if (copy_to_user(arg
, &fmtd
, sizeof(fmtd
)))
1944 et61x251_vidioc_g_fmt(struct et61x251_device
* cam
, void __user
* arg
)
1946 struct v4l2_format format
;
1947 struct v4l2_pix_format
* pfmt
= &(cam
->sensor
.pix_format
);
1949 if (copy_from_user(&format
, arg
, sizeof(format
)))
1952 if (format
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1955 pfmt
->colorspace
= (pfmt
->pixelformat
== V4L2_PIX_FMT_ET61X251
) ?
1956 0 : V4L2_COLORSPACE_SRGB
;
1957 pfmt
->bytesperline
= (pfmt
->pixelformat
==V4L2_PIX_FMT_ET61X251
)
1958 ? 0 : (pfmt
->width
* pfmt
->priv
) / 8;
1959 pfmt
->sizeimage
= pfmt
->height
* ((pfmt
->width
*pfmt
->priv
)/8);
1960 pfmt
->field
= V4L2_FIELD_NONE
;
1961 memcpy(&(format
.fmt
.pix
), pfmt
, sizeof(*pfmt
));
1963 if (copy_to_user(arg
, &format
, sizeof(format
)))
1971 et61x251_vidioc_try_s_fmt(struct et61x251_device
* cam
, unsigned int cmd
,
1974 struct et61x251_sensor
* s
= &cam
->sensor
;
1975 struct v4l2_format format
;
1976 struct v4l2_pix_format
* pix
;
1977 struct v4l2_pix_format
* pfmt
= &(s
->pix_format
);
1978 struct v4l2_rect
* bounds
= &(s
->cropcap
.bounds
);
1979 struct v4l2_rect rect
;
1981 const enum et61x251_stream_state stream
= cam
->stream
;
1982 const u32 nbuffers
= cam
->nbuffers
;
1986 if (copy_from_user(&format
, arg
, sizeof(format
)))
1989 pix
= &(format
.fmt
.pix
);
1991 if (format
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1994 memcpy(&rect
, &(s
->_rect
), sizeof(rect
));
1996 { /* calculate the actual scaling factor */
1998 a
= rect
.width
* rect
.height
;
1999 b
= pix
->width
* pix
->height
;
2000 scale
= b
? (u8
)((a
/ b
) < 4 ? 1 : 2) : 1;
2003 rect
.width
= scale
* pix
->width
;
2004 rect
.height
= scale
* pix
->height
;
2006 if (rect
.width
< 16)
2008 if (rect
.height
< 16)
2010 if (rect
.width
> bounds
->left
+ bounds
->width
- rect
.left
)
2011 rect
.width
= bounds
->left
+ bounds
->width
- rect
.left
;
2012 if (rect
.height
> bounds
->top
+ bounds
->height
- rect
.top
)
2013 rect
.height
= bounds
->top
+ bounds
->height
- rect
.top
;
2016 rect
.height
&= ~15L;
2018 { /* adjust the scaling factor */
2020 a
= rect
.width
* rect
.height
;
2021 b
= pix
->width
* pix
->height
;
2022 scale
= b
? (u8
)((a
/ b
) < 4 ? 1 : 2) : 1;
2025 pix
->width
= rect
.width
/ scale
;
2026 pix
->height
= rect
.height
/ scale
;
2028 if (pix
->pixelformat
!= V4L2_PIX_FMT_ET61X251
&&
2029 pix
->pixelformat
!= V4L2_PIX_FMT_SBGGR8
)
2030 pix
->pixelformat
= pfmt
->pixelformat
;
2031 pix
->priv
= pfmt
->priv
; /* bpp */
2032 pix
->colorspace
= (pix
->pixelformat
== V4L2_PIX_FMT_ET61X251
) ?
2033 0 : V4L2_COLORSPACE_SRGB
;
2034 pix
->colorspace
= pfmt
->colorspace
;
2035 pix
->bytesperline
= (pix
->pixelformat
== V4L2_PIX_FMT_ET61X251
)
2036 ? 0 : (pix
->width
* pix
->priv
) / 8;
2037 pix
->sizeimage
= pix
->height
* ((pix
->width
* pix
->priv
) / 8);
2038 pix
->field
= V4L2_FIELD_NONE
;
2040 if (cmd
== VIDIOC_TRY_FMT
) {
2041 if (copy_to_user(arg
, &format
, sizeof(format
)))
2046 if (cam
->module_param
.force_munmap
)
2047 for (i
= 0; i
< cam
->nbuffers
; i
++)
2048 if (cam
->frame
[i
].vma_use_count
) {
2049 DBG(3, "VIDIOC_S_FMT failed. "
2050 "Unmap the buffers first.");
2054 if (cam
->stream
== STREAM_ON
)
2055 if ((err
= et61x251_stream_interrupt(cam
)))
2058 if (copy_to_user(arg
, &format
, sizeof(format
))) {
2059 cam
->stream
= stream
;
2063 if (cam
->module_param
.force_munmap
|| cam
->io
== IO_READ
)
2064 et61x251_release_buffers(cam
);
2066 err
+= et61x251_set_pix_format(cam
, pix
);
2067 err
+= et61x251_set_crop(cam
, &rect
);
2068 if (s
->set_pix_format
)
2069 err
+= s
->set_pix_format(cam
, pix
);
2071 err
+= s
->set_crop(cam
, &rect
);
2072 err
+= et61x251_set_scale(cam
, scale
);
2074 if (err
) { /* atomic, no rollback in ioctl() */
2075 cam
->state
|= DEV_MISCONFIGURED
;
2076 DBG(1, "VIDIOC_S_FMT failed because of hardware problems. To "
2077 "use the camera, close and open %s again.",
2078 video_device_node_name(cam
->v4ldev
));
2082 memcpy(pfmt
, pix
, sizeof(*pix
));
2083 memcpy(&(s
->_rect
), &rect
, sizeof(rect
));
2085 if ((cam
->module_param
.force_munmap
|| cam
->io
== IO_READ
) &&
2086 nbuffers
!= et61x251_request_buffers(cam
, nbuffers
, cam
->io
)) {
2087 cam
->state
|= DEV_MISCONFIGURED
;
2088 DBG(1, "VIDIOC_S_FMT failed because of not enough memory. To "
2089 "use the camera, close and open %s again.",
2090 video_device_node_name(cam
->v4ldev
));
2094 if (cam
->io
== IO_READ
)
2095 et61x251_empty_framequeues(cam
);
2096 else if (cam
->module_param
.force_munmap
)
2097 et61x251_requeue_outqueue(cam
);
2099 cam
->stream
= stream
;
2106 et61x251_vidioc_g_jpegcomp(struct et61x251_device
* cam
, void __user
* arg
)
2108 if (copy_to_user(arg
, &cam
->compression
,
2109 sizeof(cam
->compression
)))
2117 et61x251_vidioc_s_jpegcomp(struct et61x251_device
* cam
, void __user
* arg
)
2119 struct v4l2_jpegcompression jc
;
2120 const enum et61x251_stream_state stream
= cam
->stream
;
2123 if (copy_from_user(&jc
, arg
, sizeof(jc
)))
2126 if (jc
.quality
!= 0 && jc
.quality
!= 1)
2129 if (cam
->stream
== STREAM_ON
)
2130 if ((err
= et61x251_stream_interrupt(cam
)))
2133 err
+= et61x251_set_compression(cam
, &jc
);
2134 if (err
) { /* atomic, no rollback in ioctl() */
2135 cam
->state
|= DEV_MISCONFIGURED
;
2136 DBG(1, "VIDIOC_S_JPEGCOMP failed because of hardware "
2137 "problems. To use the camera, close and open "
2138 "%s again.", video_device_node_name(cam
->v4ldev
));
2142 cam
->compression
.quality
= jc
.quality
;
2144 cam
->stream
= stream
;
2151 et61x251_vidioc_reqbufs(struct et61x251_device
* cam
, void __user
* arg
)
2153 struct v4l2_requestbuffers rb
;
2157 if (copy_from_user(&rb
, arg
, sizeof(rb
)))
2160 if (rb
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
2161 rb
.memory
!= V4L2_MEMORY_MMAP
)
2164 if (cam
->io
== IO_READ
) {
2165 DBG(3, "Close and open the device again to choose the mmap "
2170 for (i
= 0; i
< cam
->nbuffers
; i
++)
2171 if (cam
->frame
[i
].vma_use_count
) {
2172 DBG(3, "VIDIOC_REQBUFS failed. "
2173 "Previous buffers are still mapped.");
2177 if (cam
->stream
== STREAM_ON
)
2178 if ((err
= et61x251_stream_interrupt(cam
)))
2181 et61x251_empty_framequeues(cam
);
2183 et61x251_release_buffers(cam
);
2185 rb
.count
= et61x251_request_buffers(cam
, rb
.count
, IO_MMAP
);
2187 if (copy_to_user(arg
, &rb
, sizeof(rb
))) {
2188 et61x251_release_buffers(cam
);
2193 cam
->io
= rb
.count
? IO_MMAP
: IO_NONE
;
2200 et61x251_vidioc_querybuf(struct et61x251_device
* cam
, void __user
* arg
)
2202 struct v4l2_buffer b
;
2204 if (copy_from_user(&b
, arg
, sizeof(b
)))
2207 if (b
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
2208 b
.index
>= cam
->nbuffers
|| cam
->io
!= IO_MMAP
)
2211 memcpy(&b
, &cam
->frame
[b
.index
].buf
, sizeof(b
));
2213 if (cam
->frame
[b
.index
].vma_use_count
)
2214 b
.flags
|= V4L2_BUF_FLAG_MAPPED
;
2216 if (cam
->frame
[b
.index
].state
== F_DONE
)
2217 b
.flags
|= V4L2_BUF_FLAG_DONE
;
2218 else if (cam
->frame
[b
.index
].state
!= F_UNUSED
)
2219 b
.flags
|= V4L2_BUF_FLAG_QUEUED
;
2221 if (copy_to_user(arg
, &b
, sizeof(b
)))
2229 et61x251_vidioc_qbuf(struct et61x251_device
* cam
, void __user
* arg
)
2231 struct v4l2_buffer b
;
2232 unsigned long lock_flags
;
2234 if (copy_from_user(&b
, arg
, sizeof(b
)))
2237 if (b
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
||
2238 b
.index
>= cam
->nbuffers
|| cam
->io
!= IO_MMAP
)
2241 if (cam
->frame
[b
.index
].state
!= F_UNUSED
)
2244 cam
->frame
[b
.index
].state
= F_QUEUED
;
2246 spin_lock_irqsave(&cam
->queue_lock
, lock_flags
);
2247 list_add_tail(&cam
->frame
[b
.index
].frame
, &cam
->inqueue
);
2248 spin_unlock_irqrestore(&cam
->queue_lock
, lock_flags
);
2250 PDBGG("Frame #%lu queued", (unsigned long)b
.index
);
2257 et61x251_vidioc_dqbuf(struct et61x251_device
* cam
, struct file
* filp
,
2260 struct v4l2_buffer b
;
2261 struct et61x251_frame_t
*f
;
2262 unsigned long lock_flags
;
2265 if (copy_from_user(&b
, arg
, sizeof(b
)))
2268 if (b
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
|| cam
->io
!= IO_MMAP
)
2271 if (list_empty(&cam
->outqueue
)) {
2272 if (cam
->stream
== STREAM_OFF
)
2274 if (filp
->f_flags
& O_NONBLOCK
)
2276 timeout
= wait_event_interruptible_timeout
2278 (!list_empty(&cam
->outqueue
)) ||
2279 (cam
->state
& DEV_DISCONNECTED
) ||
2280 (cam
->state
& DEV_MISCONFIGURED
),
2281 cam
->module_param
.frame_timeout
*
2282 1000 * msecs_to_jiffies(1) );
2285 if (cam
->state
& DEV_DISCONNECTED
)
2287 if (!timeout
|| (cam
->state
& DEV_MISCONFIGURED
))
2291 spin_lock_irqsave(&cam
->queue_lock
, lock_flags
);
2292 f
= list_entry(cam
->outqueue
.next
, struct et61x251_frame_t
, frame
);
2293 list_del(cam
->outqueue
.next
);
2294 spin_unlock_irqrestore(&cam
->queue_lock
, lock_flags
);
2296 f
->state
= F_UNUSED
;
2298 memcpy(&b
, &f
->buf
, sizeof(b
));
2299 if (f
->vma_use_count
)
2300 b
.flags
|= V4L2_BUF_FLAG_MAPPED
;
2302 if (copy_to_user(arg
, &b
, sizeof(b
)))
2305 PDBGG("Frame #%lu dequeued", (unsigned long)f
->buf
.index
);
2312 et61x251_vidioc_streamon(struct et61x251_device
* cam
, void __user
* arg
)
2316 if (copy_from_user(&type
, arg
, sizeof(type
)))
2319 if (type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
|| cam
->io
!= IO_MMAP
)
2322 cam
->stream
= STREAM_ON
;
2324 DBG(3, "Stream on");
2331 et61x251_vidioc_streamoff(struct et61x251_device
* cam
, void __user
* arg
)
2335 if (copy_from_user(&type
, arg
, sizeof(type
)))
2338 if (type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
|| cam
->io
!= IO_MMAP
)
2341 if (cam
->stream
== STREAM_ON
)
2342 if ((err
= et61x251_stream_interrupt(cam
)))
2345 et61x251_empty_framequeues(cam
);
2347 DBG(3, "Stream off");
2354 et61x251_vidioc_g_parm(struct et61x251_device
* cam
, void __user
* arg
)
2356 struct v4l2_streamparm sp
;
2358 if (copy_from_user(&sp
, arg
, sizeof(sp
)))
2361 if (sp
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
2364 sp
.parm
.capture
.extendedmode
= 0;
2365 sp
.parm
.capture
.readbuffers
= cam
->nreadbuffers
;
2367 if (copy_to_user(arg
, &sp
, sizeof(sp
)))
2375 et61x251_vidioc_s_parm(struct et61x251_device
* cam
, void __user
* arg
)
2377 struct v4l2_streamparm sp
;
2379 if (copy_from_user(&sp
, arg
, sizeof(sp
)))
2382 if (sp
.type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
2385 sp
.parm
.capture
.extendedmode
= 0;
2387 if (sp
.parm
.capture
.readbuffers
== 0)
2388 sp
.parm
.capture
.readbuffers
= cam
->nreadbuffers
;
2390 if (sp
.parm
.capture
.readbuffers
> ET61X251_MAX_FRAMES
)
2391 sp
.parm
.capture
.readbuffers
= ET61X251_MAX_FRAMES
;
2393 if (copy_to_user(arg
, &sp
, sizeof(sp
)))
2396 cam
->nreadbuffers
= sp
.parm
.capture
.readbuffers
;
2402 static long et61x251_ioctl_v4l2(struct file
*filp
,
2403 unsigned int cmd
, void __user
*arg
)
2405 struct et61x251_device
*cam
= video_drvdata(filp
);
2409 case VIDIOC_QUERYCAP
:
2410 return et61x251_vidioc_querycap(cam
, arg
);
2412 case VIDIOC_ENUMINPUT
:
2413 return et61x251_vidioc_enuminput(cam
, arg
);
2415 case VIDIOC_G_INPUT
:
2416 return et61x251_vidioc_g_input(cam
, arg
);
2418 case VIDIOC_S_INPUT
:
2419 return et61x251_vidioc_s_input(cam
, arg
);
2421 case VIDIOC_QUERYCTRL
:
2422 return et61x251_vidioc_query_ctrl(cam
, arg
);
2425 return et61x251_vidioc_g_ctrl(cam
, arg
);
2428 return et61x251_vidioc_s_ctrl(cam
, arg
);
2430 case VIDIOC_CROPCAP
:
2431 return et61x251_vidioc_cropcap(cam
, arg
);
2434 return et61x251_vidioc_g_crop(cam
, arg
);
2437 return et61x251_vidioc_s_crop(cam
, arg
);
2439 case VIDIOC_ENUM_FMT
:
2440 return et61x251_vidioc_enum_fmt(cam
, arg
);
2443 return et61x251_vidioc_g_fmt(cam
, arg
);
2445 case VIDIOC_TRY_FMT
:
2447 return et61x251_vidioc_try_s_fmt(cam
, cmd
, arg
);
2449 case VIDIOC_ENUM_FRAMESIZES
:
2450 return et61x251_vidioc_enum_framesizes(cam
, arg
);
2452 case VIDIOC_G_JPEGCOMP
:
2453 return et61x251_vidioc_g_jpegcomp(cam
, arg
);
2455 case VIDIOC_S_JPEGCOMP
:
2456 return et61x251_vidioc_s_jpegcomp(cam
, arg
);
2458 case VIDIOC_REQBUFS
:
2459 return et61x251_vidioc_reqbufs(cam
, arg
);
2461 case VIDIOC_QUERYBUF
:
2462 return et61x251_vidioc_querybuf(cam
, arg
);
2465 return et61x251_vidioc_qbuf(cam
, arg
);
2468 return et61x251_vidioc_dqbuf(cam
, filp
, arg
);
2470 case VIDIOC_STREAMON
:
2471 return et61x251_vidioc_streamon(cam
, arg
);
2473 case VIDIOC_STREAMOFF
:
2474 return et61x251_vidioc_streamoff(cam
, arg
);
2477 return et61x251_vidioc_g_parm(cam
, arg
);
2480 return et61x251_vidioc_s_parm(cam
, arg
);
2484 case VIDIOC_QUERYSTD
:
2485 case VIDIOC_ENUMSTD
:
2486 case VIDIOC_QUERYMENU
:
2487 case VIDIOC_ENUM_FRAMEINTERVALS
:
2497 static long et61x251_ioctl(struct file
*filp
,
2498 unsigned int cmd
, unsigned long arg
)
2500 struct et61x251_device
*cam
= video_drvdata(filp
);
2503 if (mutex_lock_interruptible(&cam
->fileop_mutex
))
2504 return -ERESTARTSYS
;
2506 if (cam
->state
& DEV_DISCONNECTED
) {
2507 DBG(1, "Device not present");
2508 mutex_unlock(&cam
->fileop_mutex
);
2512 if (cam
->state
& DEV_MISCONFIGURED
) {
2513 DBG(1, "The camera is misconfigured. Close and open it "
2515 mutex_unlock(&cam
->fileop_mutex
);
2519 V4LDBG(3, "et61x251", cmd
);
2521 err
= et61x251_ioctl_v4l2(filp
, cmd
, (void __user
*)arg
);
2523 mutex_unlock(&cam
->fileop_mutex
);
2529 static const struct v4l2_file_operations et61x251_fops
= {
2530 .owner
= THIS_MODULE
,
2531 .open
= et61x251_open
,
2532 .release
= et61x251_release
,
2533 .ioctl
= et61x251_ioctl
,
2534 .read
= et61x251_read
,
2535 .poll
= et61x251_poll
,
2536 .mmap
= et61x251_mmap
,
2539 /*****************************************************************************/
2541 /* It exists a single interface only. We do not need to validate anything. */
2543 et61x251_usb_probe(struct usb_interface
* intf
, const struct usb_device_id
* id
)
2545 struct usb_device
*udev
= interface_to_usbdev(intf
);
2546 struct et61x251_device
* cam
;
2547 static unsigned int dev_nr
;
2551 if (!(cam
= kzalloc(sizeof(struct et61x251_device
), GFP_KERNEL
)))
2556 if (!(cam
->control_buffer
= kzalloc(8, GFP_KERNEL
))) {
2557 DBG(1, "kmalloc() failed");
2562 if (!(cam
->v4ldev
= video_device_alloc())) {
2563 DBG(1, "video_device_alloc() failed");
2568 DBG(2, "ET61X[12]51 PC Camera Controller detected "
2569 "(vid/pid 0x%04X:0x%04X)",id
->idVendor
, id
->idProduct
);
2571 for (i
= 0; et61x251_sensor_table
[i
]; i
++) {
2572 err
= et61x251_sensor_table
[i
](cam
);
2578 DBG(2, "%s image sensor detected", cam
->sensor
.name
);
2580 DBG(1, "No supported image sensor detected");
2585 if (et61x251_init(cam
)) {
2586 DBG(1, "Initialization failed. I will retry on open().");
2587 cam
->state
|= DEV_MISCONFIGURED
;
2590 strcpy(cam
->v4ldev
->name
, "ET61X[12]51 PC Camera");
2591 cam
->v4ldev
->fops
= &et61x251_fops
;
2592 cam
->v4ldev
->release
= video_device_release
;
2593 cam
->v4ldev
->parent
= &udev
->dev
;
2594 video_set_drvdata(cam
->v4ldev
, cam
);
2596 init_completion(&cam
->probe
);
2598 err
= video_register_device(cam
->v4ldev
, VFL_TYPE_GRABBER
,
2601 DBG(1, "V4L2 device registration failed");
2602 if (err
== -ENFILE
&& video_nr
[dev_nr
] == -1)
2603 DBG(1, "Free /dev/videoX node not found");
2604 video_nr
[dev_nr
] = -1;
2605 dev_nr
= (dev_nr
< ET61X251_MAX_DEVICES
-1) ? dev_nr
+1 : 0;
2606 complete_all(&cam
->probe
);
2610 DBG(2, "V4L2 device registered as %s",
2611 video_device_node_name(cam
->v4ldev
));
2613 cam
->module_param
.force_munmap
= force_munmap
[dev_nr
];
2614 cam
->module_param
.frame_timeout
= frame_timeout
[dev_nr
];
2616 dev_nr
= (dev_nr
< ET61X251_MAX_DEVICES
-1) ? dev_nr
+1 : 0;
2618 #ifdef CONFIG_VIDEO_ADV_DEBUG
2619 err
= et61x251_create_sysfs(cam
);
2621 DBG(2, "Optional device control through 'sysfs' "
2624 DBG(2, "Failed to create 'sysfs' interface for optional "
2625 "device controlling. Error #%d", err
);
2627 DBG(2, "Optional device control through 'sysfs' interface disabled");
2628 DBG(3, "Compile the kernel with the 'CONFIG_VIDEO_ADV_DEBUG' "
2629 "configuration option to enable it.");
2632 usb_set_intfdata(intf
, cam
);
2633 kref_init(&cam
->kref
);
2634 usb_get_dev(cam
->usbdev
);
2636 complete_all(&cam
->probe
);
2642 kfree(cam
->control_buffer
);
2644 video_device_release(cam
->v4ldev
);
2651 static void et61x251_usb_disconnect(struct usb_interface
* intf
)
2653 struct et61x251_device
* cam
;
2655 down_write(&et61x251_dev_lock
);
2657 cam
= usb_get_intfdata(intf
);
2659 DBG(2, "Disconnecting %s...", cam
->v4ldev
->name
);
2662 DBG(2, "Device %s is open! Deregistration and memory "
2663 "deallocation are deferred.",
2664 video_device_node_name(cam
->v4ldev
));
2665 cam
->state
|= DEV_MISCONFIGURED
;
2666 et61x251_stop_transfer(cam
);
2667 cam
->state
|= DEV_DISCONNECTED
;
2668 wake_up_interruptible(&cam
->wait_frame
);
2669 wake_up(&cam
->wait_stream
);
2671 cam
->state
|= DEV_DISCONNECTED
;
2673 wake_up_interruptible_all(&cam
->wait_open
);
2675 kref_put(&cam
->kref
, et61x251_release_resources
);
2677 up_write(&et61x251_dev_lock
);
2681 static struct usb_driver et61x251_usb_driver
= {
2683 .id_table
= et61x251_id_table
,
2684 .probe
= et61x251_usb_probe
,
2685 .disconnect
= et61x251_usb_disconnect
,
2688 /*****************************************************************************/
2690 static int __init
et61x251_module_init(void)
2694 KDBG(2, ET61X251_MODULE_NAME
" v" ET61X251_MODULE_VERSION
);
2695 KDBG(3, ET61X251_MODULE_AUTHOR
);
2697 if ((err
= usb_register(&et61x251_usb_driver
)))
2698 KDBG(1, "usb_register() failed");
2704 static void __exit
et61x251_module_exit(void)
2706 usb_deregister(&et61x251_usb_driver
);
2710 module_init(et61x251_module_init
);
2711 module_exit(et61x251_module_exit
);