diff options
author | Mauro Carvalho Chehab <mchehab@redhat.com> | 2012-08-13 23:13:22 -0400 |
---|---|---|
committer | Mauro Carvalho Chehab <mchehab@redhat.com> | 2012-08-15 15:25:07 -0400 |
commit | 0c0d06cac63ee327ceaab4b5ffe2206574ab86bd (patch) | |
tree | e759f0dc3185d97f2a0c6b5cd5e32ea6faa74d40 /drivers/media/usb/gspca/gspca.c | |
parent | 84cfe9e79bd5ac11c963f4841158454fefa872f6 (diff) |
[media] rename most media/video usb drivers to media/usb
Rename all USB drivers with their own directory under
drivers/media/video into drivers/media/usb and update the
building system.
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Diffstat (limited to 'drivers/media/usb/gspca/gspca.c')
-rw-r--r-- | drivers/media/usb/gspca/gspca.c | 2456 |
1 files changed, 2456 insertions, 0 deletions
diff --git a/drivers/media/usb/gspca/gspca.c b/drivers/media/usb/gspca/gspca.c new file mode 100644 index 00000000000..d4e8343f5b1 --- /dev/null +++ b/drivers/media/usb/gspca/gspca.c | |||
@@ -0,0 +1,2456 @@ | |||
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 <nm127@freemail.hu> | ||
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 | 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 | usb_set_intfdata(intf, NULL); | ||
2362 | gspca_dev->dev = NULL; | ||
2363 | gspca_dev->present = 0; | ||
2364 | destroy_urbs(gspca_dev); | ||
2365 | |||
2366 | #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE) | ||
2367 | gspca_input_destroy_urb(gspca_dev); | ||
2368 | input_dev = gspca_dev->input_dev; | ||
2369 | if (input_dev) { | ||
2370 | gspca_dev->input_dev = NULL; | ||
2371 | input_unregister_device(input_dev); | ||
2372 | } | ||
2373 | #endif | ||
2374 | /* Free subdriver's streaming resources / stop sd workqueue(s) */ | ||
2375 | if (gspca_dev->sd_desc->stop0 && gspca_dev->streaming) | ||
2376 | gspca_dev->sd_desc->stop0(gspca_dev); | ||
2377 | gspca_dev->streaming = 0; | ||
2378 | wake_up_interruptible(&gspca_dev->wq); | ||
2379 | |||
2380 | v4l2_device_disconnect(&gspca_dev->v4l2_dev); | ||
2381 | video_unregister_device(&gspca_dev->vdev); | ||
2382 | |||
2383 | mutex_unlock(&gspca_dev->usb_lock); | ||
2384 | |||
2385 | /* (this will call gspca_release() immediately or on last close) */ | ||
2386 | v4l2_device_put(&gspca_dev->v4l2_dev); | ||
2387 | } | ||
2388 | EXPORT_SYMBOL(gspca_disconnect); | ||
2389 | |||
2390 | #ifdef CONFIG_PM | ||
2391 | int gspca_suspend(struct usb_interface *intf, pm_message_t message) | ||
2392 | { | ||
2393 | struct gspca_dev *gspca_dev = usb_get_intfdata(intf); | ||
2394 | |||
2395 | if (!gspca_dev->streaming) | ||
2396 | return 0; | ||
2397 | mutex_lock(&gspca_dev->usb_lock); | ||
2398 | gspca_dev->frozen = 1; /* avoid urb error messages */ | ||
2399 | gspca_dev->usb_err = 0; | ||
2400 | if (gspca_dev->sd_desc->stopN) | ||
2401 | gspca_dev->sd_desc->stopN(gspca_dev); | ||
2402 | destroy_urbs(gspca_dev); | ||
2403 | gspca_input_destroy_urb(gspca_dev); | ||
2404 | gspca_set_alt0(gspca_dev); | ||
2405 | if (gspca_dev->sd_desc->stop0) | ||
2406 | gspca_dev->sd_desc->stop0(gspca_dev); | ||
2407 | mutex_unlock(&gspca_dev->usb_lock); | ||
2408 | return 0; | ||
2409 | } | ||
2410 | EXPORT_SYMBOL(gspca_suspend); | ||
2411 | |||
2412 | int gspca_resume(struct usb_interface *intf) | ||
2413 | { | ||
2414 | struct gspca_dev *gspca_dev = usb_get_intfdata(intf); | ||
2415 | int streaming, ret = 0; | ||
2416 | |||
2417 | mutex_lock(&gspca_dev->usb_lock); | ||
2418 | gspca_dev->frozen = 0; | ||
2419 | gspca_dev->usb_err = 0; | ||
2420 | gspca_dev->sd_desc->init(gspca_dev); | ||
2421 | gspca_input_create_urb(gspca_dev); | ||
2422 | /* | ||
2423 | * Most subdrivers send all ctrl values on sd_start and thus | ||
2424 | * only write to the device registers on s_ctrl when streaming -> | ||
2425 | * Clear streaming to avoid setting all ctrls twice. | ||
2426 | */ | ||
2427 | streaming = gspca_dev->streaming; | ||
2428 | gspca_dev->streaming = 0; | ||
2429 | if (streaming) | ||
2430 | ret = gspca_init_transfer(gspca_dev); | ||
2431 | mutex_unlock(&gspca_dev->usb_lock); | ||
2432 | return ret; | ||
2433 | } | ||
2434 | EXPORT_SYMBOL(gspca_resume); | ||
2435 | #endif | ||
2436 | |||
2437 | /* -- module insert / remove -- */ | ||
2438 | static int __init gspca_init(void) | ||
2439 | { | ||
2440 | pr_info("v" GSPCA_VERSION " registered\n"); | ||
2441 | return 0; | ||
2442 | } | ||
2443 | static void __exit gspca_exit(void) | ||
2444 | { | ||
2445 | } | ||
2446 | |||
2447 | module_init(gspca_init); | ||
2448 | module_exit(gspca_exit); | ||
2449 | |||
2450 | #ifdef GSPCA_DEBUG | ||
2451 | module_param_named(debug, gspca_debug, int, 0644); | ||
2452 | MODULE_PARM_DESC(debug, | ||
2453 | "Debug (bit) 0x01:error 0x02:probe 0x04:config" | ||
2454 | " 0x08:stream 0x10:frame 0x20:packet" | ||
2455 | " 0x0100: v4l2"); | ||
2456 | #endif | ||