2 * Main USB camera driver
4 * Copyright (C) 2008-2010 Jean-François Moine <http://moinejf.free.fr>
6 * Camera button input handling by Márton Németh
7 * Copyright (C) 2009-2010 Márton Németh <nm127@freemail.hu>
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2 of the License, or (at your
12 * option) any later version.
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software Foundation,
21 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #define MODULE_NAME "gspca"
26 #include <linux/init.h>
27 #include <linux/version.h>
29 #include <linux/vmalloc.h>
30 #include <linux/sched.h>
31 #include <linux/slab.h>
33 #include <linux/string.h>
34 #include <linux/pagemap.h>
37 #include <linux/uaccess.h>
38 #include <linux/ktime.h>
39 #include <media/v4l2-ioctl.h>
43 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
44 #include <linux/input.h>
45 #include <linux/usb/input.h>
49 #define DEF_NURBS 3 /* default number of URBs */
50 #if DEF_NURBS > MAX_NURBS
51 #error "DEF_NURBS too big"
54 MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>");
55 MODULE_DESCRIPTION("GSPCA USB Camera Driver");
56 MODULE_LICENSE("GPL");
58 #define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 9, 0)
61 int gspca_debug
= D_ERR
| D_PROBE
;
62 EXPORT_SYMBOL(gspca_debug
);
64 static void PDEBUG_MODE(char *txt
, __u32 pixfmt
, int w
, int h
)
66 if ((pixfmt
>> 24) >= '0' && (pixfmt
>> 24) <= 'z') {
67 PDEBUG(D_CONF
|D_STREAM
, "%s %c%c%c%c %dx%d",
71 (pixfmt
>> 16) & 0xff,
75 PDEBUG(D_CONF
|D_STREAM
, "%s 0x%08x %dx%d",
82 #define PDEBUG_MODE(txt, pixfmt, w, h)
85 /* specific memory types - !! should be different from V4L2_MEMORY_xxx */
86 #define GSPCA_MEMORY_NO 0 /* V4L2_MEMORY_xxx starts from 1 */
87 #define GSPCA_MEMORY_READ 7
89 #define BUF_ALL_FLAGS (V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE)
94 static void gspca_vm_open(struct vm_area_struct
*vma
)
96 struct gspca_frame
*frame
= vma
->vm_private_data
;
98 frame
->vma_use_count
++;
99 frame
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_MAPPED
;
102 static void gspca_vm_close(struct vm_area_struct
*vma
)
104 struct gspca_frame
*frame
= vma
->vm_private_data
;
106 if (--frame
->vma_use_count
<= 0)
107 frame
->v4l2_buf
.flags
&= ~V4L2_BUF_FLAG_MAPPED
;
110 static const struct vm_operations_struct gspca_vm_ops
= {
111 .open
= gspca_vm_open
,
112 .close
= gspca_vm_close
,
116 * Input and interrupt endpoint handling functions
118 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
119 static void int_irq(struct urb
*urb
)
121 struct gspca_dev
*gspca_dev
= (struct gspca_dev
*) urb
->context
;
127 if (gspca_dev
->sd_desc
->int_pkt_scan(gspca_dev
,
128 urb
->transfer_buffer
, urb
->actual_length
) < 0) {
129 PDEBUG(D_ERR
, "Unknown packet received");
137 /* Stop is requested either by software or hardware is gone,
138 * keep the ret value non-zero and don't resubmit later.
143 PDEBUG(D_ERR
, "URB error %i, resubmitting", urb
->status
);
149 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
151 PDEBUG(D_ERR
, "Resubmit URB failed with error %i", ret
);
155 static int gspca_input_connect(struct gspca_dev
*dev
)
157 struct input_dev
*input_dev
;
160 dev
->input_dev
= NULL
;
161 if (dev
->sd_desc
->int_pkt_scan
|| dev
->sd_desc
->other_input
) {
162 input_dev
= input_allocate_device();
166 usb_make_path(dev
->dev
, dev
->phys
, sizeof(dev
->phys
));
167 strlcat(dev
->phys
, "/input0", sizeof(dev
->phys
));
169 input_dev
->name
= dev
->sd_desc
->name
;
170 input_dev
->phys
= dev
->phys
;
172 usb_to_input_id(dev
->dev
, &input_dev
->id
);
174 input_dev
->evbit
[0] = BIT_MASK(EV_KEY
);
175 input_dev
->keybit
[BIT_WORD(KEY_CAMERA
)] = BIT_MASK(KEY_CAMERA
);
176 input_dev
->dev
.parent
= &dev
->dev
->dev
;
178 err
= input_register_device(input_dev
);
180 PDEBUG(D_ERR
, "Input device registration failed "
181 "with error %i", err
);
182 input_dev
->dev
.parent
= NULL
;
183 input_free_device(input_dev
);
185 dev
->input_dev
= input_dev
;
192 static int alloc_and_submit_int_urb(struct gspca_dev
*gspca_dev
,
193 struct usb_endpoint_descriptor
*ep
)
195 unsigned int buffer_len
;
198 struct usb_device
*dev
;
202 buffer_len
= le16_to_cpu(ep
->wMaxPacketSize
);
203 interval
= ep
->bInterval
;
204 PDEBUG(D_PROBE
, "found int in endpoint: 0x%x, "
205 "buffer_len=%u, interval=%u",
206 ep
->bEndpointAddress
, buffer_len
, interval
);
208 dev
= gspca_dev
->dev
;
210 urb
= usb_alloc_urb(0, GFP_KERNEL
);
216 buffer
= usb_buffer_alloc(dev
, buffer_len
,
217 GFP_KERNEL
, &urb
->transfer_dma
);
222 usb_fill_int_urb(urb
, dev
,
223 usb_rcvintpipe(dev
, ep
->bEndpointAddress
),
225 int_irq
, (void *)gspca_dev
, interval
);
226 gspca_dev
->int_urb
= urb
;
227 ret
= usb_submit_urb(urb
, GFP_KERNEL
);
229 PDEBUG(D_ERR
, "submit URB failed with error %i", ret
);
236 urb
->transfer_buffer_length
,
237 urb
->transfer_buffer
,
245 static void gspca_input_create_urb(struct gspca_dev
*gspca_dev
)
247 struct usb_interface
*intf
;
248 struct usb_host_interface
*intf_desc
;
249 struct usb_endpoint_descriptor
*ep
;
252 if (gspca_dev
->sd_desc
->int_pkt_scan
) {
253 intf
= usb_ifnum_to_if(gspca_dev
->dev
, gspca_dev
->iface
);
254 intf_desc
= intf
->cur_altsetting
;
255 for (i
= 0; i
< intf_desc
->desc
.bNumEndpoints
; i
++) {
256 ep
= &intf_desc
->endpoint
[i
].desc
;
257 if (usb_endpoint_dir_in(ep
) &&
258 usb_endpoint_xfer_int(ep
)) {
260 alloc_and_submit_int_urb(gspca_dev
, ep
);
267 static void gspca_input_destroy_urb(struct gspca_dev
*gspca_dev
)
271 urb
= gspca_dev
->int_urb
;
273 gspca_dev
->int_urb
= NULL
;
275 usb_buffer_free(gspca_dev
->dev
,
276 urb
->transfer_buffer_length
,
277 urb
->transfer_buffer
,
283 static inline void gspca_input_destroy_urb(struct gspca_dev
*gspca_dev
)
287 static inline void gspca_input_create_urb(struct gspca_dev
*gspca_dev
)
291 static inline int gspca_input_connect(struct gspca_dev
*dev
)
297 /* get the current input frame buffer */
298 struct gspca_frame
*gspca_get_i_frame(struct gspca_dev
*gspca_dev
)
300 struct gspca_frame
*frame
;
302 frame
= gspca_dev
->cur_frame
;
303 if ((frame
->v4l2_buf
.flags
& BUF_ALL_FLAGS
)
304 != V4L2_BUF_FLAG_QUEUED
)
308 EXPORT_SYMBOL(gspca_get_i_frame
);
311 * fill a video frame from an URB and resubmit
313 static void fill_frame(struct gspca_dev
*gspca_dev
,
316 u8
*data
; /* address of data in the iso message */
320 if (urb
->status
!= 0) {
321 if (urb
->status
== -ESHUTDOWN
)
322 return; /* disconnection */
324 if (gspca_dev
->frozen
)
327 PDEBUG(D_ERR
|D_PACK
, "urb status: %d", urb
->status
);
331 pkt_scan
= gspca_dev
->sd_desc
->pkt_scan
;
332 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
334 /* check the packet status and length */
335 len
= urb
->iso_frame_desc
[i
].actual_length
;
337 if (gspca_dev
->empty_packet
== 0)
338 gspca_dev
->empty_packet
= 1;
341 st
= urb
->iso_frame_desc
[i
].status
;
344 "ISOC data error: [%d] len=%d, status=%d",
346 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
350 /* let the packet be analyzed by the subdriver */
351 PDEBUG(D_PACK
, "packet [%d] o:%d l:%d",
352 i
, urb
->iso_frame_desc
[i
].offset
, len
);
353 data
= (u8
*) urb
->transfer_buffer
354 + urb
->iso_frame_desc
[i
].offset
;
355 pkt_scan(gspca_dev
, data
, len
);
359 /* resubmit the URB */
360 st
= usb_submit_urb(urb
, GFP_ATOMIC
);
362 PDEBUG(D_ERR
|D_PACK
, "usb_submit_urb() ret %d", st
);
366 * ISOC message interrupt from the USB device
368 * Analyse each packet and call the subdriver for copy to the frame buffer.
370 static void isoc_irq(struct urb
*urb
)
372 struct gspca_dev
*gspca_dev
= (struct gspca_dev
*) urb
->context
;
374 PDEBUG(D_PACK
, "isoc irq");
375 if (!gspca_dev
->streaming
)
377 fill_frame(gspca_dev
, urb
);
381 * bulk message interrupt from the USB device
383 static void bulk_irq(struct urb
*urb
)
385 struct gspca_dev
*gspca_dev
= (struct gspca_dev
*) urb
->context
;
388 PDEBUG(D_PACK
, "bulk irq");
389 if (!gspca_dev
->streaming
)
391 switch (urb
->status
) {
395 return; /* disconnection */
398 if (gspca_dev
->frozen
)
401 PDEBUG(D_ERR
|D_PACK
, "urb status: %d", urb
->status
);
406 PDEBUG(D_PACK
, "packet l:%d", urb
->actual_length
);
407 gspca_dev
->sd_desc
->pkt_scan(gspca_dev
,
408 urb
->transfer_buffer
,
412 /* resubmit the URB */
413 if (gspca_dev
->cam
.bulk_nurbs
!= 0) {
414 st
= usb_submit_urb(urb
, GFP_ATOMIC
);
416 PDEBUG(D_ERR
|D_PACK
, "usb_submit_urb() ret %d", st
);
421 * add data to the current frame
423 * This function is called by the subdrivers at interrupt level.
425 * To build a frame, these ones must add
427 * - 0 or many INTER_PACKETs
429 * DISCARD_PACKET invalidates the whole frame.
430 * On LAST_PACKET, a new frame is returned.
432 void gspca_frame_add(struct gspca_dev
*gspca_dev
,
433 enum gspca_packet_type packet_type
,
437 struct gspca_frame
*frame
;
440 PDEBUG(D_PACK
, "add t:%d l:%d", packet_type
, len
);
442 /* check the availability of the frame buffer */
443 frame
= gspca_dev
->cur_frame
;
444 if ((frame
->v4l2_buf
.flags
& BUF_ALL_FLAGS
)
445 != V4L2_BUF_FLAG_QUEUED
) {
446 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
450 /* when start of a new frame, if the current frame buffer
451 * is not queued, discard the whole frame */
452 if (packet_type
== FIRST_PACKET
) {
453 frame
->data_end
= frame
->data
;
454 frame
->v4l2_buf
.timestamp
= ktime_to_timeval(ktime_get());
455 frame
->v4l2_buf
.sequence
= ++gspca_dev
->sequence
;
456 } else if (gspca_dev
->last_packet_type
== DISCARD_PACKET
) {
457 if (packet_type
== LAST_PACKET
)
458 gspca_dev
->last_packet_type
= packet_type
;
462 /* append the packet to the frame buffer */
464 if (frame
->data_end
- frame
->data
+ len
465 > frame
->v4l2_buf
.length
) {
466 PDEBUG(D_ERR
|D_PACK
, "frame overflow %zd > %d",
467 frame
->data_end
- frame
->data
+ len
,
468 frame
->v4l2_buf
.length
);
469 packet_type
= DISCARD_PACKET
;
471 memcpy(frame
->data_end
, data
, len
);
472 frame
->data_end
+= len
;
475 gspca_dev
->last_packet_type
= packet_type
;
477 /* if last packet, wake up the application and advance in the queue */
478 if (packet_type
== LAST_PACKET
) {
479 frame
->v4l2_buf
.bytesused
= frame
->data_end
- frame
->data
;
480 frame
->v4l2_buf
.flags
&= ~V4L2_BUF_FLAG_QUEUED
;
481 frame
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_DONE
;
482 wake_up_interruptible(&gspca_dev
->wq
); /* event = new frame */
483 i
= (gspca_dev
->fr_i
+ 1) % gspca_dev
->nframes
;
485 PDEBUG(D_FRAM
, "frame complete len:%d q:%d i:%d o:%d",
486 frame
->v4l2_buf
.bytesused
,
490 j
= gspca_dev
->fr_queue
[i
];
491 gspca_dev
->cur_frame
= &gspca_dev
->frame
[j
];
494 EXPORT_SYMBOL(gspca_frame_add
);
496 static int gspca_is_compressed(__u32 format
)
499 case V4L2_PIX_FMT_MJPEG
:
500 case V4L2_PIX_FMT_JPEG
:
501 case V4L2_PIX_FMT_SPCA561
:
502 case V4L2_PIX_FMT_PAC207
:
503 case V4L2_PIX_FMT_MR97310A
:
509 static void *rvmalloc(long size
)
514 mem
= vmalloc_32(size
);
516 adr
= (unsigned long) mem
;
518 SetPageReserved(vmalloc_to_page((void *) adr
));
526 static void rvfree(void *mem
, long size
)
530 adr
= (unsigned long) mem
;
532 ClearPageReserved(vmalloc_to_page((void *) adr
));
539 static int frame_alloc(struct gspca_dev
*gspca_dev
,
542 struct gspca_frame
*frame
;
546 i
= gspca_dev
->curr_mode
;
547 frsz
= gspca_dev
->cam
.cam_mode
[i
].sizeimage
;
548 PDEBUG(D_STREAM
, "frame alloc frsz: %d", frsz
);
549 frsz
= PAGE_ALIGN(frsz
);
550 gspca_dev
->frsz
= frsz
;
551 if (count
> GSPCA_MAX_FRAMES
)
552 count
= GSPCA_MAX_FRAMES
;
553 gspca_dev
->frbuf
= rvmalloc(frsz
* count
);
554 if (!gspca_dev
->frbuf
) {
555 err("frame alloc failed");
558 gspca_dev
->nframes
= count
;
559 for (i
= 0; i
< count
; i
++) {
560 frame
= &gspca_dev
->frame
[i
];
561 frame
->v4l2_buf
.index
= i
;
562 frame
->v4l2_buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
563 frame
->v4l2_buf
.flags
= 0;
564 frame
->v4l2_buf
.field
= V4L2_FIELD_NONE
;
565 frame
->v4l2_buf
.length
= frsz
;
566 frame
->v4l2_buf
.memory
= gspca_dev
->memory
;
567 frame
->v4l2_buf
.sequence
= 0;
568 frame
->data
= frame
->data_end
=
569 gspca_dev
->frbuf
+ i
* frsz
;
570 frame
->v4l2_buf
.m
.offset
= i
* frsz
;
572 gspca_dev
->fr_i
= gspca_dev
->fr_o
= gspca_dev
->fr_q
= 0;
573 gspca_dev
->cur_frame
= &gspca_dev
->frame
[0];
574 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
575 gspca_dev
->sequence
= 0;
579 static void frame_free(struct gspca_dev
*gspca_dev
)
583 PDEBUG(D_STREAM
, "frame free");
584 if (gspca_dev
->frbuf
!= NULL
) {
585 rvfree(gspca_dev
->frbuf
,
586 gspca_dev
->nframes
* gspca_dev
->frsz
);
587 gspca_dev
->frbuf
= NULL
;
588 for (i
= 0; i
< gspca_dev
->nframes
; i
++)
589 gspca_dev
->frame
[i
].data
= NULL
;
591 gspca_dev
->nframes
= 0;
594 static void destroy_urbs(struct gspca_dev
*gspca_dev
)
599 PDEBUG(D_STREAM
, "kill transfer");
600 for (i
= 0; i
< MAX_NURBS
; i
++) {
601 urb
= gspca_dev
->urb
[i
];
605 gspca_dev
->urb
[i
] = NULL
;
607 if (urb
->transfer_buffer
!= NULL
)
608 usb_buffer_free(gspca_dev
->dev
,
609 urb
->transfer_buffer_length
,
610 urb
->transfer_buffer
,
616 static int gspca_set_alt0(struct gspca_dev
*gspca_dev
)
620 if (gspca_dev
->alt
== 0)
622 ret
= usb_set_interface(gspca_dev
->dev
, gspca_dev
->iface
, 0);
624 PDEBUG(D_ERR
|D_STREAM
, "set alt 0 err %d", ret
);
628 /* Note: both the queue and the usb locks should be held when calling this */
629 static void gspca_stream_off(struct gspca_dev
*gspca_dev
)
631 gspca_dev
->streaming
= 0;
632 if (gspca_dev
->present
) {
633 if (gspca_dev
->sd_desc
->stopN
)
634 gspca_dev
->sd_desc
->stopN(gspca_dev
);
635 destroy_urbs(gspca_dev
);
636 gspca_input_destroy_urb(gspca_dev
);
637 gspca_set_alt0(gspca_dev
);
638 gspca_input_create_urb(gspca_dev
);
641 /* always call stop0 to free the subdriver's resources */
642 if (gspca_dev
->sd_desc
->stop0
)
643 gspca_dev
->sd_desc
->stop0(gspca_dev
);
644 PDEBUG(D_STREAM
, "stream off OK");
648 * look for an input transfer endpoint in an alternate setting
650 static struct usb_host_endpoint
*alt_xfer(struct usb_host_interface
*alt
,
653 struct usb_host_endpoint
*ep
;
656 for (i
= 0; i
< alt
->desc
.bNumEndpoints
; i
++) {
657 ep
= &alt
->endpoint
[i
];
658 attr
= ep
->desc
.bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
;
660 && ep
->desc
.wMaxPacketSize
!= 0)
667 * look for an input (isoc or bulk) endpoint
669 * The endpoint is defined by the subdriver.
670 * Use only the first isoc (some Zoran - 0x0572:0x0001 - have two such ep).
671 * This routine may be called many times when the bandwidth is too small
672 * (the bandwidth is checked on urb submit).
674 static struct usb_host_endpoint
*get_ep(struct gspca_dev
*gspca_dev
)
676 struct usb_interface
*intf
;
677 struct usb_host_endpoint
*ep
;
680 intf
= usb_ifnum_to_if(gspca_dev
->dev
, gspca_dev
->iface
);
682 xfer
= gspca_dev
->cam
.bulk
? USB_ENDPOINT_XFER_BULK
683 : USB_ENDPOINT_XFER_ISOC
;
684 i
= gspca_dev
->alt
; /* previous alt setting */
685 if (gspca_dev
->cam
.reverse_alts
) {
686 while (++i
< gspca_dev
->nbalt
) {
687 ep
= alt_xfer(&intf
->altsetting
[i
], xfer
);
693 ep
= alt_xfer(&intf
->altsetting
[i
], xfer
);
699 err("no transfer endpoint found");
702 PDEBUG(D_STREAM
, "use alt %d ep 0x%02x",
703 i
, ep
->desc
.bEndpointAddress
);
704 gspca_dev
->alt
= i
; /* memorize the current alt setting */
705 if (gspca_dev
->nbalt
> 1) {
706 gspca_input_destroy_urb(gspca_dev
);
707 ret
= usb_set_interface(gspca_dev
->dev
, gspca_dev
->iface
, i
);
709 err("set alt %d err %d", i
, ret
);
712 gspca_input_create_urb(gspca_dev
);
718 * create the URBs for image transfer
720 static int create_urbs(struct gspca_dev
*gspca_dev
,
721 struct usb_host_endpoint
*ep
)
724 int n
, nurbs
, i
, psize
, npkt
, bsize
;
726 /* calculate the packet size and the number of packets */
727 psize
= le16_to_cpu(ep
->desc
.wMaxPacketSize
);
729 if (!gspca_dev
->cam
.bulk
) { /* isoc */
731 /* See paragraph 5.9 / table 5-11 of the usb 2.0 spec. */
732 if (gspca_dev
->pkt_size
== 0)
733 psize
= (psize
& 0x07ff) * (1 + ((psize
>> 11) & 3));
735 psize
= gspca_dev
->pkt_size
;
736 npkt
= gspca_dev
->cam
.npkt
;
738 npkt
= 32; /* default value */
739 bsize
= psize
* npkt
;
741 "isoc %d pkts size %d = bsize:%d",
746 bsize
= gspca_dev
->cam
.bulk_size
;
749 PDEBUG(D_STREAM
, "bulk bsize:%d", bsize
);
750 if (gspca_dev
->cam
.bulk_nurbs
!= 0)
751 nurbs
= gspca_dev
->cam
.bulk_nurbs
;
756 for (n
= 0; n
< nurbs
; n
++) {
757 urb
= usb_alloc_urb(npkt
, GFP_KERNEL
);
759 err("usb_alloc_urb failed");
762 gspca_dev
->urb
[n
] = urb
;
763 urb
->transfer_buffer
= usb_buffer_alloc(gspca_dev
->dev
,
768 if (urb
->transfer_buffer
== NULL
) {
769 err("usb_buffer_alloc failed");
772 urb
->dev
= gspca_dev
->dev
;
773 urb
->context
= gspca_dev
;
774 urb
->transfer_buffer_length
= bsize
;
775 if (npkt
!= 0) { /* ISOC */
776 urb
->pipe
= usb_rcvisocpipe(gspca_dev
->dev
,
777 ep
->desc
.bEndpointAddress
);
778 urb
->transfer_flags
= URB_ISO_ASAP
779 | URB_NO_TRANSFER_DMA_MAP
;
780 urb
->interval
= ep
->desc
.bInterval
;
781 urb
->complete
= isoc_irq
;
782 urb
->number_of_packets
= npkt
;
783 for (i
= 0; i
< npkt
; i
++) {
784 urb
->iso_frame_desc
[i
].length
= psize
;
785 urb
->iso_frame_desc
[i
].offset
= psize
* i
;
788 urb
->pipe
= usb_rcvbulkpipe(gspca_dev
->dev
,
789 ep
->desc
.bEndpointAddress
),
790 urb
->transfer_flags
= URB_NO_TRANSFER_DMA_MAP
;
791 urb
->complete
= bulk_irq
;
798 * start the USB transfer
800 static int gspca_init_transfer(struct gspca_dev
*gspca_dev
)
802 struct usb_host_endpoint
*ep
;
806 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
809 if (!gspca_dev
->present
) {
814 gspca_dev
->usb_err
= 0;
816 /* set the higher alternate setting and
817 * loop until urb submit succeeds */
818 if (gspca_dev
->cam
.reverse_alts
)
821 gspca_dev
->alt
= gspca_dev
->nbalt
;
823 if (gspca_dev
->sd_desc
->isoc_init
) {
824 ret
= gspca_dev
->sd_desc
->isoc_init(gspca_dev
);
828 ep
= get_ep(gspca_dev
);
834 if (!gspca_dev
->cam
.no_urb_create
) {
835 PDEBUG(D_STREAM
, "init transfer alt %d",
837 ret
= create_urbs(gspca_dev
, ep
);
839 destroy_urbs(gspca_dev
);
844 /* clear the bulk endpoint */
845 if (gspca_dev
->cam
.bulk
)
846 usb_clear_halt(gspca_dev
->dev
,
847 gspca_dev
->urb
[0]->pipe
);
850 ret
= gspca_dev
->sd_desc
->start(gspca_dev
);
852 destroy_urbs(gspca_dev
);
855 gspca_dev
->streaming
= 1;
857 /* some bulk transfers are started by the subdriver */
858 if (gspca_dev
->cam
.bulk
&& gspca_dev
->cam
.bulk_nurbs
== 0)
861 /* submit the URBs */
862 for (n
= 0; n
< MAX_NURBS
; n
++) {
863 urb
= gspca_dev
->urb
[n
];
866 ret
= usb_submit_urb(urb
, GFP_KERNEL
);
872 gspca_stream_off(gspca_dev
);
873 if (ret
!= -ENOSPC
) {
874 PDEBUG(D_ERR
|D_STREAM
,
875 "usb_submit_urb alt %d err %d",
876 gspca_dev
->alt
, ret
);
880 /* the bandwidth is not wide enough
881 * negociate or try a lower alternate setting */
882 PDEBUG(D_ERR
|D_STREAM
,
883 "bandwidth not wide enough - trying again");
884 msleep(20); /* wait for kill complete */
885 if (gspca_dev
->sd_desc
->isoc_nego
) {
886 ret
= gspca_dev
->sd_desc
->isoc_nego(gspca_dev
);
890 ep
= get_ep(gspca_dev
);
898 mutex_unlock(&gspca_dev
->usb_lock
);
902 static void gspca_set_default_mode(struct gspca_dev
*gspca_dev
)
906 i
= gspca_dev
->cam
.nmodes
- 1; /* take the highest mode */
907 gspca_dev
->curr_mode
= i
;
908 gspca_dev
->width
= gspca_dev
->cam
.cam_mode
[i
].width
;
909 gspca_dev
->height
= gspca_dev
->cam
.cam_mode
[i
].height
;
910 gspca_dev
->pixfmt
= gspca_dev
->cam
.cam_mode
[i
].pixelformat
;
913 static int wxh_to_mode(struct gspca_dev
*gspca_dev
,
914 int width
, int height
)
918 for (i
= gspca_dev
->cam
.nmodes
; --i
> 0; ) {
919 if (width
>= gspca_dev
->cam
.cam_mode
[i
].width
920 && height
>= gspca_dev
->cam
.cam_mode
[i
].height
)
927 * search a mode with the right pixel format
929 static int gspca_get_mode(struct gspca_dev
*gspca_dev
,
935 modeU
= modeD
= mode
;
936 while ((modeU
< gspca_dev
->cam
.nmodes
) || modeD
>= 0) {
938 if (gspca_dev
->cam
.cam_mode
[modeD
].pixelformat
942 if (++modeU
< gspca_dev
->cam
.nmodes
) {
943 if (gspca_dev
->cam
.cam_mode
[modeU
].pixelformat
951 #ifdef CONFIG_VIDEO_ADV_DEBUG
952 static int vidioc_g_register(struct file
*file
, void *priv
,
953 struct v4l2_dbg_register
*reg
)
956 struct gspca_dev
*gspca_dev
= priv
;
958 if (!gspca_dev
->sd_desc
->get_chip_ident
)
961 if (!gspca_dev
->sd_desc
->get_register
)
964 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
966 gspca_dev
->usb_err
= 0;
967 if (gspca_dev
->present
)
968 ret
= gspca_dev
->sd_desc
->get_register(gspca_dev
, reg
);
971 mutex_unlock(&gspca_dev
->usb_lock
);
976 static int vidioc_s_register(struct file
*file
, void *priv
,
977 struct v4l2_dbg_register
*reg
)
980 struct gspca_dev
*gspca_dev
= priv
;
982 if (!gspca_dev
->sd_desc
->get_chip_ident
)
985 if (!gspca_dev
->sd_desc
->set_register
)
988 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
990 gspca_dev
->usb_err
= 0;
991 if (gspca_dev
->present
)
992 ret
= gspca_dev
->sd_desc
->set_register(gspca_dev
, reg
);
995 mutex_unlock(&gspca_dev
->usb_lock
);
1001 static int vidioc_g_chip_ident(struct file
*file
, void *priv
,
1002 struct v4l2_dbg_chip_ident
*chip
)
1005 struct gspca_dev
*gspca_dev
= priv
;
1007 if (!gspca_dev
->sd_desc
->get_chip_ident
)
1010 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1011 return -ERESTARTSYS
;
1012 gspca_dev
->usb_err
= 0;
1013 if (gspca_dev
->present
)
1014 ret
= gspca_dev
->sd_desc
->get_chip_ident(gspca_dev
, chip
);
1017 mutex_unlock(&gspca_dev
->usb_lock
);
1022 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *priv
,
1023 struct v4l2_fmtdesc
*fmtdesc
)
1025 struct gspca_dev
*gspca_dev
= priv
;
1029 /* give an index to each format */
1032 for (i
= gspca_dev
->cam
.nmodes
; --i
>= 0; ) {
1033 fmt_tb
[index
] = gspca_dev
->cam
.cam_mode
[i
].pixelformat
;
1036 if (fmt_tb
[j
] == fmt_tb
[index
])
1041 if (fmtdesc
->index
== index
)
1042 break; /* new format */
1044 if (index
>= ARRAY_SIZE(fmt_tb
))
1049 return -EINVAL
; /* no more format */
1051 fmtdesc
->pixelformat
= fmt_tb
[index
];
1052 if (gspca_is_compressed(fmt_tb
[index
]))
1053 fmtdesc
->flags
= V4L2_FMT_FLAG_COMPRESSED
;
1054 fmtdesc
->description
[0] = fmtdesc
->pixelformat
& 0xff;
1055 fmtdesc
->description
[1] = (fmtdesc
->pixelformat
>> 8) & 0xff;
1056 fmtdesc
->description
[2] = (fmtdesc
->pixelformat
>> 16) & 0xff;
1057 fmtdesc
->description
[3] = fmtdesc
->pixelformat
>> 24;
1058 fmtdesc
->description
[4] = '\0';
1062 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
1063 struct v4l2_format
*fmt
)
1065 struct gspca_dev
*gspca_dev
= priv
;
1068 mode
= gspca_dev
->curr_mode
;
1069 memcpy(&fmt
->fmt
.pix
, &gspca_dev
->cam
.cam_mode
[mode
],
1070 sizeof fmt
->fmt
.pix
);
1074 static int try_fmt_vid_cap(struct gspca_dev
*gspca_dev
,
1075 struct v4l2_format
*fmt
)
1077 int w
, h
, mode
, mode2
;
1079 w
= fmt
->fmt
.pix
.width
;
1080 h
= fmt
->fmt
.pix
.height
;
1083 if (gspca_debug
& D_CONF
)
1084 PDEBUG_MODE("try fmt cap", fmt
->fmt
.pix
.pixelformat
, w
, h
);
1086 /* search the closest mode for width and height */
1087 mode
= wxh_to_mode(gspca_dev
, w
, h
);
1089 /* OK if right palette */
1090 if (gspca_dev
->cam
.cam_mode
[mode
].pixelformat
1091 != fmt
->fmt
.pix
.pixelformat
) {
1093 /* else, search the closest mode with the same pixel format */
1094 mode2
= gspca_get_mode(gspca_dev
, mode
,
1095 fmt
->fmt
.pix
.pixelformat
);
1099 ; * no chance, return this mode */
1101 memcpy(&fmt
->fmt
.pix
, &gspca_dev
->cam
.cam_mode
[mode
],
1102 sizeof fmt
->fmt
.pix
);
1103 return mode
; /* used when s_fmt */
1106 static int vidioc_try_fmt_vid_cap(struct file
*file
,
1108 struct v4l2_format
*fmt
)
1110 struct gspca_dev
*gspca_dev
= priv
;
1113 ret
= try_fmt_vid_cap(gspca_dev
, fmt
);
1119 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
1120 struct v4l2_format
*fmt
)
1122 struct gspca_dev
*gspca_dev
= priv
;
1125 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1126 return -ERESTARTSYS
;
1128 ret
= try_fmt_vid_cap(gspca_dev
, fmt
);
1132 if (gspca_dev
->nframes
!= 0
1133 && fmt
->fmt
.pix
.sizeimage
> gspca_dev
->frsz
) {
1138 if (ret
== gspca_dev
->curr_mode
) {
1140 goto out
; /* same mode */
1143 if (gspca_dev
->streaming
) {
1147 gspca_dev
->width
= fmt
->fmt
.pix
.width
;
1148 gspca_dev
->height
= fmt
->fmt
.pix
.height
;
1149 gspca_dev
->pixfmt
= fmt
->fmt
.pix
.pixelformat
;
1150 gspca_dev
->curr_mode
= ret
;
1154 mutex_unlock(&gspca_dev
->queue_lock
);
1158 static int vidioc_enum_framesizes(struct file
*file
, void *priv
,
1159 struct v4l2_frmsizeenum
*fsize
)
1161 struct gspca_dev
*gspca_dev
= priv
;
1165 for (i
= 0; i
< gspca_dev
->cam
.nmodes
; i
++) {
1166 if (fsize
->pixel_format
!=
1167 gspca_dev
->cam
.cam_mode
[i
].pixelformat
)
1170 if (fsize
->index
== index
) {
1171 fsize
->type
= V4L2_FRMSIZE_TYPE_DISCRETE
;
1172 fsize
->discrete
.width
=
1173 gspca_dev
->cam
.cam_mode
[i
].width
;
1174 fsize
->discrete
.height
=
1175 gspca_dev
->cam
.cam_mode
[i
].height
;
1184 static int vidioc_enum_frameintervals(struct file
*filp
, void *priv
,
1185 struct v4l2_frmivalenum
*fival
)
1187 struct gspca_dev
*gspca_dev
= priv
;
1188 int mode
= wxh_to_mode(gspca_dev
, fival
->width
, fival
->height
);
1191 if (gspca_dev
->cam
.mode_framerates
== NULL
||
1192 gspca_dev
->cam
.mode_framerates
[mode
].nrates
== 0)
1195 if (fival
->pixel_format
!=
1196 gspca_dev
->cam
.cam_mode
[mode
].pixelformat
)
1199 for (i
= 0; i
< gspca_dev
->cam
.mode_framerates
[mode
].nrates
; i
++) {
1200 if (fival
->index
== i
) {
1201 fival
->type
= V4L2_FRMSIZE_TYPE_DISCRETE
;
1202 fival
->discrete
.numerator
= 1;
1203 fival
->discrete
.denominator
=
1204 gspca_dev
->cam
.mode_framerates
[mode
].rates
[i
];
1212 static void gspca_release(struct video_device
*vfd
)
1214 struct gspca_dev
*gspca_dev
= container_of(vfd
, struct gspca_dev
, vdev
);
1216 PDEBUG(D_PROBE
, "%s released",
1217 video_device_node_name(&gspca_dev
->vdev
));
1219 kfree(gspca_dev
->usb_buf
);
1223 static int dev_open(struct file
*file
)
1225 struct gspca_dev
*gspca_dev
;
1228 PDEBUG(D_STREAM
, "[%s] open", current
->comm
);
1229 gspca_dev
= (struct gspca_dev
*) video_devdata(file
);
1230 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1231 return -ERESTARTSYS
;
1232 if (!gspca_dev
->present
) {
1237 if (gspca_dev
->users
> 4) { /* (arbitrary value) */
1242 /* protect the subdriver against rmmod */
1243 if (!try_module_get(gspca_dev
->module
)) {
1250 file
->private_data
= gspca_dev
;
1252 /* activate the v4l2 debug */
1253 if (gspca_debug
& D_V4L2
)
1254 gspca_dev
->vdev
.debug
|= V4L2_DEBUG_IOCTL
1255 | V4L2_DEBUG_IOCTL_ARG
;
1257 gspca_dev
->vdev
.debug
&= ~(V4L2_DEBUG_IOCTL
1258 | V4L2_DEBUG_IOCTL_ARG
);
1262 mutex_unlock(&gspca_dev
->queue_lock
);
1264 PDEBUG(D_ERR
|D_STREAM
, "open failed err %d", ret
);
1266 PDEBUG(D_STREAM
, "open done");
1270 static int dev_close(struct file
*file
)
1272 struct gspca_dev
*gspca_dev
= file
->private_data
;
1274 PDEBUG(D_STREAM
, "[%s] close", current
->comm
);
1275 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1276 return -ERESTARTSYS
;
1279 /* if the file did the capture, free the streaming resources */
1280 if (gspca_dev
->capt_file
== file
) {
1281 if (gspca_dev
->streaming
) {
1282 mutex_lock(&gspca_dev
->usb_lock
);
1283 gspca_dev
->usb_err
= 0;
1284 gspca_stream_off(gspca_dev
);
1285 mutex_unlock(&gspca_dev
->usb_lock
);
1287 frame_free(gspca_dev
);
1288 gspca_dev
->capt_file
= NULL
;
1289 gspca_dev
->memory
= GSPCA_MEMORY_NO
;
1291 file
->private_data
= NULL
;
1292 module_put(gspca_dev
->module
);
1293 mutex_unlock(&gspca_dev
->queue_lock
);
1295 PDEBUG(D_STREAM
, "close done");
1300 static int vidioc_querycap(struct file
*file
, void *priv
,
1301 struct v4l2_capability
*cap
)
1303 struct gspca_dev
*gspca_dev
= priv
;
1306 /* protect the access to the usb device */
1307 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1308 return -ERESTARTSYS
;
1309 if (!gspca_dev
->present
) {
1313 strncpy(cap
->driver
, gspca_dev
->sd_desc
->name
, sizeof cap
->driver
);
1314 if (gspca_dev
->dev
->product
!= NULL
) {
1315 strncpy(cap
->card
, gspca_dev
->dev
->product
,
1318 snprintf(cap
->card
, sizeof cap
->card
,
1319 "USB Camera (%04x:%04x)",
1320 le16_to_cpu(gspca_dev
->dev
->descriptor
.idVendor
),
1321 le16_to_cpu(gspca_dev
->dev
->descriptor
.idProduct
));
1323 usb_make_path(gspca_dev
->dev
, cap
->bus_info
, sizeof(cap
->bus_info
));
1324 cap
->version
= DRIVER_VERSION_NUMBER
;
1325 cap
->capabilities
= V4L2_CAP_VIDEO_CAPTURE
1326 | V4L2_CAP_STREAMING
1327 | V4L2_CAP_READWRITE
;
1330 mutex_unlock(&gspca_dev
->usb_lock
);
1334 static const struct ctrl
*get_ctrl(struct gspca_dev
*gspca_dev
,
1337 const struct ctrl
*ctrls
;
1340 for (i
= 0, ctrls
= gspca_dev
->sd_desc
->ctrls
;
1341 i
< gspca_dev
->sd_desc
->nctrls
;
1343 if (gspca_dev
->ctrl_dis
& (1 << i
))
1345 if (id
== ctrls
->qctrl
.id
)
1351 static int vidioc_queryctrl(struct file
*file
, void *priv
,
1352 struct v4l2_queryctrl
*q_ctrl
)
1354 struct gspca_dev
*gspca_dev
= priv
;
1355 const struct ctrl
*ctrls
;
1361 if (id
& V4L2_CTRL_FLAG_NEXT_CTRL
) {
1362 id
&= V4L2_CTRL_ID_MASK
;
1364 for (i
= 0; i
< gspca_dev
->sd_desc
->nctrls
; i
++) {
1365 if (gspca_dev
->ctrl_dis
& (1 << i
))
1367 if (gspca_dev
->sd_desc
->ctrls
[i
].qctrl
.id
< id
)
1369 if (ctrls
&& gspca_dev
->sd_desc
->ctrls
[i
].qctrl
.id
1372 ctrls
= &gspca_dev
->sd_desc
->ctrls
[i
];
1377 ctrls
= get_ctrl(gspca_dev
, id
);
1380 i
= ctrls
- gspca_dev
->sd_desc
->ctrls
;
1382 memcpy(q_ctrl
, ctrls
, sizeof *q_ctrl
);
1383 if (gspca_dev
->ctrl_inac
& (1 << i
))
1384 q_ctrl
->flags
|= V4L2_CTRL_FLAG_INACTIVE
;
1388 static int vidioc_s_ctrl(struct file
*file
, void *priv
,
1389 struct v4l2_control
*ctrl
)
1391 struct gspca_dev
*gspca_dev
= priv
;
1392 const struct ctrl
*ctrls
;
1395 ctrls
= get_ctrl(gspca_dev
, ctrl
->id
);
1399 if (ctrl
->value
< ctrls
->qctrl
.minimum
1400 || ctrl
->value
> ctrls
->qctrl
.maximum
)
1402 PDEBUG(D_CONF
, "set ctrl [%08x] = %d", ctrl
->id
, ctrl
->value
);
1403 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1404 return -ERESTARTSYS
;
1405 gspca_dev
->usb_err
= 0;
1406 if (gspca_dev
->present
)
1407 ret
= ctrls
->set(gspca_dev
, ctrl
->value
);
1410 mutex_unlock(&gspca_dev
->usb_lock
);
1414 static int vidioc_g_ctrl(struct file
*file
, void *priv
,
1415 struct v4l2_control
*ctrl
)
1417 struct gspca_dev
*gspca_dev
= priv
;
1418 const struct ctrl
*ctrls
;
1421 ctrls
= get_ctrl(gspca_dev
, ctrl
->id
);
1425 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1426 return -ERESTARTSYS
;
1427 gspca_dev
->usb_err
= 0;
1428 if (gspca_dev
->present
)
1429 ret
= ctrls
->get(gspca_dev
, &ctrl
->value
);
1432 mutex_unlock(&gspca_dev
->usb_lock
);
1436 /*fixme: have an audio flag in gspca_dev?*/
1437 static int vidioc_s_audio(struct file
*file
, void *priv
,
1438 struct v4l2_audio
*audio
)
1440 if (audio
->index
!= 0)
1445 static int vidioc_g_audio(struct file
*file
, void *priv
,
1446 struct v4l2_audio
*audio
)
1448 strcpy(audio
->name
, "Microphone");
1452 static int vidioc_enumaudio(struct file
*file
, void *priv
,
1453 struct v4l2_audio
*audio
)
1455 if (audio
->index
!= 0)
1458 strcpy(audio
->name
, "Microphone");
1459 audio
->capability
= 0;
1464 static int vidioc_querymenu(struct file
*file
, void *priv
,
1465 struct v4l2_querymenu
*qmenu
)
1467 struct gspca_dev
*gspca_dev
= priv
;
1469 if (!gspca_dev
->sd_desc
->querymenu
)
1471 return gspca_dev
->sd_desc
->querymenu(gspca_dev
, qmenu
);
1474 static int vidioc_enum_input(struct file
*file
, void *priv
,
1475 struct v4l2_input
*input
)
1477 struct gspca_dev
*gspca_dev
= priv
;
1479 if (input
->index
!= 0)
1481 input
->type
= V4L2_INPUT_TYPE_CAMERA
;
1482 input
->status
= gspca_dev
->cam
.input_flags
;
1483 strncpy(input
->name
, gspca_dev
->sd_desc
->name
,
1484 sizeof input
->name
);
1488 static int vidioc_g_input(struct file
*file
, void *priv
, unsigned int *i
)
1494 static int vidioc_s_input(struct file
*file
, void *priv
, unsigned int i
)
1501 static int vidioc_reqbufs(struct file
*file
, void *priv
,
1502 struct v4l2_requestbuffers
*rb
)
1504 struct gspca_dev
*gspca_dev
= priv
;
1505 int i
, ret
= 0, streaming
;
1507 switch (rb
->memory
) {
1508 case GSPCA_MEMORY_READ
: /* (internal call) */
1509 case V4L2_MEMORY_MMAP
:
1510 case V4L2_MEMORY_USERPTR
:
1515 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1516 return -ERESTARTSYS
;
1518 if (gspca_dev
->memory
!= GSPCA_MEMORY_NO
1519 && gspca_dev
->memory
!= rb
->memory
) {
1524 /* only one file may do the capture */
1525 if (gspca_dev
->capt_file
!= NULL
1526 && gspca_dev
->capt_file
!= file
) {
1531 /* if allocated, the buffers must not be mapped */
1532 for (i
= 0; i
< gspca_dev
->nframes
; i
++) {
1533 if (gspca_dev
->frame
[i
].vma_use_count
) {
1539 /* stop streaming */
1540 streaming
= gspca_dev
->streaming
;
1542 mutex_lock(&gspca_dev
->usb_lock
);
1543 gspca_dev
->usb_err
= 0;
1544 gspca_stream_off(gspca_dev
);
1545 mutex_unlock(&gspca_dev
->usb_lock
);
1548 /* free the previous allocated buffers, if any */
1549 if (gspca_dev
->nframes
!= 0) {
1550 frame_free(gspca_dev
);
1551 gspca_dev
->capt_file
= NULL
;
1553 if (rb
->count
== 0) /* unrequest */
1555 gspca_dev
->memory
= rb
->memory
;
1556 ret
= frame_alloc(gspca_dev
, rb
->count
);
1558 rb
->count
= gspca_dev
->nframes
;
1559 gspca_dev
->capt_file
= file
;
1561 ret
= gspca_init_transfer(gspca_dev
);
1564 mutex_unlock(&gspca_dev
->queue_lock
);
1565 PDEBUG(D_STREAM
, "reqbufs st:%d c:%d", ret
, rb
->count
);
1569 static int vidioc_querybuf(struct file
*file
, void *priv
,
1570 struct v4l2_buffer
*v4l2_buf
)
1572 struct gspca_dev
*gspca_dev
= priv
;
1573 struct gspca_frame
*frame
;
1575 if (v4l2_buf
->index
< 0
1576 || v4l2_buf
->index
>= gspca_dev
->nframes
)
1579 frame
= &gspca_dev
->frame
[v4l2_buf
->index
];
1580 memcpy(v4l2_buf
, &frame
->v4l2_buf
, sizeof *v4l2_buf
);
1584 static int vidioc_streamon(struct file
*file
, void *priv
,
1585 enum v4l2_buf_type buf_type
)
1587 struct gspca_dev
*gspca_dev
= priv
;
1590 if (buf_type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1592 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1593 return -ERESTARTSYS
;
1595 /* check the capture file */
1596 if (gspca_dev
->capt_file
!= file
) {
1601 if (gspca_dev
->nframes
== 0
1602 || !(gspca_dev
->frame
[0].v4l2_buf
.flags
& V4L2_BUF_FLAG_QUEUED
)) {
1606 if (!gspca_dev
->streaming
) {
1607 ret
= gspca_init_transfer(gspca_dev
);
1612 if (gspca_debug
& D_STREAM
) {
1613 PDEBUG_MODE("stream on OK",
1621 mutex_unlock(&gspca_dev
->queue_lock
);
1625 static int vidioc_streamoff(struct file
*file
, void *priv
,
1626 enum v4l2_buf_type buf_type
)
1628 struct gspca_dev
*gspca_dev
= priv
;
1631 if (buf_type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1633 if (!gspca_dev
->streaming
)
1635 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1636 return -ERESTARTSYS
;
1638 /* check the capture file */
1639 if (gspca_dev
->capt_file
!= file
) {
1644 /* stop streaming */
1645 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
)) {
1649 gspca_dev
->usb_err
= 0;
1650 gspca_stream_off(gspca_dev
);
1651 mutex_unlock(&gspca_dev
->usb_lock
);
1653 /* empty the application queues */
1654 for (i
= 0; i
< gspca_dev
->nframes
; i
++)
1655 gspca_dev
->frame
[i
].v4l2_buf
.flags
&= ~BUF_ALL_FLAGS
;
1656 gspca_dev
->fr_i
= gspca_dev
->fr_o
= gspca_dev
->fr_q
= 0;
1657 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
1658 gspca_dev
->sequence
= 0;
1661 mutex_unlock(&gspca_dev
->queue_lock
);
1665 static int vidioc_g_jpegcomp(struct file
*file
, void *priv
,
1666 struct v4l2_jpegcompression
*jpegcomp
)
1668 struct gspca_dev
*gspca_dev
= priv
;
1671 if (!gspca_dev
->sd_desc
->get_jcomp
)
1673 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1674 return -ERESTARTSYS
;
1675 gspca_dev
->usb_err
= 0;
1676 if (gspca_dev
->present
)
1677 ret
= gspca_dev
->sd_desc
->get_jcomp(gspca_dev
, jpegcomp
);
1680 mutex_unlock(&gspca_dev
->usb_lock
);
1684 static int vidioc_s_jpegcomp(struct file
*file
, void *priv
,
1685 struct v4l2_jpegcompression
*jpegcomp
)
1687 struct gspca_dev
*gspca_dev
= priv
;
1690 if (!gspca_dev
->sd_desc
->set_jcomp
)
1692 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1693 return -ERESTARTSYS
;
1694 gspca_dev
->usb_err
= 0;
1695 if (gspca_dev
->present
)
1696 ret
= gspca_dev
->sd_desc
->set_jcomp(gspca_dev
, jpegcomp
);
1699 mutex_unlock(&gspca_dev
->usb_lock
);
1703 static int vidioc_g_parm(struct file
*filp
, void *priv
,
1704 struct v4l2_streamparm
*parm
)
1706 struct gspca_dev
*gspca_dev
= priv
;
1708 parm
->parm
.capture
.readbuffers
= gspca_dev
->nbufread
;
1710 if (gspca_dev
->sd_desc
->get_streamparm
) {
1713 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1714 return -ERESTARTSYS
;
1715 gspca_dev
->usb_err
= 0;
1716 if (gspca_dev
->present
)
1717 ret
= gspca_dev
->sd_desc
->get_streamparm(gspca_dev
,
1721 mutex_unlock(&gspca_dev
->usb_lock
);
1728 static int vidioc_s_parm(struct file
*filp
, void *priv
,
1729 struct v4l2_streamparm
*parm
)
1731 struct gspca_dev
*gspca_dev
= priv
;
1734 n
= parm
->parm
.capture
.readbuffers
;
1735 if (n
== 0 || n
> GSPCA_MAX_FRAMES
)
1736 parm
->parm
.capture
.readbuffers
= gspca_dev
->nbufread
;
1738 gspca_dev
->nbufread
= n
;
1740 if (gspca_dev
->sd_desc
->set_streamparm
) {
1743 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1744 return -ERESTARTSYS
;
1745 gspca_dev
->usb_err
= 0;
1746 if (gspca_dev
->present
)
1747 ret
= gspca_dev
->sd_desc
->set_streamparm(gspca_dev
,
1751 mutex_unlock(&gspca_dev
->usb_lock
);
1758 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1759 static int vidiocgmbuf(struct file
*file
, void *priv
,
1760 struct video_mbuf
*mbuf
)
1762 struct gspca_dev
*gspca_dev
= file
->private_data
;
1765 PDEBUG(D_STREAM
, "cgmbuf");
1766 if (gspca_dev
->nframes
== 0) {
1770 struct v4l2_format fmt
;
1772 fmt
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1773 i
= gspca_dev
->cam
.nmodes
- 1; /* highest mode */
1774 fmt
.fmt
.pix
.width
= gspca_dev
->cam
.cam_mode
[i
].width
;
1775 fmt
.fmt
.pix
.height
= gspca_dev
->cam
.cam_mode
[i
].height
;
1776 fmt
.fmt
.pix
.pixelformat
= V4L2_PIX_FMT_BGR24
;
1777 ret
= vidioc_s_fmt_vid_cap(file
, priv
, &fmt
);
1782 struct v4l2_requestbuffers rb
;
1784 memset(&rb
, 0, sizeof rb
);
1786 rb
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1787 rb
.memory
= V4L2_MEMORY_MMAP
;
1788 ret
= vidioc_reqbufs(file
, priv
, &rb
);
1793 mbuf
->frames
= gspca_dev
->nframes
;
1794 mbuf
->size
= gspca_dev
->frsz
* gspca_dev
->nframes
;
1795 for (i
= 0; i
< mbuf
->frames
; i
++)
1796 mbuf
->offsets
[i
] = gspca_dev
->frame
[i
].v4l2_buf
.m
.offset
;
1801 static int dev_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1803 struct gspca_dev
*gspca_dev
= file
->private_data
;
1804 struct gspca_frame
*frame
;
1806 unsigned long addr
, start
, size
;
1809 start
= vma
->vm_start
;
1810 size
= vma
->vm_end
- vma
->vm_start
;
1811 PDEBUG(D_STREAM
, "mmap start:%08x size:%d", (int) start
, (int) size
);
1813 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1814 return -ERESTARTSYS
;
1815 if (!gspca_dev
->present
) {
1819 if (gspca_dev
->capt_file
!= file
) {
1825 for (i
= 0; i
< gspca_dev
->nframes
; ++i
) {
1826 if (gspca_dev
->frame
[i
].v4l2_buf
.memory
!= V4L2_MEMORY_MMAP
) {
1827 PDEBUG(D_STREAM
, "mmap bad memory type");
1830 if ((gspca_dev
->frame
[i
].v4l2_buf
.m
.offset
>> PAGE_SHIFT
)
1832 frame
= &gspca_dev
->frame
[i
];
1836 if (frame
== NULL
) {
1837 PDEBUG(D_STREAM
, "mmap no frame buffer found");
1841 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1842 /* v4l1 maps all the buffers */
1844 || size
!= frame
->v4l2_buf
.length
* gspca_dev
->nframes
)
1846 if (size
!= frame
->v4l2_buf
.length
) {
1847 PDEBUG(D_STREAM
, "mmap bad size");
1853 * - VM_IO marks the area as being a mmaped region for I/O to a
1854 * device. It also prevents the region from being core dumped.
1856 vma
->vm_flags
|= VM_IO
;
1858 addr
= (unsigned long) frame
->data
;
1860 page
= vmalloc_to_page((void *) addr
);
1861 ret
= vm_insert_page(vma
, start
, page
);
1869 vma
->vm_ops
= &gspca_vm_ops
;
1870 vma
->vm_private_data
= frame
;
1874 mutex_unlock(&gspca_dev
->queue_lock
);
1879 * wait for a video frame
1881 * If a frame is ready, its index is returned.
1883 static int frame_wait(struct gspca_dev
*gspca_dev
,
1886 struct gspca_frame
*frame
;
1889 /* check if a frame is ready */
1890 i
= gspca_dev
->fr_o
;
1891 j
= gspca_dev
->fr_queue
[i
];
1892 frame
= &gspca_dev
->frame
[j
];
1894 if (!(frame
->v4l2_buf
.flags
& V4L2_BUF_FLAG_DONE
)) {
1898 /* wait till a frame is ready */
1899 ret
= wait_event_interruptible_timeout(gspca_dev
->wq
,
1900 (frame
->v4l2_buf
.flags
& V4L2_BUF_FLAG_DONE
) ||
1901 !gspca_dev
->streaming
|| !gspca_dev
->present
,
1902 msecs_to_jiffies(3000));
1905 if (ret
== 0 || !gspca_dev
->streaming
|| !gspca_dev
->present
)
1909 gspca_dev
->fr_o
= (i
+ 1) % gspca_dev
->nframes
;
1910 PDEBUG(D_FRAM
, "frame wait q:%d i:%d o:%d",
1915 if (gspca_dev
->sd_desc
->dq_callback
) {
1916 mutex_lock(&gspca_dev
->usb_lock
);
1917 gspca_dev
->usb_err
= 0;
1918 if (gspca_dev
->present
)
1919 gspca_dev
->sd_desc
->dq_callback(gspca_dev
);
1920 mutex_unlock(&gspca_dev
->usb_lock
);
1926 * dequeue a video buffer
1928 * If nonblock_ing is false, block until a buffer is available.
1930 static int vidioc_dqbuf(struct file
*file
, void *priv
,
1931 struct v4l2_buffer
*v4l2_buf
)
1933 struct gspca_dev
*gspca_dev
= priv
;
1934 struct gspca_frame
*frame
;
1937 PDEBUG(D_FRAM
, "dqbuf");
1938 if (v4l2_buf
->memory
!= gspca_dev
->memory
)
1941 if (!gspca_dev
->present
)
1944 /* if not streaming, be sure the application will not loop forever */
1945 if (!(file
->f_flags
& O_NONBLOCK
)
1946 && !gspca_dev
->streaming
&& gspca_dev
->users
== 1)
1949 /* only the capturing file may dequeue */
1950 if (gspca_dev
->capt_file
!= file
)
1953 /* only one dequeue / read at a time */
1954 if (mutex_lock_interruptible(&gspca_dev
->read_lock
))
1955 return -ERESTARTSYS
;
1957 ret
= frame_wait(gspca_dev
, file
->f_flags
& O_NONBLOCK
);
1960 i
= ret
; /* frame index */
1961 frame
= &gspca_dev
->frame
[i
];
1962 if (gspca_dev
->memory
== V4L2_MEMORY_USERPTR
) {
1963 if (copy_to_user((__u8 __user
*) frame
->v4l2_buf
.m
.userptr
,
1965 frame
->v4l2_buf
.bytesused
)) {
1966 PDEBUG(D_ERR
|D_STREAM
,
1967 "dqbuf cp to user failed");
1972 frame
->v4l2_buf
.flags
&= ~V4L2_BUF_FLAG_DONE
;
1973 memcpy(v4l2_buf
, &frame
->v4l2_buf
, sizeof *v4l2_buf
);
1974 PDEBUG(D_FRAM
, "dqbuf %d", i
);
1977 mutex_unlock(&gspca_dev
->read_lock
);
1982 * queue a video buffer
1984 * Attempting to queue a buffer that has already been
1985 * queued will return -EINVAL.
1987 static int vidioc_qbuf(struct file
*file
, void *priv
,
1988 struct v4l2_buffer
*v4l2_buf
)
1990 struct gspca_dev
*gspca_dev
= priv
;
1991 struct gspca_frame
*frame
;
1994 PDEBUG(D_FRAM
, "qbuf %d", v4l2_buf
->index
);
1996 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1997 return -ERESTARTSYS
;
1999 index
= v4l2_buf
->index
;
2000 if ((unsigned) index
>= gspca_dev
->nframes
) {
2002 "qbuf idx %d >= %d", index
, gspca_dev
->nframes
);
2006 if (v4l2_buf
->memory
!= gspca_dev
->memory
) {
2007 PDEBUG(D_FRAM
, "qbuf bad memory type");
2012 frame
= &gspca_dev
->frame
[index
];
2013 if (frame
->v4l2_buf
.flags
& BUF_ALL_FLAGS
) {
2014 PDEBUG(D_FRAM
, "qbuf bad state");
2019 frame
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_QUEUED
;
2021 if (frame
->v4l2_buf
.memory
== V4L2_MEMORY_USERPTR
) {
2022 frame
->v4l2_buf
.m
.userptr
= v4l2_buf
->m
.userptr
;
2023 frame
->v4l2_buf
.length
= v4l2_buf
->length
;
2026 /* put the buffer in the 'queued' queue */
2027 i
= gspca_dev
->fr_q
;
2028 gspca_dev
->fr_queue
[i
] = index
;
2029 if (gspca_dev
->fr_i
== i
)
2030 gspca_dev
->cur_frame
= frame
;
2031 gspca_dev
->fr_q
= (i
+ 1) % gspca_dev
->nframes
;
2032 PDEBUG(D_FRAM
, "qbuf q:%d i:%d o:%d",
2037 v4l2_buf
->flags
|= V4L2_BUF_FLAG_QUEUED
;
2038 v4l2_buf
->flags
&= ~V4L2_BUF_FLAG_DONE
;
2041 mutex_unlock(&gspca_dev
->queue_lock
);
2046 * allocate the resources for read()
2048 static int read_alloc(struct gspca_dev
*gspca_dev
,
2051 struct v4l2_buffer v4l2_buf
;
2054 PDEBUG(D_STREAM
, "read alloc");
2055 if (gspca_dev
->nframes
== 0) {
2056 struct v4l2_requestbuffers rb
;
2058 memset(&rb
, 0, sizeof rb
);
2059 rb
.count
= gspca_dev
->nbufread
;
2060 rb
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2061 rb
.memory
= GSPCA_MEMORY_READ
;
2062 ret
= vidioc_reqbufs(file
, gspca_dev
, &rb
);
2064 PDEBUG(D_STREAM
, "read reqbuf err %d", ret
);
2067 memset(&v4l2_buf
, 0, sizeof v4l2_buf
);
2068 v4l2_buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2069 v4l2_buf
.memory
= GSPCA_MEMORY_READ
;
2070 for (i
= 0; i
< gspca_dev
->nbufread
; i
++) {
2072 ret
= vidioc_qbuf(file
, gspca_dev
, &v4l2_buf
);
2074 PDEBUG(D_STREAM
, "read qbuf err: %d", ret
);
2078 gspca_dev
->memory
= GSPCA_MEMORY_READ
;
2081 /* start streaming */
2082 ret
= vidioc_streamon(file
, gspca_dev
, V4L2_BUF_TYPE_VIDEO_CAPTURE
);
2084 PDEBUG(D_STREAM
, "read streamon err %d", ret
);
2088 static unsigned int dev_poll(struct file
*file
, poll_table
*wait
)
2090 struct gspca_dev
*gspca_dev
= file
->private_data
;
2093 PDEBUG(D_FRAM
, "poll");
2095 poll_wait(file
, &gspca_dev
->wq
, wait
);
2097 /* if reqbufs is not done, the user would use read() */
2098 if (gspca_dev
->nframes
== 0) {
2099 if (gspca_dev
->memory
!= GSPCA_MEMORY_NO
)
2100 return POLLERR
; /* not the 1st time */
2101 ret
= read_alloc(gspca_dev
, file
);
2106 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
) != 0)
2109 /* check the next incoming buffer */
2110 i
= gspca_dev
->fr_o
;
2111 i
= gspca_dev
->fr_queue
[i
];
2112 if (gspca_dev
->frame
[i
].v4l2_buf
.flags
& V4L2_BUF_FLAG_DONE
)
2113 ret
= POLLIN
| POLLRDNORM
; /* something to read */
2116 mutex_unlock(&gspca_dev
->queue_lock
);
2117 if (!gspca_dev
->present
)
2122 static ssize_t
dev_read(struct file
*file
, char __user
*data
,
2123 size_t count
, loff_t
*ppos
)
2125 struct gspca_dev
*gspca_dev
= file
->private_data
;
2126 struct gspca_frame
*frame
;
2127 struct v4l2_buffer v4l2_buf
;
2128 struct timeval timestamp
;
2131 PDEBUG(D_FRAM
, "read (%zd)", count
);
2132 if (!gspca_dev
->present
)
2134 switch (gspca_dev
->memory
) {
2135 case GSPCA_MEMORY_NO
: /* first time */
2136 ret
= read_alloc(gspca_dev
, file
);
2140 case GSPCA_MEMORY_READ
:
2141 if (gspca_dev
->capt_file
== file
)
2149 timestamp
= ktime_to_timeval(ktime_get());
2153 memset(&v4l2_buf
, 0, sizeof v4l2_buf
);
2154 v4l2_buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2155 v4l2_buf
.memory
= GSPCA_MEMORY_READ
;
2156 ret
= vidioc_dqbuf(file
, gspca_dev
, &v4l2_buf
);
2158 PDEBUG(D_STREAM
, "read dqbuf err %d", ret
);
2162 /* if the process slept for more than 1 second,
2163 * get a newer frame */
2164 frame
= &gspca_dev
->frame
[v4l2_buf
.index
];
2166 break; /* avoid infinite loop */
2167 if (frame
->v4l2_buf
.timestamp
.tv_sec
>= timestamp
.tv_sec
)
2169 ret
= vidioc_qbuf(file
, gspca_dev
, &v4l2_buf
);
2171 PDEBUG(D_STREAM
, "read qbuf err %d", ret
);
2176 /* copy the frame */
2177 if (count
> frame
->v4l2_buf
.bytesused
)
2178 count
= frame
->v4l2_buf
.bytesused
;
2179 ret
= copy_to_user(data
, frame
->data
, count
);
2181 PDEBUG(D_ERR
|D_STREAM
,
2182 "read cp to user lack %d / %zd", ret
, count
);
2188 /* in each case, requeue the buffer */
2189 ret2
= vidioc_qbuf(file
, gspca_dev
, &v4l2_buf
);
2195 static struct v4l2_file_operations dev_fops
= {
2196 .owner
= THIS_MODULE
,
2198 .release
= dev_close
,
2201 .unlocked_ioctl
= video_ioctl2
,
2205 static const struct v4l2_ioctl_ops dev_ioctl_ops
= {
2206 .vidioc_querycap
= vidioc_querycap
,
2207 .vidioc_dqbuf
= vidioc_dqbuf
,
2208 .vidioc_qbuf
= vidioc_qbuf
,
2209 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
2210 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
2211 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
2212 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
2213 .vidioc_streamon
= vidioc_streamon
,
2214 .vidioc_queryctrl
= vidioc_queryctrl
,
2215 .vidioc_g_ctrl
= vidioc_g_ctrl
,
2216 .vidioc_s_ctrl
= vidioc_s_ctrl
,
2217 .vidioc_g_audio
= vidioc_g_audio
,
2218 .vidioc_s_audio
= vidioc_s_audio
,
2219 .vidioc_enumaudio
= vidioc_enumaudio
,
2220 .vidioc_querymenu
= vidioc_querymenu
,
2221 .vidioc_enum_input
= vidioc_enum_input
,
2222 .vidioc_g_input
= vidioc_g_input
,
2223 .vidioc_s_input
= vidioc_s_input
,
2224 .vidioc_reqbufs
= vidioc_reqbufs
,
2225 .vidioc_querybuf
= vidioc_querybuf
,
2226 .vidioc_streamoff
= vidioc_streamoff
,
2227 .vidioc_g_jpegcomp
= vidioc_g_jpegcomp
,
2228 .vidioc_s_jpegcomp
= vidioc_s_jpegcomp
,
2229 .vidioc_g_parm
= vidioc_g_parm
,
2230 .vidioc_s_parm
= vidioc_s_parm
,
2231 .vidioc_enum_framesizes
= vidioc_enum_framesizes
,
2232 .vidioc_enum_frameintervals
= vidioc_enum_frameintervals
,
2233 #ifdef CONFIG_VIDEO_ADV_DEBUG
2234 .vidioc_g_register
= vidioc_g_register
,
2235 .vidioc_s_register
= vidioc_s_register
,
2237 .vidioc_g_chip_ident
= vidioc_g_chip_ident
,
2238 #ifdef CONFIG_VIDEO_V4L1_COMPAT
2239 .vidiocgmbuf
= vidiocgmbuf
,
2243 static struct video_device gspca_template
= {
2244 .name
= "gspca main driver",
2246 .ioctl_ops
= &dev_ioctl_ops
,
2247 .release
= gspca_release
,
2251 * probe and create a new gspca device
2253 * This function must be called by the sub-driver when it is
2254 * called for probing a new device.
2256 int gspca_dev_probe(struct usb_interface
*intf
,
2257 const struct usb_device_id
*id
,
2258 const struct sd_desc
*sd_desc
,
2260 struct module
*module
)
2262 struct usb_interface_descriptor
*interface
;
2263 struct gspca_dev
*gspca_dev
;
2264 struct usb_device
*dev
= interface_to_usbdev(intf
);
2267 PDEBUG(D_PROBE
, "probing %04x:%04x", id
->idVendor
, id
->idProduct
);
2269 /* we don't handle multi-config cameras */
2270 if (dev
->descriptor
.bNumConfigurations
!= 1) {
2271 PDEBUG(D_ERR
, "Too many config");
2275 /* the USB video interface must be the first one */
2276 interface
= &intf
->cur_altsetting
->desc
;
2277 if (dev
->config
->desc
.bNumInterfaces
!= 1 &&
2278 interface
->bInterfaceNumber
!= 0)
2281 /* create the device */
2282 if (dev_size
< sizeof *gspca_dev
)
2283 dev_size
= sizeof *gspca_dev
;
2284 gspca_dev
= kzalloc(dev_size
, GFP_KERNEL
);
2286 err("couldn't kzalloc gspca struct");
2289 gspca_dev
->usb_buf
= kmalloc(USB_BUF_SZ
, GFP_KERNEL
);
2290 if (!gspca_dev
->usb_buf
) {
2291 err("out of memory");
2295 gspca_dev
->dev
= dev
;
2296 gspca_dev
->iface
= interface
->bInterfaceNumber
;
2297 gspca_dev
->nbalt
= intf
->num_altsetting
;
2298 gspca_dev
->sd_desc
= sd_desc
;
2299 gspca_dev
->nbufread
= 2;
2300 gspca_dev
->empty_packet
= -1; /* don't check the empty packets */
2302 /* configure the subdriver and initialize the USB device */
2303 ret
= sd_desc
->config(gspca_dev
, id
);
2306 ret
= sd_desc
->init(gspca_dev
);
2309 gspca_set_default_mode(gspca_dev
);
2311 ret
= gspca_input_connect(gspca_dev
);
2315 mutex_init(&gspca_dev
->usb_lock
);
2316 mutex_init(&gspca_dev
->read_lock
);
2317 mutex_init(&gspca_dev
->queue_lock
);
2318 init_waitqueue_head(&gspca_dev
->wq
);
2320 /* init video stuff */
2321 memcpy(&gspca_dev
->vdev
, &gspca_template
, sizeof gspca_template
);
2322 gspca_dev
->vdev
.parent
= &intf
->dev
;
2323 gspca_dev
->module
= module
;
2324 gspca_dev
->present
= 1;
2325 ret
= video_register_device(&gspca_dev
->vdev
,
2329 err("video_register_device err %d", ret
);
2333 usb_set_intfdata(intf
, gspca_dev
);
2334 PDEBUG(D_PROBE
, "%s created", video_device_node_name(&gspca_dev
->vdev
));
2336 gspca_input_create_urb(gspca_dev
);
2340 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
2341 if (gspca_dev
->input_dev
)
2342 input_unregister_device(gspca_dev
->input_dev
);
2344 kfree(gspca_dev
->usb_buf
);
2348 EXPORT_SYMBOL(gspca_dev_probe
);
2353 * This function must be called by the sub-driver
2354 * when the device disconnects, after the specific resources are freed.
2356 void gspca_disconnect(struct usb_interface
*intf
)
2358 struct gspca_dev
*gspca_dev
= usb_get_intfdata(intf
);
2359 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
2360 struct input_dev
*input_dev
;
2363 PDEBUG(D_PROBE
, "%s disconnect",
2364 video_device_node_name(&gspca_dev
->vdev
));
2365 mutex_lock(&gspca_dev
->usb_lock
);
2366 gspca_dev
->present
= 0;
2368 if (gspca_dev
->streaming
) {
2369 destroy_urbs(gspca_dev
);
2370 wake_up_interruptible(&gspca_dev
->wq
);
2373 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
2374 gspca_input_destroy_urb(gspca_dev
);
2375 input_dev
= gspca_dev
->input_dev
;
2377 gspca_dev
->input_dev
= NULL
;
2378 input_unregister_device(input_dev
);
2382 /* the device is freed at exit of this function */
2383 gspca_dev
->dev
= NULL
;
2384 mutex_unlock(&gspca_dev
->usb_lock
);
2386 usb_set_intfdata(intf
, NULL
);
2388 /* release the device */
2389 /* (this will call gspca_release() immediatly or on last close) */
2390 video_unregister_device(&gspca_dev
->vdev
);
2392 /* PDEBUG(D_PROBE, "disconnect complete"); */
2394 EXPORT_SYMBOL(gspca_disconnect
);
2397 int gspca_suspend(struct usb_interface
*intf
, pm_message_t message
)
2399 struct gspca_dev
*gspca_dev
= usb_get_intfdata(intf
);
2401 if (!gspca_dev
->streaming
)
2403 gspca_dev
->frozen
= 1; /* avoid urb error messages */
2404 if (gspca_dev
->sd_desc
->stopN
)
2405 gspca_dev
->sd_desc
->stopN(gspca_dev
);
2406 destroy_urbs(gspca_dev
);
2407 gspca_input_destroy_urb(gspca_dev
);
2408 gspca_set_alt0(gspca_dev
);
2409 if (gspca_dev
->sd_desc
->stop0
)
2410 gspca_dev
->sd_desc
->stop0(gspca_dev
);
2413 EXPORT_SYMBOL(gspca_suspend
);
2415 int gspca_resume(struct usb_interface
*intf
)
2417 struct gspca_dev
*gspca_dev
= usb_get_intfdata(intf
);
2419 gspca_dev
->frozen
= 0;
2420 gspca_dev
->sd_desc
->init(gspca_dev
);
2421 gspca_input_create_urb(gspca_dev
);
2422 if (gspca_dev
->streaming
)
2423 return gspca_init_transfer(gspca_dev
);
2426 EXPORT_SYMBOL(gspca_resume
);
2428 /* -- cam driver utility functions -- */
2430 /* auto gain and exposure algorithm based on the knee algorithm described here:
2431 http://ytse.tricolour.net/docs/LowLightOptimization.html
2433 Returns 0 if no changes were made, 1 if the gain and or exposure settings
2435 int gspca_auto_gain_n_exposure(struct gspca_dev
*gspca_dev
, int avg_lum
,
2436 int desired_avg_lum
, int deadzone
, int gain_knee
, int exposure_knee
)
2438 int i
, steps
, gain
, orig_gain
, exposure
, orig_exposure
, autogain
;
2439 const struct ctrl
*gain_ctrl
= NULL
;
2440 const struct ctrl
*exposure_ctrl
= NULL
;
2441 const struct ctrl
*autogain_ctrl
= NULL
;
2444 for (i
= 0; i
< gspca_dev
->sd_desc
->nctrls
; i
++) {
2445 if (gspca_dev
->ctrl_dis
& (1 << i
))
2447 if (gspca_dev
->sd_desc
->ctrls
[i
].qctrl
.id
== V4L2_CID_GAIN
)
2448 gain_ctrl
= &gspca_dev
->sd_desc
->ctrls
[i
];
2449 if (gspca_dev
->sd_desc
->ctrls
[i
].qctrl
.id
== V4L2_CID_EXPOSURE
)
2450 exposure_ctrl
= &gspca_dev
->sd_desc
->ctrls
[i
];
2451 if (gspca_dev
->sd_desc
->ctrls
[i
].qctrl
.id
== V4L2_CID_AUTOGAIN
)
2452 autogain_ctrl
= &gspca_dev
->sd_desc
->ctrls
[i
];
2454 if (!gain_ctrl
|| !exposure_ctrl
|| !autogain_ctrl
) {
2455 PDEBUG(D_ERR
, "Error: gspca_auto_gain_n_exposure called "
2456 "on cam without (auto)gain/exposure");
2460 if (gain_ctrl
->get(gspca_dev
, &gain
) ||
2461 exposure_ctrl
->get(gspca_dev
, &exposure
) ||
2462 autogain_ctrl
->get(gspca_dev
, &autogain
) || !autogain
)
2466 orig_exposure
= exposure
;
2468 /* If we are of a multiple of deadzone, do multiple steps to reach the
2469 desired lumination fast (with the risc of a slight overshoot) */
2470 steps
= abs(desired_avg_lum
- avg_lum
) / deadzone
;
2472 PDEBUG(D_FRAM
, "autogain: lum: %d, desired: %d, steps: %d",
2473 avg_lum
, desired_avg_lum
, steps
);
2475 for (i
= 0; i
< steps
; i
++) {
2476 if (avg_lum
> desired_avg_lum
) {
2477 if (gain
> gain_knee
)
2479 else if (exposure
> exposure_knee
)
2481 else if (gain
> gain_ctrl
->qctrl
.default_value
)
2483 else if (exposure
> exposure_ctrl
->qctrl
.minimum
)
2485 else if (gain
> gain_ctrl
->qctrl
.minimum
)
2490 if (gain
< gain_ctrl
->qctrl
.default_value
)
2492 else if (exposure
< exposure_knee
)
2494 else if (gain
< gain_knee
)
2496 else if (exposure
< exposure_ctrl
->qctrl
.maximum
)
2498 else if (gain
< gain_ctrl
->qctrl
.maximum
)
2505 if (gain
!= orig_gain
) {
2506 gain_ctrl
->set(gspca_dev
, gain
);
2509 if (exposure
!= orig_exposure
) {
2510 exposure_ctrl
->set(gspca_dev
, exposure
);
2516 EXPORT_SYMBOL(gspca_auto_gain_n_exposure
);
2518 /* -- module insert / remove -- */
2519 static int __init
gspca_init(void)
2521 info("main v%d.%d.%d registered",
2522 (DRIVER_VERSION_NUMBER
>> 16) & 0xff,
2523 (DRIVER_VERSION_NUMBER
>> 8) & 0xff,
2524 DRIVER_VERSION_NUMBER
& 0xff);
2527 static void __exit
gspca_exit(void)
2529 info("main deregistered");
2532 module_init(gspca_init
);
2533 module_exit(gspca_exit
);
2536 module_param_named(debug
, gspca_debug
, int, 0644);
2537 MODULE_PARM_DESC(debug
,
2538 "Debug (bit) 0x01:error 0x02:probe 0x04:config"
2539 " 0x08:stream 0x10:frame 0x20:packet 0x40:USBin 0x80:USBout"