2 * Main USB camera driver
4 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2 of the License, or (at your
9 * option) any later version.
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software Foundation,
18 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #define MODULE_NAME "gspca"
23 #include <linux/init.h>
25 #include <linux/vmalloc.h>
26 #include <linux/sched.h>
27 #include <linux/slab.h>
29 #include <linux/string.h>
30 #include <linux/pagemap.h>
33 #include <linux/uaccess.h>
34 #include <linux/jiffies.h>
35 #include <media/v4l2-ioctl.h>
40 #define DEF_NURBS 2 /* default number of URBs */
42 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
43 MODULE_DESCRIPTION("GSPCA USB Camera Driver");
44 MODULE_LICENSE("GPL");
46 #define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 2, 0)
48 static int video_nr
= -1;
50 #ifdef CONFIG_VIDEO_ADV_DEBUG
51 int gspca_debug
= D_ERR
| D_PROBE
;
52 EXPORT_SYMBOL(gspca_debug
);
54 static void PDEBUG_MODE(char *txt
, __u32 pixfmt
, int w
, int h
)
56 if ((pixfmt
>> 24) >= '0' && (pixfmt
>> 24) <= 'z') {
57 PDEBUG(D_CONF
|D_STREAM
, "%s %c%c%c%c %dx%d",
61 (pixfmt
>> 16) & 0xff,
65 PDEBUG(D_CONF
|D_STREAM
, "%s 0x%08x %dx%d",
72 #define PDEBUG_MODE(txt, pixfmt, w, h)
75 /* specific memory types - !! should different from V4L2_MEMORY_xxx */
76 #define GSPCA_MEMORY_NO 0 /* V4L2_MEMORY_xxx starts from 1 */
77 #define GSPCA_MEMORY_READ 7
79 #define BUF_ALL_FLAGS (V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE)
84 static void gspca_vm_open(struct vm_area_struct
*vma
)
86 struct gspca_frame
*frame
= vma
->vm_private_data
;
88 frame
->vma_use_count
++;
89 frame
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_MAPPED
;
92 static void gspca_vm_close(struct vm_area_struct
*vma
)
94 struct gspca_frame
*frame
= vma
->vm_private_data
;
96 if (--frame
->vma_use_count
<= 0)
97 frame
->v4l2_buf
.flags
&= ~V4L2_BUF_FLAG_MAPPED
;
100 static struct vm_operations_struct gspca_vm_ops
= {
101 .open
= gspca_vm_open
,
102 .close
= gspca_vm_close
,
106 * fill a video frame from an URB and resubmit
108 static void fill_frame(struct gspca_dev
*gspca_dev
,
111 struct gspca_frame
*frame
;
112 __u8
*data
; /* address of data in the iso message */
116 if (urb
->status
!= 0) {
117 PDEBUG(D_ERR
|D_PACK
, "urb status: %d", urb
->status
);
118 return; /* disconnection ? */
120 pkt_scan
= gspca_dev
->sd_desc
->pkt_scan
;
121 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
123 /* check the availability of the frame buffer */
125 j
= gspca_dev
->fr_queue
[j
];
126 frame
= &gspca_dev
->frame
[j
];
127 if ((frame
->v4l2_buf
.flags
& BUF_ALL_FLAGS
)
128 != V4L2_BUF_FLAG_QUEUED
) {
129 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
133 /* check the packet status and length */
134 len
= urb
->iso_frame_desc
[i
].actual_length
;
137 st
= urb
->iso_frame_desc
[i
].status
;
140 "ISOC data error: [%d] len=%d, status=%d",
142 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
146 /* let the packet be analyzed by the subdriver */
147 PDEBUG(D_PACK
, "packet [%d] o:%d l:%d",
148 i
, urb
->iso_frame_desc
[i
].offset
, len
);
149 data
= (__u8
*) urb
->transfer_buffer
150 + urb
->iso_frame_desc
[i
].offset
;
151 pkt_scan(gspca_dev
, frame
, data
, len
);
154 /* resubmit the URB */
156 st
= usb_submit_urb(urb
, GFP_ATOMIC
);
158 PDEBUG(D_ERR
|D_PACK
, "usb_submit_urb() ret %d", st
);
162 * ISOC message interrupt from the USB device
164 * Analyse each packet and call the subdriver for copy to the frame buffer.
166 static void isoc_irq(struct urb
*urb
169 struct gspca_dev
*gspca_dev
= (struct gspca_dev
*) urb
->context
;
171 PDEBUG(D_PACK
, "isoc irq");
172 if (!gspca_dev
->streaming
)
174 fill_frame(gspca_dev
, urb
);
178 * add data to the current frame
180 * This function is called by the subdrivers at interrupt level.
182 * To build a frame, these ones must add
184 * - 0 or many INTER_PACKETs
186 * DISCARD_PACKET invalidates the whole frame.
187 * On LAST_PACKET, a new frame is returned.
189 struct gspca_frame
*gspca_frame_add(struct gspca_dev
*gspca_dev
,
191 struct gspca_frame
*frame
,
197 PDEBUG(D_PACK
, "add t:%d l:%d", packet_type
, len
);
199 /* when start of a new frame, if the current frame buffer
200 * is not queued, discard the whole frame */
201 if (packet_type
== FIRST_PACKET
) {
202 if ((frame
->v4l2_buf
.flags
& BUF_ALL_FLAGS
)
203 != V4L2_BUF_FLAG_QUEUED
) {
204 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
207 frame
->data_end
= frame
->data
;
208 jiffies_to_timeval(get_jiffies_64(),
209 &frame
->v4l2_buf
.timestamp
);
210 frame
->v4l2_buf
.sequence
= ++gspca_dev
->sequence
;
211 } else if (gspca_dev
->last_packet_type
== DISCARD_PACKET
) {
212 if (packet_type
== LAST_PACKET
)
213 gspca_dev
->last_packet_type
= packet_type
;
217 /* append the packet to the frame buffer */
219 if (frame
->data_end
- frame
->data
+ len
220 > frame
->v4l2_buf
.length
) {
221 PDEBUG(D_ERR
|D_PACK
, "frame overflow %zd > %d",
222 frame
->data_end
- frame
->data
+ len
,
223 frame
->v4l2_buf
.length
);
224 packet_type
= DISCARD_PACKET
;
226 memcpy(frame
->data_end
, data
, len
);
227 frame
->data_end
+= len
;
230 gspca_dev
->last_packet_type
= packet_type
;
232 /* if last packet, wake the application and advance in the queue */
233 if (packet_type
== LAST_PACKET
) {
234 frame
->v4l2_buf
.bytesused
= frame
->data_end
- frame
->data
;
235 frame
->v4l2_buf
.flags
&= ~V4L2_BUF_FLAG_QUEUED
;
236 frame
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_DONE
;
237 atomic_inc(&gspca_dev
->nevent
);
238 wake_up_interruptible(&gspca_dev
->wq
); /* event = new frame */
239 i
= (gspca_dev
->fr_i
+ 1) % gspca_dev
->nframes
;
241 PDEBUG(D_FRAM
, "frame complete len:%d q:%d i:%d o:%d",
242 frame
->v4l2_buf
.bytesused
,
246 j
= gspca_dev
->fr_queue
[i
];
247 frame
= &gspca_dev
->frame
[j
];
251 EXPORT_SYMBOL(gspca_frame_add
);
253 static int gspca_is_compressed(__u32 format
)
256 case V4L2_PIX_FMT_MJPEG
:
257 case V4L2_PIX_FMT_JPEG
:
258 case V4L2_PIX_FMT_SPCA561
:
259 case V4L2_PIX_FMT_PAC207
:
265 static void *rvmalloc(unsigned long size
)
270 /* size = PAGE_ALIGN(size); (already done) */
271 mem
= vmalloc_32(size
);
273 adr
= (unsigned long) mem
;
274 while ((long) size
> 0) {
275 SetPageReserved(vmalloc_to_page((void *) adr
));
283 static void rvfree(void *mem
, long size
)
287 adr
= (unsigned long) mem
;
289 ClearPageReserved(vmalloc_to_page((void *) adr
));
296 static int frame_alloc(struct gspca_dev
*gspca_dev
,
299 struct gspca_frame
*frame
;
303 i
= gspca_dev
->curr_mode
;
304 frsz
= gspca_dev
->cam
.cam_mode
[i
].sizeimage
;
305 PDEBUG(D_STREAM
, "frame alloc frsz: %d", frsz
);
306 frsz
= PAGE_ALIGN(frsz
);
307 gspca_dev
->frsz
= frsz
;
308 if (count
> GSPCA_MAX_FRAMES
)
309 count
= GSPCA_MAX_FRAMES
;
310 gspca_dev
->frbuf
= rvmalloc(frsz
* count
);
311 if (!gspca_dev
->frbuf
) {
312 err("frame alloc failed");
315 gspca_dev
->nframes
= count
;
316 for (i
= 0; i
< count
; i
++) {
317 frame
= &gspca_dev
->frame
[i
];
318 frame
->v4l2_buf
.index
= i
;
319 frame
->v4l2_buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
320 frame
->v4l2_buf
.flags
= 0;
321 frame
->v4l2_buf
.field
= V4L2_FIELD_NONE
;
322 frame
->v4l2_buf
.length
= frsz
;
323 frame
->v4l2_buf
.memory
= gspca_dev
->memory
;
324 frame
->v4l2_buf
.sequence
= 0;
325 frame
->data
= frame
->data_end
=
326 gspca_dev
->frbuf
+ i
* frsz
;
327 frame
->v4l2_buf
.m
.offset
= i
* frsz
;
329 gspca_dev
->fr_i
= gspca_dev
->fr_o
= gspca_dev
->fr_q
= 0;
330 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
331 gspca_dev
->sequence
= 0;
332 atomic_set(&gspca_dev
->nevent
, 0);
336 static void frame_free(struct gspca_dev
*gspca_dev
)
340 PDEBUG(D_STREAM
, "frame free");
341 if (gspca_dev
->frbuf
!= NULL
) {
342 rvfree(gspca_dev
->frbuf
,
343 gspca_dev
->nframes
* gspca_dev
->frsz
);
344 gspca_dev
->frbuf
= NULL
;
345 for (i
= 0; i
< gspca_dev
->nframes
; i
++)
346 gspca_dev
->frame
[i
].data
= NULL
;
348 gspca_dev
->nframes
= 0;
351 static void destroy_urbs(struct gspca_dev
*gspca_dev
)
356 PDEBUG(D_STREAM
, "kill transfer");
357 for (i
= 0; i
< MAX_NURBS
; ++i
) {
358 urb
= gspca_dev
->urb
[i
];
362 gspca_dev
->urb
[i
] = NULL
;
364 if (urb
->transfer_buffer
!= NULL
)
365 usb_buffer_free(gspca_dev
->dev
,
366 urb
->transfer_buffer_length
,
367 urb
->transfer_buffer
,
374 * search an input isochronous endpoint in an alternate setting
376 static struct usb_host_endpoint
*alt_isoc(struct usb_host_interface
*alt
,
379 struct usb_host_endpoint
*ep
;
382 epaddr
|= USB_DIR_IN
;
383 for (i
= 0; i
< alt
->desc
.bNumEndpoints
; i
++) {
384 ep
= &alt
->endpoint
[i
];
385 if (ep
->desc
.bEndpointAddress
== epaddr
) {
386 attr
= ep
->desc
.bmAttributes
387 & USB_ENDPOINT_XFERTYPE_MASK
;
388 if (attr
== USB_ENDPOINT_XFER_ISOC
)
397 * search an input isochronous endpoint
399 * The endpoint is defined by the subdriver.
400 * Use only the first isoc (some Zoran - 0x0572:0x0001 - have two such ep).
401 * This routine may be called many times when the bandwidth is too small
402 * (the bandwidth is checked on urb submit).
404 static struct usb_host_endpoint
*get_isoc_ep(struct gspca_dev
*gspca_dev
)
406 struct usb_interface
*intf
;
407 struct usb_host_endpoint
*ep
;
410 intf
= usb_ifnum_to_if(gspca_dev
->dev
, gspca_dev
->iface
);
412 i
= gspca_dev
->alt
; /* previous alt setting */
413 while (--i
> 0) { /* alt 0 is unusable */
414 ep
= alt_isoc(&intf
->altsetting
[i
], gspca_dev
->cam
.epaddr
);
419 err("no ISOC endpoint found");
422 PDEBUG(D_STREAM
, "use ISOC alt %d ep 0x%02x",
423 i
, ep
->desc
.bEndpointAddress
);
424 ret
= usb_set_interface(gspca_dev
->dev
, gspca_dev
->iface
, i
);
426 err("set interface err %d", ret
);
429 gspca_dev
->alt
= i
; /* memorize the current alt setting */
434 * create the isochronous URBs
436 static int create_urbs(struct gspca_dev
*gspca_dev
,
437 struct usb_host_endpoint
*ep
)
440 int n
, nurbs
, i
, psize
, npkt
, bsize
;
442 /* calculate the packet size and the number of packets */
443 psize
= le16_to_cpu(ep
->desc
.wMaxPacketSize
);
445 /* See paragraph 5.9 / table 5-11 of the usb 2.0 spec. */
446 psize
= (psize
& 0x07ff) * (1 + ((psize
>> 11) & 3));
447 npkt
= ISO_MAX_SIZE
/ psize
;
448 if (npkt
> ISO_MAX_PKT
)
450 bsize
= psize
* npkt
;
452 "isoc %d pkts size %d (bsize:%d)", npkt
, psize
, bsize
);
454 gspca_dev
->nurbs
= nurbs
;
455 for (n
= 0; n
< nurbs
; n
++) {
456 urb
= usb_alloc_urb(npkt
, GFP_KERNEL
);
458 err("usb_alloc_urb failed");
461 urb
->transfer_buffer
= usb_buffer_alloc(gspca_dev
->dev
,
466 if (urb
->transfer_buffer
== NULL
) {
468 destroy_urbs(gspca_dev
);
469 err("usb_buffer_urb failed");
472 gspca_dev
->urb
[n
] = urb
;
473 urb
->dev
= gspca_dev
->dev
;
474 urb
->context
= gspca_dev
;
475 urb
->pipe
= usb_rcvisocpipe(gspca_dev
->dev
,
476 ep
->desc
.bEndpointAddress
);
477 urb
->transfer_flags
= URB_ISO_ASAP
478 | URB_NO_TRANSFER_DMA_MAP
;
479 urb
->interval
= ep
->desc
.bInterval
;
480 urb
->complete
= isoc_irq
;
481 urb
->number_of_packets
= npkt
;
482 urb
->transfer_buffer_length
= bsize
;
483 for (i
= 0; i
< npkt
; i
++) {
484 urb
->iso_frame_desc
[i
].length
= psize
;
485 urb
->iso_frame_desc
[i
].offset
= psize
* i
;
492 * start the USB transfer
494 static int gspca_init_transfer(struct gspca_dev
*gspca_dev
)
496 struct usb_host_endpoint
*ep
;
499 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
502 /* set the higher alternate setting and
503 * loop until urb submit succeeds */
504 gspca_dev
->alt
= gspca_dev
->nbalt
;
506 PDEBUG(D_STREAM
, "init transfer alt %d", gspca_dev
->alt
);
507 ep
= get_isoc_ep(gspca_dev
);
512 ret
= create_urbs(gspca_dev
, ep
);
517 gspca_dev
->sd_desc
->start(gspca_dev
);
518 gspca_dev
->streaming
= 1;
519 atomic_set(&gspca_dev
->nevent
, 0);
521 /* submit the URBs */
522 for (n
= 0; n
< gspca_dev
->nurbs
; n
++) {
523 ret
= usb_submit_urb(gspca_dev
->urb
[n
], GFP_KERNEL
);
525 PDEBUG(D_ERR
|D_STREAM
,
526 "usb_submit_urb [%d] err %d", n
, ret
);
527 gspca_dev
->streaming
= 0;
528 destroy_urbs(gspca_dev
);
530 break; /* try the previous alt */
538 mutex_unlock(&gspca_dev
->usb_lock
);
542 static int gspca_set_alt0(struct gspca_dev
*gspca_dev
)
546 ret
= usb_set_interface(gspca_dev
->dev
, gspca_dev
->iface
, 0);
548 PDEBUG(D_ERR
|D_STREAM
, "set interface 0 err %d", ret
);
552 /* Note both the queue and the usb lock should be hold when calling this */
553 static void gspca_stream_off(struct gspca_dev
*gspca_dev
)
555 gspca_dev
->streaming
= 0;
556 atomic_set(&gspca_dev
->nevent
, 0);
557 if (gspca_dev
->present
) {
558 gspca_dev
->sd_desc
->stopN(gspca_dev
);
559 destroy_urbs(gspca_dev
);
560 gspca_set_alt0(gspca_dev
);
561 gspca_dev
->sd_desc
->stop0(gspca_dev
);
562 PDEBUG(D_STREAM
, "stream off OK");
566 static void gspca_set_default_mode(struct gspca_dev
*gspca_dev
)
570 i
= gspca_dev
->cam
.nmodes
- 1; /* take the highest mode */
571 gspca_dev
->curr_mode
= i
;
572 gspca_dev
->width
= gspca_dev
->cam
.cam_mode
[i
].width
;
573 gspca_dev
->height
= gspca_dev
->cam
.cam_mode
[i
].height
;
574 gspca_dev
->pixfmt
= gspca_dev
->cam
.cam_mode
[i
].pixelformat
;
577 static int wxh_to_mode(struct gspca_dev
*gspca_dev
,
578 int width
, int height
)
582 for (i
= gspca_dev
->cam
.nmodes
; --i
> 0; ) {
583 if (width
>= gspca_dev
->cam
.cam_mode
[i
].width
584 && height
>= gspca_dev
->cam
.cam_mode
[i
].height
)
591 * search a mode with the right pixel format
593 static int gspca_get_mode(struct gspca_dev
*gspca_dev
,
599 modeU
= modeD
= mode
;
600 while ((modeU
< gspca_dev
->cam
.nmodes
) || modeD
>= 0) {
602 if (gspca_dev
->cam
.cam_mode
[modeD
].pixelformat
606 if (++modeU
< gspca_dev
->cam
.nmodes
) {
607 if (gspca_dev
->cam
.cam_mode
[modeU
].pixelformat
615 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *priv
,
616 struct v4l2_fmtdesc
*fmtdesc
)
618 struct gspca_dev
*gspca_dev
= priv
;
622 /* give an index to each format */
625 for (i
= gspca_dev
->cam
.nmodes
; --i
>= 0; ) {
626 fmt_tb
[index
] = gspca_dev
->cam
.cam_mode
[i
].pixelformat
;
629 if (fmt_tb
[j
] == fmt_tb
[index
])
634 if (fmtdesc
->index
== index
)
635 break; /* new format */
637 if (index
>= sizeof fmt_tb
/ sizeof fmt_tb
[0])
642 return -EINVAL
; /* no more format */
644 fmtdesc
->pixelformat
= fmt_tb
[index
];
645 if (gspca_is_compressed(fmt_tb
[index
]))
646 fmtdesc
->flags
= V4L2_FMT_FLAG_COMPRESSED
;
647 fmtdesc
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
648 fmtdesc
->description
[0] = fmtdesc
->pixelformat
& 0xff;
649 fmtdesc
->description
[1] = (fmtdesc
->pixelformat
>> 8) & 0xff;
650 fmtdesc
->description
[2] = (fmtdesc
->pixelformat
>> 16) & 0xff;
651 fmtdesc
->description
[3] = fmtdesc
->pixelformat
>> 24;
652 fmtdesc
->description
[4] = '\0';
656 static int vidioc_g_fmt_vid_cap(struct file
*file
, void *priv
,
657 struct v4l2_format
*fmt
)
659 struct gspca_dev
*gspca_dev
= priv
;
662 if (fmt
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
664 mode
= gspca_dev
->curr_mode
;
665 memcpy(&fmt
->fmt
.pix
, &gspca_dev
->cam
.cam_mode
[mode
],
666 sizeof fmt
->fmt
.pix
);
670 static int try_fmt_vid_cap(struct gspca_dev
*gspca_dev
,
671 struct v4l2_format
*fmt
)
673 int w
, h
, mode
, mode2
;
675 if (fmt
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
677 w
= fmt
->fmt
.pix
.width
;
678 h
= fmt
->fmt
.pix
.height
;
680 #ifdef CONFIG_VIDEO_ADV_DEBUG
681 if (gspca_debug
& D_CONF
)
682 PDEBUG_MODE("try fmt cap", fmt
->fmt
.pix
.pixelformat
, w
, h
);
684 /* search the closest mode for width and height */
685 mode
= wxh_to_mode(gspca_dev
, w
, h
);
687 /* OK if right palette */
688 if (gspca_dev
->cam
.cam_mode
[mode
].pixelformat
689 != fmt
->fmt
.pix
.pixelformat
) {
691 /* else, search the closest mode with the same pixel format */
692 mode2
= gspca_get_mode(gspca_dev
, mode
,
693 fmt
->fmt
.pix
.pixelformat
);
697 ; * no chance, return this mode */
699 memcpy(&fmt
->fmt
.pix
, &gspca_dev
->cam
.cam_mode
[mode
],
700 sizeof fmt
->fmt
.pix
);
701 return mode
; /* used when s_fmt */
704 static int vidioc_try_fmt_vid_cap(struct file
*file
,
706 struct v4l2_format
*fmt
)
708 struct gspca_dev
*gspca_dev
= priv
;
711 ret
= try_fmt_vid_cap(gspca_dev
, fmt
);
717 static int vidioc_s_fmt_vid_cap(struct file
*file
, void *priv
,
718 struct v4l2_format
*fmt
)
720 struct gspca_dev
*gspca_dev
= priv
;
723 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
726 ret
= try_fmt_vid_cap(gspca_dev
, fmt
);
730 if (gspca_dev
->nframes
!= 0
731 && fmt
->fmt
.pix
.sizeimage
> gspca_dev
->frsz
) {
736 if (ret
== gspca_dev
->curr_mode
) {
738 goto out
; /* same mode */
741 if (gspca_dev
->streaming
) {
745 gspca_dev
->width
= fmt
->fmt
.pix
.width
;
746 gspca_dev
->height
= fmt
->fmt
.pix
.height
;
747 gspca_dev
->pixfmt
= fmt
->fmt
.pix
.pixelformat
;
748 gspca_dev
->curr_mode
= ret
;
752 mutex_unlock(&gspca_dev
->queue_lock
);
756 static int dev_open(struct inode
*inode
, struct file
*file
)
758 struct gspca_dev
*gspca_dev
;
761 PDEBUG(D_STREAM
, "%s open", current
->comm
);
762 gspca_dev
= (struct gspca_dev
*) video_devdata(file
);
763 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
765 if (!gspca_dev
->present
) {
770 /* if not done yet, initialize the sensor */
771 if (gspca_dev
->users
== 0) {
772 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
)) {
776 ret
= gspca_dev
->sd_desc
->open(gspca_dev
);
777 mutex_unlock(&gspca_dev
->usb_lock
);
779 PDEBUG(D_ERR
|D_CONF
, "init device failed %d", ret
);
782 } else if (gspca_dev
->users
> 4) { /* (arbitrary value) */
787 file
->private_data
= gspca_dev
;
788 #ifdef CONFIG_VIDEO_ADV_DEBUG
789 /* activate the v4l2 debug */
790 if (gspca_debug
& D_V4L2
)
791 gspca_dev
->vdev
.debug
|= 3;
793 gspca_dev
->vdev
.debug
&= ~3;
796 mutex_unlock(&gspca_dev
->queue_lock
);
798 PDEBUG(D_ERR
|D_STREAM
, "open failed err %d", ret
);
800 PDEBUG(D_STREAM
, "open done");
804 static int dev_close(struct inode
*inode
, struct file
*file
)
806 struct gspca_dev
*gspca_dev
= file
->private_data
;
808 PDEBUG(D_STREAM
, "%s close", current
->comm
);
809 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
813 /* if the file did the capture, free the streaming resources */
814 if (gspca_dev
->capt_file
== file
) {
815 mutex_lock(&gspca_dev
->usb_lock
);
816 if (gspca_dev
->streaming
)
817 gspca_stream_off(gspca_dev
);
818 gspca_dev
->sd_desc
->close(gspca_dev
);
819 mutex_unlock(&gspca_dev
->usb_lock
);
820 frame_free(gspca_dev
);
821 gspca_dev
->capt_file
= NULL
;
822 gspca_dev
->memory
= GSPCA_MEMORY_NO
;
824 file
->private_data
= NULL
;
825 mutex_unlock(&gspca_dev
->queue_lock
);
826 PDEBUG(D_STREAM
, "close done");
830 static int vidioc_querycap(struct file
*file
, void *priv
,
831 struct v4l2_capability
*cap
)
833 struct gspca_dev
*gspca_dev
= priv
;
835 memset(cap
, 0, sizeof *cap
);
836 strncpy(cap
->driver
, gspca_dev
->sd_desc
->name
, sizeof cap
->driver
);
837 /* strncpy(cap->card, gspca_dev->cam.dev_name, sizeof cap->card); */
838 if (gspca_dev
->dev
->product
!= NULL
) {
839 strncpy(cap
->card
, gspca_dev
->dev
->product
,
842 snprintf(cap
->card
, sizeof cap
->card
,
843 "USB Camera (%04x:%04x)",
844 le16_to_cpu(gspca_dev
->dev
->descriptor
.idVendor
),
845 le16_to_cpu(gspca_dev
->dev
->descriptor
.idProduct
));
847 strncpy(cap
->bus_info
, gspca_dev
->dev
->bus
->bus_name
,
848 sizeof cap
->bus_info
);
849 cap
->version
= DRIVER_VERSION_NUMBER
;
850 cap
->capabilities
= V4L2_CAP_VIDEO_CAPTURE
852 | V4L2_CAP_READWRITE
;
856 /* the use of V4L2_CTRL_FLAG_NEXT_CTRL asks for the controls to be sorted */
857 static int vidioc_queryctrl(struct file
*file
, void *priv
,
858 struct v4l2_queryctrl
*q_ctrl
)
860 struct gspca_dev
*gspca_dev
= priv
;
865 if (id
& V4L2_CTRL_FLAG_NEXT_CTRL
) {
866 id
&= V4L2_CTRL_ID_MASK
;
868 for (i
= 0; i
< gspca_dev
->sd_desc
->nctrls
; i
++) {
869 if (id
>= gspca_dev
->sd_desc
->ctrls
[i
].qctrl
.id
) {
871 &gspca_dev
->sd_desc
->ctrls
[i
].qctrl
,
878 for (i
= 0; i
< gspca_dev
->sd_desc
->nctrls
; i
++) {
879 if (id
== gspca_dev
->sd_desc
->ctrls
[i
].qctrl
.id
) {
881 &gspca_dev
->sd_desc
->ctrls
[i
].qctrl
,
886 if (id
>= V4L2_CID_BASE
887 && id
<= V4L2_CID_LASTP1
) {
888 q_ctrl
->flags
|= V4L2_CTRL_FLAG_DISABLED
;
894 static int vidioc_s_ctrl(struct file
*file
, void *priv
,
895 struct v4l2_control
*ctrl
)
897 struct gspca_dev
*gspca_dev
= priv
;
898 const struct ctrl
*ctrls
;
901 for (i
= 0, ctrls
= gspca_dev
->sd_desc
->ctrls
;
902 i
< gspca_dev
->sd_desc
->nctrls
;
904 if (ctrl
->id
!= ctrls
->qctrl
.id
)
906 if (ctrl
->value
< ctrls
->qctrl
.minimum
907 && ctrl
->value
> ctrls
->qctrl
.maximum
)
909 PDEBUG(D_CONF
, "set ctrl [%08x] = %d", ctrl
->id
, ctrl
->value
);
910 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
912 ret
= ctrls
->set(gspca_dev
, ctrl
->value
);
913 mutex_unlock(&gspca_dev
->usb_lock
);
919 static int vidioc_g_ctrl(struct file
*file
, void *priv
,
920 struct v4l2_control
*ctrl
)
922 struct gspca_dev
*gspca_dev
= priv
;
924 const struct ctrl
*ctrls
;
927 for (i
= 0, ctrls
= gspca_dev
->sd_desc
->ctrls
;
928 i
< gspca_dev
->sd_desc
->nctrls
;
930 if (ctrl
->id
!= ctrls
->qctrl
.id
)
932 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
934 ret
= ctrls
->get(gspca_dev
, &ctrl
->value
);
935 mutex_unlock(&gspca_dev
->usb_lock
);
941 static int vidioc_querymenu(struct file
*file
, void *priv
,
942 struct v4l2_querymenu
*qmenu
)
944 struct gspca_dev
*gspca_dev
= priv
;
946 if (!gspca_dev
->sd_desc
->querymenu
)
948 return gspca_dev
->sd_desc
->querymenu(gspca_dev
, qmenu
);
951 static int vidioc_enum_input(struct file
*file
, void *priv
,
952 struct v4l2_input
*input
)
954 struct gspca_dev
*gspca_dev
= priv
;
956 if (input
->index
!= 0)
958 memset(input
, 0, sizeof *input
);
959 input
->type
= V4L2_INPUT_TYPE_CAMERA
;
960 strncpy(input
->name
, gspca_dev
->sd_desc
->name
,
965 static int vidioc_g_input(struct file
*file
, void *priv
, unsigned int *i
)
971 static int vidioc_s_input(struct file
*file
, void *priv
, unsigned int i
)
978 static int vidioc_reqbufs(struct file
*file
, void *priv
,
979 struct v4l2_requestbuffers
*rb
)
981 struct gspca_dev
*gspca_dev
= priv
;
984 if (rb
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
986 switch (rb
->memory
) {
987 case GSPCA_MEMORY_READ
: /* (internal call) */
988 case V4L2_MEMORY_MMAP
:
989 case V4L2_MEMORY_USERPTR
:
994 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
997 if (gspca_dev
->memory
!= GSPCA_MEMORY_NO
998 && gspca_dev
->memory
!= rb
->memory
) {
1003 /* only one file may do the capture */
1004 if (gspca_dev
->capt_file
!= NULL
1005 && gspca_dev
->capt_file
!= file
) {
1010 /* if allocated, the buffers must not be mapped */
1011 for (i
= 0; i
< gspca_dev
->nframes
; i
++) {
1012 if (gspca_dev
->frame
[i
].vma_use_count
) {
1018 /* stop streaming */
1019 if (gspca_dev
->streaming
) {
1020 mutex_lock(&gspca_dev
->usb_lock
);
1021 gspca_stream_off(gspca_dev
);
1022 mutex_unlock(&gspca_dev
->usb_lock
);
1025 /* free the previous allocated buffers, if any */
1026 if (gspca_dev
->nframes
!= 0) {
1027 frame_free(gspca_dev
);
1028 gspca_dev
->capt_file
= NULL
;
1030 if (rb
->count
== 0) /* unrequest */
1032 gspca_dev
->memory
= rb
->memory
;
1033 ret
= frame_alloc(gspca_dev
, rb
->count
);
1035 rb
->count
= gspca_dev
->nframes
;
1036 gspca_dev
->capt_file
= file
;
1039 mutex_unlock(&gspca_dev
->queue_lock
);
1040 PDEBUG(D_STREAM
, "reqbufs st:%d c:%d", ret
, rb
->count
);
1044 static int vidioc_querybuf(struct file
*file
, void *priv
,
1045 struct v4l2_buffer
*v4l2_buf
)
1047 struct gspca_dev
*gspca_dev
= priv
;
1048 struct gspca_frame
*frame
;
1050 if (v4l2_buf
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
1051 || v4l2_buf
->index
< 0
1052 || v4l2_buf
->index
>= gspca_dev
->nframes
)
1055 frame
= &gspca_dev
->frame
[v4l2_buf
->index
];
1056 memcpy(v4l2_buf
, &frame
->v4l2_buf
, sizeof *v4l2_buf
);
1060 static int vidioc_streamon(struct file
*file
, void *priv
,
1061 enum v4l2_buf_type buf_type
)
1063 struct gspca_dev
*gspca_dev
= priv
;
1066 if (buf_type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1068 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1069 return -ERESTARTSYS
;
1070 if (!gspca_dev
->present
) {
1074 if (gspca_dev
->nframes
== 0) {
1078 if (!gspca_dev
->streaming
) {
1079 ret
= gspca_init_transfer(gspca_dev
);
1083 #ifdef CONFIG_VIDEO_ADV_DEBUG
1084 if (gspca_debug
& D_STREAM
) {
1085 PDEBUG_MODE("stream on OK",
1093 mutex_unlock(&gspca_dev
->queue_lock
);
1097 static int vidioc_streamoff(struct file
*file
, void *priv
,
1098 enum v4l2_buf_type buf_type
)
1100 struct gspca_dev
*gspca_dev
= priv
;
1103 if (buf_type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1105 if (!gspca_dev
->streaming
)
1107 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1108 return -ERESTARTSYS
;
1110 /* stop streaming */
1111 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
)) {
1115 gspca_stream_off(gspca_dev
);
1116 mutex_unlock(&gspca_dev
->usb_lock
);
1118 /* empty the application queues */
1119 for (i
= 0; i
< gspca_dev
->nframes
; i
++)
1120 gspca_dev
->frame
[i
].v4l2_buf
.flags
&= ~BUF_ALL_FLAGS
;
1121 gspca_dev
->fr_i
= gspca_dev
->fr_o
= gspca_dev
->fr_q
= 0;
1122 gspca_dev
->last_packet_type
= DISCARD_PACKET
;
1123 gspca_dev
->sequence
= 0;
1124 atomic_set(&gspca_dev
->nevent
, 0);
1127 mutex_unlock(&gspca_dev
->queue_lock
);
1131 static int vidioc_g_jpegcomp(struct file
*file
, void *priv
,
1132 struct v4l2_jpegcompression
*jpegcomp
)
1134 struct gspca_dev
*gspca_dev
= priv
;
1137 if (!gspca_dev
->sd_desc
->get_jcomp
)
1139 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1140 return -ERESTARTSYS
;
1141 ret
= gspca_dev
->sd_desc
->get_jcomp(gspca_dev
, jpegcomp
);
1142 mutex_unlock(&gspca_dev
->usb_lock
);
1146 static int vidioc_s_jpegcomp(struct file
*file
, void *priv
,
1147 struct v4l2_jpegcompression
*jpegcomp
)
1149 struct gspca_dev
*gspca_dev
= priv
;
1152 if (mutex_lock_interruptible(&gspca_dev
->usb_lock
))
1153 return -ERESTARTSYS
;
1154 if (!gspca_dev
->sd_desc
->set_jcomp
)
1156 ret
= gspca_dev
->sd_desc
->set_jcomp(gspca_dev
, jpegcomp
);
1157 mutex_unlock(&gspca_dev
->usb_lock
);
1161 static int vidioc_g_parm(struct file
*filp
, void *priv
,
1162 struct v4l2_streamparm
*parm
)
1164 struct gspca_dev
*gspca_dev
= priv
;
1166 memset(parm
, 0, sizeof *parm
);
1167 parm
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1168 parm
->parm
.capture
.readbuffers
= gspca_dev
->nbufread
;
1172 static int vidioc_s_parm(struct file
*filp
, void *priv
,
1173 struct v4l2_streamparm
*parm
)
1175 struct gspca_dev
*gspca_dev
= priv
;
1178 n
= parm
->parm
.capture
.readbuffers
;
1179 if (n
== 0 || n
> GSPCA_MAX_FRAMES
)
1180 parm
->parm
.capture
.readbuffers
= gspca_dev
->nbufread
;
1182 gspca_dev
->nbufread
= n
;
1186 static int vidioc_s_std(struct file
*filp
, void *priv
,
1192 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1193 static int vidiocgmbuf(struct file
*file
, void *priv
,
1194 struct video_mbuf
*mbuf
)
1196 struct gspca_dev
*gspca_dev
= file
->private_data
;
1199 PDEBUG(D_STREAM
, "cgmbuf");
1200 if (gspca_dev
->nframes
== 0) {
1204 struct v4l2_format fmt
;
1206 memset(&fmt
, 0, sizeof fmt
);
1207 fmt
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1208 i
= gspca_dev
->cam
.nmodes
- 1; /* highest mode */
1209 fmt
.fmt
.pix
.width
= gspca_dev
->cam
.cam_mode
[i
].width
;
1210 fmt
.fmt
.pix
.height
= gspca_dev
->cam
.cam_mode
[i
].height
;
1211 fmt
.fmt
.pix
.pixelformat
= V4L2_PIX_FMT_BGR24
;
1212 ret
= vidioc_s_fmt_vid_cap(file
, priv
, &fmt
);
1217 struct v4l2_requestbuffers rb
;
1219 memset(&rb
, 0, sizeof rb
);
1221 rb
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1222 rb
.memory
= V4L2_MEMORY_MMAP
;
1223 ret
= vidioc_reqbufs(file
, priv
, &rb
);
1228 mbuf
->frames
= gspca_dev
->nframes
;
1229 mbuf
->size
= gspca_dev
->frsz
* gspca_dev
->nframes
;
1230 for (i
= 0; i
< mbuf
->frames
; i
++)
1231 mbuf
->offsets
[i
] = gspca_dev
->frame
[i
].v4l2_buf
.m
.offset
;
1236 static int dev_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1238 struct gspca_dev
*gspca_dev
= file
->private_data
;
1239 struct gspca_frame
*frame
;
1241 unsigned long addr
, start
, size
;
1244 start
= vma
->vm_start
;
1245 size
= vma
->vm_end
- vma
->vm_start
;
1246 PDEBUG(D_STREAM
, "mmap start:%08x size:%d", (int) start
, (int) size
);
1248 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1249 return -ERESTARTSYS
;
1250 if (!gspca_dev
->present
) {
1254 if (gspca_dev
->capt_file
!= file
) {
1260 for (i
= 0; i
< gspca_dev
->nframes
; ++i
) {
1261 if (gspca_dev
->frame
[i
].v4l2_buf
.memory
!= V4L2_MEMORY_MMAP
) {
1262 PDEBUG(D_STREAM
, "mmap bad memory type");
1265 if ((gspca_dev
->frame
[i
].v4l2_buf
.m
.offset
>> PAGE_SHIFT
)
1267 frame
= &gspca_dev
->frame
[i
];
1271 if (frame
== NULL
) {
1272 PDEBUG(D_STREAM
, "mmap no frame buffer found");
1276 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1277 /* v4l1 maps all the buffers */
1279 || size
!= frame
->v4l2_buf
.length
* gspca_dev
->nframes
)
1281 if (size
!= frame
->v4l2_buf
.length
) {
1282 PDEBUG(D_STREAM
, "mmap bad size");
1288 * - VM_IO marks the area as being a mmaped region for I/O to a
1289 * device. It also prevents the region from being core dumped.
1291 vma
->vm_flags
|= VM_IO
;
1293 addr
= (unsigned long) frame
->data
;
1295 page
= vmalloc_to_page((void *) addr
);
1296 ret
= vm_insert_page(vma
, start
, page
);
1304 vma
->vm_ops
= &gspca_vm_ops
;
1305 vma
->vm_private_data
= frame
;
1309 mutex_unlock(&gspca_dev
->queue_lock
);
1314 * wait for a video frame
1316 * If a frame is ready, its index is returned.
1318 static int frame_wait(struct gspca_dev
*gspca_dev
,
1321 struct gspca_frame
*frame
;
1324 /* check if a frame is ready */
1325 i
= gspca_dev
->fr_o
;
1326 j
= gspca_dev
->fr_queue
[i
];
1327 frame
= &gspca_dev
->frame
[j
];
1328 if (frame
->v4l2_buf
.flags
& V4L2_BUF_FLAG_DONE
) {
1329 atomic_dec(&gspca_dev
->nevent
);
1332 if (nonblock_ing
) /* no frame yet */
1335 /* wait till a frame is ready */
1337 ret
= wait_event_interruptible_timeout(gspca_dev
->wq
,
1338 atomic_read(&gspca_dev
->nevent
) > 0,
1339 msecs_to_jiffies(3000));
1342 return ret
; /* interrupt */
1343 return -EIO
; /* timeout */
1345 atomic_dec(&gspca_dev
->nevent
);
1346 if (!gspca_dev
->streaming
|| !gspca_dev
->present
)
1348 i
= gspca_dev
->fr_o
;
1349 j
= gspca_dev
->fr_queue
[i
];
1350 frame
= &gspca_dev
->frame
[j
];
1351 if (frame
->v4l2_buf
.flags
& V4L2_BUF_FLAG_DONE
)
1355 gspca_dev
->fr_o
= (i
+ 1) % gspca_dev
->nframes
;
1356 PDEBUG(D_FRAM
, "frame wait q:%d i:%d o:%d",
1361 if (gspca_dev
->sd_desc
->dq_callback
) {
1362 mutex_lock(&gspca_dev
->usb_lock
);
1363 gspca_dev
->sd_desc
->dq_callback(gspca_dev
);
1364 mutex_unlock(&gspca_dev
->usb_lock
);
1370 * dequeue a video buffer
1372 * If nonblock_ing is false, block until a buffer is available.
1374 static int vidioc_dqbuf(struct file
*file
, void *priv
,
1375 struct v4l2_buffer
*v4l2_buf
)
1377 struct gspca_dev
*gspca_dev
= priv
;
1378 struct gspca_frame
*frame
;
1381 PDEBUG(D_FRAM
, "dqbuf");
1382 if (v4l2_buf
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1384 if (v4l2_buf
->memory
!= gspca_dev
->memory
)
1387 /* if not streaming, be sure the application will not loop forever */
1388 if (!(file
->f_flags
& O_NONBLOCK
)
1389 && !gspca_dev
->streaming
&& gspca_dev
->users
== 1)
1392 /* only the capturing file may dequeue */
1393 if (gspca_dev
->capt_file
!= file
)
1396 /* only one dequeue / read at a time */
1397 if (mutex_lock_interruptible(&gspca_dev
->read_lock
))
1398 return -ERESTARTSYS
;
1400 ret
= frame_wait(gspca_dev
, file
->f_flags
& O_NONBLOCK
);
1403 i
= ret
; /* frame index */
1404 frame
= &gspca_dev
->frame
[i
];
1405 if (gspca_dev
->memory
== V4L2_MEMORY_USERPTR
) {
1406 if (copy_to_user((__u8
*) frame
->v4l2_buf
.m
.userptr
,
1408 frame
->v4l2_buf
.bytesused
)) {
1409 PDEBUG(D_ERR
|D_STREAM
,
1410 "dqbuf cp to user failed");
1415 frame
->v4l2_buf
.flags
&= ~V4L2_BUF_FLAG_DONE
;
1416 memcpy(v4l2_buf
, &frame
->v4l2_buf
, sizeof *v4l2_buf
);
1417 PDEBUG(D_FRAM
, "dqbuf %d", i
);
1420 mutex_unlock(&gspca_dev
->read_lock
);
1425 * queue a video buffer
1427 * Attempting to queue a buffer that has already been
1428 * queued will return -EINVAL.
1430 static int vidioc_qbuf(struct file
*file
, void *priv
,
1431 struct v4l2_buffer
*v4l2_buf
)
1433 struct gspca_dev
*gspca_dev
= priv
;
1434 struct gspca_frame
*frame
;
1437 PDEBUG(D_FRAM
, "qbuf %d", v4l2_buf
->index
);
1438 if (v4l2_buf
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1441 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
))
1442 return -ERESTARTSYS
;
1444 index
= v4l2_buf
->index
;
1445 if ((unsigned) index
>= gspca_dev
->nframes
) {
1447 "qbuf idx %d >= %d", index
, gspca_dev
->nframes
);
1451 if (v4l2_buf
->memory
!= gspca_dev
->memory
) {
1452 PDEBUG(D_FRAM
, "qbuf bad memory type");
1457 frame
= &gspca_dev
->frame
[index
];
1458 if (frame
->v4l2_buf
.flags
& BUF_ALL_FLAGS
) {
1459 PDEBUG(D_FRAM
, "qbuf bad state");
1464 frame
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_QUEUED
;
1465 /* frame->v4l2_buf.flags &= ~V4L2_BUF_FLAG_DONE; */
1467 if (frame
->v4l2_buf
.memory
== V4L2_MEMORY_USERPTR
) {
1468 frame
->v4l2_buf
.m
.userptr
= v4l2_buf
->m
.userptr
;
1469 frame
->v4l2_buf
.length
= v4l2_buf
->length
;
1472 /* put the buffer in the 'queued' queue */
1473 i
= gspca_dev
->fr_q
;
1474 gspca_dev
->fr_queue
[i
] = index
;
1475 gspca_dev
->fr_q
= (i
+ 1) % gspca_dev
->nframes
;
1476 PDEBUG(D_FRAM
, "qbuf q:%d i:%d o:%d",
1481 v4l2_buf
->flags
|= V4L2_BUF_FLAG_QUEUED
;
1482 v4l2_buf
->flags
&= ~V4L2_BUF_FLAG_DONE
;
1485 mutex_unlock(&gspca_dev
->queue_lock
);
1490 * allocate the resources for read()
1492 static int read_alloc(struct gspca_dev
*gspca_dev
,
1495 struct v4l2_buffer v4l2_buf
;
1498 PDEBUG(D_STREAM
, "read alloc");
1499 if (gspca_dev
->nframes
== 0) {
1500 struct v4l2_requestbuffers rb
;
1502 memset(&rb
, 0, sizeof rb
);
1503 rb
.count
= gspca_dev
->nbufread
;
1504 rb
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1505 rb
.memory
= GSPCA_MEMORY_READ
;
1506 ret
= vidioc_reqbufs(file
, gspca_dev
, &rb
);
1508 PDEBUG(D_STREAM
, "read reqbuf err %d", ret
);
1511 memset(&v4l2_buf
, 0, sizeof v4l2_buf
);
1512 v4l2_buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1513 v4l2_buf
.memory
= GSPCA_MEMORY_READ
;
1514 for (i
= 0; i
< gspca_dev
->nbufread
; i
++) {
1516 ret
= vidioc_qbuf(file
, gspca_dev
, &v4l2_buf
);
1518 PDEBUG(D_STREAM
, "read qbuf err: %d", ret
);
1522 gspca_dev
->memory
= GSPCA_MEMORY_READ
;
1525 /* start streaming */
1526 ret
= vidioc_streamon(file
, gspca_dev
, V4L2_BUF_TYPE_VIDEO_CAPTURE
);
1528 PDEBUG(D_STREAM
, "read streamon err %d", ret
);
1532 static unsigned int dev_poll(struct file
*file
, poll_table
*wait
)
1534 struct gspca_dev
*gspca_dev
= file
->private_data
;
1537 PDEBUG(D_FRAM
, "poll");
1539 poll_wait(file
, &gspca_dev
->wq
, wait
);
1540 if (!gspca_dev
->present
)
1543 /* if reqbufs is not done, the user would use read() */
1544 if (gspca_dev
->nframes
== 0) {
1545 if (gspca_dev
->memory
!= GSPCA_MEMORY_NO
)
1546 return POLLERR
; /* not the 1st time */
1547 ret
= read_alloc(gspca_dev
, file
);
1552 if (mutex_lock_interruptible(&gspca_dev
->queue_lock
) != 0)
1554 if (!gspca_dev
->present
) {
1559 /* check the next incoming buffer */
1560 i
= gspca_dev
->fr_o
;
1561 i
= gspca_dev
->fr_queue
[i
];
1562 if (gspca_dev
->frame
[i
].v4l2_buf
.flags
& V4L2_BUF_FLAG_DONE
)
1563 ret
= POLLIN
| POLLRDNORM
; /* something to read */
1567 mutex_unlock(&gspca_dev
->queue_lock
);
1571 static ssize_t
dev_read(struct file
*file
, char __user
*data
,
1572 size_t count
, loff_t
*ppos
)
1574 struct gspca_dev
*gspca_dev
= file
->private_data
;
1575 struct gspca_frame
*frame
;
1576 struct v4l2_buffer v4l2_buf
;
1577 struct timeval timestamp
;
1580 PDEBUG(D_FRAM
, "read (%zd)", count
);
1581 if (!gspca_dev
->present
)
1583 switch (gspca_dev
->memory
) {
1584 case GSPCA_MEMORY_NO
: /* first time */
1585 ret
= read_alloc(gspca_dev
, file
);
1589 case GSPCA_MEMORY_READ
:
1590 if (gspca_dev
->capt_file
== file
)
1598 jiffies_to_timeval(get_jiffies_64(), ×tamp
);
1602 memset(&v4l2_buf
, 0, sizeof v4l2_buf
);
1603 v4l2_buf
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1604 v4l2_buf
.memory
= GSPCA_MEMORY_READ
;
1605 ret
= vidioc_dqbuf(file
, gspca_dev
, &v4l2_buf
);
1607 PDEBUG(D_STREAM
, "read dqbuf err %d", ret
);
1611 /* if the process slept for more than 1 second,
1612 * get anewer frame */
1613 frame
= &gspca_dev
->frame
[v4l2_buf
.index
];
1615 break; /* avoid infinite loop */
1616 if (frame
->v4l2_buf
.timestamp
.tv_sec
>= timestamp
.tv_sec
)
1618 ret
= vidioc_qbuf(file
, gspca_dev
, &v4l2_buf
);
1620 PDEBUG(D_STREAM
, "read qbuf err %d", ret
);
1625 /* copy the frame */
1626 if (count
> frame
->v4l2_buf
.bytesused
)
1627 count
= frame
->v4l2_buf
.bytesused
;
1628 ret
= copy_to_user(data
, frame
->data
, count
);
1630 PDEBUG(D_ERR
|D_STREAM
,
1631 "read cp to user lack %d / %zd", ret
, count
);
1637 /* in each case, requeue the buffer */
1638 ret2
= vidioc_qbuf(file
, gspca_dev
, &v4l2_buf
);
1644 static void dev_release(struct video_device
*vfd
)
1649 static struct file_operations dev_fops
= {
1650 .owner
= THIS_MODULE
,
1652 .release
= dev_close
,
1655 .ioctl
= video_ioctl2
,
1656 #ifdef CONFIG_COMPAT
1657 .compat_ioctl
= v4l_compat_ioctl32
,
1659 .llseek
= no_llseek
,
1663 static const struct v4l2_ioctl_ops dev_ioctl_ops
= {
1664 .vidioc_querycap
= vidioc_querycap
,
1665 .vidioc_dqbuf
= vidioc_dqbuf
,
1666 .vidioc_qbuf
= vidioc_qbuf
,
1667 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
1668 .vidioc_try_fmt_vid_cap
= vidioc_try_fmt_vid_cap
,
1669 .vidioc_g_fmt_vid_cap
= vidioc_g_fmt_vid_cap
,
1670 .vidioc_s_fmt_vid_cap
= vidioc_s_fmt_vid_cap
,
1671 .vidioc_streamon
= vidioc_streamon
,
1672 .vidioc_queryctrl
= vidioc_queryctrl
,
1673 .vidioc_g_ctrl
= vidioc_g_ctrl
,
1674 .vidioc_s_ctrl
= vidioc_s_ctrl
,
1675 .vidioc_querymenu
= vidioc_querymenu
,
1676 .vidioc_enum_input
= vidioc_enum_input
,
1677 .vidioc_g_input
= vidioc_g_input
,
1678 .vidioc_s_input
= vidioc_s_input
,
1679 .vidioc_reqbufs
= vidioc_reqbufs
,
1680 .vidioc_querybuf
= vidioc_querybuf
,
1681 .vidioc_streamoff
= vidioc_streamoff
,
1682 .vidioc_g_jpegcomp
= vidioc_g_jpegcomp
,
1683 .vidioc_s_jpegcomp
= vidioc_s_jpegcomp
,
1684 .vidioc_g_parm
= vidioc_g_parm
,
1685 .vidioc_s_parm
= vidioc_s_parm
,
1686 .vidioc_s_std
= vidioc_s_std
,
1687 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1688 .vidiocgmbuf
= vidiocgmbuf
,
1692 static struct video_device gspca_template
= {
1693 .name
= "gspca main driver",
1695 .ioctl_ops
= &dev_ioctl_ops
,
1696 .release
= dev_release
, /* mandatory */
1701 * probe and create a new gspca device
1703 * This function must be called by the sub-driver when it is
1704 * called for probing a new device.
1706 int gspca_dev_probe(struct usb_interface
*intf
,
1707 const struct usb_device_id
*id
,
1708 const struct sd_desc
*sd_desc
,
1710 struct module
*module
)
1712 struct usb_interface_descriptor
*interface
;
1713 struct gspca_dev
*gspca_dev
;
1714 struct usb_device
*dev
= interface_to_usbdev(intf
);
1717 PDEBUG(D_PROBE
, "probing %04x:%04x", id
->idVendor
, id
->idProduct
);
1719 /* we don't handle multi-config cameras */
1720 if (dev
->descriptor
.bNumConfigurations
!= 1)
1722 interface
= &intf
->cur_altsetting
->desc
;
1723 if (interface
->bInterfaceNumber
> 0)
1726 /* create the device */
1727 if (dev_size
< sizeof *gspca_dev
)
1728 dev_size
= sizeof *gspca_dev
;
1729 gspca_dev
= kzalloc(dev_size
, GFP_KERNEL
);
1730 if (gspca_dev
== NULL
) {
1731 err("couldn't kzalloc gspca struct");
1734 gspca_dev
->dev
= dev
;
1735 gspca_dev
->iface
= interface
->bInterfaceNumber
;
1736 gspca_dev
->nbalt
= intf
->num_altsetting
;
1737 gspca_dev
->sd_desc
= sd_desc
;
1738 /* gspca_dev->users = 0; (done by kzalloc) */
1739 gspca_dev
->nbufread
= 2;
1741 /* configure the subdriver */
1742 ret
= gspca_dev
->sd_desc
->config(gspca_dev
, id
);
1745 ret
= gspca_set_alt0(gspca_dev
);
1748 gspca_set_default_mode(gspca_dev
);
1750 mutex_init(&gspca_dev
->usb_lock
);
1751 mutex_init(&gspca_dev
->read_lock
);
1752 mutex_init(&gspca_dev
->queue_lock
);
1753 init_waitqueue_head(&gspca_dev
->wq
);
1755 /* init video stuff */
1756 memcpy(&gspca_dev
->vdev
, &gspca_template
, sizeof gspca_template
);
1757 gspca_dev
->vdev
.parent
= &dev
->dev
;
1758 memcpy(&gspca_dev
->fops
, &dev_fops
, sizeof gspca_dev
->fops
);
1759 gspca_dev
->vdev
.fops
= &gspca_dev
->fops
;
1760 gspca_dev
->fops
.owner
= module
; /* module protection */
1761 ret
= video_register_device(&gspca_dev
->vdev
,
1765 err("video_register_device err %d", ret
);
1769 gspca_dev
->present
= 1;
1770 usb_set_intfdata(intf
, gspca_dev
);
1771 PDEBUG(D_PROBE
, "probe ok");
1777 EXPORT_SYMBOL(gspca_dev_probe
);
1782 * This function must be called by the sub-driver
1783 * when the device disconnects, after the specific resources are freed.
1785 void gspca_disconnect(struct usb_interface
*intf
)
1787 struct gspca_dev
*gspca_dev
= usb_get_intfdata(intf
);
1791 gspca_dev
->present
= 0;
1792 mutex_lock(&gspca_dev
->queue_lock
);
1793 mutex_lock(&gspca_dev
->usb_lock
);
1794 gspca_dev
->streaming
= 0;
1795 destroy_urbs(gspca_dev
);
1796 mutex_unlock(&gspca_dev
->usb_lock
);
1797 mutex_unlock(&gspca_dev
->queue_lock
);
1798 while (gspca_dev
->users
!= 0) { /* wait until fully closed */
1799 atomic_inc(&gspca_dev
->nevent
);
1800 wake_up_interruptible(&gspca_dev
->wq
); /* wake processes */
1803 /* We don't want people trying to open up the device */
1804 video_unregister_device(&gspca_dev
->vdev
);
1805 /* Free the memory */
1807 PDEBUG(D_PROBE
, "disconnect complete");
1809 EXPORT_SYMBOL(gspca_disconnect
);
1811 /* -- cam driver utility functions -- */
1813 /* auto gain and exposure algorithm based on the knee algorithm described here:
1814 http://ytse.tricolour.net/docs/LowLightOptimization.html
1816 Returns 0 if no changes were made, 1 if the gain and or exposure settings
1818 int gspca_auto_gain_n_exposure(struct gspca_dev
*gspca_dev
, int avg_lum
,
1819 int desired_avg_lum
, int deadzone
, int gain_knee
, int exposure_knee
)
1821 int i
, steps
, gain
, orig_gain
, exposure
, orig_exposure
, autogain
;
1822 const struct ctrl
*gain_ctrl
= NULL
;
1823 const struct ctrl
*exposure_ctrl
= NULL
;
1824 const struct ctrl
*autogain_ctrl
= NULL
;
1827 for (i
= 0; i
< gspca_dev
->sd_desc
->nctrls
; i
++) {
1828 if (gspca_dev
->sd_desc
->ctrls
[i
].qctrl
.id
== V4L2_CID_GAIN
)
1829 gain_ctrl
= &gspca_dev
->sd_desc
->ctrls
[i
];
1830 if (gspca_dev
->sd_desc
->ctrls
[i
].qctrl
.id
== V4L2_CID_EXPOSURE
)
1831 exposure_ctrl
= &gspca_dev
->sd_desc
->ctrls
[i
];
1832 if (gspca_dev
->sd_desc
->ctrls
[i
].qctrl
.id
== V4L2_CID_AUTOGAIN
)
1833 autogain_ctrl
= &gspca_dev
->sd_desc
->ctrls
[i
];
1835 if (!gain_ctrl
|| !exposure_ctrl
|| !autogain_ctrl
) {
1836 PDEBUG(D_ERR
, "Error: gspca_auto_gain_n_exposure called "
1837 "on cam without (auto)gain/exposure");
1841 if (gain_ctrl
->get(gspca_dev
, &gain
) ||
1842 exposure_ctrl
->get(gspca_dev
, &exposure
) ||
1843 autogain_ctrl
->get(gspca_dev
, &autogain
) || !autogain
)
1847 orig_exposure
= exposure
;
1849 /* If we are of a multiple of deadzone, do multiple steps to reach the
1850 desired lumination fast (with the risc of a slight overshoot) */
1851 steps
= abs(desired_avg_lum
- avg_lum
) / deadzone
;
1853 PDEBUG(D_FRAM
, "autogain: lum: %d, desired: %d, steps: %d\n",
1854 avg_lum
, desired_avg_lum
, steps
);
1856 for (i
= 0; i
< steps
; i
++) {
1857 if (avg_lum
> desired_avg_lum
) {
1858 if (gain
> gain_knee
)
1860 else if (exposure
> exposure_knee
)
1862 else if (gain
> gain_ctrl
->qctrl
.default_value
)
1864 else if (exposure
> exposure_ctrl
->qctrl
.minimum
)
1866 else if (gain
> gain_ctrl
->qctrl
.minimum
)
1871 if (gain
< gain_ctrl
->qctrl
.default_value
)
1873 else if (exposure
< exposure_knee
)
1875 else if (gain
< gain_knee
)
1877 else if (exposure
< exposure_ctrl
->qctrl
.maximum
)
1879 else if (gain
< gain_ctrl
->qctrl
.maximum
)
1886 if (gain
!= orig_gain
) {
1887 gain_ctrl
->set(gspca_dev
, gain
);
1890 if (exposure
!= orig_exposure
) {
1891 exposure_ctrl
->set(gspca_dev
, exposure
);
1897 EXPORT_SYMBOL(gspca_auto_gain_n_exposure
);
1899 /* -- module insert / remove -- */
1900 static int __init
gspca_init(void)
1902 info("main v%d.%d.%d registered",
1903 (DRIVER_VERSION_NUMBER
>> 16) & 0xff,
1904 (DRIVER_VERSION_NUMBER
>> 8) & 0xff,
1905 DRIVER_VERSION_NUMBER
& 0xff);
1908 static void __exit
gspca_exit(void)
1910 info("main deregistered");
1913 module_init(gspca_init
);
1914 module_exit(gspca_exit
);
1916 #ifdef CONFIG_VIDEO_ADV_DEBUG
1917 module_param_named(debug
, gspca_debug
, int, 0644);
1918 MODULE_PARM_DESC(debug
,
1919 "Debug (bit) 0x01:error 0x02:probe 0x04:config"
1920 " 0x08:stream 0x10:frame 0x20:packet 0x40:USBin 0x80:USBout"