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