2 * Main USB camera driver
4 * Copyright (C) 2008-2009 Jean-Francois 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/jiffies.h>
39 #include <media/v4l2-ioctl.h>
43 #include <linux/input.h>
44 #include <linux/usb/input.h>
47 #define DEF_NURBS 3 /* default number of URBs */
48 #if DEF_NURBS > MAX_NURBS
49 #error "DEF_NURBS too big"
52 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
53 MODULE_DESCRIPTION("GSPCA USB Camera Driver");
54 MODULE_LICENSE("GPL");
56 #define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 9, 0)
59 int gspca_debug
= D_ERR
| D_PROBE
;
60 EXPORT_SYMBOL(gspca_debug
);
62 static void PDEBUG_MODE(char *txt
, __u32 pixfmt
, int w
, int h
)
64 if ((pixfmt
>> 24) >= '0' && (pixfmt
>> 24) <= 'z') {
65 PDEBUG(D_CONF
|D_STREAM
, "%s %c%c%c%c %dx%d",
69 (pixfmt
>> 16) & 0xff,
73 PDEBUG(D_CONF
|D_STREAM
, "%s 0x%08x %dx%d",
80 #define PDEBUG_MODE(txt, pixfmt, w, h)
83 /* specific memory types - !! should be different from V4L2_MEMORY_xxx */
84 #define GSPCA_MEMORY_NO 0 /* V4L2_MEMORY_xxx starts from 1 */
85 #define GSPCA_MEMORY_READ 7
87 #define BUF_ALL_FLAGS (V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE)
92 static void gspca_vm_open(struct vm_area_struct
*vma
)
94 struct gspca_frame
*frame
= vma
->vm_private_data
;
96 frame
->vma_use_count
++;
97 frame
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_MAPPED
;
100 static void gspca_vm_close(struct vm_area_struct
*vma
)
102 struct gspca_frame
*frame
= vma
->vm_private_data
;
104 if (--frame
->vma_use_count
<= 0)
105 frame
->v4l2_buf
.flags
&= ~V4L2_BUF_FLAG_MAPPED
;
108 static const struct vm_operations_struct gspca_vm_ops
= {
109 .open
= gspca_vm_open
,
110 .close
= gspca_vm_close
,
114 * Input and interrupt endpoint handling functions
117 static void int_irq(struct urb
*urb
)
119 struct gspca_dev
*gspca_dev
= (struct gspca_dev
*) urb
->context
;
125 if (gspca_dev
->sd_desc
->int_pkt_scan(gspca_dev
,
126 urb
->transfer_buffer
, urb
->actual_length
) < 0) {
127 PDEBUG(D_ERR
, "Unknown packet received");
135 /* Stop is requested either by software or hardware is gone,
136 * keep the ret value non-zero and don't resubmit later.
141 PDEBUG(D_ERR
, "URB error %i, resubmitting", urb
->status
);
147 ret
= usb_submit_urb(urb
, GFP_ATOMIC
);
149 PDEBUG(D_ERR
, "Resubmit URB failed with error %i", ret
);
153 static int gspca_input_connect(struct gspca_dev
*dev
)
155 struct input_dev
*input_dev
;
158 dev
->input_dev
= NULL
;
159 if (dev
->sd_desc
->int_pkt_scan
) {
160 input_dev
= input_allocate_device();
164 usb_make_path(dev
->dev
, dev
->phys
, sizeof(dev
->phys
));
165 strlcat(dev
->phys
, "/input0", sizeof(dev
->phys
));
167 input_dev
->name
= dev
->sd_desc
->name
;
168 input_dev
->phys
= dev
->phys
;
170 usb_to_input_id(dev
->dev
, &input_dev
->id
);
172 input_dev
->evbit
[0] = BIT_MASK(EV_KEY
);
173 input_dev
->keybit
[BIT_WORD(KEY_CAMERA
)] = BIT_MASK(KEY_CAMERA
);
174 input_dev
->dev
.parent
= &dev
->dev
->dev
;
176 err
= input_register_device(input_dev
);
178 PDEBUG(D_ERR
, "Input device registration failed "
179 "with error %i", err
);
180 input_dev
->dev
.parent
= NULL
;
181 input_free_device(input_dev
);
183 dev
->input_dev
= input_dev
;
191 static int alloc_and_submit_int_urb(struct gspca_dev
*gspca_dev
,
192 struct usb_endpoint_descriptor
*ep
)
194 unsigned int buffer_len
;
197 struct usb_device
*dev
;
201 buffer_len
= ep
->wMaxPacketSize
;
202 interval
= ep
->bInterval
;
203 PDEBUG(D_PROBE
, "found int in endpoint: 0x%x, "
204 "buffer_len=%u, interval=%u",
205 ep
->bEndpointAddress
, buffer_len
, interval
);
207 dev
= gspca_dev
->dev
;
209 urb
= usb_alloc_urb(0, GFP_KERNEL
);
215 buffer
= usb_buffer_alloc(dev
, ep
->wMaxPacketSize
,
216 GFP_KERNEL
, &urb
->transfer_dma
);
221 usb_fill_int_urb(urb
, dev
,
222 usb_rcvintpipe(dev
, ep
->bEndpointAddress
),
224 int_irq
, (void *)gspca_dev
, interval
);
225 gspca_dev
->int_urb
= urb
;
226 ret
= usb_submit_urb(urb
, GFP_KERNEL
);
228 PDEBUG(D_ERR
, "submit URB failed with error %i", ret
);
235 urb
->transfer_buffer_length
,
236 urb
->transfer_buffer
,
244 static int 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 ret
= alloc_and_submit_int_urb(gspca_dev
, ep
);
268 static void gspca_input_destroy_urb(struct gspca_dev
*gspca_dev
)
272 urb
= gspca_dev
->int_urb
;
274 gspca_dev
->int_urb
= NULL
;
276 usb_buffer_free(gspca_dev
->dev
,
277 urb
->transfer_buffer_length
,
278 urb
->transfer_buffer
,
284 #define gspca_input_connect(gspca_dev) 0
285 #define gspca_input_create_urb(gspca_dev) 0
286 #define gspca_input_destroy_urb(gspca_dev)
289 /* get the current input frame buffer */
290 struct gspca_frame
*gspca_get_i_frame(struct gspca_dev
*gspca_dev
)
292 struct gspca_frame
*frame
;
294 frame
= gspca_dev
->cur_frame
;
295 if ((frame
->v4l2_buf
.flags
& BUF_ALL_FLAGS
)
296 != V4L2_BUF_FLAG_QUEUED
)
300 EXPORT_SYMBOL(gspca_get_i_frame
);
303 * fill a video frame from an URB and resubmit
305 static void fill_frame(struct gspca_dev
*gspca_dev
,
308 u8
*data
; /* address of data in the iso message */
312 if (urb
->status
!= 0) {
313 if (urb
->status
== -ESHUTDOWN
)
314 return; /* disconnection */
316 if (gspca_dev
->frozen
)
319 PDEBUG(D_ERR
|D_PACK
, "urb status: %d", urb
->status
);
323 pkt_scan
= gspca_dev
->sd_desc
->pkt_scan
;
324 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
326 /* check the packet status and length */
327 len
= urb
->iso_frame_desc
[i
].actual_length
;
329 if (gspca_dev
->empty_packet
== 0)
330 gspca_dev
->empty_packet
= 1;
333 st
= urb
->iso_frame_desc
[i
].status
;
336 "ISOC data error: [%d] len=%d, status=%d",
338 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
342 /* let the packet be analyzed by the subdriver */
343 PDEBUG(D_PACK
, "packet [%d] o:%d l:%d",
344 i
, urb
->iso_frame_desc
[i
].offset
, len
);
345 data
= (u8
*) urb
->transfer_buffer
346 + urb
->iso_frame_desc
[i
].offset
;
347 pkt_scan(gspca_dev
, data
, len
);
351 /* resubmit the URB */
352 st
= usb_submit_urb(urb
, GFP_ATOMIC
);
354 PDEBUG(D_ERR
|D_PACK
, "usb_submit_urb() ret %d", st
);
358 * ISOC message interrupt from the USB device
360 * Analyse each packet and call the subdriver for copy to the frame buffer.
362 static void isoc_irq(struct urb
*urb
)
364 struct gspca_dev
*gspca_dev
= (struct gspca_dev
*) urb
->context
;
366 PDEBUG(D_PACK
, "isoc irq");
367 if (!gspca_dev
->streaming
)
369 fill_frame(gspca_dev
, urb
);
373 * bulk message interrupt from the USB device
375 static void bulk_irq(struct urb
*urb
)
377 struct gspca_dev
*gspca_dev
= (struct gspca_dev
*) urb
->context
;
380 PDEBUG(D_PACK
, "bulk irq");
381 if (!gspca_dev
->streaming
)
383 switch (urb
->status
) {
387 return; /* disconnection */
390 if (gspca_dev
->frozen
)
393 PDEBUG(D_ERR
|D_PACK
, "urb status: %d", urb
->status
);
398 PDEBUG(D_PACK
, "packet l:%d", urb
->actual_length
);
399 gspca_dev
->sd_desc
->pkt_scan(gspca_dev
,
400 urb
->transfer_buffer
,
404 /* resubmit the URB */
405 if (gspca_dev
->cam
.bulk_nurbs
!= 0) {
406 st
= usb_submit_urb(urb
, GFP_ATOMIC
);
408 PDEBUG(D_ERR
|D_PACK
, "usb_submit_urb() ret %d", st
);
413 * add data to the current frame
415 * This function is called by the subdrivers at interrupt level.
417 * To build a frame, these ones must add
419 * - 0 or many INTER_PACKETs
421 * DISCARD_PACKET invalidates the whole frame.
422 * On LAST_PACKET, a new frame is returned.
424 void gspca_frame_add(struct gspca_dev
*gspca_dev
,
425 enum gspca_packet_type packet_type
,
429 struct gspca_frame
*frame
;
432 PDEBUG(D_PACK
, "add t:%d l:%d", packet_type
, len
);
434 /* check the availability of the frame buffer */
435 frame
= gspca_dev
->cur_frame
;
436 if ((frame
->v4l2_buf
.flags
& BUF_ALL_FLAGS
)
437 != V4L2_BUF_FLAG_QUEUED
) {
438 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
442 /* when start of a new frame, if the current frame buffer
443 * is not queued, discard the whole frame */
444 if (packet_type
== FIRST_PACKET
) {
445 frame
->data_end
= frame
->data
;
446 jiffies_to_timeval(get_jiffies_64(),
447 &frame
->v4l2_buf
.timestamp
);
448 frame
->v4l2_buf
.sequence
= ++gspca_dev
->sequence
;
449 } else if (gspca_dev
->last_packet_type
== DISCARD_PACKET
) {
450 if (packet_type
== LAST_PACKET
)
451 gspca_dev
->last_packet_type
= packet_type
;
455 /* append the packet to the frame buffer */
457 if (frame
->data_end
- frame
->data
+ len
458 > frame
->v4l2_buf
.length
) {
459 PDEBUG(D_ERR
|D_PACK
, "frame overflow %zd > %d",
460 frame
->data_end
- frame
->data
+ len
,
461 frame
->v4l2_buf
.length
);
462 packet_type
= DISCARD_PACKET
;
464 memcpy(frame
->data_end
, data
, len
);
465 frame
->data_end
+= len
;
468 gspca_dev
->last_packet_type
= packet_type
;
470 /* if last packet, wake up the application and advance in the queue */
471 if (packet_type
== LAST_PACKET
) {
472 frame
->v4l2_buf
.bytesused
= frame
->data_end
- frame
->data
;
473 frame
->v4l2_buf
.flags
&= ~V4L2_BUF_FLAG_QUEUED
;
474 frame
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_DONE
;
475 wake_up_interruptible(&gspca_dev
->wq
); /* event = new frame */
476 i
= (gspca_dev
->fr_i
+ 1) % gspca_dev
->nframes
;
478 PDEBUG(D_FRAM
, "frame complete len:%d q:%d i:%d o:%d",
479 frame
->v4l2_buf
.bytesused
,
483 j
= gspca_dev
->fr_queue
[i
];
484 gspca_dev
->cur_frame
= &gspca_dev
->frame
[j
];
487 EXPORT_SYMBOL(gspca_frame_add
);
489 static int gspca_is_compressed(__u32 format
)
492 case V4L2_PIX_FMT_MJPEG
:
493 case V4L2_PIX_FMT_JPEG
:
494 case V4L2_PIX_FMT_SPCA561
:
495 case V4L2_PIX_FMT_PAC207
:
496 case V4L2_PIX_FMT_MR97310A
:
502 static void *rvmalloc(long size
)
507 mem
= vmalloc_32(size
);
509 adr
= (unsigned long) mem
;
511 SetPageReserved(vmalloc_to_page((void *) adr
));
519 static void rvfree(void *mem
, long size
)
523 adr
= (unsigned long) mem
;
525 ClearPageReserved(vmalloc_to_page((void *) adr
));
532 static int frame_alloc(struct gspca_dev
*gspca_dev
,
535 struct gspca_frame
*frame
;
539 i
= gspca_dev
->curr_mode
;
540 frsz
= gspca_dev
->cam
.cam_mode
[i
].sizeimage
;
541 PDEBUG(D_STREAM
, "frame alloc frsz: %d", frsz
);
542 frsz
= PAGE_ALIGN(frsz
);
543 gspca_dev
->frsz
= frsz
;
544 if (count
> GSPCA_MAX_FRAMES
)
545 count
= GSPCA_MAX_FRAMES
;
546 gspca_dev
->frbuf
= rvmalloc(frsz
* count
);
547 if (!gspca_dev
->frbuf
) {
548 err("frame alloc failed");
551 gspca_dev
->nframes
= count
;
552 for (i
= 0; i
< count
; i
++) {
553 frame
= &gspca_dev
->frame
[i
];
554 frame
->v4l2_buf
.index
= i
;
555 frame
->v4l2_buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
556 frame
->v4l2_buf
.flags
= 0;
557 frame
->v4l2_buf
.field
= V4L2_FIELD_NONE
;
558 frame
->v4l2_buf
.length
= frsz
;
559 frame
->v4l2_buf
.memory
= gspca_dev
->memory
;
560 frame
->v4l2_buf
.sequence
= 0;
561 frame
->data
= frame
->data_end
=
562 gspca_dev
->frbuf
+ i
* frsz
;
563 frame
->v4l2_buf
.m
.offset
= i
* frsz
;
565 gspca_dev
->fr_i
= gspca_dev
->fr_o
= gspca_dev
->fr_q
= 0;
566 gspca_dev
->cur_frame
= &gspca_dev
->frame
[0];
567 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
568 gspca_dev
->sequence
= 0;
572 static void frame_free(struct gspca_dev
*gspca_dev
)
576 PDEBUG(D_STREAM
, "frame free");
577 if (gspca_dev
->frbuf
!= NULL
) {
578 rvfree(gspca_dev
->frbuf
,
579 gspca_dev
->nframes
* gspca_dev
->frsz
);
580 gspca_dev
->frbuf
= NULL
;
581 for (i
= 0; i
< gspca_dev
->nframes
; i
++)
582 gspca_dev
->frame
[i
].data
= NULL
;
584 gspca_dev
->nframes
= 0;
587 static void destroy_urbs(struct gspca_dev
*gspca_dev
)
592 PDEBUG(D_STREAM
, "kill transfer");
593 for (i
= 0; i
< MAX_NURBS
; i
++) {
594 urb
= gspca_dev
->urb
[i
];
598 gspca_dev
->urb
[i
] = NULL
;
600 if (urb
->transfer_buffer
!= NULL
)
601 usb_buffer_free(gspca_dev
->dev
,
602 urb
->transfer_buffer_length
,
603 urb
->transfer_buffer
,
610 * look for an input transfer endpoint in an alternate setting
612 static struct usb_host_endpoint
*alt_xfer(struct usb_host_interface
*alt
,
615 struct usb_host_endpoint
*ep
;
618 for (i
= 0; i
< alt
->desc
.bNumEndpoints
; i
++) {
619 ep
= &alt
->endpoint
[i
];
620 attr
= ep
->desc
.bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
;
622 && ep
->desc
.wMaxPacketSize
!= 0)
629 * look for an input (isoc or bulk) endpoint
631 * The endpoint is defined by the subdriver.
632 * Use only the first isoc (some Zoran - 0x0572:0x0001 - have two such ep).
633 * This routine may be called many times when the bandwidth is too small
634 * (the bandwidth is checked on urb submit).
636 static struct usb_host_endpoint
*get_ep(struct gspca_dev
*gspca_dev
)
638 struct usb_interface
*intf
;
639 struct usb_host_endpoint
*ep
;
642 intf
= usb_ifnum_to_if(gspca_dev
->dev
, gspca_dev
->iface
);
644 xfer
= gspca_dev
->cam
.bulk
? USB_ENDPOINT_XFER_BULK
645 : USB_ENDPOINT_XFER_ISOC
;
646 i
= gspca_dev
->alt
; /* previous alt setting */
647 if (gspca_dev
->cam
.reverse_alts
) {
648 while (++i
< gspca_dev
->nbalt
) {
649 ep
= alt_xfer(&intf
->altsetting
[i
], xfer
);
655 ep
= alt_xfer(&intf
->altsetting
[i
], xfer
);
661 err("no transfer endpoint found");
664 PDEBUG(D_STREAM
, "use alt %d ep 0x%02x",
665 i
, ep
->desc
.bEndpointAddress
);
666 gspca_dev
->alt
= i
; /* memorize the current alt setting */
667 if (gspca_dev
->nbalt
> 1) {
668 gspca_input_destroy_urb(gspca_dev
);
669 ret
= usb_set_interface(gspca_dev
->dev
, gspca_dev
->iface
, i
);
671 err("set alt %d err %d", i
, ret
);
674 gspca_input_create_urb(gspca_dev
);
680 * create the URBs for image transfer
682 static int create_urbs(struct gspca_dev
*gspca_dev
,
683 struct usb_host_endpoint
*ep
)
686 int n
, nurbs
, i
, psize
, npkt
, bsize
;
688 /* calculate the packet size and the number of packets */
689 psize
= le16_to_cpu(ep
->desc
.wMaxPacketSize
);
691 if (!gspca_dev
->cam
.bulk
) { /* isoc */
693 /* See paragraph 5.9 / table 5-11 of the usb 2.0 spec. */
694 if (gspca_dev
->pkt_size
== 0)
695 psize
= (psize
& 0x07ff) * (1 + ((psize
>> 11) & 3));
697 psize
= gspca_dev
->pkt_size
;
698 npkt
= gspca_dev
->cam
.npkt
;
700 npkt
= 32; /* default value */
701 bsize
= psize
* npkt
;
703 "isoc %d pkts size %d = bsize:%d",
708 bsize
= gspca_dev
->cam
.bulk_size
;
711 PDEBUG(D_STREAM
, "bulk bsize:%d", bsize
);
712 if (gspca_dev
->cam
.bulk_nurbs
!= 0)
713 nurbs
= gspca_dev
->cam
.bulk_nurbs
;
718 for (n
= 0; n
< nurbs
; n
++) {
719 urb
= usb_alloc_urb(npkt
, GFP_KERNEL
);
721 err("usb_alloc_urb failed");
724 gspca_dev
->urb
[n
] = urb
;
725 urb
->transfer_buffer
= usb_buffer_alloc(gspca_dev
->dev
,
730 if (urb
->transfer_buffer
== NULL
) {
731 err("usb_buffer_alloc failed");
734 urb
->dev
= gspca_dev
->dev
;
735 urb
->context
= gspca_dev
;
736 urb
->transfer_buffer_length
= bsize
;
737 if (npkt
!= 0) { /* ISOC */
738 urb
->pipe
= usb_rcvisocpipe(gspca_dev
->dev
,
739 ep
->desc
.bEndpointAddress
);
740 urb
->transfer_flags
= URB_ISO_ASAP
741 | URB_NO_TRANSFER_DMA_MAP
;
742 urb
->interval
= ep
->desc
.bInterval
;
743 urb
->complete
= isoc_irq
;
744 urb
->number_of_packets
= npkt
;
745 for (i
= 0; i
< npkt
; i
++) {
746 urb
->iso_frame_desc
[i
].length
= psize
;
747 urb
->iso_frame_desc
[i
].offset
= psize
* i
;
750 urb
->pipe
= usb_rcvbulkpipe(gspca_dev
->dev
,
751 ep
->desc
.bEndpointAddress
),
752 urb
->transfer_flags
= URB_NO_TRANSFER_DMA_MAP
;
753 urb
->complete
= bulk_irq
;
760 * start the USB transfer
762 static int gspca_init_transfer(struct gspca_dev
*gspca_dev
)
764 struct usb_host_endpoint
*ep
;
768 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
771 if (!gspca_dev
->present
) {
776 gspca_dev
->usb_err
= 0;
778 /* set the higher alternate setting and
779 * loop until urb submit succeeds */
780 if (gspca_dev
->cam
.reverse_alts
)
783 gspca_dev
->alt
= gspca_dev
->nbalt
;
785 if (gspca_dev
->sd_desc
->isoc_init
) {
786 ret
= gspca_dev
->sd_desc
->isoc_init(gspca_dev
);
790 ep
= get_ep(gspca_dev
);
796 if (!gspca_dev
->cam
.no_urb_create
) {
797 PDEBUG(D_STREAM
, "init transfer alt %d",
799 ret
= create_urbs(gspca_dev
, ep
);
801 destroy_urbs(gspca_dev
);
806 /* clear the bulk endpoint */
807 if (gspca_dev
->cam
.bulk
)
808 usb_clear_halt(gspca_dev
->dev
,
809 gspca_dev
->urb
[0]->pipe
);
812 ret
= gspca_dev
->sd_desc
->start(gspca_dev
);
814 destroy_urbs(gspca_dev
);
817 gspca_dev
->streaming
= 1;
819 /* some bulk transfers are started by the subdriver */
820 if (gspca_dev
->cam
.bulk
&& gspca_dev
->cam
.bulk_nurbs
== 0)
823 /* submit the URBs */
824 for (n
= 0; n
< MAX_NURBS
; n
++) {
825 urb
= gspca_dev
->urb
[n
];
828 ret
= usb_submit_urb(urb
, GFP_KERNEL
);
834 gspca_dev
->streaming
= 0;
835 destroy_urbs(gspca_dev
);
836 if (ret
!= -ENOSPC
) {
837 PDEBUG(D_ERR
|D_STREAM
,
838 "usb_submit_urb alt %d err %d",
839 gspca_dev
->alt
, ret
);
843 /* the bandwidth is not wide enough
844 * negociate or try a lower alternate setting */
845 PDEBUG(D_ERR
|D_STREAM
,
846 "bandwidth not wide enough - trying again");
847 msleep(20); /* wait for kill complete */
848 if (gspca_dev
->sd_desc
->isoc_nego
) {
849 ret
= gspca_dev
->sd_desc
->isoc_nego(gspca_dev
);
853 ep
= get_ep(gspca_dev
);
861 mutex_unlock(&gspca_dev
->usb_lock
);
865 static int gspca_set_alt0(struct gspca_dev
*gspca_dev
)
869 if (gspca_dev
->alt
== 0)
871 ret
= usb_set_interface(gspca_dev
->dev
, gspca_dev
->iface
, 0);
873 PDEBUG(D_ERR
|D_STREAM
, "set alt 0 err %d", ret
);
877 /* Note: both the queue and the usb locks should be held when calling this */
878 static void gspca_stream_off(struct gspca_dev
*gspca_dev
)
880 gspca_dev
->streaming
= 0;
881 if (gspca_dev
->present
) {
882 if (gspca_dev
->sd_desc
->stopN
)
883 gspca_dev
->sd_desc
->stopN(gspca_dev
);
884 destroy_urbs(gspca_dev
);
885 gspca_input_destroy_urb(gspca_dev
);
886 gspca_set_alt0(gspca_dev
);
887 gspca_input_create_urb(gspca_dev
);
890 /* always call stop0 to free the subdriver's resources */
891 if (gspca_dev
->sd_desc
->stop0
)
892 gspca_dev
->sd_desc
->stop0(gspca_dev
);
893 PDEBUG(D_STREAM
, "stream off OK");
896 static void gspca_set_default_mode(struct gspca_dev
*gspca_dev
)
900 i
= gspca_dev
->cam
.nmodes
- 1; /* take the highest mode */
901 gspca_dev
->curr_mode
= i
;
902 gspca_dev
->width
= gspca_dev
->cam
.cam_mode
[i
].width
;
903 gspca_dev
->height
= gspca_dev
->cam
.cam_mode
[i
].height
;
904 gspca_dev
->pixfmt
= gspca_dev
->cam
.cam_mode
[i
].pixelformat
;
907 static int wxh_to_mode(struct gspca_dev
*gspca_dev
,
908 int width
, int height
)
912 for (i
= gspca_dev
->cam
.nmodes
; --i
> 0; ) {
913 if (width
>= gspca_dev
->cam
.cam_mode
[i
].width
914 && height
>= gspca_dev
->cam
.cam_mode
[i
].height
)
921 * search a mode with the right pixel format
923 static int gspca_get_mode(struct gspca_dev
*gspca_dev
,
929 modeU
= modeD
= mode
;
930 while ((modeU
< gspca_dev
->cam
.nmodes
) || modeD
>= 0) {
932 if (gspca_dev
->cam
.cam_mode
[modeD
].pixelformat
936 if (++modeU
< gspca_dev
->cam
.nmodes
) {
937 if (gspca_dev
->cam
.cam_mode
[modeU
].pixelformat
945 #ifdef CONFIG_VIDEO_ADV_DEBUG
946 static int vidioc_g_register(struct file
*file
, void *priv
,
947 struct v4l2_dbg_register
*reg
)
950 struct gspca_dev
*gspca_dev
= priv
;
952 if (!gspca_dev
->sd_desc
->get_chip_ident
)
955 if (!gspca_dev
->sd_desc
->get_register
)
958 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
960 gspca_dev
->usb_err
= 0;
961 if (gspca_dev
->present
)
962 ret
= gspca_dev
->sd_desc
->get_register(gspca_dev
, reg
);
965 mutex_unlock(&gspca_dev
->usb_lock
);
970 static int vidioc_s_register(struct file
*file
, void *priv
,
971 struct v4l2_dbg_register
*reg
)
974 struct gspca_dev
*gspca_dev
= priv
;
976 if (!gspca_dev
->sd_desc
->get_chip_ident
)
979 if (!gspca_dev
->sd_desc
->set_register
)
982 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
984 gspca_dev
->usb_err
= 0;
985 if (gspca_dev
->present
)
986 ret
= gspca_dev
->sd_desc
->set_register(gspca_dev
, reg
);
989 mutex_unlock(&gspca_dev
->usb_lock
);
995 static int vidioc_g_chip_ident(struct file
*file
, void *priv
,
996 struct v4l2_dbg_chip_ident
*chip
)
999 struct gspca_dev
*gspca_dev
= priv
;
1001 if (!gspca_dev
->sd_desc
->get_chip_ident
)
1004 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1005 return -ERESTARTSYS
;
1006 gspca_dev
->usb_err
= 0;
1007 if (gspca_dev
->present
)
1008 ret
= gspca_dev
->sd_desc
->get_chip_ident(gspca_dev
, chip
);
1011 mutex_unlock(&gspca_dev
->usb_lock
);
1016 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *priv
,
1017 struct v4l2_fmtdesc
*fmtdesc
)
1019 struct gspca_dev
*gspca_dev
= priv
;
1023 /* give an index to each format */
1026 for (i
= gspca_dev
->cam
.nmodes
; --i
>= 0; ) {
1027 fmt_tb
[index
] = gspca_dev
->cam
.cam_mode
[i
].pixelformat
;
1030 if (fmt_tb
[j
] == fmt_tb
[index
])
1035 if (fmtdesc
->index
== index
)
1036 break; /* new format */
1038 if (index
>= ARRAY_SIZE(fmt_tb
))
1043 return -EINVAL
; /* no more format */
1045 fmtdesc
->pixelformat
= fmt_tb
[index
];
1046 if (gspca_is_compressed(fmt_tb
[index
]))
1047 fmtdesc
->flags
= V4L2_FMT_FLAG_COMPRESSED
;
1048 fmtdesc
->description
[0] = fmtdesc
->pixelformat
& 0xff;
1049 fmtdesc
->description
[1] = (fmtdesc
->pixelformat
>> 8) & 0xff;
1050 fmtdesc
->description
[2] = (fmtdesc
->pixelformat
>> 16) & 0xff;
1051 fmtdesc
->description
[3] = fmtdesc
->pixelformat
>> 24;
1052 fmtdesc
->description
[4] = '\0';
1056 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
1057 struct v4l2_format
*fmt
)
1059 struct gspca_dev
*gspca_dev
= priv
;
1062 mode
= gspca_dev
->curr_mode
;
1063 memcpy(&fmt
->fmt
.pix
, &gspca_dev
->cam
.cam_mode
[mode
],
1064 sizeof fmt
->fmt
.pix
);
1068 static int try_fmt_vid_cap(struct gspca_dev
*gspca_dev
,
1069 struct v4l2_format
*fmt
)
1071 int w
, h
, mode
, mode2
;
1073 w
= fmt
->fmt
.pix
.width
;
1074 h
= fmt
->fmt
.pix
.height
;
1077 if (gspca_debug
& D_CONF
)
1078 PDEBUG_MODE("try fmt cap", fmt
->fmt
.pix
.pixelformat
, w
, h
);
1080 /* search the closest mode for width and height */
1081 mode
= wxh_to_mode(gspca_dev
, w
, h
);
1083 /* OK if right palette */
1084 if (gspca_dev
->cam
.cam_mode
[mode
].pixelformat
1085 != fmt
->fmt
.pix
.pixelformat
) {
1087 /* else, search the closest mode with the same pixel format */
1088 mode2
= gspca_get_mode(gspca_dev
, mode
,
1089 fmt
->fmt
.pix
.pixelformat
);
1093 ; * no chance, return this mode */
1095 memcpy(&fmt
->fmt
.pix
, &gspca_dev
->cam
.cam_mode
[mode
],
1096 sizeof fmt
->fmt
.pix
);
1097 return mode
; /* used when s_fmt */
1100 static int vidioc_try_fmt_vid_cap(struct file
*file
,
1102 struct v4l2_format
*fmt
)
1104 struct gspca_dev
*gspca_dev
= priv
;
1107 ret
= try_fmt_vid_cap(gspca_dev
, fmt
);
1113 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
1114 struct v4l2_format
*fmt
)
1116 struct gspca_dev
*gspca_dev
= priv
;
1119 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1120 return -ERESTARTSYS
;
1122 ret
= try_fmt_vid_cap(gspca_dev
, fmt
);
1126 if (gspca_dev
->nframes
!= 0
1127 && fmt
->fmt
.pix
.sizeimage
> gspca_dev
->frsz
) {
1132 if (ret
== gspca_dev
->curr_mode
) {
1134 goto out
; /* same mode */
1137 if (gspca_dev
->streaming
) {
1141 gspca_dev
->width
= fmt
->fmt
.pix
.width
;
1142 gspca_dev
->height
= fmt
->fmt
.pix
.height
;
1143 gspca_dev
->pixfmt
= fmt
->fmt
.pix
.pixelformat
;
1144 gspca_dev
->curr_mode
= ret
;
1148 mutex_unlock(&gspca_dev
->queue_lock
);
1152 static int vidioc_enum_framesizes(struct file
*file
, void *priv
,
1153 struct v4l2_frmsizeenum
*fsize
)
1155 struct gspca_dev
*gspca_dev
= priv
;
1159 for (i
= 0; i
< gspca_dev
->cam
.nmodes
; i
++) {
1160 if (fsize
->pixel_format
!=
1161 gspca_dev
->cam
.cam_mode
[i
].pixelformat
)
1164 if (fsize
->index
== index
) {
1165 fsize
->type
= V4L2_FRMSIZE_TYPE_DISCRETE
;
1166 fsize
->discrete
.width
=
1167 gspca_dev
->cam
.cam_mode
[i
].width
;
1168 fsize
->discrete
.height
=
1169 gspca_dev
->cam
.cam_mode
[i
].height
;
1178 static int vidioc_enum_frameintervals(struct file
*filp
, void *priv
,
1179 struct v4l2_frmivalenum
*fival
)
1181 struct gspca_dev
*gspca_dev
= priv
;
1182 int mode
= wxh_to_mode(gspca_dev
, fival
->width
, fival
->height
);
1185 if (gspca_dev
->cam
.mode_framerates
== NULL
||
1186 gspca_dev
->cam
.mode_framerates
[mode
].nrates
== 0)
1189 if (fival
->pixel_format
!=
1190 gspca_dev
->cam
.cam_mode
[mode
].pixelformat
)
1193 for (i
= 0; i
< gspca_dev
->cam
.mode_framerates
[mode
].nrates
; i
++) {
1194 if (fival
->index
== i
) {
1195 fival
->type
= V4L2_FRMSIZE_TYPE_DISCRETE
;
1196 fival
->discrete
.numerator
= 1;
1197 fival
->discrete
.denominator
=
1198 gspca_dev
->cam
.mode_framerates
[mode
].rates
[i
];
1206 static void gspca_release(struct video_device
*vfd
)
1208 struct gspca_dev
*gspca_dev
= container_of(vfd
, struct gspca_dev
, vdev
);
1210 PDEBUG(D_PROBE
, "%s released",
1211 video_device_node_name(&gspca_dev
->vdev
));
1213 kfree(gspca_dev
->usb_buf
);
1217 static int dev_open(struct file
*file
)
1219 struct gspca_dev
*gspca_dev
;
1222 PDEBUG(D_STREAM
, "[%s] open", current
->comm
);
1223 gspca_dev
= (struct gspca_dev
*) video_devdata(file
);
1224 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1225 return -ERESTARTSYS
;
1226 if (!gspca_dev
->present
) {
1231 if (gspca_dev
->users
> 4) { /* (arbitrary value) */
1236 /* protect the subdriver against rmmod */
1237 if (!try_module_get(gspca_dev
->module
)) {
1244 file
->private_data
= gspca_dev
;
1246 /* activate the v4l2 debug */
1247 if (gspca_debug
& D_V4L2
)
1248 gspca_dev
->vdev
.debug
|= V4L2_DEBUG_IOCTL
1249 | V4L2_DEBUG_IOCTL_ARG
;
1251 gspca_dev
->vdev
.debug
&= ~(V4L2_DEBUG_IOCTL
1252 | V4L2_DEBUG_IOCTL_ARG
);
1256 mutex_unlock(&gspca_dev
->queue_lock
);
1258 PDEBUG(D_ERR
|D_STREAM
, "open failed err %d", ret
);
1260 PDEBUG(D_STREAM
, "open done");
1264 static int dev_close(struct file
*file
)
1266 struct gspca_dev
*gspca_dev
= file
->private_data
;
1268 PDEBUG(D_STREAM
, "[%s] close", current
->comm
);
1269 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1270 return -ERESTARTSYS
;
1273 /* if the file did the capture, free the streaming resources */
1274 if (gspca_dev
->capt_file
== file
) {
1275 if (gspca_dev
->streaming
) {
1276 mutex_lock(&gspca_dev
->usb_lock
);
1277 gspca_dev
->usb_err
= 0;
1278 gspca_stream_off(gspca_dev
);
1279 mutex_unlock(&gspca_dev
->usb_lock
);
1281 frame_free(gspca_dev
);
1282 gspca_dev
->capt_file
= NULL
;
1283 gspca_dev
->memory
= GSPCA_MEMORY_NO
;
1285 file
->private_data
= NULL
;
1286 module_put(gspca_dev
->module
);
1287 mutex_unlock(&gspca_dev
->queue_lock
);
1289 PDEBUG(D_STREAM
, "close done");
1294 static int vidioc_querycap(struct file
*file
, void *priv
,
1295 struct v4l2_capability
*cap
)
1297 struct gspca_dev
*gspca_dev
= priv
;
1300 /* protect the access to the usb device */
1301 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1302 return -ERESTARTSYS
;
1303 if (!gspca_dev
->present
) {
1307 strncpy(cap
->driver
, gspca_dev
->sd_desc
->name
, sizeof cap
->driver
);
1308 if (gspca_dev
->dev
->product
!= NULL
) {
1309 strncpy(cap
->card
, gspca_dev
->dev
->product
,
1312 snprintf(cap
->card
, sizeof cap
->card
,
1313 "USB Camera (%04x:%04x)",
1314 le16_to_cpu(gspca_dev
->dev
->descriptor
.idVendor
),
1315 le16_to_cpu(gspca_dev
->dev
->descriptor
.idProduct
));
1317 usb_make_path(gspca_dev
->dev
, cap
->bus_info
, sizeof(cap
->bus_info
));
1318 cap
->version
= DRIVER_VERSION_NUMBER
;
1319 cap
->capabilities
= V4L2_CAP_VIDEO_CAPTURE
1320 | V4L2_CAP_STREAMING
1321 | V4L2_CAP_READWRITE
;
1324 mutex_unlock(&gspca_dev
->usb_lock
);
1328 static const struct ctrl
*get_ctrl(struct gspca_dev
*gspca_dev
,
1331 const struct ctrl
*ctrls
;
1334 for (i
= 0, ctrls
= gspca_dev
->sd_desc
->ctrls
;
1335 i
< gspca_dev
->sd_desc
->nctrls
;
1337 if (gspca_dev
->ctrl_dis
& (1 << i
))
1339 if (id
== ctrls
->qctrl
.id
)
1345 static int vidioc_queryctrl(struct file
*file
, void *priv
,
1346 struct v4l2_queryctrl
*q_ctrl
)
1348 struct gspca_dev
*gspca_dev
= priv
;
1349 const struct ctrl
*ctrls
;
1355 if (id
& V4L2_CTRL_FLAG_NEXT_CTRL
) {
1356 id
&= V4L2_CTRL_ID_MASK
;
1358 for (i
= 0; i
< gspca_dev
->sd_desc
->nctrls
; i
++) {
1359 if (gspca_dev
->ctrl_dis
& (1 << i
))
1361 if (gspca_dev
->sd_desc
->ctrls
[i
].qctrl
.id
< id
)
1363 if (ctrls
&& gspca_dev
->sd_desc
->ctrls
[i
].qctrl
.id
1366 ctrls
= &gspca_dev
->sd_desc
->ctrls
[i
];
1371 ctrls
= get_ctrl(gspca_dev
, id
);
1374 i
= ctrls
- gspca_dev
->sd_desc
->ctrls
;
1376 memcpy(q_ctrl
, ctrls
, sizeof *q_ctrl
);
1377 if (gspca_dev
->ctrl_inac
& (1 << i
))
1378 q_ctrl
->flags
|= V4L2_CTRL_FLAG_INACTIVE
;
1382 static int vidioc_s_ctrl(struct file
*file
, void *priv
,
1383 struct v4l2_control
*ctrl
)
1385 struct gspca_dev
*gspca_dev
= priv
;
1386 const struct ctrl
*ctrls
;
1389 ctrls
= get_ctrl(gspca_dev
, ctrl
->id
);
1393 if (ctrl
->value
< ctrls
->qctrl
.minimum
1394 || ctrl
->value
> ctrls
->qctrl
.maximum
)
1396 PDEBUG(D_CONF
, "set ctrl [%08x] = %d", ctrl
->id
, ctrl
->value
);
1397 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1398 return -ERESTARTSYS
;
1399 gspca_dev
->usb_err
= 0;
1400 if (gspca_dev
->present
)
1401 ret
= ctrls
->set(gspca_dev
, ctrl
->value
);
1404 mutex_unlock(&gspca_dev
->usb_lock
);
1408 static int vidioc_g_ctrl(struct file
*file
, void *priv
,
1409 struct v4l2_control
*ctrl
)
1411 struct gspca_dev
*gspca_dev
= priv
;
1412 const struct ctrl
*ctrls
;
1415 ctrls
= get_ctrl(gspca_dev
, ctrl
->id
);
1419 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1420 return -ERESTARTSYS
;
1421 gspca_dev
->usb_err
= 0;
1422 if (gspca_dev
->present
)
1423 ret
= ctrls
->get(gspca_dev
, &ctrl
->value
);
1426 mutex_unlock(&gspca_dev
->usb_lock
);
1430 /*fixme: have an audio flag in gspca_dev?*/
1431 static int vidioc_s_audio(struct file
*file
, void *priv
,
1432 struct v4l2_audio
*audio
)
1434 if (audio
->index
!= 0)
1439 static int vidioc_g_audio(struct file
*file
, void *priv
,
1440 struct v4l2_audio
*audio
)
1442 strcpy(audio
->name
, "Microphone");
1446 static int vidioc_enumaudio(struct file
*file
, void *priv
,
1447 struct v4l2_audio
*audio
)
1449 if (audio
->index
!= 0)
1452 strcpy(audio
->name
, "Microphone");
1453 audio
->capability
= 0;
1458 static int vidioc_querymenu(struct file
*file
, void *priv
,
1459 struct v4l2_querymenu
*qmenu
)
1461 struct gspca_dev
*gspca_dev
= priv
;
1463 if (!gspca_dev
->sd_desc
->querymenu
)
1465 return gspca_dev
->sd_desc
->querymenu(gspca_dev
, qmenu
);
1468 static int vidioc_enum_input(struct file
*file
, void *priv
,
1469 struct v4l2_input
*input
)
1471 struct gspca_dev
*gspca_dev
= priv
;
1473 if (input
->index
!= 0)
1475 input
->type
= V4L2_INPUT_TYPE_CAMERA
;
1476 input
->status
= gspca_dev
->cam
.input_flags
;
1477 strncpy(input
->name
, gspca_dev
->sd_desc
->name
,
1478 sizeof input
->name
);
1482 static int vidioc_g_input(struct file
*file
, void *priv
, unsigned int *i
)
1488 static int vidioc_s_input(struct file
*file
, void *priv
, unsigned int i
)
1495 static int vidioc_reqbufs(struct file
*file
, void *priv
,
1496 struct v4l2_requestbuffers
*rb
)
1498 struct gspca_dev
*gspca_dev
= priv
;
1501 switch (rb
->memory
) {
1502 case GSPCA_MEMORY_READ
: /* (internal call) */
1503 case V4L2_MEMORY_MMAP
:
1504 case V4L2_MEMORY_USERPTR
:
1509 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1510 return -ERESTARTSYS
;
1512 if (gspca_dev
->memory
!= GSPCA_MEMORY_NO
1513 && gspca_dev
->memory
!= rb
->memory
) {
1518 /* only one file may do the capture */
1519 if (gspca_dev
->capt_file
!= NULL
1520 && gspca_dev
->capt_file
!= file
) {
1525 /* if allocated, the buffers must not be mapped */
1526 for (i
= 0; i
< gspca_dev
->nframes
; i
++) {
1527 if (gspca_dev
->frame
[i
].vma_use_count
) {
1533 /* stop streaming */
1534 if (gspca_dev
->streaming
) {
1535 mutex_lock(&gspca_dev
->usb_lock
);
1536 gspca_dev
->usb_err
= 0;
1537 gspca_stream_off(gspca_dev
);
1538 mutex_unlock(&gspca_dev
->usb_lock
);
1541 /* free the previous allocated buffers, if any */
1542 if (gspca_dev
->nframes
!= 0) {
1543 frame_free(gspca_dev
);
1544 gspca_dev
->capt_file
= NULL
;
1546 if (rb
->count
== 0) /* unrequest */
1548 gspca_dev
->memory
= rb
->memory
;
1549 ret
= frame_alloc(gspca_dev
, rb
->count
);
1551 rb
->count
= gspca_dev
->nframes
;
1552 gspca_dev
->capt_file
= file
;
1555 mutex_unlock(&gspca_dev
->queue_lock
);
1556 PDEBUG(D_STREAM
, "reqbufs st:%d c:%d", ret
, rb
->count
);
1560 static int vidioc_querybuf(struct file
*file
, void *priv
,
1561 struct v4l2_buffer
*v4l2_buf
)
1563 struct gspca_dev
*gspca_dev
= priv
;
1564 struct gspca_frame
*frame
;
1566 if (v4l2_buf
->index
< 0
1567 || v4l2_buf
->index
>= gspca_dev
->nframes
)
1570 frame
= &gspca_dev
->frame
[v4l2_buf
->index
];
1571 memcpy(v4l2_buf
, &frame
->v4l2_buf
, sizeof *v4l2_buf
);
1575 static int vidioc_streamon(struct file
*file
, void *priv
,
1576 enum v4l2_buf_type buf_type
)
1578 struct gspca_dev
*gspca_dev
= priv
;
1581 if (buf_type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1583 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1584 return -ERESTARTSYS
;
1586 if (gspca_dev
->nframes
== 0
1587 || !(gspca_dev
->frame
[0].v4l2_buf
.flags
& V4L2_BUF_FLAG_QUEUED
)) {
1591 if (!gspca_dev
->streaming
) {
1592 ret
= gspca_init_transfer(gspca_dev
);
1597 if (gspca_debug
& D_STREAM
) {
1598 PDEBUG_MODE("stream on OK",
1606 mutex_unlock(&gspca_dev
->queue_lock
);
1610 static int vidioc_streamoff(struct file
*file
, void *priv
,
1611 enum v4l2_buf_type buf_type
)
1613 struct gspca_dev
*gspca_dev
= priv
;
1616 if (buf_type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1618 if (!gspca_dev
->streaming
)
1620 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1621 return -ERESTARTSYS
;
1623 /* stop streaming */
1624 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
)) {
1628 gspca_dev
->usb_err
= 0;
1629 gspca_stream_off(gspca_dev
);
1630 mutex_unlock(&gspca_dev
->usb_lock
);
1632 /* empty the application queues */
1633 for (i
= 0; i
< gspca_dev
->nframes
; i
++)
1634 gspca_dev
->frame
[i
].v4l2_buf
.flags
&= ~BUF_ALL_FLAGS
;
1635 gspca_dev
->fr_i
= gspca_dev
->fr_o
= gspca_dev
->fr_q
= 0;
1636 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
1637 gspca_dev
->sequence
= 0;
1640 mutex_unlock(&gspca_dev
->queue_lock
);
1644 static int vidioc_g_jpegcomp(struct file
*file
, void *priv
,
1645 struct v4l2_jpegcompression
*jpegcomp
)
1647 struct gspca_dev
*gspca_dev
= priv
;
1650 if (!gspca_dev
->sd_desc
->get_jcomp
)
1652 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1653 return -ERESTARTSYS
;
1654 gspca_dev
->usb_err
= 0;
1655 if (gspca_dev
->present
)
1656 ret
= gspca_dev
->sd_desc
->get_jcomp(gspca_dev
, jpegcomp
);
1659 mutex_unlock(&gspca_dev
->usb_lock
);
1663 static int vidioc_s_jpegcomp(struct file
*file
, void *priv
,
1664 struct v4l2_jpegcompression
*jpegcomp
)
1666 struct gspca_dev
*gspca_dev
= priv
;
1669 if (!gspca_dev
->sd_desc
->set_jcomp
)
1671 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1672 return -ERESTARTSYS
;
1673 gspca_dev
->usb_err
= 0;
1674 if (gspca_dev
->present
)
1675 ret
= gspca_dev
->sd_desc
->set_jcomp(gspca_dev
, jpegcomp
);
1678 mutex_unlock(&gspca_dev
->usb_lock
);
1682 static int vidioc_g_parm(struct file
*filp
, void *priv
,
1683 struct v4l2_streamparm
*parm
)
1685 struct gspca_dev
*gspca_dev
= priv
;
1687 parm
->parm
.capture
.readbuffers
= gspca_dev
->nbufread
;
1689 if (gspca_dev
->sd_desc
->get_streamparm
) {
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
->get_streamparm(gspca_dev
,
1700 mutex_unlock(&gspca_dev
->usb_lock
);
1707 static int vidioc_s_parm(struct file
*filp
, void *priv
,
1708 struct v4l2_streamparm
*parm
)
1710 struct gspca_dev
*gspca_dev
= priv
;
1713 n
= parm
->parm
.capture
.readbuffers
;
1714 if (n
== 0 || n
> GSPCA_MAX_FRAMES
)
1715 parm
->parm
.capture
.readbuffers
= gspca_dev
->nbufread
;
1717 gspca_dev
->nbufread
= n
;
1719 if (gspca_dev
->sd_desc
->set_streamparm
) {
1722 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1723 return -ERESTARTSYS
;
1724 gspca_dev
->usb_err
= 0;
1725 if (gspca_dev
->present
)
1726 ret
= gspca_dev
->sd_desc
->set_streamparm(gspca_dev
,
1730 mutex_unlock(&gspca_dev
->usb_lock
);
1737 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1738 static int vidiocgmbuf(struct file
*file
, void *priv
,
1739 struct video_mbuf
*mbuf
)
1741 struct gspca_dev
*gspca_dev
= file
->private_data
;
1744 PDEBUG(D_STREAM
, "cgmbuf");
1745 if (gspca_dev
->nframes
== 0) {
1749 struct v4l2_format fmt
;
1751 fmt
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1752 i
= gspca_dev
->cam
.nmodes
- 1; /* highest mode */
1753 fmt
.fmt
.pix
.width
= gspca_dev
->cam
.cam_mode
[i
].width
;
1754 fmt
.fmt
.pix
.height
= gspca_dev
->cam
.cam_mode
[i
].height
;
1755 fmt
.fmt
.pix
.pixelformat
= V4L2_PIX_FMT_BGR24
;
1756 ret
= vidioc_s_fmt_vid_cap(file
, priv
, &fmt
);
1761 struct v4l2_requestbuffers rb
;
1763 memset(&rb
, 0, sizeof rb
);
1765 rb
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1766 rb
.memory
= V4L2_MEMORY_MMAP
;
1767 ret
= vidioc_reqbufs(file
, priv
, &rb
);
1772 mbuf
->frames
= gspca_dev
->nframes
;
1773 mbuf
->size
= gspca_dev
->frsz
* gspca_dev
->nframes
;
1774 for (i
= 0; i
< mbuf
->frames
; i
++)
1775 mbuf
->offsets
[i
] = gspca_dev
->frame
[i
].v4l2_buf
.m
.offset
;
1780 static int dev_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1782 struct gspca_dev
*gspca_dev
= file
->private_data
;
1783 struct gspca_frame
*frame
;
1785 unsigned long addr
, start
, size
;
1788 start
= vma
->vm_start
;
1789 size
= vma
->vm_end
- vma
->vm_start
;
1790 PDEBUG(D_STREAM
, "mmap start:%08x size:%d", (int) start
, (int) size
);
1792 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1793 return -ERESTARTSYS
;
1794 if (!gspca_dev
->present
) {
1798 if (gspca_dev
->capt_file
!= file
) {
1804 for (i
= 0; i
< gspca_dev
->nframes
; ++i
) {
1805 if (gspca_dev
->frame
[i
].v4l2_buf
.memory
!= V4L2_MEMORY_MMAP
) {
1806 PDEBUG(D_STREAM
, "mmap bad memory type");
1809 if ((gspca_dev
->frame
[i
].v4l2_buf
.m
.offset
>> PAGE_SHIFT
)
1811 frame
= &gspca_dev
->frame
[i
];
1815 if (frame
== NULL
) {
1816 PDEBUG(D_STREAM
, "mmap no frame buffer found");
1820 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1821 /* v4l1 maps all the buffers */
1823 || size
!= frame
->v4l2_buf
.length
* gspca_dev
->nframes
)
1825 if (size
!= frame
->v4l2_buf
.length
) {
1826 PDEBUG(D_STREAM
, "mmap bad size");
1832 * - VM_IO marks the area as being a mmaped region for I/O to a
1833 * device. It also prevents the region from being core dumped.
1835 vma
->vm_flags
|= VM_IO
;
1837 addr
= (unsigned long) frame
->data
;
1839 page
= vmalloc_to_page((void *) addr
);
1840 ret
= vm_insert_page(vma
, start
, page
);
1848 vma
->vm_ops
= &gspca_vm_ops
;
1849 vma
->vm_private_data
= frame
;
1853 mutex_unlock(&gspca_dev
->queue_lock
);
1858 * wait for a video frame
1860 * If a frame is ready, its index is returned.
1862 static int frame_wait(struct gspca_dev
*gspca_dev
,
1865 struct gspca_frame
*frame
;
1868 /* check if a frame is ready */
1869 i
= gspca_dev
->fr_o
;
1870 j
= gspca_dev
->fr_queue
[i
];
1871 frame
= &gspca_dev
->frame
[j
];
1873 if (!(frame
->v4l2_buf
.flags
& V4L2_BUF_FLAG_DONE
)) {
1877 /* wait till a frame is ready */
1878 ret
= wait_event_interruptible_timeout(gspca_dev
->wq
,
1879 (frame
->v4l2_buf
.flags
& V4L2_BUF_FLAG_DONE
) ||
1880 !gspca_dev
->streaming
|| !gspca_dev
->present
,
1881 msecs_to_jiffies(3000));
1884 if (ret
== 0 || !gspca_dev
->streaming
|| !gspca_dev
->present
)
1888 gspca_dev
->fr_o
= (i
+ 1) % gspca_dev
->nframes
;
1889 PDEBUG(D_FRAM
, "frame wait q:%d i:%d o:%d",
1894 if (gspca_dev
->sd_desc
->dq_callback
) {
1895 mutex_lock(&gspca_dev
->usb_lock
);
1896 gspca_dev
->usb_err
= 0;
1897 if (gspca_dev
->present
)
1898 gspca_dev
->sd_desc
->dq_callback(gspca_dev
);
1899 mutex_unlock(&gspca_dev
->usb_lock
);
1905 * dequeue a video buffer
1907 * If nonblock_ing is false, block until a buffer is available.
1909 static int vidioc_dqbuf(struct file
*file
, void *priv
,
1910 struct v4l2_buffer
*v4l2_buf
)
1912 struct gspca_dev
*gspca_dev
= priv
;
1913 struct gspca_frame
*frame
;
1916 PDEBUG(D_FRAM
, "dqbuf");
1917 if (v4l2_buf
->memory
!= gspca_dev
->memory
)
1920 if (!gspca_dev
->present
)
1923 /* if not streaming, be sure the application will not loop forever */
1924 if (!(file
->f_flags
& O_NONBLOCK
)
1925 && !gspca_dev
->streaming
&& gspca_dev
->users
== 1)
1928 /* only the capturing file may dequeue */
1929 if (gspca_dev
->capt_file
!= file
)
1932 /* only one dequeue / read at a time */
1933 if (mutex_lock_interruptible(&gspca_dev
->read_lock
))
1934 return -ERESTARTSYS
;
1936 ret
= frame_wait(gspca_dev
, file
->f_flags
& O_NONBLOCK
);
1939 i
= ret
; /* frame index */
1940 frame
= &gspca_dev
->frame
[i
];
1941 if (gspca_dev
->memory
== V4L2_MEMORY_USERPTR
) {
1942 if (copy_to_user((__u8 __user
*) frame
->v4l2_buf
.m
.userptr
,
1944 frame
->v4l2_buf
.bytesused
)) {
1945 PDEBUG(D_ERR
|D_STREAM
,
1946 "dqbuf cp to user failed");
1951 frame
->v4l2_buf
.flags
&= ~V4L2_BUF_FLAG_DONE
;
1952 memcpy(v4l2_buf
, &frame
->v4l2_buf
, sizeof *v4l2_buf
);
1953 PDEBUG(D_FRAM
, "dqbuf %d", i
);
1956 mutex_unlock(&gspca_dev
->read_lock
);
1961 * queue a video buffer
1963 * Attempting to queue a buffer that has already been
1964 * queued will return -EINVAL.
1966 static int vidioc_qbuf(struct file
*file
, void *priv
,
1967 struct v4l2_buffer
*v4l2_buf
)
1969 struct gspca_dev
*gspca_dev
= priv
;
1970 struct gspca_frame
*frame
;
1973 PDEBUG(D_FRAM
, "qbuf %d", v4l2_buf
->index
);
1975 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1976 return -ERESTARTSYS
;
1978 index
= v4l2_buf
->index
;
1979 if ((unsigned) index
>= gspca_dev
->nframes
) {
1981 "qbuf idx %d >= %d", index
, gspca_dev
->nframes
);
1985 if (v4l2_buf
->memory
!= gspca_dev
->memory
) {
1986 PDEBUG(D_FRAM
, "qbuf bad memory type");
1991 frame
= &gspca_dev
->frame
[index
];
1992 if (frame
->v4l2_buf
.flags
& BUF_ALL_FLAGS
) {
1993 PDEBUG(D_FRAM
, "qbuf bad state");
1998 frame
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_QUEUED
;
2000 if (frame
->v4l2_buf
.memory
== V4L2_MEMORY_USERPTR
) {
2001 frame
->v4l2_buf
.m
.userptr
= v4l2_buf
->m
.userptr
;
2002 frame
->v4l2_buf
.length
= v4l2_buf
->length
;
2005 /* put the buffer in the 'queued' queue */
2006 i
= gspca_dev
->fr_q
;
2007 gspca_dev
->fr_queue
[i
] = index
;
2008 if (gspca_dev
->fr_i
== i
)
2009 gspca_dev
->cur_frame
= frame
;
2010 gspca_dev
->fr_q
= (i
+ 1) % gspca_dev
->nframes
;
2011 PDEBUG(D_FRAM
, "qbuf q:%d i:%d o:%d",
2016 v4l2_buf
->flags
|= V4L2_BUF_FLAG_QUEUED
;
2017 v4l2_buf
->flags
&= ~V4L2_BUF_FLAG_DONE
;
2020 mutex_unlock(&gspca_dev
->queue_lock
);
2025 * allocate the resources for read()
2027 static int read_alloc(struct gspca_dev
*gspca_dev
,
2030 struct v4l2_buffer v4l2_buf
;
2033 PDEBUG(D_STREAM
, "read alloc");
2034 if (gspca_dev
->nframes
== 0) {
2035 struct v4l2_requestbuffers rb
;
2037 memset(&rb
, 0, sizeof rb
);
2038 rb
.count
= gspca_dev
->nbufread
;
2039 rb
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2040 rb
.memory
= GSPCA_MEMORY_READ
;
2041 ret
= vidioc_reqbufs(file
, gspca_dev
, &rb
);
2043 PDEBUG(D_STREAM
, "read reqbuf err %d", ret
);
2046 memset(&v4l2_buf
, 0, sizeof v4l2_buf
);
2047 v4l2_buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2048 v4l2_buf
.memory
= GSPCA_MEMORY_READ
;
2049 for (i
= 0; i
< gspca_dev
->nbufread
; i
++) {
2051 ret
= vidioc_qbuf(file
, gspca_dev
, &v4l2_buf
);
2053 PDEBUG(D_STREAM
, "read qbuf err: %d", ret
);
2057 gspca_dev
->memory
= GSPCA_MEMORY_READ
;
2060 /* start streaming */
2061 ret
= vidioc_streamon(file
, gspca_dev
, V4L2_BUF_TYPE_VIDEO_CAPTURE
);
2063 PDEBUG(D_STREAM
, "read streamon err %d", ret
);
2067 static unsigned int dev_poll(struct file
*file
, poll_table
*wait
)
2069 struct gspca_dev
*gspca_dev
= file
->private_data
;
2072 PDEBUG(D_FRAM
, "poll");
2074 poll_wait(file
, &gspca_dev
->wq
, wait
);
2076 /* if reqbufs is not done, the user would use read() */
2077 if (gspca_dev
->nframes
== 0) {
2078 if (gspca_dev
->memory
!= GSPCA_MEMORY_NO
)
2079 return POLLERR
; /* not the 1st time */
2080 ret
= read_alloc(gspca_dev
, file
);
2085 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
) != 0)
2088 /* check the next incoming buffer */
2089 i
= gspca_dev
->fr_o
;
2090 i
= gspca_dev
->fr_queue
[i
];
2091 if (gspca_dev
->frame
[i
].v4l2_buf
.flags
& V4L2_BUF_FLAG_DONE
)
2092 ret
= POLLIN
| POLLRDNORM
; /* something to read */
2095 mutex_unlock(&gspca_dev
->queue_lock
);
2096 if (!gspca_dev
->present
)
2101 static ssize_t
dev_read(struct file
*file
, char __user
*data
,
2102 size_t count
, loff_t
*ppos
)
2104 struct gspca_dev
*gspca_dev
= file
->private_data
;
2105 struct gspca_frame
*frame
;
2106 struct v4l2_buffer v4l2_buf
;
2107 struct timeval timestamp
;
2110 PDEBUG(D_FRAM
, "read (%zd)", count
);
2111 if (!gspca_dev
->present
)
2113 switch (gspca_dev
->memory
) {
2114 case GSPCA_MEMORY_NO
: /* first time */
2115 ret
= read_alloc(gspca_dev
, file
);
2119 case GSPCA_MEMORY_READ
:
2120 if (gspca_dev
->capt_file
== file
)
2128 jiffies_to_timeval(get_jiffies_64(), ×tamp
);
2132 memset(&v4l2_buf
, 0, sizeof v4l2_buf
);
2133 v4l2_buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2134 v4l2_buf
.memory
= GSPCA_MEMORY_READ
;
2135 ret
= vidioc_dqbuf(file
, gspca_dev
, &v4l2_buf
);
2137 PDEBUG(D_STREAM
, "read dqbuf err %d", ret
);
2141 /* if the process slept for more than 1 second,
2142 * get a newer frame */
2143 frame
= &gspca_dev
->frame
[v4l2_buf
.index
];
2145 break; /* avoid infinite loop */
2146 if (frame
->v4l2_buf
.timestamp
.tv_sec
>= timestamp
.tv_sec
)
2148 ret
= vidioc_qbuf(file
, gspca_dev
, &v4l2_buf
);
2150 PDEBUG(D_STREAM
, "read qbuf err %d", ret
);
2155 /* copy the frame */
2156 if (count
> frame
->v4l2_buf
.bytesused
)
2157 count
= frame
->v4l2_buf
.bytesused
;
2158 ret
= copy_to_user(data
, frame
->data
, count
);
2160 PDEBUG(D_ERR
|D_STREAM
,
2161 "read cp to user lack %d / %zd", ret
, count
);
2167 /* in each case, requeue the buffer */
2168 ret2
= vidioc_qbuf(file
, gspca_dev
, &v4l2_buf
);
2174 static struct v4l2_file_operations dev_fops
= {
2175 .owner
= THIS_MODULE
,
2177 .release
= dev_close
,
2180 .unlocked_ioctl
= video_ioctl2
,
2184 static const struct v4l2_ioctl_ops dev_ioctl_ops
= {
2185 .vidioc_querycap
= vidioc_querycap
,
2186 .vidioc_dqbuf
= vidioc_dqbuf
,
2187 .vidioc_qbuf
= vidioc_qbuf
,
2188 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
2189 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
2190 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
2191 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
2192 .vidioc_streamon
= vidioc_streamon
,
2193 .vidioc_queryctrl
= vidioc_queryctrl
,
2194 .vidioc_g_ctrl
= vidioc_g_ctrl
,
2195 .vidioc_s_ctrl
= vidioc_s_ctrl
,
2196 .vidioc_g_audio
= vidioc_g_audio
,
2197 .vidioc_s_audio
= vidioc_s_audio
,
2198 .vidioc_enumaudio
= vidioc_enumaudio
,
2199 .vidioc_querymenu
= vidioc_querymenu
,
2200 .vidioc_enum_input
= vidioc_enum_input
,
2201 .vidioc_g_input
= vidioc_g_input
,
2202 .vidioc_s_input
= vidioc_s_input
,
2203 .vidioc_reqbufs
= vidioc_reqbufs
,
2204 .vidioc_querybuf
= vidioc_querybuf
,
2205 .vidioc_streamoff
= vidioc_streamoff
,
2206 .vidioc_g_jpegcomp
= vidioc_g_jpegcomp
,
2207 .vidioc_s_jpegcomp
= vidioc_s_jpegcomp
,
2208 .vidioc_g_parm
= vidioc_g_parm
,
2209 .vidioc_s_parm
= vidioc_s_parm
,
2210 .vidioc_enum_framesizes
= vidioc_enum_framesizes
,
2211 .vidioc_enum_frameintervals
= vidioc_enum_frameintervals
,
2212 #ifdef CONFIG_VIDEO_ADV_DEBUG
2213 .vidioc_g_register
= vidioc_g_register
,
2214 .vidioc_s_register
= vidioc_s_register
,
2216 .vidioc_g_chip_ident
= vidioc_g_chip_ident
,
2217 #ifdef CONFIG_VIDEO_V4L1_COMPAT
2218 .vidiocgmbuf
= vidiocgmbuf
,
2222 static struct video_device gspca_template
= {
2223 .name
= "gspca main driver",
2225 .ioctl_ops
= &dev_ioctl_ops
,
2226 .release
= gspca_release
,
2230 * probe and create a new gspca device
2232 * This function must be called by the sub-driver when it is
2233 * called for probing a new device.
2235 int gspca_dev_probe(struct usb_interface
*intf
,
2236 const struct usb_device_id
*id
,
2237 const struct sd_desc
*sd_desc
,
2239 struct module
*module
)
2241 struct usb_interface_descriptor
*interface
;
2242 struct gspca_dev
*gspca_dev
;
2243 struct usb_device
*dev
= interface_to_usbdev(intf
);
2246 PDEBUG(D_PROBE
, "probing %04x:%04x", id
->idVendor
, id
->idProduct
);
2248 /* we don't handle multi-config cameras */
2249 if (dev
->descriptor
.bNumConfigurations
!= 1) {
2250 PDEBUG(D_ERR
, "Too many config");
2254 /* the USB video interface must be the first one */
2255 interface
= &intf
->cur_altsetting
->desc
;
2256 if (dev
->config
->desc
.bNumInterfaces
!= 1 &&
2257 interface
->bInterfaceNumber
!= 0)
2260 /* create the device */
2261 if (dev_size
< sizeof *gspca_dev
)
2262 dev_size
= sizeof *gspca_dev
;
2263 gspca_dev
= kzalloc(dev_size
, GFP_KERNEL
);
2265 err("couldn't kzalloc gspca struct");
2268 gspca_dev
->usb_buf
= kmalloc(USB_BUF_SZ
, GFP_KERNEL
);
2269 if (!gspca_dev
->usb_buf
) {
2270 err("out of memory");
2274 gspca_dev
->dev
= dev
;
2275 gspca_dev
->iface
= interface
->bInterfaceNumber
;
2276 gspca_dev
->nbalt
= intf
->num_altsetting
;
2277 gspca_dev
->sd_desc
= sd_desc
;
2278 gspca_dev
->nbufread
= 2;
2279 gspca_dev
->empty_packet
= -1; /* don't check the empty packets */
2281 /* configure the subdriver and initialize the USB device */
2282 ret
= sd_desc
->config(gspca_dev
, id
);
2285 ret
= sd_desc
->init(gspca_dev
);
2288 gspca_set_default_mode(gspca_dev
);
2290 mutex_init(&gspca_dev
->usb_lock
);
2291 mutex_init(&gspca_dev
->read_lock
);
2292 mutex_init(&gspca_dev
->queue_lock
);
2293 init_waitqueue_head(&gspca_dev
->wq
);
2295 /* init video stuff */
2296 memcpy(&gspca_dev
->vdev
, &gspca_template
, sizeof gspca_template
);
2297 gspca_dev
->vdev
.parent
= &intf
->dev
;
2298 gspca_dev
->module
= module
;
2299 gspca_dev
->present
= 1;
2300 ret
= video_register_device(&gspca_dev
->vdev
,
2304 err("video_register_device err %d", ret
);
2308 usb_set_intfdata(intf
, gspca_dev
);
2309 PDEBUG(D_PROBE
, "%s created", video_device_node_name(&gspca_dev
->vdev
));
2311 ret
= gspca_input_connect(gspca_dev
);
2313 ret
= gspca_input_create_urb(gspca_dev
);
2317 kfree(gspca_dev
->usb_buf
);
2321 EXPORT_SYMBOL(gspca_dev_probe
);
2326 * This function must be called by the sub-driver
2327 * when the device disconnects, after the specific resources are freed.
2329 void gspca_disconnect(struct usb_interface
*intf
)
2331 struct gspca_dev
*gspca_dev
= usb_get_intfdata(intf
);
2332 struct input_dev
*input_dev
;
2334 PDEBUG(D_PROBE
, "%s disconnect",
2335 video_device_node_name(&gspca_dev
->vdev
));
2336 mutex_lock(&gspca_dev
->usb_lock
);
2337 gspca_dev
->present
= 0;
2339 if (gspca_dev
->streaming
) {
2340 destroy_urbs(gspca_dev
);
2341 wake_up_interruptible(&gspca_dev
->wq
);
2344 gspca_input_destroy_urb(gspca_dev
);
2345 input_dev
= gspca_dev
->input_dev
;
2347 gspca_dev
->input_dev
= NULL
;
2348 input_unregister_device(input_dev
);
2351 /* the device is freed at exit of this function */
2352 gspca_dev
->dev
= NULL
;
2353 mutex_unlock(&gspca_dev
->usb_lock
);
2355 usb_set_intfdata(intf
, NULL
);
2357 /* release the device */
2358 /* (this will call gspca_release() immediatly or on last close) */
2359 video_unregister_device(&gspca_dev
->vdev
);
2361 /* PDEBUG(D_PROBE, "disconnect complete"); */
2363 EXPORT_SYMBOL(gspca_disconnect
);
2366 int gspca_suspend(struct usb_interface
*intf
, pm_message_t message
)
2368 struct gspca_dev
*gspca_dev
= usb_get_intfdata(intf
);
2370 if (!gspca_dev
->streaming
)
2372 gspca_dev
->frozen
= 1; /* avoid urb error messages */
2373 if (gspca_dev
->sd_desc
->stopN
)
2374 gspca_dev
->sd_desc
->stopN(gspca_dev
);
2375 destroy_urbs(gspca_dev
);
2376 gspca_input_destroy_urb(gspca_dev
);
2377 gspca_set_alt0(gspca_dev
);
2378 if (gspca_dev
->sd_desc
->stop0
)
2379 gspca_dev
->sd_desc
->stop0(gspca_dev
);
2382 EXPORT_SYMBOL(gspca_suspend
);
2384 int gspca_resume(struct usb_interface
*intf
)
2386 struct gspca_dev
*gspca_dev
= usb_get_intfdata(intf
);
2388 gspca_dev
->frozen
= 0;
2389 gspca_dev
->sd_desc
->init(gspca_dev
);
2390 gspca_input_create_urb(gspca_dev
);
2391 if (gspca_dev
->streaming
)
2392 return gspca_init_transfer(gspca_dev
);
2395 EXPORT_SYMBOL(gspca_resume
);
2397 /* -- cam driver utility functions -- */
2399 /* auto gain and exposure algorithm based on the knee algorithm described here:
2400 http://ytse.tricolour.net/docs/LowLightOptimization.html
2402 Returns 0 if no changes were made, 1 if the gain and or exposure settings
2404 int gspca_auto_gain_n_exposure(struct gspca_dev
*gspca_dev
, int avg_lum
,
2405 int desired_avg_lum
, int deadzone
, int gain_knee
, int exposure_knee
)
2407 int i
, steps
, gain
, orig_gain
, exposure
, orig_exposure
, autogain
;
2408 const struct ctrl
*gain_ctrl
= NULL
;
2409 const struct ctrl
*exposure_ctrl
= NULL
;
2410 const struct ctrl
*autogain_ctrl
= NULL
;
2413 for (i
= 0; i
< gspca_dev
->sd_desc
->nctrls
; i
++) {
2414 if (gspca_dev
->sd_desc
->ctrls
[i
].qctrl
.id
== V4L2_CID_GAIN
)
2415 gain_ctrl
= &gspca_dev
->sd_desc
->ctrls
[i
];
2416 if (gspca_dev
->sd_desc
->ctrls
[i
].qctrl
.id
== V4L2_CID_EXPOSURE
)
2417 exposure_ctrl
= &gspca_dev
->sd_desc
->ctrls
[i
];
2418 if (gspca_dev
->sd_desc
->ctrls
[i
].qctrl
.id
== V4L2_CID_AUTOGAIN
)
2419 autogain_ctrl
= &gspca_dev
->sd_desc
->ctrls
[i
];
2421 if (!gain_ctrl
|| !exposure_ctrl
|| !autogain_ctrl
) {
2422 PDEBUG(D_ERR
, "Error: gspca_auto_gain_n_exposure called "
2423 "on cam without (auto)gain/exposure");
2427 if (gain_ctrl
->get(gspca_dev
, &gain
) ||
2428 exposure_ctrl
->get(gspca_dev
, &exposure
) ||
2429 autogain_ctrl
->get(gspca_dev
, &autogain
) || !autogain
)
2433 orig_exposure
= exposure
;
2435 /* If we are of a multiple of deadzone, do multiple steps to reach the
2436 desired lumination fast (with the risc of a slight overshoot) */
2437 steps
= abs(desired_avg_lum
- avg_lum
) / deadzone
;
2439 PDEBUG(D_FRAM
, "autogain: lum: %d, desired: %d, steps: %d",
2440 avg_lum
, desired_avg_lum
, steps
);
2442 for (i
= 0; i
< steps
; i
++) {
2443 if (avg_lum
> desired_avg_lum
) {
2444 if (gain
> gain_knee
)
2446 else if (exposure
> exposure_knee
)
2448 else if (gain
> gain_ctrl
->qctrl
.default_value
)
2450 else if (exposure
> exposure_ctrl
->qctrl
.minimum
)
2452 else if (gain
> gain_ctrl
->qctrl
.minimum
)
2457 if (gain
< gain_ctrl
->qctrl
.default_value
)
2459 else if (exposure
< exposure_knee
)
2461 else if (gain
< gain_knee
)
2463 else if (exposure
< exposure_ctrl
->qctrl
.maximum
)
2465 else if (gain
< gain_ctrl
->qctrl
.maximum
)
2472 if (gain
!= orig_gain
) {
2473 gain_ctrl
->set(gspca_dev
, gain
);
2476 if (exposure
!= orig_exposure
) {
2477 exposure_ctrl
->set(gspca_dev
, exposure
);
2483 EXPORT_SYMBOL(gspca_auto_gain_n_exposure
);
2485 /* -- module insert / remove -- */
2486 static int __init
gspca_init(void)
2488 info("main v%d.%d.%d registered",
2489 (DRIVER_VERSION_NUMBER
>> 16) & 0xff,
2490 (DRIVER_VERSION_NUMBER
>> 8) & 0xff,
2491 DRIVER_VERSION_NUMBER
& 0xff);
2494 static void __exit
gspca_exit(void)
2496 info("main deregistered");
2499 module_init(gspca_init
);
2500 module_exit(gspca_exit
);
2503 module_param_named(debug
, gspca_debug
, int, 0644);
2504 MODULE_PARM_DESC(debug
,
2505 "Debug (bit) 0x01:error 0x02:probe 0x04:config"
2506 " 0x08:stream 0x10:frame 0x20:packet 0x40:USBin 0x80:USBout"