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>
39 #define DEF_NURBS 2 /* default number of URBs (mmap) */
40 #define USR_NURBS 5 /* default number of URBs (userptr) */
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, 1, 2)
47 static const char version[] = "2.1.2";
49 static int video_nr = -1;
51 static int comp_fac = 30; /* Buffer size ratio when compressed in % */
53 #ifdef VIDEO_ADV_DEBUG
54 int gspca_debug = D_ERR | D_PROBE;
55 EXPORT_SYMBOL(gspca_debug);
57 static void PDEBUG_MODE(char *txt, __u32 pixfmt, int w, int h)
59 if ((pixfmt >> 24) >= '0' && (pixfmt >> 24) <= 'z') {
60 PDEBUG(D_CONF|D_STREAM, "%s %c%c%c%c %dx%d",
64 (pixfmt >> 16) & 0xff,
68 PDEBUG(D_CONF|D_STREAM, "%s 0x%08x %dx%d",
75 #define PDEBUG_MODE(txt, pixfmt, w, h)
78 /* specific memory types - !! should different from V4L2_MEMORY_xxx */
79 #define GSPCA_MEMORY_NO 0 /* V4L2_MEMORY_xxx starts from 1 */
80 #define GSPCA_MEMORY_READ 7
82 #define BUF_ALL_FLAGS (V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE)
87 static void gspca_vm_open(struct vm_area_struct *vma)
89 struct gspca_frame *frame = vma->vm_private_data;
91 frame->vma_use_count++;
92 frame->v4l2_buf.flags |= V4L2_BUF_FLAG_MAPPED;
95 static void gspca_vm_close(struct vm_area_struct *vma)
97 struct gspca_frame *frame = vma->vm_private_data;
99 if (--frame->vma_use_count <= 0)
100 frame->v4l2_buf.flags &= ~V4L2_BUF_FLAG_MAPPED;
103 static struct vm_operations_struct gspca_vm_ops = {
104 .open = gspca_vm_open,
105 .close = gspca_vm_close,
109 * fill a video frame from an URB and resubmit
111 static void fill_frame(struct gspca_dev *gspca_dev,
114 struct gspca_frame *frame;
115 __u8 *data; /* address of data in the iso message */
119 if (urb->status != 0) {
120 PDEBUG(D_ERR|D_PACK, "urb status: %d", urb->status);
121 return; /* disconnection ? */
123 pkt_scan = gspca_dev->sd_desc->pkt_scan;
124 for (i = 0; i < urb->number_of_packets; i++) {
126 /* check the availability of the frame buffer */
128 j = gspca_dev->fr_queue[j];
129 frame = &gspca_dev->frame[j];
130 if ((frame->v4l2_buf.flags & BUF_ALL_FLAGS)
131 != V4L2_BUF_FLAG_QUEUED) {
132 gspca_dev->last_packet_type = DISCARD_PACKET;
136 /* check the packet status and length */
137 len = urb->iso_frame_desc[i].actual_length;
140 st = urb->iso_frame_desc[i].status;
143 "ISOC data error: [%d] len=%d, status=%d",
145 gspca_dev->last_packet_type = DISCARD_PACKET;
149 /* let the packet be analyzed by the subdriver */
150 PDEBUG(D_PACK, "packet [%d] o:%d l:%d",
151 i, urb->iso_frame_desc[i].offset, len);
152 data = (__u8 *) urb->transfer_buffer
153 + urb->iso_frame_desc[i].offset;
154 pkt_scan(gspca_dev, frame, data, len);
157 /* resubmit the URB */
158 /*fixme: don't do that when userptr and too many URBs sent*/
160 st = usb_submit_urb(urb, GFP_ATOMIC);
162 PDEBUG(D_ERR|D_PACK, "usb_submit_urb() ret %d", st);
166 * ISOC message interrupt from the USB device
168 * Analyse each packet and call the subdriver for copy
169 * to the frame buffer.
171 * There are 2 functions:
172 * - the first one (isoc_irq_mmap) is used when the application
173 * buffers are mapped. The frame detection and copy is done
174 * at interrupt level.
175 * - the second one (isoc_irq_user) is used when the application
176 * buffers are in user space (userptr). The frame detection
177 * and copy is done by the application.
179 static void isoc_irq_mmap(struct urb *urb
182 struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
184 PDEBUG(D_PACK, "isoc irq mmap");
185 if (!gspca_dev->streaming)
187 fill_frame(gspca_dev, urb);
190 static void isoc_irq_user(struct urb *urb
193 struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
196 PDEBUG(D_PACK, "isoc irq user");
197 if (!gspca_dev->streaming)
200 i = gspca_dev->urb_in % gspca_dev->nurbs;
201 if (urb != gspca_dev->urb[i]) {
202 PDEBUG(D_ERR|D_PACK, "urb out of sequence");
203 return; /* should never occur */
207 atomic_inc(&gspca_dev->nevent); /* new event */
208 wake_up_interruptible(&gspca_dev->wq);
209 /*fixme: submit a new URBs until urb_in == urb_out (% nurbs)*/
213 * treat the isoc messages
215 * This routine is called by the application (case userptr).
217 static void isoc_transfer(struct gspca_dev *gspca_dev)
223 i = gspca_dev->urb_out;
224 PDEBUG(D_PACK, "isoc transf i:%d o:%d", gspca_dev->urb_in, i);
225 if (i == gspca_dev->urb_in) /* isoc message to read */
226 break; /* no (more) message */
227 atomic_dec(&gspca_dev->nevent);
228 /*PDEBUG(D_PACK, "isoc_trf nevent: %d", atomic_read(&gspca_dev->nevent));*/
229 gspca_dev->urb_out = i + 1; /* message treated */
230 urb = gspca_dev->urb[i % gspca_dev->nurbs];
231 fill_frame(gspca_dev, urb);
236 * add data to the current frame
238 * This function is called by the subdrivers at interrupt level
240 * To build a frame, these ones must add
242 * - 0 or many INTER_PACKETs
244 * DISCARD_PACKET invalidates the whole frame.
245 * On LAST_PACKET, a new frame is returned.
247 struct gspca_frame *gspca_frame_add(struct gspca_dev *gspca_dev,
249 struct gspca_frame *frame,
255 PDEBUG(D_PACK, "add t:%d l:%d", packet_type, len);
257 /* when start of a new frame, if the current frame buffer
258 * is not queued, discard the whole frame */
259 if (packet_type == FIRST_PACKET) {
260 if ((frame->v4l2_buf.flags & BUF_ALL_FLAGS)
261 != V4L2_BUF_FLAG_QUEUED) {
262 gspca_dev->last_packet_type = DISCARD_PACKET;
265 frame->data_end = frame->data;
266 jiffies_to_timeval(get_jiffies_64(),
267 &frame->v4l2_buf.timestamp);
268 frame->v4l2_buf.sequence = ++gspca_dev->sequence;
269 } else if (gspca_dev->last_packet_type == DISCARD_PACKET) {
273 /* append the packet to the frame buffer */
275 if (frame->data_end - frame->data + len
276 > frame->v4l2_buf.length) {
277 PDEBUG(D_ERR|D_PACK, "frame overflow %d > %d",
278 frame->data_end - frame->data + len,
279 frame->v4l2_buf.length);
280 packet_type = DISCARD_PACKET;
282 if (frame->v4l2_buf.memory != V4L2_MEMORY_USERPTR) {
283 memcpy(frame->data_end, data, len);
285 if (copy_to_user(frame->data_end,
288 "copy to user failed");
289 packet_type = DISCARD_PACKET;
292 frame->data_end += len;
295 gspca_dev->last_packet_type = packet_type;
297 /* if last packet, wake the application and advance in the queue */
298 if (packet_type == LAST_PACKET) {
299 frame->v4l2_buf.bytesused = frame->data_end - frame->data;
300 frame->v4l2_buf.flags &= ~V4L2_BUF_FLAG_QUEUED;
301 frame->v4l2_buf.flags |= V4L2_BUF_FLAG_DONE;
302 atomic_inc(&gspca_dev->nevent);
303 wake_up_interruptible(&gspca_dev->wq); /* event = new frame */
304 i = (gspca_dev->fr_i + 1) % gspca_dev->nframes;
306 PDEBUG(D_FRAM, "frame complete len:%d q:%d i:%d o:%d",
307 frame->v4l2_buf.bytesused,
311 j = gspca_dev->fr_queue[i];
312 frame = &gspca_dev->frame[j];
316 EXPORT_SYMBOL(gspca_frame_add);
318 static int gspca_is_compressed(__u32 format)
321 case V4L2_PIX_FMT_MJPEG:
322 case V4L2_PIX_FMT_JPEG:
323 case V4L2_PIX_FMT_SPCA561:
329 static void *rvmalloc(unsigned long size)
334 /* size = PAGE_ALIGN(size); (already done) */
335 mem = vmalloc_32(size);
337 memset(mem, 0, size);
338 adr = (unsigned long) mem;
339 while ((long) size > 0) {
340 SetPageReserved(vmalloc_to_page((void *) adr));
348 static void rvfree(void *mem, unsigned long size)
354 adr = (unsigned long) mem;
355 while ((long) size > 0) {
356 ClearPageReserved(vmalloc_to_page((void *) adr));
363 static __u32 get_v4l2_depth(__u32 pixfmt)
366 /* case V4L2_PIX_FMT_BGR32:
367 case V4L2_PIX_FMT_RGB32:
369 case V4L2_PIX_FMT_RGB24: /* 'RGB3' */
370 case V4L2_PIX_FMT_BGR24:
372 /* case V4L2_PIX_FMT_RGB565: * 'RGBP' */
373 case V4L2_PIX_FMT_YUYV: /* 'YUYV' packed 4.2.2 */
374 case V4L2_PIX_FMT_YYUV: /* 'YYUV' */
376 case V4L2_PIX_FMT_YUV420: /* 'YU12' planar 4.2.0 */
377 case V4L2_PIX_FMT_SPCA501: /* 'S501' YUYV per line */
379 case V4L2_PIX_FMT_MJPEG:
380 case V4L2_PIX_FMT_JPEG:
381 case V4L2_PIX_FMT_SBGGR8: /* 'BA81' Bayer */
382 case V4L2_PIX_FMT_SN9C10X: /* 'S910' SN9C10x compression */
383 case V4L2_PIX_FMT_SPCA561: /* 'S561' compressed BGGR bayer */
386 PDEBUG(D_ERR|D_CONF, "Unknown pixel format %c%c%c%c",
388 (pixfmt >> 8) & 0xff,
389 (pixfmt >> 16) & 0xff,
394 static int gspca_get_buff_size(struct gspca_dev *gspca_dev)
398 size = gspca_dev->width * gspca_dev->height
399 * get_v4l2_depth(gspca_dev->pixfmt) / 8;
405 static int frame_alloc(struct gspca_dev *gspca_dev,
408 struct gspca_frame *frame;
412 frsz = gspca_get_buff_size(gspca_dev);
415 PDEBUG(D_STREAM, "frame alloc frsz: %d", frsz);
416 if (count > GSPCA_MAX_FRAMES)
417 count = GSPCA_MAX_FRAMES;
418 /* if compressed (JPEG), reduce the buffer size */
419 if (gspca_is_compressed(gspca_dev->pixfmt))
420 frsz = (frsz * comp_fac) / 100 + 600; /* (+ JPEG header sz) */
421 frsz = PAGE_ALIGN(frsz);
422 PDEBUG(D_STREAM, "new fr_sz: %d", frsz);
423 gspca_dev->frsz = frsz;
424 if (gspca_dev->memory == V4L2_MEMORY_MMAP) {
425 gspca_dev->frbuf = rvmalloc(frsz * count);
426 if (!gspca_dev->frbuf) {
427 err("frame alloc failed");
431 gspca_dev->nframes = count;
432 for (i = 0; i < count; i++) {
433 frame = &gspca_dev->frame[i];
434 frame->v4l2_buf.index = i;
435 frame->v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
436 frame->v4l2_buf.flags = 0;
437 frame->v4l2_buf.field = V4L2_FIELD_NONE;
438 frame->v4l2_buf.length = frsz;
439 frame->v4l2_buf.memory = gspca_dev->memory;
440 frame->v4l2_buf.sequence = 0;
441 if (gspca_dev->memory == V4L2_MEMORY_MMAP) {
442 frame->data = frame->data_end =
443 gspca_dev->frbuf + i * frsz;
444 frame->v4l2_buf.m.offset = i * frsz;
447 gspca_dev->fr_i = gspca_dev->fr_o = gspca_dev->fr_q = 0;
448 gspca_dev->last_packet_type = DISCARD_PACKET;
449 gspca_dev->sequence = 0;
450 atomic_set(&gspca_dev->nevent, 0);
454 static void frame_free(struct gspca_dev *gspca_dev)
458 PDEBUG(D_STREAM, "frame free");
459 if (gspca_dev->frbuf != 0) {
460 rvfree(gspca_dev->frbuf,
461 gspca_dev->nframes * gspca_dev->frsz);
462 gspca_dev->frbuf = NULL;
463 for (i = 0; i < gspca_dev->nframes; i++)
464 gspca_dev->frame[i].data = NULL;
466 gspca_dev->nframes = 0;
469 static void destroy_urbs(struct gspca_dev *gspca_dev)
474 PDEBUG(D_STREAM, "kill transfer");
475 for (i = 0; i < MAX_NURBS; ++i) {
476 urb = gspca_dev->urb[i];
480 gspca_dev->urb[i] = NULL;
482 if (urb->transfer_buffer != 0)
483 usb_buffer_free(gspca_dev->dev,
484 urb->transfer_buffer_length,
485 urb->transfer_buffer,
492 * search an input isochronous endpoint in an alternate setting
494 static struct usb_host_endpoint *alt_isoc(struct usb_host_interface *alt,
497 struct usb_host_endpoint *ep;
500 epaddr |= USB_DIR_IN;
501 for (i = 0; i < alt->desc.bNumEndpoints; i++) {
502 ep = &alt->endpoint[i];
503 if (ep->desc.bEndpointAddress == epaddr) {
504 attr = ep->desc.bmAttributes
505 & USB_ENDPOINT_XFERTYPE_MASK;
506 if (attr == USB_ENDPOINT_XFER_ISOC)
515 * search an input isochronous endpoint
517 * The endpoint is defined by the subdriver.
518 * Use only the first isoc (some Zoran - 0x0572:0x0001 - have two such ep).
519 * This routine may be called many times when the bandwidth is too small
520 * (the bandwidth is checked on urb submit).
522 struct usb_host_endpoint *get_isoc_ep(struct gspca_dev *gspca_dev)
524 struct usb_interface *intf;
525 struct usb_host_endpoint *ep;
528 intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
530 i = gspca_dev->alt; /* previous alt setting */
531 while (--i > 0) { /* alt 0 is unusable */
532 ep = alt_isoc(&intf->altsetting[i], gspca_dev->cam.epaddr);
537 err("no ISOC endpoint found");
540 PDEBUG(D_STREAM, "use ISOC alt %d ep 0x%02x",
541 i, ep->desc.bEndpointAddress);
542 ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, i);
544 err("set interface err %d", ret);
547 gspca_dev->alt = i; /* memorize the current alt setting */
552 * create the isochronous URBs
554 static int create_urbs(struct gspca_dev *gspca_dev,
555 struct usb_host_endpoint *ep)
558 int n, nurbs, i, psize, npkt, bsize;
559 usb_complete_t usb_complete;
561 /* calculate the packet size and the number of packets */
562 psize = le16_to_cpu(ep->desc.wMaxPacketSize);
564 /* See paragraph 5.9 / table 5-11 of the usb 2.0 spec. */
565 psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
566 npkt = ISO_MAX_SIZE / psize;
567 if (npkt > ISO_MAX_PKT)
569 bsize = psize * npkt;
571 "isoc %d pkts size %d (bsize:%d)", npkt, psize, bsize);
572 /*fixme:don't submit all URBs when userptr*/
573 if (gspca_dev->memory != V4L2_MEMORY_USERPTR) {
574 usb_complete = isoc_irq_mmap;
577 usb_complete = isoc_irq_user;
580 gspca_dev->nurbs = nurbs;
581 for (n = 0; n < nurbs; n++) {
582 urb = usb_alloc_urb(npkt, GFP_KERNEL);
584 err("usb_alloc_urb failed");
587 urb->transfer_buffer = usb_buffer_alloc(gspca_dev->dev,
592 if (urb->transfer_buffer == NULL) {
594 destroy_urbs(gspca_dev);
595 err("usb_buffer_urb failed");
598 gspca_dev->urb[n] = urb;
599 urb->dev = gspca_dev->dev;
600 urb->context = gspca_dev;
601 urb->pipe = usb_rcvisocpipe(gspca_dev->dev,
602 ep->desc.bEndpointAddress);
603 urb->transfer_flags = URB_ISO_ASAP
604 | URB_NO_TRANSFER_DMA_MAP;
605 urb->interval = ep->desc.bInterval;
606 urb->complete = usb_complete;
607 urb->number_of_packets = npkt;
608 urb->transfer_buffer_length = bsize;
609 for (i = 0; i < npkt; i++) {
610 urb->iso_frame_desc[i].length = psize;
611 urb->iso_frame_desc[i].offset = psize * i;
614 gspca_dev->urb_in = gspca_dev->urb_out = 0;
619 * start the USB transfer
621 static int gspca_init_transfer(struct gspca_dev *gspca_dev)
623 struct usb_host_endpoint *ep;
626 if (mutex_lock_interruptible(&gspca_dev->usb_lock))
629 /* set the higher alternate setting and
630 * loop until urb submit succeeds */
631 gspca_dev->alt = gspca_dev->nbalt;
633 PDEBUG(D_STREAM, "init transfer alt %d", gspca_dev->alt);
634 ep = get_isoc_ep(gspca_dev);
639 ret = create_urbs(gspca_dev, ep);
644 gspca_dev->sd_desc->start(gspca_dev);
645 gspca_dev->streaming = 1;
646 atomic_set(&gspca_dev->nevent, 0);
648 /* submit the URBs */
649 for (n = 0; n < gspca_dev->nurbs; n++) {
650 ret = usb_submit_urb(gspca_dev->urb[n], GFP_KERNEL);
652 PDEBUG(D_ERR|D_STREAM,
653 "usb_submit_urb [%d] err %d", n, ret);
654 gspca_dev->streaming = 0;
655 destroy_urbs(gspca_dev);
657 break; /* try the previous alt */
665 mutex_unlock(&gspca_dev->usb_lock);
669 static int gspca_set_alt0(struct gspca_dev *gspca_dev)
673 ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 0);
675 PDEBUG(D_ERR|D_STREAM, "set interface 0 err %d", ret);
679 /* Note both the queue and the usb lock should be hold when calling this */
680 static void gspca_stream_off(struct gspca_dev *gspca_dev)
682 gspca_dev->streaming = 0;
683 atomic_set(&gspca_dev->nevent, 0);
684 if (gspca_dev->present) {
685 gspca_dev->sd_desc->stopN(gspca_dev);
686 destroy_urbs(gspca_dev);
687 gspca_set_alt0(gspca_dev);
688 gspca_dev->sd_desc->stop0(gspca_dev);
689 PDEBUG(D_STREAM, "stream off OK");
691 destroy_urbs(gspca_dev);
692 atomic_inc(&gspca_dev->nevent);
693 wake_up_interruptible(&gspca_dev->wq);
694 PDEBUG(D_ERR|D_STREAM, "stream off no device ??");
698 static void gspca_set_default_mode(struct gspca_dev *gspca_dev)
702 i = gspca_dev->cam.nmodes - 1; /* take the highest mode */
703 gspca_dev->curr_mode = i;
704 gspca_dev->width = gspca_dev->cam.cam_mode[i].width;
705 gspca_dev->height = gspca_dev->cam.cam_mode[i].height;
706 gspca_dev->pixfmt = gspca_dev->cam.cam_mode[i].pixfmt;
709 static int wxh_to_mode(struct gspca_dev *gspca_dev,
710 int width, int height)
714 for (i = gspca_dev->cam.nmodes; --i > 0; ) {
715 if (width >= gspca_dev->cam.cam_mode[i].width
716 && height >= gspca_dev->cam.cam_mode[i].height)
723 * search a mode with the right pixel format
725 static int gspca_get_mode(struct gspca_dev *gspca_dev,
731 modeU = modeD = mode;
732 while ((modeU < gspca_dev->cam.nmodes) || modeD >= 0) {
734 if (gspca_dev->cam.cam_mode[modeD].pixfmt == pixfmt)
737 if (++modeU < gspca_dev->cam.nmodes) {
738 if (gspca_dev->cam.cam_mode[modeU].pixfmt == pixfmt)
745 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
746 struct v4l2_fmtdesc *fmtdesc)
748 struct gspca_dev *gspca_dev = priv;
752 /* give an index to each format */
755 for (i = gspca_dev->cam.nmodes; --i >= 0; ) {
756 fmt_tb[index] = gspca_dev->cam.cam_mode[i].pixfmt;
759 if (fmt_tb[j] == fmt_tb[index])
764 if (fmtdesc->index == index)
765 break; /* new format */
767 if (index >= sizeof fmt_tb / sizeof fmt_tb[0])
772 return -EINVAL; /* no more format */
774 fmtdesc->pixelformat = fmt_tb[index];
775 if (gspca_is_compressed(fmt_tb[index]))
776 fmtdesc->flags = V4L2_FMT_FLAG_COMPRESSED;
777 fmtdesc->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
778 fmtdesc->description[0] = fmtdesc->pixelformat & 0xff;
779 fmtdesc->description[1] = (fmtdesc->pixelformat >> 8) & 0xff;
780 fmtdesc->description[2] = (fmtdesc->pixelformat >> 16) & 0xff;
781 fmtdesc->description[3] = fmtdesc->pixelformat >> 24;
782 fmtdesc->description[4] = '\0';
786 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
787 struct v4l2_format *fmt)
789 struct gspca_dev *gspca_dev = priv;
791 if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
793 fmt->fmt.pix.width = gspca_dev->width;
794 fmt->fmt.pix.height = gspca_dev->height;
795 fmt->fmt.pix.pixelformat = gspca_dev->pixfmt;
796 fmt->fmt.pix.field = V4L2_FIELD_NONE;
797 fmt->fmt.pix.bytesperline = get_v4l2_depth(fmt->fmt.pix.pixelformat)
798 * fmt->fmt.pix.width / 8;
799 fmt->fmt.pix.sizeimage = fmt->fmt.pix.bytesperline
800 * fmt->fmt.pix.height;
801 /* (should be in the subdriver) */
802 fmt->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
803 fmt->fmt.pix.priv = 0;
807 static int try_fmt_vid_cap(struct gspca_dev *gspca_dev,
808 struct v4l2_format *fmt)
810 int w, h, mode, mode2, frsz;
812 if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
814 w = fmt->fmt.pix.width;
815 h = fmt->fmt.pix.height;
817 /* (luvcview problem) */
818 if (fmt->fmt.pix.pixelformat == V4L2_PIX_FMT_MJPEG)
819 fmt->fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG;
820 #ifdef VIDEO_ADV_DEBUG
821 if (gspca_debug & D_CONF)
822 PDEBUG_MODE("try fmt cap", fmt->fmt.pix.pixelformat, w, h);
824 /* search the closest mode for width and height */
825 mode = wxh_to_mode(gspca_dev, w, h);
827 /* OK if right palette */
828 if (gspca_dev->cam.cam_mode[mode].pixfmt != fmt->fmt.pix.pixelformat) {
830 /* else, search the closest mode with the same pixel format */
831 mode2 = gspca_get_mode(gspca_dev, mode,
832 fmt->fmt.pix.pixelformat);
837 /* no chance, return this mode */
838 fmt->fmt.pix.pixelformat =
839 gspca_dev->cam.cam_mode[mode].pixfmt;
840 #ifdef VIDEO_ADV_DEBUG
841 if (gspca_debug & D_CONF) {
842 PDEBUG_MODE("new format",
843 fmt->fmt.pix.pixelformat,
844 gspca_dev->cam.cam_mode[mode].width,
845 gspca_dev->cam.cam_mode[mode].height);
850 fmt->fmt.pix.width = gspca_dev->cam.cam_mode[mode].width;
851 fmt->fmt.pix.height = gspca_dev->cam.cam_mode[mode].height;
852 fmt->fmt.pix.bytesperline = get_v4l2_depth(fmt->fmt.pix.pixelformat)
853 * fmt->fmt.pix.width / 8;
854 frsz = fmt->fmt.pix.bytesperline * fmt->fmt.pix.height;
855 if (gspca_is_compressed(fmt->fmt.pix.pixelformat))
856 frsz = (frsz * comp_fac) / 100;
857 fmt->fmt.pix.sizeimage = frsz;
858 return mode; /* used when s_fmt */
861 static int vidioc_try_fmt_vid_cap(struct file *file,
863 struct v4l2_format *fmt)
865 struct gspca_dev *gspca_dev = priv;
868 ret = try_fmt_vid_cap(gspca_dev, fmt);
874 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
875 struct v4l2_format *fmt)
877 struct gspca_dev *gspca_dev = priv;
880 #ifdef CONFIG_VIDEO_V4L1_COMPAT
881 /* if v4l1 got JPEG */
882 if (fmt->fmt.pix.pixelformat == 0
883 && gspca_dev->streaming) {
884 fmt->fmt.pix.width = gspca_dev->width;
885 fmt->fmt.pix.height = gspca_dev->height;
886 fmt->fmt.pix.pixelformat = gspca_dev->pixfmt;
890 if (mutex_lock_interruptible(&gspca_dev->queue_lock))
893 ret = try_fmt_vid_cap(gspca_dev, fmt);
897 if (gspca_dev->nframes != 0
898 && fmt->fmt.pix.sizeimage > gspca_dev->frsz) {
903 if (ret == gspca_dev->curr_mode) {
905 goto out; /* same mode */
908 if (gspca_dev->streaming) {
912 gspca_dev->width = fmt->fmt.pix.width;
913 gspca_dev->height = fmt->fmt.pix.height;
914 gspca_dev->pixfmt = fmt->fmt.pix.pixelformat;
915 gspca_dev->curr_mode = ret;
919 mutex_unlock(&gspca_dev->queue_lock);
923 static int dev_open(struct inode *inode, struct file *file)
925 struct gspca_dev *gspca_dev;
928 PDEBUG(D_STREAM, "%s open", current->comm);
929 gspca_dev = (struct gspca_dev *) video_devdata(file);
930 if (mutex_lock_interruptible(&gspca_dev->queue_lock))
932 if (!gspca_dev->present) {
937 /* if not done yet, initialize the sensor */
938 if (gspca_dev->users == 0) {
939 if (mutex_lock_interruptible(&gspca_dev->usb_lock)) {
943 ret = gspca_dev->sd_desc->open(gspca_dev);
944 mutex_unlock(&gspca_dev->usb_lock);
946 PDEBUG(D_ERR|D_CONF, "init device failed %d", ret);
949 } else if (gspca_dev->users > 4) { /* (arbitrary value) */
954 file->private_data = gspca_dev;
955 #ifdef VIDEO_ADV_DEBUG
956 /* activate the v4l2 debug */
957 if (gspca_debug & D_V4L2)
958 gspca_dev->vdev.debug |= 3;
960 gspca_dev->vdev.debug &= ~3;
963 mutex_unlock(&gspca_dev->queue_lock);
965 PDEBUG(D_ERR|D_STREAM, "open failed err %d", ret);
967 PDEBUG(D_STREAM, "open done");
971 static int dev_close(struct inode *inode, struct file *file)
973 struct gspca_dev *gspca_dev = file->private_data;
975 PDEBUG(D_STREAM, "%s close", current->comm);
976 if (mutex_lock_interruptible(&gspca_dev->queue_lock))
980 /* if the file did capture, free the streaming resources */
981 if (gspca_dev->capt_file == file) {
982 mutex_lock(&gspca_dev->usb_lock);
983 if (gspca_dev->streaming)
984 gspca_stream_off(gspca_dev);
985 gspca_dev->sd_desc->close(gspca_dev);
986 mutex_unlock(&gspca_dev->usb_lock);
987 frame_free(gspca_dev);
988 gspca_dev->capt_file = 0;
989 gspca_dev->memory = GSPCA_MEMORY_NO;
991 file->private_data = NULL;
992 mutex_unlock(&gspca_dev->queue_lock);
993 PDEBUG(D_STREAM, "close done");
997 static int vidioc_querycap(struct file *file, void *priv,
998 struct v4l2_capability *cap)
1000 struct gspca_dev *gspca_dev = priv;
1002 memset(cap, 0, sizeof *cap);
1003 strncpy(cap->driver, gspca_dev->sd_desc->name, sizeof cap->driver);
1004 strncpy(cap->card, gspca_dev->cam.dev_name, sizeof cap->card);
1005 strncpy(cap->bus_info, gspca_dev->dev->bus->bus_name,
1006 sizeof cap->bus_info);
1007 cap->version = DRIVER_VERSION_NUMBER;
1008 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE
1009 | V4L2_CAP_STREAMING
1010 | V4L2_CAP_READWRITE;
1014 /* the use of V4L2_CTRL_FLAG_NEXT_CTRL asks for the controls to be sorted */
1015 static int vidioc_queryctrl(struct file *file, void *priv,
1016 struct v4l2_queryctrl *q_ctrl)
1018 struct gspca_dev *gspca_dev = priv;
1023 if (id & V4L2_CTRL_FLAG_NEXT_CTRL) {
1024 id &= V4L2_CTRL_ID_MASK;
1026 for (i = 0; i < gspca_dev->sd_desc->nctrls; i++) {
1027 if (id >= gspca_dev->sd_desc->ctrls[i].qctrl.id) {
1029 &gspca_dev->sd_desc->ctrls[i].qctrl,
1036 for (i = 0; i < gspca_dev->sd_desc->nctrls; i++) {
1037 if (id == gspca_dev->sd_desc->ctrls[i].qctrl.id) {
1039 &gspca_dev->sd_desc->ctrls[i].qctrl,
1044 if (id >= V4L2_CID_BASE
1045 && id <= V4L2_CID_LASTP1) {
1046 q_ctrl->flags |= V4L2_CTRL_FLAG_DISABLED;
1052 static int vidioc_s_ctrl(struct file *file, void *priv,
1053 struct v4l2_control *ctrl)
1055 struct gspca_dev *gspca_dev = priv;
1059 for (i = 0, ctrls = gspca_dev->sd_desc->ctrls;
1060 i < gspca_dev->sd_desc->nctrls;
1062 if (ctrl->id != ctrls->qctrl.id)
1064 if (ctrl->value < ctrls->qctrl.minimum
1065 && ctrl->value > ctrls->qctrl.maximum)
1067 PDEBUG(D_CONF, "set ctrl [%08x] = %d", ctrl->id, ctrl->value);
1068 if (mutex_lock_interruptible(&gspca_dev->usb_lock))
1069 return -ERESTARTSYS;
1070 ret = ctrls->set(gspca_dev, ctrl->value);
1071 mutex_unlock(&gspca_dev->usb_lock);
1077 static int vidioc_g_ctrl(struct file *file, void *priv,
1078 struct v4l2_control *ctrl)
1080 struct gspca_dev *gspca_dev = priv;
1085 for (i = 0, ctrls = gspca_dev->sd_desc->ctrls;
1086 i < gspca_dev->sd_desc->nctrls;
1088 if (ctrl->id != ctrls->qctrl.id)
1090 if (mutex_lock_interruptible(&gspca_dev->usb_lock))
1091 return -ERESTARTSYS;
1092 ret = ctrls->get(gspca_dev, &ctrl->value);
1093 mutex_unlock(&gspca_dev->usb_lock);
1099 static int vidioc_querymenu(struct file *file, void *priv,
1100 struct v4l2_querymenu *qmenu)
1102 struct gspca_dev *gspca_dev = priv;
1104 if (!gspca_dev->sd_desc->querymenu)
1106 return gspca_dev->sd_desc->querymenu(gspca_dev, qmenu);
1109 static int vidioc_enum_input(struct file *file, void *priv,
1110 struct v4l2_input *input)
1112 struct gspca_dev *gspca_dev = priv;
1114 if (input->index != 0)
1116 memset(input, 0, sizeof *input);
1117 input->type = V4L2_INPUT_TYPE_CAMERA;
1118 strncpy(input->name, gspca_dev->sd_desc->name,
1119 sizeof input->name);
1123 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1129 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1136 static int vidioc_reqbufs(struct file *file, void *priv,
1137 struct v4l2_requestbuffers *rb)
1139 struct gspca_dev *gspca_dev = priv;
1142 if (rb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1144 switch (rb->memory) {
1145 case V4L2_MEMORY_MMAP:
1146 case V4L2_MEMORY_USERPTR:
1151 if (mutex_lock_interruptible(&gspca_dev->queue_lock))
1152 return -ERESTARTSYS;
1154 for (i = 0; i < gspca_dev->nframes; i++) {
1155 if (gspca_dev->frame[i].vma_use_count) {
1161 /* only one file may do capture */
1162 if ((gspca_dev->capt_file != 0 && gspca_dev->capt_file != file)
1163 || gspca_dev->streaming) {
1168 if (rb->count == 0) { /* unrequest? */
1169 frame_free(gspca_dev);
1170 gspca_dev->capt_file = 0;
1172 gspca_dev->memory = rb->memory;
1173 ret = frame_alloc(gspca_dev, rb->count);
1175 rb->count = gspca_dev->nframes;
1176 gspca_dev->capt_file = file;
1180 mutex_unlock(&gspca_dev->queue_lock);
1181 PDEBUG(D_STREAM, "reqbufs st:%d c:%d", ret, rb->count);
1185 static int vidioc_querybuf(struct file *file, void *priv,
1186 struct v4l2_buffer *v4l2_buf)
1188 struct gspca_dev *gspca_dev = priv;
1189 struct gspca_frame *frame;
1191 if (v4l2_buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE
1192 || v4l2_buf->index < 0
1193 || v4l2_buf->index >= gspca_dev->nframes)
1196 frame = &gspca_dev->frame[v4l2_buf->index];
1197 memcpy(v4l2_buf, &frame->v4l2_buf, sizeof *v4l2_buf);
1201 static int vidioc_streamon(struct file *file, void *priv,
1202 enum v4l2_buf_type buf_type)
1204 struct gspca_dev *gspca_dev = priv;
1207 if (buf_type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1209 if (mutex_lock_interruptible(&gspca_dev->queue_lock))
1210 return -ERESTARTSYS;
1211 if (!gspca_dev->present) {
1215 if (gspca_dev->nframes == 0) {
1219 if (gspca_dev->capt_file != file) {
1223 if (!gspca_dev->streaming) {
1224 ret = gspca_init_transfer(gspca_dev);
1228 #ifdef VIDEO_ADV_DEBUG
1229 if (gspca_debug & D_STREAM) {
1230 PDEBUG_MODE("stream on OK",
1238 mutex_unlock(&gspca_dev->queue_lock);
1242 static int vidioc_streamoff(struct file *file, void *priv,
1243 enum v4l2_buf_type buf_type)
1245 struct gspca_dev *gspca_dev = priv;
1248 if (buf_type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1250 if (!gspca_dev->streaming)
1252 if (mutex_lock_interruptible(&gspca_dev->queue_lock))
1253 return -ERESTARTSYS;
1254 if (mutex_lock_interruptible(&gspca_dev->usb_lock)) {
1258 if (gspca_dev->capt_file != file) {
1262 gspca_stream_off(gspca_dev);
1265 mutex_unlock(&gspca_dev->usb_lock);
1267 mutex_unlock(&gspca_dev->queue_lock);
1271 static int vidioc_g_jpegcomp(struct file *file, void *priv,
1272 struct v4l2_jpegcompression *jpegcomp)
1274 struct gspca_dev *gspca_dev = priv;
1277 if (!gspca_dev->sd_desc->get_jcomp)
1279 if (mutex_lock_interruptible(&gspca_dev->usb_lock))
1280 return -ERESTARTSYS;
1281 ret = gspca_dev->sd_desc->get_jcomp(gspca_dev, jpegcomp);
1282 mutex_unlock(&gspca_dev->usb_lock);
1286 static int vidioc_s_jpegcomp(struct file *file, void *priv,
1287 struct v4l2_jpegcompression *jpegcomp)
1289 struct gspca_dev *gspca_dev = priv;
1292 if (mutex_lock_interruptible(&gspca_dev->usb_lock))
1293 return -ERESTARTSYS;
1294 if (!gspca_dev->sd_desc->set_jcomp)
1296 ret = gspca_dev->sd_desc->set_jcomp(gspca_dev, jpegcomp);
1297 mutex_unlock(&gspca_dev->usb_lock);
1301 static int vidioc_g_parm(struct file *filp, void *priv,
1302 struct v4l2_streamparm *parm)
1304 struct gspca_dev *gspca_dev = priv;
1306 memset(parm, 0, sizeof *parm);
1307 parm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1308 parm->parm.capture.readbuffers = gspca_dev->nbufread;
1312 static int vidioc_s_parm(struct file *filp, void *priv,
1313 struct v4l2_streamparm *parm)
1315 struct gspca_dev *gspca_dev = priv;
1318 n = parm->parm.capture.readbuffers;
1319 if (n == 0 || n > GSPCA_MAX_FRAMES)
1320 parm->parm.capture.readbuffers = gspca_dev->nbufread;
1322 gspca_dev->nbufread = n;
1326 static int vidioc_s_std(struct file *filp, void *priv,
1332 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1333 static int vidiocgmbuf(struct file *file, void *priv,
1334 struct video_mbuf *mbuf)
1336 struct gspca_dev *gspca_dev = file->private_data;
1339 PDEBUG(D_STREAM, "cgmbuf");
1340 if (gspca_dev->nframes == 0) {
1344 struct v4l2_format fmt;
1346 memset(&fmt, 0, sizeof fmt);
1347 fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1348 i = gspca_dev->cam.nmodes - 1; /* highest mode */
1349 fmt.fmt.pix.width = gspca_dev->cam.cam_mode[i].width;
1350 fmt.fmt.pix.height = gspca_dev->cam.cam_mode[i].height;
1351 fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_BGR24;
1352 ret = vidioc_s_fmt_vid_cap(file, priv, &fmt);
1357 struct v4l2_requestbuffers rb;
1359 memset(&rb, 0, sizeof rb);
1361 rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1362 rb.memory = V4L2_MEMORY_MMAP;
1363 ret = vidioc_reqbufs(file, priv, &rb);
1368 mbuf->frames = gspca_dev->nframes;
1369 mbuf->size = gspca_dev->frsz * gspca_dev->nframes;
1370 for (i = 0; i < mbuf->frames; i++)
1371 mbuf->offsets[i] = gspca_dev->frame[i].v4l2_buf.m.offset;
1376 static int dev_mmap(struct file *file, struct vm_area_struct *vma)
1378 struct gspca_dev *gspca_dev = file->private_data;
1379 struct gspca_frame *frame = 0;
1381 unsigned long addr, start, size;
1383 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1387 start = vma->vm_start;
1388 size = vma->vm_end - vma->vm_start;
1389 PDEBUG(D_STREAM, "mmap start:%08x size:%d", (int) start, (int) size);
1391 if (mutex_lock_interruptible(&gspca_dev->queue_lock))
1392 return -ERESTARTSYS;
1393 if (!gspca_dev->present) {
1397 if (gspca_dev->capt_file != file) {
1402 for (i = 0; i < gspca_dev->nframes; ++i) {
1403 if (gspca_dev->frame[i].v4l2_buf.memory != V4L2_MEMORY_MMAP) {
1404 PDEBUG(D_STREAM, "mmap bad memory type");
1407 if ((gspca_dev->frame[i].v4l2_buf.m.offset >> PAGE_SHIFT)
1409 frame = &gspca_dev->frame[i];
1414 PDEBUG(D_STREAM, "mmap no frame buffer found");
1418 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1419 if (i == 0 && size == frame->v4l2_buf.length * gspca_dev->nframes)
1423 if (size != frame->v4l2_buf.length) {
1424 PDEBUG(D_STREAM, "mmap bad size");
1430 * - VM_IO marks the area as being a mmaped region for I/O to a
1431 * device. It also prevents the region from being core dumped.
1433 vma->vm_flags |= VM_IO;
1435 addr = (unsigned long) frame->data;
1437 page = vmalloc_to_page((void *) addr);
1438 ret = vm_insert_page(vma, start, page);
1446 vma->vm_ops = &gspca_vm_ops;
1447 vma->vm_private_data = frame;
1449 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1452 for (i = 1; i < gspca_dev->nframes; ++i)
1453 gspca_dev->frame[i].v4l2_buf.flags |=
1454 V4L2_BUF_FLAG_MAPPED;
1459 mutex_unlock(&gspca_dev->queue_lock);
1464 * wait for a video frame
1466 * If a frame is ready, its index is returned.
1468 static int frame_wait(struct gspca_dev *gspca_dev,
1471 struct gspca_frame *frame;
1474 /* if userptr, treat the awaiting URBs */
1475 if (gspca_dev->memory == V4L2_MEMORY_USERPTR)
1476 isoc_transfer(gspca_dev);
1478 /* check if a frame is ready */
1479 i = gspca_dev->fr_o;
1480 j = gspca_dev->fr_queue[i];
1481 frame = &gspca_dev->frame[j];
1482 if (frame->v4l2_buf.flags & V4L2_BUF_FLAG_DONE) {
1483 atomic_dec(&gspca_dev->nevent);
1486 if (nonblock_ing) /* no frame yet */
1489 /* wait till a frame is ready */
1491 ret = wait_event_interruptible_timeout(gspca_dev->wq,
1492 atomic_read(&gspca_dev->nevent) > 0,
1493 msecs_to_jiffies(3000));
1496 return ret; /* interrupt */
1497 return -EIO; /* timeout */
1499 atomic_dec(&gspca_dev->nevent);
1500 if (!gspca_dev->streaming || !gspca_dev->present)
1502 if (gspca_dev->memory == V4L2_MEMORY_USERPTR)
1503 isoc_transfer(gspca_dev);
1504 i = gspca_dev->fr_o;
1505 j = gspca_dev->fr_queue[i];
1506 frame = &gspca_dev->frame[j];
1507 if (frame->v4l2_buf.flags & V4L2_BUF_FLAG_DONE)
1511 gspca_dev->fr_o = (i + 1) % gspca_dev->nframes;
1512 PDEBUG(D_FRAM, "frame wait q:%d i:%d o:%d",
1517 if (gspca_dev->sd_desc->dq_callback)
1518 gspca_dev->sd_desc->dq_callback(gspca_dev);
1524 * dequeue a video buffer
1526 * If nonblock_ing is false, block until a buffer is available.
1528 static int vidioc_dqbuf(struct file *file, void *priv,
1529 struct v4l2_buffer *v4l2_buf)
1531 struct gspca_dev *gspca_dev = priv;
1532 struct gspca_frame *frame;
1535 PDEBUG(D_FRAM, "dqbuf");
1536 if (v4l2_buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE
1537 || (v4l2_buf->memory != V4L2_MEMORY_MMAP
1538 && v4l2_buf->memory != V4L2_MEMORY_USERPTR))
1540 if (!gspca_dev->streaming)
1542 if (gspca_dev->capt_file != file) {
1548 if (mutex_lock_interruptible(&gspca_dev->read_lock))
1549 return -ERESTARTSYS;
1551 ret = frame_wait(gspca_dev, file->f_flags & O_NONBLOCK);
1554 i = ret; /* frame index */
1555 frame = &gspca_dev->frame[i];
1556 frame->v4l2_buf.flags &= ~V4L2_BUF_FLAG_DONE;
1557 memcpy(v4l2_buf, &frame->v4l2_buf, sizeof *v4l2_buf);
1558 PDEBUG(D_FRAM, "dqbuf %d", i);
1561 mutex_unlock(&gspca_dev->read_lock);
1566 * queue a video buffer
1568 * Attempting to queue a buffer that has already been
1569 * queued will return -EINVAL.
1571 static int vidioc_qbuf(struct file *file, void *priv,
1572 struct v4l2_buffer *v4l2_buf)
1574 struct gspca_dev *gspca_dev = priv;
1575 struct gspca_frame *frame;
1578 PDEBUG(D_FRAM, "qbuf %d", v4l2_buf->index);
1579 if (v4l2_buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1582 index = v4l2_buf->index;
1583 if ((unsigned) index >= gspca_dev->nframes) {
1585 "qbuf idx %d >= %d", index, gspca_dev->nframes);
1588 frame = &gspca_dev->frame[index];
1590 if (v4l2_buf->memory != frame->v4l2_buf.memory) {
1591 PDEBUG(D_FRAM, "qbuf bad memory type");
1594 if (gspca_dev->capt_file != file)
1597 if (mutex_lock_interruptible(&gspca_dev->queue_lock))
1598 return -ERESTARTSYS;
1600 if (frame->v4l2_buf.flags & BUF_ALL_FLAGS) {
1601 PDEBUG(D_FRAM, "qbuf bad state");
1606 frame->v4l2_buf.flags |= V4L2_BUF_FLAG_QUEUED;
1607 /* frame->v4l2_buf.flags &= ~V4L2_BUF_FLAG_DONE; */
1609 if (frame->v4l2_buf.memory == V4L2_MEMORY_USERPTR) {
1610 frame->data = frame->data_end =
1611 (__u8 *) v4l2_buf->m.userptr;
1612 frame->v4l2_buf.m.userptr = v4l2_buf->m.userptr;
1613 frame->v4l2_buf.length = v4l2_buf->length;
1616 /* put the buffer in the 'queued' queue */
1617 i = gspca_dev->fr_q;
1618 gspca_dev->fr_queue[i] = index;
1619 gspca_dev->fr_q = (i + 1) % gspca_dev->nframes;
1620 PDEBUG(D_FRAM, "qbuf q:%d i:%d o:%d",
1625 v4l2_buf->flags |= V4L2_BUF_FLAG_QUEUED;
1626 v4l2_buf->flags &= ~V4L2_BUF_FLAG_DONE;
1629 mutex_unlock(&gspca_dev->queue_lock);
1634 * allocate the resources for read()
1636 static int read_alloc(struct gspca_dev *gspca_dev,
1639 struct v4l2_buffer v4l2_buf;
1642 PDEBUG(D_STREAM, "read alloc");
1643 if (gspca_dev->nframes == 0) {
1644 struct v4l2_requestbuffers rb;
1646 memset(&rb, 0, sizeof rb);
1647 rb.count = gspca_dev->nbufread;
1648 rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1649 rb.memory = V4L2_MEMORY_MMAP;
1650 ret = vidioc_reqbufs(file, gspca_dev, &rb);
1652 PDEBUG(D_STREAM, "read reqbuf err %d", ret);
1655 memset(&v4l2_buf, 0, sizeof v4l2_buf);
1656 v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1657 v4l2_buf.memory = V4L2_MEMORY_MMAP;
1658 for (i = 0; i < gspca_dev->nbufread; i++) {
1661 gspca_dev->frame[i].v4l2_buf.flags |=
1662 V4L2_BUF_FLAG_MAPPED;
1663 ret = vidioc_qbuf(file, gspca_dev, &v4l2_buf);
1665 PDEBUG(D_STREAM, "read qbuf err: %d", ret);
1669 gspca_dev->memory = GSPCA_MEMORY_READ;
1672 /* start streaming */
1673 ret = vidioc_streamon(file, gspca_dev, V4L2_BUF_TYPE_VIDEO_CAPTURE);
1675 PDEBUG(D_STREAM, "read streamon err %d", ret);
1679 static unsigned int dev_poll(struct file *file, poll_table *wait)
1681 struct gspca_dev *gspca_dev = file->private_data;
1684 PDEBUG(D_FRAM, "poll");
1686 poll_wait(file, &gspca_dev->wq, wait);
1687 if (!gspca_dev->present)
1690 /* if not streaming, the user would use read() */
1691 if (!gspca_dev->streaming) {
1692 if (gspca_dev->memory != GSPCA_MEMORY_NO) {
1693 ret = POLLERR; /* not the 1st time */
1696 ret = read_alloc(gspca_dev, file);
1703 if (mutex_lock_interruptible(&gspca_dev->queue_lock) != 0)
1705 if (!gspca_dev->present) {
1710 /* if userptr, treat the awaiting URBs */
1711 if (gspca_dev->memory == V4L2_MEMORY_USERPTR
1712 && gspca_dev->capt_file == file)
1713 isoc_transfer(gspca_dev);
1715 i = gspca_dev->fr_o;
1716 i = gspca_dev->fr_queue[i];
1717 if (gspca_dev->frame[i].v4l2_buf.flags & V4L2_BUF_FLAG_DONE)
1718 ret = POLLIN | POLLRDNORM; /* something to read */
1722 mutex_unlock(&gspca_dev->queue_lock);
1726 static ssize_t dev_read(struct file *file, char __user *data,
1727 size_t count, loff_t *ppos)
1729 struct gspca_dev *gspca_dev = file->private_data;
1730 struct gspca_frame *frame;
1731 struct v4l2_buffer v4l2_buf;
1732 struct timeval timestamp;
1735 PDEBUG(D_FRAM, "read (%d)", count);
1736 if (!gspca_dev->present)
1738 switch (gspca_dev->memory) {
1739 case GSPCA_MEMORY_NO: /* first time */
1740 ret = read_alloc(gspca_dev, file);
1744 case GSPCA_MEMORY_READ:
1745 if (gspca_dev->capt_file == file)
1753 jiffies_to_timeval(get_jiffies_64(), ×tamp);
1757 memset(&v4l2_buf, 0, sizeof v4l2_buf);
1758 v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1759 v4l2_buf.memory = V4L2_MEMORY_MMAP;
1760 ret = vidioc_dqbuf(file, gspca_dev, &v4l2_buf);
1762 PDEBUG(D_STREAM, "read dqbuf err %d", ret);
1766 /* if the process slept for more than 1 second,
1767 * get anewer frame */
1768 frame = &gspca_dev->frame[v4l2_buf.index];
1770 break; /* avoid infinite loop */
1771 if (frame->v4l2_buf.timestamp.tv_sec >= timestamp.tv_sec)
1773 ret = vidioc_qbuf(file, gspca_dev, &v4l2_buf);
1775 PDEBUG(D_STREAM, "read qbuf err %d", ret);
1780 /* copy the frame */
1781 if (count < frame->v4l2_buf.bytesused) {
1782 PDEBUG(D_STREAM, "read bad count: %d < %d",
1783 count, frame->v4l2_buf.bytesused);
1784 /*fixme: special errno?*/
1788 count = frame->v4l2_buf.bytesused;
1789 ret = copy_to_user(data, frame->data, count);
1791 PDEBUG(D_ERR|D_STREAM,
1792 "read cp to user lack %d / %d", ret, count);
1798 /* in each case, requeue the buffer */
1799 ret2 = vidioc_qbuf(file, gspca_dev, &v4l2_buf);
1805 static void dev_release(struct video_device *vfd)
1810 static struct file_operations dev_fops = {
1811 .owner = THIS_MODULE,
1813 .release = dev_close,
1816 .ioctl = video_ioctl2,
1817 #ifdef CONFIG_COMPAT
1818 .compat_ioctl = v4l_compat_ioctl32,
1820 .llseek = no_llseek,
1824 static struct video_device gspca_template = {
1825 .name = "gspca main driver",
1826 .type = VID_TYPE_CAPTURE,
1828 .release = dev_release, /* mandatory */
1830 .vidioc_querycap = vidioc_querycap,
1831 .vidioc_dqbuf = vidioc_dqbuf,
1832 .vidioc_qbuf = vidioc_qbuf,
1833 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1834 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1835 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1836 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1837 .vidioc_streamon = vidioc_streamon,
1838 .vidioc_queryctrl = vidioc_queryctrl,
1839 .vidioc_g_ctrl = vidioc_g_ctrl,
1840 .vidioc_s_ctrl = vidioc_s_ctrl,
1841 .vidioc_querymenu = vidioc_querymenu,
1842 .vidioc_enum_input = vidioc_enum_input,
1843 .vidioc_g_input = vidioc_g_input,
1844 .vidioc_s_input = vidioc_s_input,
1845 .vidioc_reqbufs = vidioc_reqbufs,
1846 .vidioc_querybuf = vidioc_querybuf,
1847 .vidioc_streamoff = vidioc_streamoff,
1848 .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
1849 .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
1850 .vidioc_g_parm = vidioc_g_parm,
1851 .vidioc_s_parm = vidioc_s_parm,
1852 .vidioc_s_std = vidioc_s_std,
1853 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1854 .vidiocgmbuf = vidiocgmbuf,
1859 * probe and create a new gspca device
1861 * This function must be called by the sub-driver when it is
1862 * called for probing a new device.
1864 int gspca_dev_probe(struct usb_interface *intf,
1865 const struct usb_device_id *id,
1866 const struct sd_desc *sd_desc,
1868 struct module *module)
1870 struct usb_interface_descriptor *interface;
1871 struct gspca_dev *gspca_dev;
1872 struct usb_device *dev = interface_to_usbdev(intf);
1875 PDEBUG(D_PROBE, "probing %04x:%04x", id->idVendor, id->idProduct);
1877 /* we don't handle multi-config cameras */
1878 if (dev->descriptor.bNumConfigurations != 1)
1880 interface = &intf->cur_altsetting->desc;
1881 if (interface->bInterfaceNumber > 0)
1884 /* create the device */
1885 if (dev_size < sizeof *gspca_dev)
1886 dev_size = sizeof *gspca_dev;
1887 gspca_dev = kzalloc(dev_size, GFP_KERNEL);
1888 if (gspca_dev == NULL) {
1889 err("couldn't kzalloc gspca struct");
1892 gspca_dev->dev = dev;
1893 gspca_dev->iface = interface->bInterfaceNumber;
1894 gspca_dev->nbalt = intf->num_altsetting;
1895 gspca_dev->sd_desc = sd_desc;
1896 /* gspca_dev->users = 0; (done by kzalloc) */
1897 gspca_dev->nbufread = 2;
1899 /* configure the subdriver */
1900 ret = gspca_dev->sd_desc->config(gspca_dev, id);
1903 ret = gspca_set_alt0(gspca_dev);
1906 gspca_set_default_mode(gspca_dev);
1908 mutex_init(&gspca_dev->usb_lock);
1909 mutex_init(&gspca_dev->read_lock);
1910 mutex_init(&gspca_dev->queue_lock);
1911 init_waitqueue_head(&gspca_dev->wq);
1913 /* init video stuff */
1914 memcpy(&gspca_dev->vdev, &gspca_template, sizeof gspca_template);
1915 gspca_dev->vdev.dev = &dev->dev;
1916 memcpy(&gspca_dev->fops, &dev_fops, sizeof gspca_dev->fops);
1917 gspca_dev->vdev.fops = &gspca_dev->fops;
1918 gspca_dev->fops.owner = module; /* module protection */
1919 ret = video_register_device(&gspca_dev->vdev,
1923 err("video_register_device err %d", ret);
1927 gspca_dev->present = 1;
1928 usb_set_intfdata(intf, gspca_dev);
1929 PDEBUG(D_PROBE, "probe ok");
1935 EXPORT_SYMBOL(gspca_dev_probe);
1940 * This function must be called by the sub-driver
1941 * when the device disconnects, after the specific resources are freed.
1943 void gspca_disconnect(struct usb_interface *intf)
1945 struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
1949 gspca_dev->present = 0;
1950 mutex_lock(&gspca_dev->queue_lock);
1951 mutex_lock(&gspca_dev->usb_lock);
1952 gspca_dev->streaming = 0;
1953 destroy_urbs(gspca_dev);
1954 mutex_unlock(&gspca_dev->usb_lock);
1955 mutex_unlock(&gspca_dev->queue_lock);
1956 while (gspca_dev->users != 0) { /* wait until fully closed */
1957 atomic_inc(&gspca_dev->nevent);
1958 wake_up_interruptible(&gspca_dev->wq); /* wake processes */
1961 /* We don't want people trying to open up the device */
1962 video_unregister_device(&gspca_dev->vdev);
1963 /* Free the memory */
1965 PDEBUG(D_PROBE, "disconnect complete");
1967 EXPORT_SYMBOL(gspca_disconnect);
1969 /* -- module insert / remove -- */
1970 static int __init gspca_init(void)
1972 info("main v%s registered", version);
1975 static void __exit gspca_exit(void)
1977 info("main deregistered");
1980 module_init(gspca_init);
1981 module_exit(gspca_exit);
1983 #ifdef VIDEO_ADV_DEBUG
1984 module_param_named(debug, gspca_debug, int, 0644);
1985 MODULE_PARM_DESC(debug,
1986 "Debug (bit) 0x01:error 0x02:probe 0x04:config"
1987 " 0x08:stream 0x10:frame 0x20:packet 0x40:USBin 0x80:USBout"
1990 module_param(comp_fac, int, 0644);
1991 MODULE_PARM_DESC(comp_fac,
1992 "Buffer size ratio when compressed in percent");