Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
gspca.c
Go to the documentation of this file.
1 /*
2  * Main USB camera driver
3  *
4  * Copyright (C) 2008-2011 Jean-François Moine <http://moinejf.free.fr>
5  *
6  * Camera button input handling by Márton Németh
7  * Copyright (C) 2009-2010 Márton Németh <[email protected]>
8  *
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.
13  *
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
17  * for more details.
18  *
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.
22  */
23 
24 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
25 
26 #define GSPCA_VERSION "2.14.0"
27 
28 #include <linux/init.h>
29 #include <linux/fs.h>
30 #include <linux/vmalloc.h>
31 #include <linux/sched.h>
32 #include <linux/slab.h>
33 #include <linux/mm.h>
34 #include <linux/string.h>
35 #include <linux/pagemap.h>
36 #include <linux/io.h>
37 #include <asm/page.h>
38 #include <linux/uaccess.h>
39 #include <linux/ktime.h>
40 #include <media/v4l2-ioctl.h>
41 #include <media/v4l2-ctrls.h>
42 #include <media/v4l2-fh.h>
43 #include <media/v4l2-event.h>
44 
45 #include "gspca.h"
46 
47 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
48 #include <linux/input.h>
49 #include <linux/usb/input.h>
50 #endif
51 
52 /* global values */
53 #define DEF_NURBS 3 /* default number of URBs */
54 #if DEF_NURBS > MAX_NURBS
55 #error "DEF_NURBS too big"
56 #endif
57 
58 MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>");
59 MODULE_DESCRIPTION("GSPCA USB Camera Driver");
60 MODULE_LICENSE("GPL");
61 MODULE_VERSION(GSPCA_VERSION);
62 
63 #ifdef GSPCA_DEBUG
64 int gspca_debug = D_ERR | D_PROBE;
65 EXPORT_SYMBOL(gspca_debug);
66 
67 static void PDEBUG_MODE(char *txt, __u32 pixfmt, int w, int h)
68 {
69  if ((pixfmt >> 24) >= '0' && (pixfmt >> 24) <= 'z') {
70  PDEBUG(D_CONF|D_STREAM, "%s %c%c%c%c %dx%d",
71  txt,
72  pixfmt & 0xff,
73  (pixfmt >> 8) & 0xff,
74  (pixfmt >> 16) & 0xff,
75  pixfmt >> 24,
76  w, h);
77  } else {
78  PDEBUG(D_CONF|D_STREAM, "%s 0x%08x %dx%d",
79  txt,
80  pixfmt,
81  w, h);
82  }
83 }
84 #else
85 #define PDEBUG_MODE(txt, pixfmt, w, h)
86 #endif
87 
88 /* specific memory types - !! should be different from V4L2_MEMORY_xxx */
89 #define GSPCA_MEMORY_NO 0 /* V4L2_MEMORY_xxx starts from 1 */
90 #define GSPCA_MEMORY_READ 7
91 
92 #define BUF_ALL_FLAGS (V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE)
93 
94 /*
95  * VMA operations.
96  */
97 static void gspca_vm_open(struct vm_area_struct *vma)
98 {
99  struct gspca_frame *frame = vma->vm_private_data;
100 
101  frame->vma_use_count++;
102  frame->v4l2_buf.flags |= V4L2_BUF_FLAG_MAPPED;
103 }
104 
105 static void gspca_vm_close(struct vm_area_struct *vma)
106 {
107  struct gspca_frame *frame = vma->vm_private_data;
108 
109  if (--frame->vma_use_count <= 0)
110  frame->v4l2_buf.flags &= ~V4L2_BUF_FLAG_MAPPED;
111 }
112 
113 static const struct vm_operations_struct gspca_vm_ops = {
114  .open = gspca_vm_open,
115  .close = gspca_vm_close,
116 };
117 
118 /*
119  * Input and interrupt endpoint handling functions
120  */
121 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
122 static void int_irq(struct urb *urb)
123 {
124  struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
125  int ret;
126 
127  ret = urb->status;
128  switch (ret) {
129  case 0:
130  if (gspca_dev->sd_desc->int_pkt_scan(gspca_dev,
131  urb->transfer_buffer, urb->actual_length) < 0) {
132  PDEBUG(D_ERR, "Unknown packet received");
133  }
134  break;
135 
136  case -ENOENT:
137  case -ECONNRESET:
138  case -ENODEV:
139  case -ESHUTDOWN:
140  /* Stop is requested either by software or hardware is gone,
141  * keep the ret value non-zero and don't resubmit later.
142  */
143  break;
144 
145  default:
146  PDEBUG(D_ERR, "URB error %i, resubmitting", urb->status);
147  urb->status = 0;
148  ret = 0;
149  }
150 
151  if (ret == 0) {
152  ret = usb_submit_urb(urb, GFP_ATOMIC);
153  if (ret < 0)
154  pr_err("Resubmit URB failed with error %i\n", ret);
155  }
156 }
157 
158 static int gspca_input_connect(struct gspca_dev *dev)
159 {
160  struct input_dev *input_dev;
161  int err = 0;
162 
163  dev->input_dev = NULL;
164  if (dev->sd_desc->int_pkt_scan || dev->sd_desc->other_input) {
165  input_dev = input_allocate_device();
166  if (!input_dev)
167  return -ENOMEM;
168 
169  usb_make_path(dev->dev, dev->phys, sizeof(dev->phys));
170  strlcat(dev->phys, "/input0", sizeof(dev->phys));
171 
172  input_dev->name = dev->sd_desc->name;
173  input_dev->phys = dev->phys;
174 
175  usb_to_input_id(dev->dev, &input_dev->id);
176 
177  input_dev->evbit[0] = BIT_MASK(EV_KEY);
178  input_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
179  input_dev->dev.parent = &dev->dev->dev;
180 
181  err = input_register_device(input_dev);
182  if (err) {
183  pr_err("Input device registration failed with error %i\n",
184  err);
185  input_dev->dev.parent = NULL;
186  input_free_device(input_dev);
187  } else {
188  dev->input_dev = input_dev;
189  }
190  }
191 
192  return err;
193 }
194 
195 static int alloc_and_submit_int_urb(struct gspca_dev *gspca_dev,
196  struct usb_endpoint_descriptor *ep)
197 {
198  unsigned int buffer_len;
199  int interval;
200  struct urb *urb;
201  struct usb_device *dev;
202  void *buffer = NULL;
203  int ret = -EINVAL;
204 
205  buffer_len = le16_to_cpu(ep->wMaxPacketSize);
206  interval = ep->bInterval;
207  PDEBUG(D_CONF, "found int in endpoint: 0x%x, "
208  "buffer_len=%u, interval=%u",
209  ep->bEndpointAddress, buffer_len, interval);
210 
211  dev = gspca_dev->dev;
212 
213  urb = usb_alloc_urb(0, GFP_KERNEL);
214  if (!urb) {
215  ret = -ENOMEM;
216  goto error;
217  }
218 
219  buffer = usb_alloc_coherent(dev, buffer_len,
220  GFP_KERNEL, &urb->transfer_dma);
221  if (!buffer) {
222  ret = -ENOMEM;
223  goto error_buffer;
224  }
225  usb_fill_int_urb(urb, dev,
226  usb_rcvintpipe(dev, ep->bEndpointAddress),
227  buffer, buffer_len,
228  int_irq, (void *)gspca_dev, interval);
229  urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
230  ret = usb_submit_urb(urb, GFP_KERNEL);
231  if (ret < 0) {
232  PDEBUG(D_ERR, "submit int URB failed with error %i", ret);
233  goto error_submit;
234  }
235  gspca_dev->int_urb = urb;
236  return ret;
237 
238 error_submit:
239  usb_free_coherent(dev,
240  urb->transfer_buffer_length,
241  urb->transfer_buffer,
242  urb->transfer_dma);
243 error_buffer:
244  usb_free_urb(urb);
245 error:
246  return ret;
247 }
248 
249 static void gspca_input_create_urb(struct gspca_dev *gspca_dev)
250 {
251  struct usb_interface *intf;
252  struct usb_host_interface *intf_desc;
253  struct usb_endpoint_descriptor *ep;
254  int i;
255 
256  if (gspca_dev->sd_desc->int_pkt_scan) {
257  intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
258  intf_desc = intf->cur_altsetting;
259  for (i = 0; i < intf_desc->desc.bNumEndpoints; i++) {
260  ep = &intf_desc->endpoint[i].desc;
261  if (usb_endpoint_dir_in(ep) &&
262  usb_endpoint_xfer_int(ep)) {
263 
264  alloc_and_submit_int_urb(gspca_dev, ep);
265  break;
266  }
267  }
268  }
269 }
270 
271 static void gspca_input_destroy_urb(struct gspca_dev *gspca_dev)
272 {
273  struct urb *urb;
274 
275  urb = gspca_dev->int_urb;
276  if (urb) {
277  gspca_dev->int_urb = NULL;
278  usb_kill_urb(urb);
279  usb_free_coherent(gspca_dev->dev,
280  urb->transfer_buffer_length,
281  urb->transfer_buffer,
282  urb->transfer_dma);
283  usb_free_urb(urb);
284  }
285 }
286 #else
287 static inline void gspca_input_destroy_urb(struct gspca_dev *gspca_dev)
288 {
289 }
290 
291 static inline void gspca_input_create_urb(struct gspca_dev *gspca_dev)
292 {
293 }
294 
295 static inline int gspca_input_connect(struct gspca_dev *dev)
296 {
297  return 0;
298 }
299 #endif
300 
301 /*
302  * fill a video frame from an URB and resubmit
303  */
304 static void fill_frame(struct gspca_dev *gspca_dev,
305  struct urb *urb)
306 {
307  u8 *data; /* address of data in the iso message */
308  int i, len, st;
309  cam_pkt_op pkt_scan;
310 
311  if (urb->status != 0) {
312  if (urb->status == -ESHUTDOWN)
313  return; /* disconnection */
314 #ifdef CONFIG_PM
315  if (gspca_dev->frozen)
316  return;
317 #endif
318  PDEBUG(D_ERR|D_PACK, "urb status: %d", urb->status);
319  urb->status = 0;
320  goto resubmit;
321  }
322  pkt_scan = gspca_dev->sd_desc->pkt_scan;
323  for (i = 0; i < urb->number_of_packets; i++) {
324  len = urb->iso_frame_desc[i].actual_length;
325 
326  /* check the packet status and length */
327  st = urb->iso_frame_desc[i].status;
328  if (st) {
329  pr_err("ISOC data error: [%d] len=%d, status=%d\n",
330  i, len, st);
331  gspca_dev->last_packet_type = DISCARD_PACKET;
332  continue;
333  }
334  if (len == 0) {
335  if (gspca_dev->empty_packet == 0)
336  gspca_dev->empty_packet = 1;
337  continue;
338  }
339 
340  /* let the packet be analyzed by the subdriver */
341  PDEBUG(D_PACK, "packet [%d] o:%d l:%d",
342  i, urb->iso_frame_desc[i].offset, len);
343  data = (u8 *) urb->transfer_buffer
344  + urb->iso_frame_desc[i].offset;
345  pkt_scan(gspca_dev, data, len);
346  }
347 
348 resubmit:
349  /* resubmit the URB */
350  st = usb_submit_urb(urb, GFP_ATOMIC);
351  if (st < 0)
352  pr_err("usb_submit_urb() ret %d\n", st);
353 }
354 
355 /*
356  * ISOC message interrupt from the USB device
357  *
358  * Analyse each packet and call the subdriver for copy to the frame buffer.
359  */
360 static void isoc_irq(struct urb *urb)
361 {
362  struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
363 
364  PDEBUG(D_PACK, "isoc irq");
365  if (!gspca_dev->streaming)
366  return;
367  fill_frame(gspca_dev, urb);
368 }
369 
370 /*
371  * bulk message interrupt from the USB device
372  */
373 static void bulk_irq(struct urb *urb)
374 {
375  struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context;
376  int st;
377 
378  PDEBUG(D_PACK, "bulk irq");
379  if (!gspca_dev->streaming)
380  return;
381  switch (urb->status) {
382  case 0:
383  break;
384  case -ESHUTDOWN:
385  return; /* disconnection */
386  default:
387 #ifdef CONFIG_PM
388  if (gspca_dev->frozen)
389  return;
390 #endif
391  PDEBUG(D_ERR|D_PACK, "urb status: %d", urb->status);
392  urb->status = 0;
393  goto resubmit;
394  }
395 
396  PDEBUG(D_PACK, "packet l:%d", urb->actual_length);
397  gspca_dev->sd_desc->pkt_scan(gspca_dev,
398  urb->transfer_buffer,
399  urb->actual_length);
400 
401 resubmit:
402  /* resubmit the URB */
403  if (gspca_dev->cam.bulk_nurbs != 0) {
404  st = usb_submit_urb(urb, GFP_ATOMIC);
405  if (st < 0)
406  pr_err("usb_submit_urb() ret %d\n", st);
407  }
408 }
409 
410 /*
411  * add data to the current frame
412  *
413  * This function is called by the subdrivers at interrupt level.
414  *
415  * To build a frame, these ones must add
416  * - one FIRST_PACKET
417  * - 0 or many INTER_PACKETs
418  * - one LAST_PACKET
419  * DISCARD_PACKET invalidates the whole frame.
420  */
421 void gspca_frame_add(struct gspca_dev *gspca_dev,
422  enum gspca_packet_type packet_type,
423  const u8 *data,
424  int len)
425 {
426  struct gspca_frame *frame;
427  int i, j;
428 
429  PDEBUG(D_PACK, "add t:%d l:%d", packet_type, len);
430 
431  if (packet_type == FIRST_PACKET) {
432  i = atomic_read(&gspca_dev->fr_i);
433 
434  /* if there are no queued buffer, discard the whole frame */
435  if (i == atomic_read(&gspca_dev->fr_q)) {
436  gspca_dev->last_packet_type = DISCARD_PACKET;
437  gspca_dev->sequence++;
438  return;
439  }
440  j = gspca_dev->fr_queue[i];
441  frame = &gspca_dev->frame[j];
442  frame->v4l2_buf.timestamp = ktime_to_timeval(ktime_get());
443  frame->v4l2_buf.sequence = gspca_dev->sequence++;
444  gspca_dev->image = frame->data;
445  gspca_dev->image_len = 0;
446  } else {
447  switch (gspca_dev->last_packet_type) {
448  case DISCARD_PACKET:
449  if (packet_type == LAST_PACKET) {
450  gspca_dev->last_packet_type = packet_type;
451  gspca_dev->image = NULL;
452  gspca_dev->image_len = 0;
453  }
454  return;
455  case LAST_PACKET:
456  return;
457  }
458  }
459 
460  /* append the packet to the frame buffer */
461  if (len > 0) {
462  if (gspca_dev->image_len + len > gspca_dev->frsz) {
463  PDEBUG(D_ERR|D_PACK, "frame overflow %d > %d",
464  gspca_dev->image_len + len,
465  gspca_dev->frsz);
466  packet_type = DISCARD_PACKET;
467  } else {
468 /* !! image is NULL only when last pkt is LAST or DISCARD
469  if (gspca_dev->image == NULL) {
470  pr_err("gspca_frame_add() image == NULL\n");
471  return;
472  }
473  */
474  memcpy(gspca_dev->image + gspca_dev->image_len,
475  data, len);
476  gspca_dev->image_len += len;
477  }
478  }
479  gspca_dev->last_packet_type = packet_type;
480 
481  /* if last packet, invalidate packet concatenation until
482  * next first packet, wake up the application and advance
483  * in the queue */
484  if (packet_type == LAST_PACKET) {
485  i = atomic_read(&gspca_dev->fr_i);
486  j = gspca_dev->fr_queue[i];
487  frame = &gspca_dev->frame[j];
488  frame->v4l2_buf.bytesused = gspca_dev->image_len;
489  frame->v4l2_buf.flags = (frame->v4l2_buf.flags
490  | V4L2_BUF_FLAG_DONE)
491  & ~V4L2_BUF_FLAG_QUEUED;
492  i = (i + 1) % GSPCA_MAX_FRAMES;
493  atomic_set(&gspca_dev->fr_i, i);
494  wake_up_interruptible(&gspca_dev->wq); /* event = new frame */
495  PDEBUG(D_FRAM, "frame complete len:%d",
496  frame->v4l2_buf.bytesused);
497  gspca_dev->image = NULL;
498  gspca_dev->image_len = 0;
499  }
500 }
501 EXPORT_SYMBOL(gspca_frame_add);
502 
503 static int frame_alloc(struct gspca_dev *gspca_dev, struct file *file,
504  enum v4l2_memory memory, unsigned int count)
505 {
506  struct gspca_frame *frame;
507  unsigned int frsz;
508  int i;
509 
510  i = gspca_dev->curr_mode;
511  frsz = gspca_dev->cam.cam_mode[i].sizeimage;
512  PDEBUG(D_STREAM, "frame alloc frsz: %d", frsz);
513  frsz = PAGE_ALIGN(frsz);
514  if (count >= GSPCA_MAX_FRAMES)
515  count = GSPCA_MAX_FRAMES - 1;
516  gspca_dev->frbuf = vmalloc_32(frsz * count);
517  if (!gspca_dev->frbuf) {
518  pr_err("frame alloc failed\n");
519  return -ENOMEM;
520  }
521  gspca_dev->capt_file = file;
522  gspca_dev->memory = memory;
523  gspca_dev->frsz = frsz;
524  gspca_dev->nframes = count;
525  for (i = 0; i < count; i++) {
526  frame = &gspca_dev->frame[i];
527  frame->v4l2_buf.index = i;
528  frame->v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
529  frame->v4l2_buf.flags = 0;
530  frame->v4l2_buf.field = V4L2_FIELD_NONE;
531  frame->v4l2_buf.length = frsz;
532  frame->v4l2_buf.memory = memory;
533  frame->v4l2_buf.sequence = 0;
534  frame->data = gspca_dev->frbuf + i * frsz;
535  frame->v4l2_buf.m.offset = i * frsz;
536  }
537  atomic_set(&gspca_dev->fr_q, 0);
538  atomic_set(&gspca_dev->fr_i, 0);
539  gspca_dev->fr_o = 0;
540  return 0;
541 }
542 
543 static void frame_free(struct gspca_dev *gspca_dev)
544 {
545  int i;
546 
547  PDEBUG(D_STREAM, "frame free");
548  if (gspca_dev->frbuf != NULL) {
549  vfree(gspca_dev->frbuf);
550  gspca_dev->frbuf = NULL;
551  for (i = 0; i < gspca_dev->nframes; i++)
552  gspca_dev->frame[i].data = NULL;
553  }
554  gspca_dev->nframes = 0;
555  gspca_dev->frsz = 0;
556  gspca_dev->capt_file = NULL;
557  gspca_dev->memory = GSPCA_MEMORY_NO;
558 }
559 
560 static void destroy_urbs(struct gspca_dev *gspca_dev)
561 {
562  struct urb *urb;
563  unsigned int i;
564 
565  PDEBUG(D_STREAM, "kill transfer");
566  for (i = 0; i < MAX_NURBS; i++) {
567  urb = gspca_dev->urb[i];
568  if (urb == NULL)
569  break;
570 
571  gspca_dev->urb[i] = NULL;
572  usb_kill_urb(urb);
573  if (urb->transfer_buffer != NULL)
574  usb_free_coherent(gspca_dev->dev,
575  urb->transfer_buffer_length,
576  urb->transfer_buffer,
577  urb->transfer_dma);
578  usb_free_urb(urb);
579  }
580 }
581 
582 static int gspca_set_alt0(struct gspca_dev *gspca_dev)
583 {
584  int ret;
585 
586  if (gspca_dev->alt == 0)
587  return 0;
588  ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 0);
589  if (ret < 0)
590  pr_err("set alt 0 err %d\n", ret);
591  return ret;
592 }
593 
594 /* Note: both the queue and the usb locks should be held when calling this */
595 static void gspca_stream_off(struct gspca_dev *gspca_dev)
596 {
597  gspca_dev->streaming = 0;
598  gspca_dev->usb_err = 0;
599  if (gspca_dev->sd_desc->stopN)
600  gspca_dev->sd_desc->stopN(gspca_dev);
601  destroy_urbs(gspca_dev);
602  gspca_input_destroy_urb(gspca_dev);
603  gspca_set_alt0(gspca_dev);
604  gspca_input_create_urb(gspca_dev);
605  if (gspca_dev->sd_desc->stop0)
606  gspca_dev->sd_desc->stop0(gspca_dev);
607  PDEBUG(D_STREAM, "stream off OK");
608 }
609 
610 /*
611  * look for an input transfer endpoint in an alternate setting
612  */
613 static struct usb_host_endpoint *alt_xfer(struct usb_host_interface *alt,
614  int xfer)
615 {
616  struct usb_host_endpoint *ep;
617  int i, attr;
618 
619  for (i = 0; i < alt->desc.bNumEndpoints; i++) {
620  ep = &alt->endpoint[i];
621  attr = ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
622  if (attr == xfer
623  && ep->desc.wMaxPacketSize != 0
624  && usb_endpoint_dir_in(&ep->desc))
625  return ep;
626  }
627  return NULL;
628 }
629 
630 /* compute the minimum bandwidth for the current transfer */
631 static u32 which_bandwidth(struct gspca_dev *gspca_dev)
632 {
633  u32 bandwidth;
634  int i;
635 
636  /* get the (max) image size */
637  i = gspca_dev->curr_mode;
638  bandwidth = gspca_dev->cam.cam_mode[i].sizeimage;
639 
640  /* if the image is compressed, estimate its mean size */
641  if (!gspca_dev->cam.needs_full_bandwidth &&
642  bandwidth < gspca_dev->cam.cam_mode[i].width *
643  gspca_dev->cam.cam_mode[i].height)
644  bandwidth = bandwidth * 3 / 8; /* 0.375 */
645 
646  /* estimate the frame rate */
647  if (gspca_dev->sd_desc->get_streamparm) {
648  struct v4l2_streamparm parm;
649 
650  gspca_dev->sd_desc->get_streamparm(gspca_dev, &parm);
651  bandwidth *= parm.parm.capture.timeperframe.denominator;
652  bandwidth /= parm.parm.capture.timeperframe.numerator;
653  } else {
654 
655  /* don't hope more than 15 fps with USB 1.1 and
656  * image resolution >= 640x480 */
657  if (gspca_dev->width >= 640
658  && gspca_dev->dev->speed == USB_SPEED_FULL)
659  bandwidth *= 15; /* 15 fps */
660  else
661  bandwidth *= 30; /* 30 fps */
662  }
663 
664  PDEBUG(D_STREAM, "min bandwidth: %d", bandwidth);
665  return bandwidth;
666 }
667 
668 /* endpoint table */
669 #define MAX_ALT 16
670 struct ep_tb_s {
671  u32 alt;
672  u32 bandwidth;
673 };
674 
675 /*
676  * build the table of the endpoints
677  * and compute the minimum bandwidth for the image transfer
678  */
679 static int build_isoc_ep_tb(struct gspca_dev *gspca_dev,
680  struct usb_interface *intf,
681  struct ep_tb_s *ep_tb)
682 {
683  struct usb_host_endpoint *ep;
684  int i, j, nbalt, psize, found;
685  u32 bandwidth, last_bw;
686 
687  nbalt = intf->num_altsetting;
688  if (nbalt > MAX_ALT)
689  nbalt = MAX_ALT; /* fixme: should warn */
690 
691  /* build the endpoint table */
692  i = 0;
693  last_bw = 0;
694  for (;;) {
695  ep_tb->bandwidth = 2000 * 2000 * 120;
696  found = 0;
697  for (j = 0; j < nbalt; j++) {
698  ep = alt_xfer(&intf->altsetting[j],
699  USB_ENDPOINT_XFER_ISOC);
700  if (ep == NULL)
701  continue;
702  if (ep->desc.bInterval == 0) {
703  pr_err("alt %d iso endp with 0 interval\n", j);
704  continue;
705  }
706  psize = le16_to_cpu(ep->desc.wMaxPacketSize);
707  psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
708  bandwidth = psize * 1000;
709  if (gspca_dev->dev->speed == USB_SPEED_HIGH
710  || gspca_dev->dev->speed == USB_SPEED_SUPER)
711  bandwidth *= 8;
712  bandwidth /= 1 << (ep->desc.bInterval - 1);
713  if (bandwidth <= last_bw)
714  continue;
715  if (bandwidth < ep_tb->bandwidth) {
716  ep_tb->bandwidth = bandwidth;
717  ep_tb->alt = j;
718  found = 1;
719  }
720  }
721  if (!found)
722  break;
723  PDEBUG(D_STREAM, "alt %d bandwidth %d",
724  ep_tb->alt, ep_tb->bandwidth);
725  last_bw = ep_tb->bandwidth;
726  i++;
727  ep_tb++;
728  }
729 
730  /*
731  * If the camera:
732  * has a usb audio class interface (a built in usb mic); and
733  * is a usb 1 full speed device; and
734  * uses the max full speed iso bandwidth; and
735  * and has more than 1 alt setting
736  * then skip the highest alt setting to spare bandwidth for the mic
737  */
738  if (gspca_dev->audio &&
739  gspca_dev->dev->speed == USB_SPEED_FULL &&
740  last_bw >= 1000000 &&
741  i > 1) {
742  PDEBUG(D_STREAM, "dev has usb audio, skipping highest alt");
743  i--;
744  ep_tb--;
745  }
746 
747  /* get the requested bandwidth and start at the highest atlsetting */
748  bandwidth = which_bandwidth(gspca_dev);
749  ep_tb--;
750  while (i > 1) {
751  ep_tb--;
752  if (ep_tb->bandwidth < bandwidth)
753  break;
754  i--;
755  }
756  return i;
757 }
758 
759 /*
760  * create the URBs for image transfer
761  */
762 static int create_urbs(struct gspca_dev *gspca_dev,
763  struct usb_host_endpoint *ep)
764 {
765  struct urb *urb;
766  int n, nurbs, i, psize, npkt, bsize;
767 
768  /* calculate the packet size and the number of packets */
769  psize = le16_to_cpu(ep->desc.wMaxPacketSize);
770 
771  if (!gspca_dev->cam.bulk) { /* isoc */
772 
773  /* See paragraph 5.9 / table 5-11 of the usb 2.0 spec. */
774  if (gspca_dev->pkt_size == 0)
775  psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3));
776  else
777  psize = gspca_dev->pkt_size;
778  npkt = gspca_dev->cam.npkt;
779  if (npkt == 0)
780  npkt = 32; /* default value */
781  bsize = psize * npkt;
782  PDEBUG(D_STREAM,
783  "isoc %d pkts size %d = bsize:%d",
784  npkt, psize, bsize);
785  nurbs = DEF_NURBS;
786  } else { /* bulk */
787  npkt = 0;
788  bsize = gspca_dev->cam.bulk_size;
789  if (bsize == 0)
790  bsize = psize;
791  PDEBUG(D_STREAM, "bulk bsize:%d", bsize);
792  if (gspca_dev->cam.bulk_nurbs != 0)
793  nurbs = gspca_dev->cam.bulk_nurbs;
794  else
795  nurbs = 1;
796  }
797 
798  for (n = 0; n < nurbs; n++) {
799  urb = usb_alloc_urb(npkt, GFP_KERNEL);
800  if (!urb) {
801  pr_err("usb_alloc_urb failed\n");
802  return -ENOMEM;
803  }
804  gspca_dev->urb[n] = urb;
805  urb->transfer_buffer = usb_alloc_coherent(gspca_dev->dev,
806  bsize,
807  GFP_KERNEL,
808  &urb->transfer_dma);
809 
810  if (urb->transfer_buffer == NULL) {
811  pr_err("usb_alloc_coherent failed\n");
812  return -ENOMEM;
813  }
814  urb->dev = gspca_dev->dev;
815  urb->context = gspca_dev;
816  urb->transfer_buffer_length = bsize;
817  if (npkt != 0) { /* ISOC */
818  urb->pipe = usb_rcvisocpipe(gspca_dev->dev,
819  ep->desc.bEndpointAddress);
820  urb->transfer_flags = URB_ISO_ASAP
821  | URB_NO_TRANSFER_DMA_MAP;
822  urb->interval = 1 << (ep->desc.bInterval - 1);
823  urb->complete = isoc_irq;
824  urb->number_of_packets = npkt;
825  for (i = 0; i < npkt; i++) {
826  urb->iso_frame_desc[i].length = psize;
827  urb->iso_frame_desc[i].offset = psize * i;
828  }
829  } else { /* bulk */
830  urb->pipe = usb_rcvbulkpipe(gspca_dev->dev,
831  ep->desc.bEndpointAddress);
832  urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
833  urb->complete = bulk_irq;
834  }
835  }
836  return 0;
837 }
838 
839 /*
840  * start the USB transfer
841  */
842 static int gspca_init_transfer(struct gspca_dev *gspca_dev)
843 {
844  struct usb_interface *intf;
845  struct usb_host_endpoint *ep;
846  struct urb *urb;
847  struct ep_tb_s ep_tb[MAX_ALT];
848  int n, ret, xfer, alt, alt_idx;
849 
850  /* reset the streaming variables */
851  gspca_dev->image = NULL;
852  gspca_dev->image_len = 0;
853  gspca_dev->last_packet_type = DISCARD_PACKET;
854  gspca_dev->sequence = 0;
855 
856  gspca_dev->usb_err = 0;
857 
858  /* do the specific subdriver stuff before endpoint selection */
859  intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface);
860  gspca_dev->alt = gspca_dev->cam.bulk ? intf->num_altsetting : 0;
861  if (gspca_dev->sd_desc->isoc_init) {
862  ret = gspca_dev->sd_desc->isoc_init(gspca_dev);
863  if (ret < 0)
864  return ret;
865  }
866  xfer = gspca_dev->cam.bulk ? USB_ENDPOINT_XFER_BULK
867  : USB_ENDPOINT_XFER_ISOC;
868 
869  /* if bulk or the subdriver forced an altsetting, get the endpoint */
870  if (gspca_dev->alt != 0) {
871  gspca_dev->alt--; /* (previous version compatibility) */
872  ep = alt_xfer(&intf->altsetting[gspca_dev->alt], xfer);
873  if (ep == NULL) {
874  pr_err("bad altsetting %d\n", gspca_dev->alt);
875  return -EIO;
876  }
877  ep_tb[0].alt = gspca_dev->alt;
878  alt_idx = 1;
879  } else {
880 
881  /* else, compute the minimum bandwidth
882  * and build the endpoint table */
883  alt_idx = build_isoc_ep_tb(gspca_dev, intf, ep_tb);
884  if (alt_idx <= 0) {
885  pr_err("no transfer endpoint found\n");
886  return -EIO;
887  }
888  }
889 
890  /* set the highest alternate setting and
891  * loop until urb submit succeeds */
892  gspca_input_destroy_urb(gspca_dev);
893 
894  gspca_dev->alt = ep_tb[--alt_idx].alt;
895  alt = -1;
896  for (;;) {
897  if (alt != gspca_dev->alt) {
898  alt = gspca_dev->alt;
899  if (intf->num_altsetting > 1) {
900  ret = usb_set_interface(gspca_dev->dev,
901  gspca_dev->iface,
902  alt);
903  if (ret < 0) {
904  if (ret == -ENOSPC)
905  goto retry; /*fixme: ugly*/
906  pr_err("set alt %d err %d\n", alt, ret);
907  goto out;
908  }
909  }
910  }
911  if (!gspca_dev->cam.no_urb_create) {
912  PDEBUG(D_STREAM, "init transfer alt %d", alt);
913  ret = create_urbs(gspca_dev,
914  alt_xfer(&intf->altsetting[alt], xfer));
915  if (ret < 0) {
916  destroy_urbs(gspca_dev);
917  goto out;
918  }
919  }
920 
921  /* clear the bulk endpoint */
922  if (gspca_dev->cam.bulk)
923  usb_clear_halt(gspca_dev->dev,
924  gspca_dev->urb[0]->pipe);
925 
926  /* start the cam */
927  ret = gspca_dev->sd_desc->start(gspca_dev);
928  if (ret < 0) {
929  destroy_urbs(gspca_dev);
930  goto out;
931  }
932  gspca_dev->streaming = 1;
933  v4l2_ctrl_handler_setup(gspca_dev->vdev.ctrl_handler);
934 
935  /* some bulk transfers are started by the subdriver */
936  if (gspca_dev->cam.bulk && gspca_dev->cam.bulk_nurbs == 0)
937  break;
938 
939  /* submit the URBs */
940  for (n = 0; n < MAX_NURBS; n++) {
941  urb = gspca_dev->urb[n];
942  if (urb == NULL)
943  break;
944  ret = usb_submit_urb(urb, GFP_KERNEL);
945  if (ret < 0)
946  break;
947  }
948  if (ret >= 0)
949  break; /* transfer is started */
950 
951  /* something when wrong
952  * stop the webcam and free the transfer resources */
953  gspca_stream_off(gspca_dev);
954  if (ret != -ENOSPC) {
955  pr_err("usb_submit_urb alt %d err %d\n",
956  gspca_dev->alt, ret);
957  goto out;
958  }
959 
960  /* the bandwidth is not wide enough
961  * negotiate or try a lower alternate setting */
962 retry:
963  PDEBUG(D_ERR|D_STREAM,
964  "alt %d - bandwidth not wide enough - trying again",
965  alt);
966  msleep(20); /* wait for kill complete */
967  if (gspca_dev->sd_desc->isoc_nego) {
968  ret = gspca_dev->sd_desc->isoc_nego(gspca_dev);
969  if (ret < 0)
970  goto out;
971  } else {
972  if (alt_idx <= 0) {
973  pr_err("no transfer endpoint found\n");
974  ret = -EIO;
975  goto out;
976  }
977  gspca_dev->alt = ep_tb[--alt_idx].alt;
978  }
979  }
980 out:
981  gspca_input_create_urb(gspca_dev);
982  return ret;
983 }
984 
985 static void gspca_set_default_mode(struct gspca_dev *gspca_dev)
986 {
987  struct gspca_ctrl *ctrl;
988  int i;
989 
990  i = gspca_dev->cam.nmodes - 1; /* take the highest mode */
991  gspca_dev->curr_mode = i;
992  gspca_dev->width = gspca_dev->cam.cam_mode[i].width;
993  gspca_dev->height = gspca_dev->cam.cam_mode[i].height;
994  gspca_dev->pixfmt = gspca_dev->cam.cam_mode[i].pixelformat;
995 
996  /* set the current control values to their default values
997  * which may have changed in sd_init() */
998  /* does nothing if ctrl_handler == NULL */
999  v4l2_ctrl_handler_setup(gspca_dev->vdev.ctrl_handler);
1000  ctrl = gspca_dev->cam.ctrls;
1001  if (ctrl != NULL) {
1002  for (i = 0;
1003  i < gspca_dev->sd_desc->nctrls;
1004  i++, ctrl++)
1005  ctrl->val = ctrl->def;
1006  }
1007 }
1008 
1009 static int wxh_to_mode(struct gspca_dev *gspca_dev,
1010  int width, int height)
1011 {
1012  int i;
1013 
1014  for (i = gspca_dev->cam.nmodes; --i > 0; ) {
1015  if (width >= gspca_dev->cam.cam_mode[i].width
1016  && height >= gspca_dev->cam.cam_mode[i].height)
1017  break;
1018  }
1019  return i;
1020 }
1021 
1022 /*
1023  * search a mode with the right pixel format
1024  */
1025 static int gspca_get_mode(struct gspca_dev *gspca_dev,
1026  int mode,
1027  int pixfmt)
1028 {
1029  int modeU, modeD;
1030 
1031  modeU = modeD = mode;
1032  while ((modeU < gspca_dev->cam.nmodes) || modeD >= 0) {
1033  if (--modeD >= 0) {
1034  if (gspca_dev->cam.cam_mode[modeD].pixelformat
1035  == pixfmt)
1036  return modeD;
1037  }
1038  if (++modeU < gspca_dev->cam.nmodes) {
1039  if (gspca_dev->cam.cam_mode[modeU].pixelformat
1040  == pixfmt)
1041  return modeU;
1042  }
1043  }
1044  return -EINVAL;
1045 }
1046 
1047 #ifdef CONFIG_VIDEO_ADV_DEBUG
1048 static int vidioc_g_register(struct file *file, void *priv,
1049  struct v4l2_dbg_register *reg)
1050 {
1051  struct gspca_dev *gspca_dev = video_drvdata(file);
1052 
1053  gspca_dev->usb_err = 0;
1054  return gspca_dev->sd_desc->get_register(gspca_dev, reg);
1055 }
1056 
1057 static int vidioc_s_register(struct file *file, void *priv,
1058  struct v4l2_dbg_register *reg)
1059 {
1060  struct gspca_dev *gspca_dev = video_drvdata(file);
1061 
1062  gspca_dev->usb_err = 0;
1063  return gspca_dev->sd_desc->set_register(gspca_dev, reg);
1064 }
1065 #endif
1066 
1067 static int vidioc_g_chip_ident(struct file *file, void *priv,
1068  struct v4l2_dbg_chip_ident *chip)
1069 {
1070  struct gspca_dev *gspca_dev = video_drvdata(file);
1071 
1072  gspca_dev->usb_err = 0;
1073  return gspca_dev->sd_desc->get_chip_ident(gspca_dev, chip);
1074 }
1075 
1076 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
1077  struct v4l2_fmtdesc *fmtdesc)
1078 {
1079  struct gspca_dev *gspca_dev = video_drvdata(file);
1080  int i, j, index;
1081  __u32 fmt_tb[8];
1082 
1083  /* give an index to each format */
1084  index = 0;
1085  j = 0;
1086  for (i = gspca_dev->cam.nmodes; --i >= 0; ) {
1087  fmt_tb[index] = gspca_dev->cam.cam_mode[i].pixelformat;
1088  j = 0;
1089  for (;;) {
1090  if (fmt_tb[j] == fmt_tb[index])
1091  break;
1092  j++;
1093  }
1094  if (j == index) {
1095  if (fmtdesc->index == index)
1096  break; /* new format */
1097  index++;
1098  if (index >= ARRAY_SIZE(fmt_tb))
1099  return -EINVAL;
1100  }
1101  }
1102  if (i < 0)
1103  return -EINVAL; /* no more format */
1104 
1105  fmtdesc->pixelformat = fmt_tb[index];
1106  if (gspca_dev->cam.cam_mode[i].sizeimage <
1107  gspca_dev->cam.cam_mode[i].width *
1108  gspca_dev->cam.cam_mode[i].height)
1109  fmtdesc->flags = V4L2_FMT_FLAG_COMPRESSED;
1110  fmtdesc->description[0] = fmtdesc->pixelformat & 0xff;
1111  fmtdesc->description[1] = (fmtdesc->pixelformat >> 8) & 0xff;
1112  fmtdesc->description[2] = (fmtdesc->pixelformat >> 16) & 0xff;
1113  fmtdesc->description[3] = fmtdesc->pixelformat >> 24;
1114  fmtdesc->description[4] = '\0';
1115  return 0;
1116 }
1117 
1118 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1119  struct v4l2_format *fmt)
1120 {
1121  struct gspca_dev *gspca_dev = video_drvdata(file);
1122  int mode;
1123 
1124  mode = gspca_dev->curr_mode;
1125  fmt->fmt.pix = gspca_dev->cam.cam_mode[mode];
1126  /* some drivers use priv internally, zero it before giving it to
1127  userspace */
1128  fmt->fmt.pix.priv = 0;
1129  return 0;
1130 }
1131 
1132 static int try_fmt_vid_cap(struct gspca_dev *gspca_dev,
1133  struct v4l2_format *fmt)
1134 {
1135  int w, h, mode, mode2;
1136 
1137  w = fmt->fmt.pix.width;
1138  h = fmt->fmt.pix.height;
1139 
1140 #ifdef GSPCA_DEBUG
1141  if (gspca_debug & D_CONF)
1142  PDEBUG_MODE("try fmt cap", fmt->fmt.pix.pixelformat, w, h);
1143 #endif
1144  /* search the closest mode for width and height */
1145  mode = wxh_to_mode(gspca_dev, w, h);
1146 
1147  /* OK if right palette */
1148  if (gspca_dev->cam.cam_mode[mode].pixelformat
1149  != fmt->fmt.pix.pixelformat) {
1150 
1151  /* else, search the closest mode with the same pixel format */
1152  mode2 = gspca_get_mode(gspca_dev, mode,
1153  fmt->fmt.pix.pixelformat);
1154  if (mode2 >= 0)
1155  mode = mode2;
1156 /* else
1157  ; * no chance, return this mode */
1158  }
1159  fmt->fmt.pix = gspca_dev->cam.cam_mode[mode];
1160  /* some drivers use priv internally, zero it before giving it to
1161  userspace */
1162  fmt->fmt.pix.priv = 0;
1163  return mode; /* used when s_fmt */
1164 }
1165 
1166 static int vidioc_try_fmt_vid_cap(struct file *file,
1167  void *priv,
1168  struct v4l2_format *fmt)
1169 {
1170  struct gspca_dev *gspca_dev = video_drvdata(file);
1171  int ret;
1172 
1173  ret = try_fmt_vid_cap(gspca_dev, fmt);
1174  if (ret < 0)
1175  return ret;
1176  return 0;
1177 }
1178 
1179 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1180  struct v4l2_format *fmt)
1181 {
1182  struct gspca_dev *gspca_dev = video_drvdata(file);
1183  int ret;
1184 
1185  if (mutex_lock_interruptible(&gspca_dev->queue_lock))
1186  return -ERESTARTSYS;
1187 
1188  ret = try_fmt_vid_cap(gspca_dev, fmt);
1189  if (ret < 0)
1190  goto out;
1191 
1192  if (gspca_dev->nframes != 0
1193  && fmt->fmt.pix.sizeimage > gspca_dev->frsz) {
1194  ret = -EINVAL;
1195  goto out;
1196  }
1197 
1198  if (ret == gspca_dev->curr_mode) {
1199  ret = 0;
1200  goto out; /* same mode */
1201  }
1202 
1203  if (gspca_dev->streaming) {
1204  ret = -EBUSY;
1205  goto out;
1206  }
1207  gspca_dev->width = fmt->fmt.pix.width;
1208  gspca_dev->height = fmt->fmt.pix.height;
1209  gspca_dev->pixfmt = fmt->fmt.pix.pixelformat;
1210  gspca_dev->curr_mode = ret;
1211 
1212  ret = 0;
1213 out:
1214  mutex_unlock(&gspca_dev->queue_lock);
1215  return ret;
1216 }
1217 
1218 static int vidioc_enum_framesizes(struct file *file, void *priv,
1219  struct v4l2_frmsizeenum *fsize)
1220 {
1221  struct gspca_dev *gspca_dev = video_drvdata(file);
1222  int i;
1223  __u32 index = 0;
1224 
1225  for (i = 0; i < gspca_dev->cam.nmodes; i++) {
1226  if (fsize->pixel_format !=
1227  gspca_dev->cam.cam_mode[i].pixelformat)
1228  continue;
1229 
1230  if (fsize->index == index) {
1231  fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1232  fsize->discrete.width =
1233  gspca_dev->cam.cam_mode[i].width;
1234  fsize->discrete.height =
1235  gspca_dev->cam.cam_mode[i].height;
1236  return 0;
1237  }
1238  index++;
1239  }
1240 
1241  return -EINVAL;
1242 }
1243 
1244 static int vidioc_enum_frameintervals(struct file *filp, void *priv,
1245  struct v4l2_frmivalenum *fival)
1246 {
1247  struct gspca_dev *gspca_dev = video_drvdata(filp);
1248  int mode = wxh_to_mode(gspca_dev, fival->width, fival->height);
1249  __u32 i;
1250 
1251  if (gspca_dev->cam.mode_framerates == NULL ||
1252  gspca_dev->cam.mode_framerates[mode].nrates == 0)
1253  return -EINVAL;
1254 
1255  if (fival->pixel_format !=
1256  gspca_dev->cam.cam_mode[mode].pixelformat)
1257  return -EINVAL;
1258 
1259  for (i = 0; i < gspca_dev->cam.mode_framerates[mode].nrates; i++) {
1260  if (fival->index == i) {
1261  fival->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1262  fival->discrete.numerator = 1;
1263  fival->discrete.denominator =
1264  gspca_dev->cam.mode_framerates[mode].rates[i];
1265  return 0;
1266  }
1267  }
1268 
1269  return -EINVAL;
1270 }
1271 
1272 static void gspca_release(struct v4l2_device *v4l2_device)
1273 {
1274  struct gspca_dev *gspca_dev =
1275  container_of(v4l2_device, struct gspca_dev, v4l2_dev);
1276 
1277  v4l2_ctrl_handler_free(gspca_dev->vdev.ctrl_handler);
1278  v4l2_device_unregister(&gspca_dev->v4l2_dev);
1279  kfree(gspca_dev->usb_buf);
1280  kfree(gspca_dev);
1281 }
1282 
1283 static int dev_open(struct file *file)
1284 {
1285  struct gspca_dev *gspca_dev = video_drvdata(file);
1286 
1287  PDEBUG(D_STREAM, "[%s] open", current->comm);
1288 
1289  /* protect the subdriver against rmmod */
1290  if (!try_module_get(gspca_dev->module))
1291  return -ENODEV;
1292 
1293 #ifdef GSPCA_DEBUG
1294  /* activate the v4l2 debug */
1295  if (gspca_debug & D_V4L2)
1296  gspca_dev->vdev.debug |= V4L2_DEBUG_IOCTL
1297  | V4L2_DEBUG_IOCTL_ARG;
1298  else
1299  gspca_dev->vdev.debug &= ~(V4L2_DEBUG_IOCTL
1300  | V4L2_DEBUG_IOCTL_ARG);
1301 #endif
1302  return v4l2_fh_open(file);
1303 }
1304 
1305 static int dev_close(struct file *file)
1306 {
1307  struct gspca_dev *gspca_dev = video_drvdata(file);
1308 
1309  PDEBUG(D_STREAM, "[%s] close", current->comm);
1310 
1311  /* Needed for gspca_stream_off, always lock before queue_lock! */
1312  if (mutex_lock_interruptible(&gspca_dev->usb_lock))
1313  return -ERESTARTSYS;
1314 
1315  if (mutex_lock_interruptible(&gspca_dev->queue_lock)) {
1316  mutex_unlock(&gspca_dev->usb_lock);
1317  return -ERESTARTSYS;
1318  }
1319 
1320  /* if the file did the capture, free the streaming resources */
1321  if (gspca_dev->capt_file == file) {
1322  if (gspca_dev->streaming)
1323  gspca_stream_off(gspca_dev);
1324  frame_free(gspca_dev);
1325  }
1326  module_put(gspca_dev->module);
1327  mutex_unlock(&gspca_dev->queue_lock);
1328  mutex_unlock(&gspca_dev->usb_lock);
1329 
1330  PDEBUG(D_STREAM, "close done");
1331 
1332  return v4l2_fh_release(file);
1333 }
1334 
1335 static int vidioc_querycap(struct file *file, void *priv,
1336  struct v4l2_capability *cap)
1337 {
1338  struct gspca_dev *gspca_dev = video_drvdata(file);
1339 
1340  strlcpy((char *) cap->driver, gspca_dev->sd_desc->name,
1341  sizeof cap->driver);
1342  if (gspca_dev->dev->product != NULL) {
1343  strlcpy((char *) cap->card, gspca_dev->dev->product,
1344  sizeof cap->card);
1345  } else {
1346  snprintf((char *) cap->card, sizeof cap->card,
1347  "USB Camera (%04x:%04x)",
1348  le16_to_cpu(gspca_dev->dev->descriptor.idVendor),
1349  le16_to_cpu(gspca_dev->dev->descriptor.idProduct));
1350  }
1351  usb_make_path(gspca_dev->dev, (char *) cap->bus_info,
1352  sizeof(cap->bus_info));
1353  cap->device_caps = V4L2_CAP_VIDEO_CAPTURE
1354  | V4L2_CAP_STREAMING
1355  | V4L2_CAP_READWRITE;
1356  cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1357  return 0;
1358 }
1359 
1360 static int get_ctrl(struct gspca_dev *gspca_dev,
1361  int id)
1362 {
1363  const struct ctrl *ctrls;
1364  int i;
1365 
1366  for (i = 0, ctrls = gspca_dev->sd_desc->ctrls;
1367  i < gspca_dev->sd_desc->nctrls;
1368  i++, ctrls++) {
1369  if (gspca_dev->ctrl_dis & (1 << i))
1370  continue;
1371  if (id == ctrls->qctrl.id)
1372  return i;
1373  }
1374  return -1;
1375 }
1376 
1377 static int vidioc_queryctrl(struct file *file, void *priv,
1378  struct v4l2_queryctrl *q_ctrl)
1379 {
1380  struct gspca_dev *gspca_dev = video_drvdata(file);
1381  const struct ctrl *ctrls;
1382  struct gspca_ctrl *gspca_ctrl;
1383  int i, idx;
1384  u32 id;
1385 
1386  id = q_ctrl->id;
1387  if (id & V4L2_CTRL_FLAG_NEXT_CTRL) {
1388  id &= V4L2_CTRL_ID_MASK;
1389  id++;
1390  idx = -1;
1391  for (i = 0; i < gspca_dev->sd_desc->nctrls; i++) {
1392  if (gspca_dev->ctrl_dis & (1 << i))
1393  continue;
1394  if (gspca_dev->sd_desc->ctrls[i].qctrl.id < id)
1395  continue;
1396  if (idx >= 0
1397  && gspca_dev->sd_desc->ctrls[i].qctrl.id
1398  > gspca_dev->sd_desc->ctrls[idx].qctrl.id)
1399  continue;
1400  idx = i;
1401  }
1402  } else {
1403  idx = get_ctrl(gspca_dev, id);
1404  }
1405  if (idx < 0)
1406  return -EINVAL;
1407  ctrls = &gspca_dev->sd_desc->ctrls[idx];
1408  memcpy(q_ctrl, &ctrls->qctrl, sizeof *q_ctrl);
1409  if (gspca_dev->cam.ctrls != NULL) {
1410  gspca_ctrl = &gspca_dev->cam.ctrls[idx];
1411  q_ctrl->default_value = gspca_ctrl->def;
1412  q_ctrl->minimum = gspca_ctrl->min;
1413  q_ctrl->maximum = gspca_ctrl->max;
1414  }
1415  if (gspca_dev->ctrl_inac & (1 << idx))
1416  q_ctrl->flags |= V4L2_CTRL_FLAG_INACTIVE;
1417  return 0;
1418 }
1419 
1420 static int vidioc_s_ctrl(struct file *file, void *priv,
1421  struct v4l2_control *ctrl)
1422 {
1423  struct gspca_dev *gspca_dev = video_drvdata(file);
1424  const struct ctrl *ctrls;
1425  struct gspca_ctrl *gspca_ctrl;
1426  int idx;
1427 
1428  idx = get_ctrl(gspca_dev, ctrl->id);
1429  if (idx < 0)
1430  return -EINVAL;
1431  if (gspca_dev->ctrl_inac & (1 << idx))
1432  return -EINVAL;
1433  ctrls = &gspca_dev->sd_desc->ctrls[idx];
1434  if (gspca_dev->cam.ctrls != NULL) {
1435  gspca_ctrl = &gspca_dev->cam.ctrls[idx];
1436  if (ctrl->value < gspca_ctrl->min
1437  || ctrl->value > gspca_ctrl->max)
1438  return -ERANGE;
1439  } else {
1440  gspca_ctrl = NULL;
1441  if (ctrl->value < ctrls->qctrl.minimum
1442  || ctrl->value > ctrls->qctrl.maximum)
1443  return -ERANGE;
1444  }
1445  PDEBUG(D_CONF, "set ctrl [%08x] = %d", ctrl->id, ctrl->value);
1446  gspca_dev->usb_err = 0;
1447  if (ctrls->set != NULL)
1448  return ctrls->set(gspca_dev, ctrl->value);
1449  if (gspca_ctrl != NULL) {
1450  gspca_ctrl->val = ctrl->value;
1451  if (ctrls->set_control != NULL
1452  && gspca_dev->streaming)
1453  ctrls->set_control(gspca_dev);
1454  }
1455  return gspca_dev->usb_err;
1456 }
1457 
1458 static int vidioc_g_ctrl(struct file *file, void *priv,
1459  struct v4l2_control *ctrl)
1460 {
1461  struct gspca_dev *gspca_dev = video_drvdata(file);
1462  const struct ctrl *ctrls;
1463  int idx;
1464 
1465  idx = get_ctrl(gspca_dev, ctrl->id);
1466  if (idx < 0)
1467  return -EINVAL;
1468  ctrls = &gspca_dev->sd_desc->ctrls[idx];
1469 
1470  gspca_dev->usb_err = 0;
1471  if (ctrls->get != NULL)
1472  return ctrls->get(gspca_dev, &ctrl->value);
1473  if (gspca_dev->cam.ctrls != NULL)
1474  ctrl->value = gspca_dev->cam.ctrls[idx].val;
1475  return 0;
1476 }
1477 
1478 static int vidioc_querymenu(struct file *file, void *priv,
1479  struct v4l2_querymenu *qmenu)
1480 {
1481  struct gspca_dev *gspca_dev = video_drvdata(file);
1482 
1483  if (!gspca_dev->sd_desc->querymenu)
1484  return -ENOTTY;
1485  return gspca_dev->sd_desc->querymenu(gspca_dev, qmenu);
1486 }
1487 
1488 static int vidioc_enum_input(struct file *file, void *priv,
1489  struct v4l2_input *input)
1490 {
1491  struct gspca_dev *gspca_dev = video_drvdata(file);
1492 
1493  if (input->index != 0)
1494  return -EINVAL;
1495  input->type = V4L2_INPUT_TYPE_CAMERA;
1496  input->status = gspca_dev->cam.input_flags;
1497  strlcpy(input->name, gspca_dev->sd_desc->name,
1498  sizeof input->name);
1499  return 0;
1500 }
1501 
1502 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1503 {
1504  *i = 0;
1505  return 0;
1506 }
1507 
1508 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1509 {
1510  if (i > 0)
1511  return -EINVAL;
1512  return (0);
1513 }
1514 
1515 static int vidioc_reqbufs(struct file *file, void *priv,
1516  struct v4l2_requestbuffers *rb)
1517 {
1518  struct gspca_dev *gspca_dev = video_drvdata(file);
1519  int i, ret = 0, streaming;
1520 
1521  i = rb->memory; /* (avoid compilation warning) */
1522  switch (i) {
1523  case GSPCA_MEMORY_READ: /* (internal call) */
1524  case V4L2_MEMORY_MMAP:
1525  case V4L2_MEMORY_USERPTR:
1526  break;
1527  default:
1528  return -EINVAL;
1529  }
1530  if (mutex_lock_interruptible(&gspca_dev->queue_lock))
1531  return -ERESTARTSYS;
1532 
1533  if (gspca_dev->memory != GSPCA_MEMORY_NO
1534  && gspca_dev->memory != GSPCA_MEMORY_READ
1535  && gspca_dev->memory != rb->memory) {
1536  ret = -EBUSY;
1537  goto out;
1538  }
1539 
1540  /* only one file may do the capture */
1541  if (gspca_dev->capt_file != NULL
1542  && gspca_dev->capt_file != file) {
1543  ret = -EBUSY;
1544  goto out;
1545  }
1546 
1547  /* if allocated, the buffers must not be mapped */
1548  for (i = 0; i < gspca_dev->nframes; i++) {
1549  if (gspca_dev->frame[i].vma_use_count) {
1550  ret = -EBUSY;
1551  goto out;
1552  }
1553  }
1554 
1555  /* stop streaming */
1556  streaming = gspca_dev->streaming;
1557  if (streaming) {
1558  gspca_stream_off(gspca_dev);
1559 
1560  /* Don't restart the stream when switching from read
1561  * to mmap mode */
1562  if (gspca_dev->memory == GSPCA_MEMORY_READ)
1563  streaming = 0;
1564  }
1565 
1566  /* free the previous allocated buffers, if any */
1567  if (gspca_dev->nframes != 0)
1568  frame_free(gspca_dev);
1569  if (rb->count == 0) /* unrequest */
1570  goto out;
1571  ret = frame_alloc(gspca_dev, file, rb->memory, rb->count);
1572  if (ret == 0) {
1573  rb->count = gspca_dev->nframes;
1574  if (streaming)
1575  ret = gspca_init_transfer(gspca_dev);
1576  }
1577 out:
1578  mutex_unlock(&gspca_dev->queue_lock);
1579  PDEBUG(D_STREAM, "reqbufs st:%d c:%d", ret, rb->count);
1580  return ret;
1581 }
1582 
1583 static int vidioc_querybuf(struct file *file, void *priv,
1584  struct v4l2_buffer *v4l2_buf)
1585 {
1586  struct gspca_dev *gspca_dev = video_drvdata(file);
1587  struct gspca_frame *frame;
1588 
1589  if (v4l2_buf->index < 0
1590  || v4l2_buf->index >= gspca_dev->nframes)
1591  return -EINVAL;
1592 
1593  frame = &gspca_dev->frame[v4l2_buf->index];
1594  memcpy(v4l2_buf, &frame->v4l2_buf, sizeof *v4l2_buf);
1595  return 0;
1596 }
1597 
1598 static int vidioc_streamon(struct file *file, void *priv,
1599  enum v4l2_buf_type buf_type)
1600 {
1601  struct gspca_dev *gspca_dev = video_drvdata(file);
1602  int ret;
1603 
1604  if (buf_type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1605  return -EINVAL;
1606  if (mutex_lock_interruptible(&gspca_dev->queue_lock))
1607  return -ERESTARTSYS;
1608 
1609  /* check the capture file */
1610  if (gspca_dev->capt_file != file) {
1611  ret = -EBUSY;
1612  goto out;
1613  }
1614 
1615  if (gspca_dev->nframes == 0
1616  || !(gspca_dev->frame[0].v4l2_buf.flags & V4L2_BUF_FLAG_QUEUED)) {
1617  ret = -EINVAL;
1618  goto out;
1619  }
1620  if (!gspca_dev->streaming) {
1621  ret = gspca_init_transfer(gspca_dev);
1622  if (ret < 0)
1623  goto out;
1624  }
1625 #ifdef GSPCA_DEBUG
1626  if (gspca_debug & D_STREAM) {
1627  PDEBUG_MODE("stream on OK",
1628  gspca_dev->pixfmt,
1629  gspca_dev->width,
1630  gspca_dev->height);
1631  }
1632 #endif
1633  ret = 0;
1634 out:
1635  mutex_unlock(&gspca_dev->queue_lock);
1636  return ret;
1637 }
1638 
1639 static int vidioc_streamoff(struct file *file, void *priv,
1640  enum v4l2_buf_type buf_type)
1641 {
1642  struct gspca_dev *gspca_dev = video_drvdata(file);
1643  int i, ret;
1644 
1645  if (buf_type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1646  return -EINVAL;
1647 
1648  if (mutex_lock_interruptible(&gspca_dev->queue_lock))
1649  return -ERESTARTSYS;
1650 
1651  if (!gspca_dev->streaming) {
1652  ret = 0;
1653  goto out;
1654  }
1655 
1656  /* check the capture file */
1657  if (gspca_dev->capt_file != file) {
1658  ret = -EBUSY;
1659  goto out;
1660  }
1661 
1662  /* stop streaming */
1663  gspca_stream_off(gspca_dev);
1664  /* In case another thread is waiting in dqbuf */
1665  wake_up_interruptible(&gspca_dev->wq);
1666 
1667  /* empty the transfer queues */
1668  for (i = 0; i < gspca_dev->nframes; i++)
1669  gspca_dev->frame[i].v4l2_buf.flags &= ~BUF_ALL_FLAGS;
1670  atomic_set(&gspca_dev->fr_q, 0);
1671  atomic_set(&gspca_dev->fr_i, 0);
1672  gspca_dev->fr_o = 0;
1673  ret = 0;
1674 out:
1675  mutex_unlock(&gspca_dev->queue_lock);
1676  return ret;
1677 }
1678 
1679 static int vidioc_g_jpegcomp(struct file *file, void *priv,
1680  struct v4l2_jpegcompression *jpegcomp)
1681 {
1682  struct gspca_dev *gspca_dev = video_drvdata(file);
1683 
1684  gspca_dev->usb_err = 0;
1685  return gspca_dev->sd_desc->get_jcomp(gspca_dev, jpegcomp);
1686 }
1687 
1688 static int vidioc_s_jpegcomp(struct file *file, void *priv,
1689  const struct v4l2_jpegcompression *jpegcomp)
1690 {
1691  struct gspca_dev *gspca_dev = video_drvdata(file);
1692 
1693  gspca_dev->usb_err = 0;
1694  return gspca_dev->sd_desc->set_jcomp(gspca_dev, jpegcomp);
1695 }
1696 
1697 static int vidioc_g_parm(struct file *filp, void *priv,
1698  struct v4l2_streamparm *parm)
1699 {
1700  struct gspca_dev *gspca_dev = video_drvdata(filp);
1701 
1702  parm->parm.capture.readbuffers = gspca_dev->nbufread;
1703 
1704  if (gspca_dev->sd_desc->get_streamparm) {
1705  gspca_dev->usb_err = 0;
1706  gspca_dev->sd_desc->get_streamparm(gspca_dev, parm);
1707  return gspca_dev->usb_err;
1708  }
1709  return 0;
1710 }
1711 
1712 static int vidioc_s_parm(struct file *filp, void *priv,
1713  struct v4l2_streamparm *parm)
1714 {
1715  struct gspca_dev *gspca_dev = video_drvdata(filp);
1716  int n;
1717 
1718  n = parm->parm.capture.readbuffers;
1719  if (n == 0 || n >= GSPCA_MAX_FRAMES)
1720  parm->parm.capture.readbuffers = gspca_dev->nbufread;
1721  else
1722  gspca_dev->nbufread = n;
1723 
1724  if (gspca_dev->sd_desc->set_streamparm) {
1725  gspca_dev->usb_err = 0;
1726  gspca_dev->sd_desc->set_streamparm(gspca_dev, parm);
1727  return gspca_dev->usb_err;
1728  }
1729 
1730  return 0;
1731 }
1732 
1733 static int dev_mmap(struct file *file, struct vm_area_struct *vma)
1734 {
1735  struct gspca_dev *gspca_dev = video_drvdata(file);
1736  struct gspca_frame *frame;
1737  struct page *page;
1738  unsigned long addr, start, size;
1739  int i, ret;
1740 
1741  start = vma->vm_start;
1742  size = vma->vm_end - vma->vm_start;
1743  PDEBUG(D_STREAM, "mmap start:%08x size:%d", (int) start, (int) size);
1744 
1745  if (mutex_lock_interruptible(&gspca_dev->queue_lock))
1746  return -ERESTARTSYS;
1747  if (gspca_dev->capt_file != file) {
1748  ret = -EINVAL;
1749  goto out;
1750  }
1751 
1752  frame = NULL;
1753  for (i = 0; i < gspca_dev->nframes; ++i) {
1754  if (gspca_dev->frame[i].v4l2_buf.memory != V4L2_MEMORY_MMAP) {
1755  PDEBUG(D_STREAM, "mmap bad memory type");
1756  break;
1757  }
1758  if ((gspca_dev->frame[i].v4l2_buf.m.offset >> PAGE_SHIFT)
1759  == vma->vm_pgoff) {
1760  frame = &gspca_dev->frame[i];
1761  break;
1762  }
1763  }
1764  if (frame == NULL) {
1765  PDEBUG(D_STREAM, "mmap no frame buffer found");
1766  ret = -EINVAL;
1767  goto out;
1768  }
1769  if (size != frame->v4l2_buf.length) {
1770  PDEBUG(D_STREAM, "mmap bad size");
1771  ret = -EINVAL;
1772  goto out;
1773  }
1774 
1775  /*
1776  * - VM_IO marks the area as being a mmaped region for I/O to a
1777  * device. It also prevents the region from being core dumped.
1778  */
1779  vma->vm_flags |= VM_IO;
1780 
1781  addr = (unsigned long) frame->data;
1782  while (size > 0) {
1783  page = vmalloc_to_page((void *) addr);
1784  ret = vm_insert_page(vma, start, page);
1785  if (ret < 0)
1786  goto out;
1787  start += PAGE_SIZE;
1788  addr += PAGE_SIZE;
1789  size -= PAGE_SIZE;
1790  }
1791 
1792  vma->vm_ops = &gspca_vm_ops;
1793  vma->vm_private_data = frame;
1794  gspca_vm_open(vma);
1795  ret = 0;
1796 out:
1797  mutex_unlock(&gspca_dev->queue_lock);
1798  return ret;
1799 }
1800 
1801 static int frame_ready_nolock(struct gspca_dev *gspca_dev, struct file *file,
1802  enum v4l2_memory memory)
1803 {
1804  if (!gspca_dev->present)
1805  return -ENODEV;
1806  if (gspca_dev->capt_file != file || gspca_dev->memory != memory ||
1807  !gspca_dev->streaming)
1808  return -EINVAL;
1809 
1810  /* check if a frame is ready */
1811  return gspca_dev->fr_o != atomic_read(&gspca_dev->fr_i);
1812 }
1813 
1814 static int frame_ready(struct gspca_dev *gspca_dev, struct file *file,
1815  enum v4l2_memory memory)
1816 {
1817  int ret;
1818 
1819  if (mutex_lock_interruptible(&gspca_dev->queue_lock))
1820  return -ERESTARTSYS;
1821  ret = frame_ready_nolock(gspca_dev, file, memory);
1822  mutex_unlock(&gspca_dev->queue_lock);
1823  return ret;
1824 }
1825 
1826 /*
1827  * dequeue a video buffer
1828  *
1829  * If nonblock_ing is false, block until a buffer is available.
1830  */
1831 static int vidioc_dqbuf(struct file *file, void *priv,
1832  struct v4l2_buffer *v4l2_buf)
1833 {
1834  struct gspca_dev *gspca_dev = video_drvdata(file);
1835  struct gspca_frame *frame;
1836  int i, j, ret;
1837 
1838  PDEBUG(D_FRAM, "dqbuf");
1839 
1840  if (mutex_lock_interruptible(&gspca_dev->queue_lock))
1841  return -ERESTARTSYS;
1842 
1843  for (;;) {
1844  ret = frame_ready_nolock(gspca_dev, file, v4l2_buf->memory);
1845  if (ret < 0)
1846  goto out;
1847  if (ret > 0)
1848  break;
1849 
1850  mutex_unlock(&gspca_dev->queue_lock);
1851 
1852  if (file->f_flags & O_NONBLOCK)
1853  return -EAGAIN;
1854 
1855  /* wait till a frame is ready */
1856  ret = wait_event_interruptible_timeout(gspca_dev->wq,
1857  frame_ready(gspca_dev, file, v4l2_buf->memory),
1858  msecs_to_jiffies(3000));
1859  if (ret < 0)
1860  return ret;
1861  if (ret == 0)
1862  return -EIO;
1863 
1864  if (mutex_lock_interruptible(&gspca_dev->queue_lock))
1865  return -ERESTARTSYS;
1866  }
1867 
1868  i = gspca_dev->fr_o;
1869  j = gspca_dev->fr_queue[i];
1870  frame = &gspca_dev->frame[j];
1871 
1872  gspca_dev->fr_o = (i + 1) % GSPCA_MAX_FRAMES;
1873 
1874  frame->v4l2_buf.flags &= ~V4L2_BUF_FLAG_DONE;
1875  memcpy(v4l2_buf, &frame->v4l2_buf, sizeof *v4l2_buf);
1876  PDEBUG(D_FRAM, "dqbuf %d", j);
1877  ret = 0;
1878 
1879  if (gspca_dev->memory == V4L2_MEMORY_USERPTR) {
1880  if (copy_to_user((__u8 __user *) frame->v4l2_buf.m.userptr,
1881  frame->data,
1882  frame->v4l2_buf.bytesused)) {
1883  PDEBUG(D_ERR|D_STREAM,
1884  "dqbuf cp to user failed");
1885  ret = -EFAULT;
1886  }
1887  }
1888 out:
1889  mutex_unlock(&gspca_dev->queue_lock);
1890 
1891  if (ret == 0 && gspca_dev->sd_desc->dq_callback) {
1892  mutex_lock(&gspca_dev->usb_lock);
1893  gspca_dev->usb_err = 0;
1894  if (gspca_dev->present)
1895  gspca_dev->sd_desc->dq_callback(gspca_dev);
1896  mutex_unlock(&gspca_dev->usb_lock);
1897  }
1898 
1899  return ret;
1900 }
1901 
1902 /*
1903  * queue a video buffer
1904  *
1905  * Attempting to queue a buffer that has already been
1906  * queued will return -EINVAL.
1907  */
1908 static int vidioc_qbuf(struct file *file, void *priv,
1909  struct v4l2_buffer *v4l2_buf)
1910 {
1911  struct gspca_dev *gspca_dev = video_drvdata(file);
1912  struct gspca_frame *frame;
1913  int i, index, ret;
1914 
1915  PDEBUG(D_FRAM, "qbuf %d", v4l2_buf->index);
1916 
1917  if (mutex_lock_interruptible(&gspca_dev->queue_lock))
1918  return -ERESTARTSYS;
1919 
1920  index = v4l2_buf->index;
1921  if ((unsigned) index >= gspca_dev->nframes) {
1922  PDEBUG(D_FRAM,
1923  "qbuf idx %d >= %d", index, gspca_dev->nframes);
1924  ret = -EINVAL;
1925  goto out;
1926  }
1927  if (v4l2_buf->memory != gspca_dev->memory) {
1928  PDEBUG(D_FRAM, "qbuf bad memory type");
1929  ret = -EINVAL;
1930  goto out;
1931  }
1932 
1933  frame = &gspca_dev->frame[index];
1934  if (frame->v4l2_buf.flags & BUF_ALL_FLAGS) {
1935  PDEBUG(D_FRAM, "qbuf bad state");
1936  ret = -EINVAL;
1937  goto out;
1938  }
1939 
1940  frame->v4l2_buf.flags |= V4L2_BUF_FLAG_QUEUED;
1941 
1942  if (frame->v4l2_buf.memory == V4L2_MEMORY_USERPTR) {
1943  frame->v4l2_buf.m.userptr = v4l2_buf->m.userptr;
1944  frame->v4l2_buf.length = v4l2_buf->length;
1945  }
1946 
1947  /* put the buffer in the 'queued' queue */
1948  i = atomic_read(&gspca_dev->fr_q);
1949  gspca_dev->fr_queue[i] = index;
1950  atomic_set(&gspca_dev->fr_q, (i + 1) % GSPCA_MAX_FRAMES);
1951 
1952  v4l2_buf->flags |= V4L2_BUF_FLAG_QUEUED;
1953  v4l2_buf->flags &= ~V4L2_BUF_FLAG_DONE;
1954  ret = 0;
1955 out:
1956  mutex_unlock(&gspca_dev->queue_lock);
1957  return ret;
1958 }
1959 
1960 /*
1961  * allocate the resources for read()
1962  */
1963 static int read_alloc(struct gspca_dev *gspca_dev,
1964  struct file *file)
1965 {
1966  struct v4l2_buffer v4l2_buf;
1967  int i, ret;
1968 
1969  PDEBUG(D_STREAM, "read alloc");
1970 
1971  if (mutex_lock_interruptible(&gspca_dev->usb_lock))
1972  return -ERESTARTSYS;
1973 
1974  if (gspca_dev->nframes == 0) {
1975  struct v4l2_requestbuffers rb;
1976 
1977  memset(&rb, 0, sizeof rb);
1978  rb.count = gspca_dev->nbufread;
1979  rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1980  rb.memory = GSPCA_MEMORY_READ;
1981  ret = vidioc_reqbufs(file, gspca_dev, &rb);
1982  if (ret != 0) {
1983  PDEBUG(D_STREAM, "read reqbuf err %d", ret);
1984  goto out;
1985  }
1986  memset(&v4l2_buf, 0, sizeof v4l2_buf);
1987  v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1988  v4l2_buf.memory = GSPCA_MEMORY_READ;
1989  for (i = 0; i < gspca_dev->nbufread; i++) {
1990  v4l2_buf.index = i;
1991  ret = vidioc_qbuf(file, gspca_dev, &v4l2_buf);
1992  if (ret != 0) {
1993  PDEBUG(D_STREAM, "read qbuf err: %d", ret);
1994  goto out;
1995  }
1996  }
1997  }
1998 
1999  /* start streaming */
2000  ret = vidioc_streamon(file, gspca_dev, V4L2_BUF_TYPE_VIDEO_CAPTURE);
2001  if (ret != 0)
2002  PDEBUG(D_STREAM, "read streamon err %d", ret);
2003 out:
2004  mutex_unlock(&gspca_dev->usb_lock);
2005  return ret;
2006 }
2007 
2008 static unsigned int dev_poll(struct file *file, poll_table *wait)
2009 {
2010  struct gspca_dev *gspca_dev = video_drvdata(file);
2011  unsigned long req_events = poll_requested_events(wait);
2012  int ret = 0;
2013 
2014  PDEBUG(D_FRAM, "poll");
2015 
2016  if (req_events & POLLPRI)
2017  ret |= v4l2_ctrl_poll(file, wait);
2018 
2019  if (req_events & (POLLIN | POLLRDNORM)) {
2020  /* if reqbufs is not done, the user would use read() */
2021  if (gspca_dev->memory == GSPCA_MEMORY_NO) {
2022  if (read_alloc(gspca_dev, file) != 0) {
2023  ret |= POLLERR;
2024  goto out;
2025  }
2026  }
2027 
2028  poll_wait(file, &gspca_dev->wq, wait);
2029 
2030  /* check if an image has been received */
2031  if (mutex_lock_interruptible(&gspca_dev->queue_lock) != 0) {
2032  ret |= POLLERR;
2033  goto out;
2034  }
2035  if (gspca_dev->fr_o != atomic_read(&gspca_dev->fr_i))
2036  ret |= POLLIN | POLLRDNORM;
2037  mutex_unlock(&gspca_dev->queue_lock);
2038  }
2039 
2040 out:
2041  if (!gspca_dev->present)
2042  ret |= POLLHUP;
2043 
2044  return ret;
2045 }
2046 
2047 static ssize_t dev_read(struct file *file, char __user *data,
2048  size_t count, loff_t *ppos)
2049 {
2050  struct gspca_dev *gspca_dev = video_drvdata(file);
2051  struct gspca_frame *frame;
2052  struct v4l2_buffer v4l2_buf;
2053  struct timeval timestamp;
2054  int n, ret, ret2;
2055 
2056  PDEBUG(D_FRAM, "read (%zd)", count);
2057  if (gspca_dev->memory == GSPCA_MEMORY_NO) { /* first time ? */
2058  ret = read_alloc(gspca_dev, file);
2059  if (ret != 0)
2060  return ret;
2061  }
2062 
2063  /* get a frame */
2064  timestamp = ktime_to_timeval(ktime_get());
2065  timestamp.tv_sec--;
2066  n = 2;
2067  for (;;) {
2068  memset(&v4l2_buf, 0, sizeof v4l2_buf);
2069  v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2070  v4l2_buf.memory = GSPCA_MEMORY_READ;
2071  ret = vidioc_dqbuf(file, gspca_dev, &v4l2_buf);
2072  if (ret != 0) {
2073  PDEBUG(D_STREAM, "read dqbuf err %d", ret);
2074  return ret;
2075  }
2076 
2077  /* if the process slept for more than 1 second,
2078  * get a newer frame */
2079  frame = &gspca_dev->frame[v4l2_buf.index];
2080  if (--n < 0)
2081  break; /* avoid infinite loop */
2082  if (frame->v4l2_buf.timestamp.tv_sec >= timestamp.tv_sec)
2083  break;
2084  ret = vidioc_qbuf(file, gspca_dev, &v4l2_buf);
2085  if (ret != 0) {
2086  PDEBUG(D_STREAM, "read qbuf err %d", ret);
2087  return ret;
2088  }
2089  }
2090 
2091  /* copy the frame */
2092  if (count > frame->v4l2_buf.bytesused)
2093  count = frame->v4l2_buf.bytesused;
2094  ret = copy_to_user(data, frame->data, count);
2095  if (ret != 0) {
2096  PDEBUG(D_ERR|D_STREAM,
2097  "read cp to user lack %d / %zd", ret, count);
2098  ret = -EFAULT;
2099  goto out;
2100  }
2101  ret = count;
2102 out:
2103  /* in each case, requeue the buffer */
2104  ret2 = vidioc_qbuf(file, gspca_dev, &v4l2_buf);
2105  if (ret2 != 0)
2106  return ret2;
2107  return ret;
2108 }
2109 
2110 static struct v4l2_file_operations dev_fops = {
2111  .owner = THIS_MODULE,
2112  .open = dev_open,
2113  .release = dev_close,
2114  .read = dev_read,
2115  .mmap = dev_mmap,
2116  .unlocked_ioctl = video_ioctl2,
2117  .poll = dev_poll,
2118 };
2119 
2120 static const struct v4l2_ioctl_ops dev_ioctl_ops = {
2121  .vidioc_querycap = vidioc_querycap,
2122  .vidioc_dqbuf = vidioc_dqbuf,
2123  .vidioc_qbuf = vidioc_qbuf,
2124  .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
2125  .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
2126  .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
2127  .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
2128  .vidioc_streamon = vidioc_streamon,
2129  .vidioc_queryctrl = vidioc_queryctrl,
2130  .vidioc_g_ctrl = vidioc_g_ctrl,
2131  .vidioc_s_ctrl = vidioc_s_ctrl,
2132  .vidioc_querymenu = vidioc_querymenu,
2133  .vidioc_enum_input = vidioc_enum_input,
2134  .vidioc_g_input = vidioc_g_input,
2135  .vidioc_s_input = vidioc_s_input,
2136  .vidioc_reqbufs = vidioc_reqbufs,
2137  .vidioc_querybuf = vidioc_querybuf,
2138  .vidioc_streamoff = vidioc_streamoff,
2139  .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
2140  .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
2141  .vidioc_g_parm = vidioc_g_parm,
2142  .vidioc_s_parm = vidioc_s_parm,
2143  .vidioc_enum_framesizes = vidioc_enum_framesizes,
2144  .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
2145 #ifdef CONFIG_VIDEO_ADV_DEBUG
2146  .vidioc_g_register = vidioc_g_register,
2147  .vidioc_s_register = vidioc_s_register,
2148 #endif
2149  .vidioc_g_chip_ident = vidioc_g_chip_ident,
2150  .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
2151  .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2152 };
2153 
2154 static const struct video_device gspca_template = {
2155  .name = "gspca main driver",
2156  .fops = &dev_fops,
2157  .ioctl_ops = &dev_ioctl_ops,
2158  .release = video_device_release_empty, /* We use v4l2_dev.release */
2159 };
2160 
2161 /* initialize the controls */
2162 static void ctrls_init(struct gspca_dev *gspca_dev)
2163 {
2164  struct gspca_ctrl *ctrl;
2165  int i;
2166 
2167  for (i = 0, ctrl = gspca_dev->cam.ctrls;
2168  i < gspca_dev->sd_desc->nctrls;
2169  i++, ctrl++) {
2170  ctrl->def = gspca_dev->sd_desc->ctrls[i].qctrl.default_value;
2171  ctrl->val = ctrl->def;
2172  ctrl->min = gspca_dev->sd_desc->ctrls[i].qctrl.minimum;
2173  ctrl->max = gspca_dev->sd_desc->ctrls[i].qctrl.maximum;
2174  }
2175 }
2176 
2177 /*
2178  * probe and create a new gspca device
2179  *
2180  * This function must be called by the sub-driver when it is
2181  * called for probing a new device.
2182  */
2183 int gspca_dev_probe2(struct usb_interface *intf,
2184  const struct usb_device_id *id,
2185  const struct sd_desc *sd_desc,
2186  int dev_size,
2187  struct module *module)
2188 {
2189  struct gspca_dev *gspca_dev;
2190  struct usb_device *dev = interface_to_usbdev(intf);
2191  int ret;
2192 
2193  pr_info("%s-" GSPCA_VERSION " probing %04x:%04x\n",
2194  sd_desc->name, id->idVendor, id->idProduct);
2195 
2196  /* create the device */
2197  if (dev_size < sizeof *gspca_dev)
2198  dev_size = sizeof *gspca_dev;
2199  gspca_dev = kzalloc(dev_size, GFP_KERNEL);
2200  if (!gspca_dev) {
2201  pr_err("couldn't kzalloc gspca struct\n");
2202  return -ENOMEM;
2203  }
2204  gspca_dev->usb_buf = kmalloc(USB_BUF_SZ, GFP_KERNEL);
2205  if (!gspca_dev->usb_buf) {
2206  pr_err("out of memory\n");
2207  ret = -ENOMEM;
2208  goto out;
2209  }
2210  gspca_dev->dev = dev;
2211  gspca_dev->iface = intf->cur_altsetting->desc.bInterfaceNumber;
2212 
2213  /* check if any audio device */
2214  if (dev->actconfig->desc.bNumInterfaces != 1) {
2215  int i;
2216  struct usb_interface *intf2;
2217 
2218  for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) {
2219  intf2 = dev->actconfig->interface[i];
2220  if (intf2 != NULL
2221  && intf2->altsetting != NULL
2222  && intf2->altsetting->desc.bInterfaceClass ==
2223  USB_CLASS_AUDIO) {
2224  gspca_dev->audio = 1;
2225  break;
2226  }
2227  }
2228  }
2229 
2230  gspca_dev->v4l2_dev.release = gspca_release;
2231  ret = v4l2_device_register(&intf->dev, &gspca_dev->v4l2_dev);
2232  if (ret)
2233  goto out;
2234  gspca_dev->sd_desc = sd_desc;
2235  gspca_dev->nbufread = 2;
2236  gspca_dev->empty_packet = -1; /* don't check the empty packets */
2237  gspca_dev->vdev = gspca_template;
2238  gspca_dev->vdev.v4l2_dev = &gspca_dev->v4l2_dev;
2239  video_set_drvdata(&gspca_dev->vdev, gspca_dev);
2240  set_bit(V4L2_FL_USE_FH_PRIO, &gspca_dev->vdev.flags);
2241  gspca_dev->module = module;
2242  gspca_dev->present = 1;
2243 
2244  mutex_init(&gspca_dev->usb_lock);
2245  gspca_dev->vdev.lock = &gspca_dev->usb_lock;
2246  mutex_init(&gspca_dev->queue_lock);
2247  init_waitqueue_head(&gspca_dev->wq);
2248 
2249  /* configure the subdriver and initialize the USB device */
2250  ret = sd_desc->config(gspca_dev, id);
2251  if (ret < 0)
2252  goto out;
2253  if (gspca_dev->cam.ctrls != NULL)
2254  ctrls_init(gspca_dev);
2255  ret = sd_desc->init(gspca_dev);
2256  if (ret < 0)
2257  goto out;
2258  if (sd_desc->init_controls)
2259  ret = sd_desc->init_controls(gspca_dev);
2260  if (ret < 0)
2261  goto out;
2262  gspca_set_default_mode(gspca_dev);
2263 
2264  ret = gspca_input_connect(gspca_dev);
2265  if (ret)
2266  goto out;
2267 
2268  /*
2269  * Don't take usb_lock for these ioctls. This improves latency if
2270  * usb_lock is taken for a long time, e.g. when changing a control
2271  * value, and a new frame is ready to be dequeued.
2272  */
2273  v4l2_disable_ioctl_locking(&gspca_dev->vdev, VIDIOC_DQBUF);
2274  v4l2_disable_ioctl_locking(&gspca_dev->vdev, VIDIOC_QBUF);
2275  v4l2_disable_ioctl_locking(&gspca_dev->vdev, VIDIOC_QUERYBUF);
2276  if (!gspca_dev->sd_desc->get_chip_ident)
2277  v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_DBG_G_CHIP_IDENT);
2278 #ifdef CONFIG_VIDEO_ADV_DEBUG
2279  if (!gspca_dev->sd_desc->get_chip_ident ||
2280  !gspca_dev->sd_desc->get_register)
2281  v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_DBG_G_REGISTER);
2282  if (!gspca_dev->sd_desc->get_chip_ident ||
2283  !gspca_dev->sd_desc->set_register)
2284  v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_DBG_S_REGISTER);
2285 #endif
2286  if (!gspca_dev->sd_desc->get_jcomp)
2287  v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_G_JPEGCOMP);
2288  if (!gspca_dev->sd_desc->set_jcomp)
2289  v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_S_JPEGCOMP);
2290 
2291  /* init video stuff */
2292  ret = video_register_device(&gspca_dev->vdev,
2293  VFL_TYPE_GRABBER,
2294  -1);
2295  if (ret < 0) {
2296  pr_err("video_register_device err %d\n", ret);
2297  goto out;
2298  }
2299 
2300  usb_set_intfdata(intf, gspca_dev);
2301  PDEBUG(D_PROBE, "%s created", video_device_node_name(&gspca_dev->vdev));
2302 
2303  gspca_input_create_urb(gspca_dev);
2304 
2305  return 0;
2306 out:
2307 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
2308  if (gspca_dev->input_dev)
2309  input_unregister_device(gspca_dev->input_dev);
2310 #endif
2311  v4l2_ctrl_handler_free(gspca_dev->vdev.ctrl_handler);
2312  kfree(gspca_dev->usb_buf);
2313  kfree(gspca_dev);
2314  return ret;
2315 }
2316 EXPORT_SYMBOL(gspca_dev_probe2);
2317 
2318 /* same function as the previous one, but check the interface */
2319 int gspca_dev_probe(struct usb_interface *intf,
2320  const struct usb_device_id *id,
2321  const struct sd_desc *sd_desc,
2322  int dev_size,
2323  struct module *module)
2324 {
2325  struct usb_device *dev = interface_to_usbdev(intf);
2326 
2327  /* we don't handle multi-config cameras */
2328  if (dev->descriptor.bNumConfigurations != 1) {
2329  pr_err("%04x:%04x too many config\n",
2330  id->idVendor, id->idProduct);
2331  return -ENODEV;
2332  }
2333 
2334  /* the USB video interface must be the first one */
2335  if (dev->actconfig->desc.bNumInterfaces != 1
2336  && intf->cur_altsetting->desc.bInterfaceNumber != 0)
2337  return -ENODEV;
2338 
2339  return gspca_dev_probe2(intf, id, sd_desc, dev_size, module);
2340 }
2341 EXPORT_SYMBOL(gspca_dev_probe);
2342 
2343 /*
2344  * USB disconnection
2345  *
2346  * This function must be called by the sub-driver
2347  * when the device disconnects, after the specific resources are freed.
2348  */
2349 void gspca_disconnect(struct usb_interface *intf)
2350 {
2351  struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
2352 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
2353  struct input_dev *input_dev;
2354 #endif
2355 
2356  PDEBUG(D_PROBE, "%s disconnect",
2357  video_device_node_name(&gspca_dev->vdev));
2358 
2359  mutex_lock(&gspca_dev->usb_lock);
2360 
2361  gspca_dev->present = 0;
2362  destroy_urbs(gspca_dev);
2363 
2364 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
2365  gspca_input_destroy_urb(gspca_dev);
2366  input_dev = gspca_dev->input_dev;
2367  if (input_dev) {
2368  gspca_dev->input_dev = NULL;
2369  input_unregister_device(input_dev);
2370  }
2371 #endif
2372  /* Free subdriver's streaming resources / stop sd workqueue(s) */
2373  if (gspca_dev->sd_desc->stop0 && gspca_dev->streaming)
2374  gspca_dev->sd_desc->stop0(gspca_dev);
2375  gspca_dev->streaming = 0;
2376  gspca_dev->dev = NULL;
2377  wake_up_interruptible(&gspca_dev->wq);
2378 
2379  v4l2_device_disconnect(&gspca_dev->v4l2_dev);
2380  video_unregister_device(&gspca_dev->vdev);
2381 
2382  mutex_unlock(&gspca_dev->usb_lock);
2383 
2384  /* (this will call gspca_release() immediately or on last close) */
2385  v4l2_device_put(&gspca_dev->v4l2_dev);
2386 }
2387 EXPORT_SYMBOL(gspca_disconnect);
2388 
2389 #ifdef CONFIG_PM
2390 int gspca_suspend(struct usb_interface *intf, pm_message_t message)
2391 {
2392  struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
2393 
2394  gspca_input_destroy_urb(gspca_dev);
2395 
2396  if (!gspca_dev->streaming)
2397  return 0;
2398 
2399  mutex_lock(&gspca_dev->usb_lock);
2400  gspca_dev->frozen = 1; /* avoid urb error messages */
2401  gspca_dev->usb_err = 0;
2402  if (gspca_dev->sd_desc->stopN)
2403  gspca_dev->sd_desc->stopN(gspca_dev);
2404  destroy_urbs(gspca_dev);
2405  gspca_set_alt0(gspca_dev);
2406  if (gspca_dev->sd_desc->stop0)
2407  gspca_dev->sd_desc->stop0(gspca_dev);
2408  mutex_unlock(&gspca_dev->usb_lock);
2409 
2410  return 0;
2411 }
2412 EXPORT_SYMBOL(gspca_suspend);
2413 
2414 int gspca_resume(struct usb_interface *intf)
2415 {
2416  struct gspca_dev *gspca_dev = usb_get_intfdata(intf);
2417  int streaming, ret = 0;
2418 
2419  mutex_lock(&gspca_dev->usb_lock);
2420  gspca_dev->frozen = 0;
2421  gspca_dev->usb_err = 0;
2422  gspca_dev->sd_desc->init(gspca_dev);
2423  /*
2424  * Most subdrivers send all ctrl values on sd_start and thus
2425  * only write to the device registers on s_ctrl when streaming ->
2426  * Clear streaming to avoid setting all ctrls twice.
2427  */
2428  streaming = gspca_dev->streaming;
2429  gspca_dev->streaming = 0;
2430  if (streaming)
2431  ret = gspca_init_transfer(gspca_dev);
2432  else
2433  gspca_input_create_urb(gspca_dev);
2434  mutex_unlock(&gspca_dev->usb_lock);
2435 
2436  return ret;
2437 }
2438 EXPORT_SYMBOL(gspca_resume);
2439 #endif
2440 
2441 /* -- module insert / remove -- */
2442 static int __init gspca_init(void)
2443 {
2444  pr_info("v" GSPCA_VERSION " registered\n");
2445  return 0;
2446 }
2447 static void __exit gspca_exit(void)
2448 {
2449 }
2450 
2451 module_init(gspca_init);
2452 module_exit(gspca_exit);
2453 
2454 #ifdef GSPCA_DEBUG
2455 module_param_named(debug, gspca_debug, int, 0644);
2456 MODULE_PARM_DESC(debug,
2457  "Debug (bit) 0x01:error 0x02:probe 0x04:config"
2458  " 0x08:stream 0x10:frame 0x20:packet"
2459  " 0x0100: v4l2");
2460 #endif
Generated on Thu Jan 10 2013 13:51:46 for Linux Kernel by   doxygen 1.8.2