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 const struct v4l2_jpegcompression *jpegcomp) 1690 { 1691 struct gspca_dev *gspca_dev = video_drvdata(file); 1692 1693 gspca_dev->usb_err = 0; 1694 return gspca_dev->sd_desc->set_jcomp(gspca_dev, jpegcomp); 1695 } 1696 1697 static int vidioc_g_parm(struct file *filp, void *priv, 1698 struct v4l2_streamparm *parm) 1699 { 1700 struct gspca_dev *gspca_dev = video_drvdata(filp); 1701 1702 parm->parm.capture.readbuffers = gspca_dev->nbufread; 1703 1704 if (gspca_dev->sd_desc->get_streamparm) { 1705 gspca_dev->usb_err = 0; 1706 gspca_dev->sd_desc->get_streamparm(gspca_dev, parm); 1707 return gspca_dev->usb_err; 1708 } 1709 return 0; 1710 } 1711 1712 static int vidioc_s_parm(struct file *filp, void *priv, 1713 struct v4l2_streamparm *parm) 1714 { 1715 struct gspca_dev *gspca_dev = video_drvdata(filp); 1716 int n; 1717 1718 n = parm->parm.capture.readbuffers; 1719 if (n == 0 || n >= GSPCA_MAX_FRAMES) 1720 parm->parm.capture.readbuffers = gspca_dev->nbufread; 1721 else 1722 gspca_dev->nbufread = n; 1723 1724 if (gspca_dev->sd_desc->set_streamparm) { 1725 gspca_dev->usb_err = 0; 1726 gspca_dev->sd_desc->set_streamparm(gspca_dev, parm); 1727 return gspca_dev->usb_err; 1728 } 1729 1730 return 0; 1731 } 1732 1733 static int dev_mmap(struct file *file, struct vm_area_struct *vma) 1734 { 1735 struct gspca_dev *gspca_dev = video_drvdata(file); 1736 struct gspca_frame *frame; 1737 struct page *page; 1738 unsigned long addr, start, size; 1739 int i, ret; 1740 1741 start = vma->vm_start; 1742 size = vma->vm_end - vma->vm_start; 1743 PDEBUG(D_STREAM, "mmap start:%08x size:%d", (int) start, (int) size); 1744 1745 if (mutex_lock_interruptible(&gspca_dev->queue_lock)) 1746 return -ERESTARTSYS; 1747 if (gspca_dev->capt_file != file) { 1748 ret = -EINVAL; 1749 goto out; 1750 } 1751 1752 frame = NULL; 1753 for (i = 0; i < gspca_dev->nframes; ++i) { 1754 if (gspca_dev->frame[i].v4l2_buf.memory != V4L2_MEMORY_MMAP) { 1755 PDEBUG(D_STREAM, "mmap bad memory type"); 1756 break; 1757 } 1758 if ((gspca_dev->frame[i].v4l2_buf.m.offset >> PAGE_SHIFT) 1759 == vma->vm_pgoff) { 1760 frame = &gspca_dev->frame[i]; 1761 break; 1762 } 1763 } 1764 if (frame == NULL) { 1765 PDEBUG(D_STREAM, "mmap no frame buffer found"); 1766 ret = -EINVAL; 1767 goto out; 1768 } 1769 if (size != frame->v4l2_buf.length) { 1770 PDEBUG(D_STREAM, "mmap bad size"); 1771 ret = -EINVAL; 1772 goto out; 1773 } 1774 1775 /* 1776 * - VM_IO marks the area as being a mmaped region for I/O to a 1777 * device. It also prevents the region from being core dumped. 1778 */ 1779 vma->vm_flags |= VM_IO; 1780 1781 addr = (unsigned long) frame->data; 1782 while (size > 0) { 1783 page = vmalloc_to_page((void *) addr); 1784 ret = vm_insert_page(vma, start, page); 1785 if (ret < 0) 1786 goto out; 1787 start += PAGE_SIZE; 1788 addr += PAGE_SIZE; 1789 size -= PAGE_SIZE; 1790 } 1791 1792 vma->vm_ops = &gspca_vm_ops; 1793 vma->vm_private_data = frame; 1794 gspca_vm_open(vma); 1795 ret = 0; 1796 out: 1797 mutex_unlock(&gspca_dev->queue_lock); 1798 return ret; 1799 } 1800 1801 static int frame_ready_nolock(struct gspca_dev *gspca_dev, struct file *file, 1802 enum v4l2_memory memory) 1803 { 1804 if (!gspca_dev->present) 1805 return -ENODEV; 1806 if (gspca_dev->capt_file != file || gspca_dev->memory != memory || 1807 !gspca_dev->streaming) 1808 return -EINVAL; 1809 1810 /* check if a frame is ready */ 1811 return gspca_dev->fr_o != atomic_read(&gspca_dev->fr_i); 1812 } 1813 1814 static int frame_ready(struct gspca_dev *gspca_dev, struct file *file, 1815 enum v4l2_memory memory) 1816 { 1817 int ret; 1818 1819 if (mutex_lock_interruptible(&gspca_dev->queue_lock)) 1820 return -ERESTARTSYS; 1821 ret = frame_ready_nolock(gspca_dev, file, memory); 1822 mutex_unlock(&gspca_dev->queue_lock); 1823 return ret; 1824 } 1825 1826 /* 1827 * dequeue a video buffer 1828 * 1829 * If nonblock_ing is false, block until a buffer is available. 1830 */ 1831 static int vidioc_dqbuf(struct file *file, void *priv, 1832 struct v4l2_buffer *v4l2_buf) 1833 { 1834 struct gspca_dev *gspca_dev = video_drvdata(file); 1835 struct gspca_frame *frame; 1836 int i, j, ret; 1837 1838 PDEBUG(D_FRAM, "dqbuf"); 1839 1840 if (mutex_lock_interruptible(&gspca_dev->queue_lock)) 1841 return -ERESTARTSYS; 1842 1843 for (;;) { 1844 ret = frame_ready_nolock(gspca_dev, file, v4l2_buf->memory); 1845 if (ret < 0) 1846 goto out; 1847 if (ret > 0) 1848 break; 1849 1850 mutex_unlock(&gspca_dev->queue_lock); 1851 1852 if (file->f_flags & O_NONBLOCK) 1853 return -EAGAIN; 1854 1855 /* wait till a frame is ready */ 1856 ret = wait_event_interruptible_timeout(gspca_dev->wq, 1857 frame_ready(gspca_dev, file, v4l2_buf->memory), 1858 msecs_to_jiffies(3000)); 1859 if (ret < 0) 1860 return ret; 1861 if (ret == 0) 1862 return -EIO; 1863 1864 if (mutex_lock_interruptible(&gspca_dev->queue_lock)) 1865 return -ERESTARTSYS; 1866 } 1867 1868 i = gspca_dev->fr_o; 1869 j = gspca_dev->fr_queue[i]; 1870 frame = &gspca_dev->frame[j]; 1871 1872 gspca_dev->fr_o = (i + 1) % GSPCA_MAX_FRAMES; 1873 1874 frame->v4l2_buf.flags &= ~V4L2_BUF_FLAG_DONE; 1875 memcpy(v4l2_buf, &frame->v4l2_buf, sizeof *v4l2_buf); 1876 PDEBUG(D_FRAM, "dqbuf %d", j); 1877 ret = 0; 1878 1879 if (gspca_dev->memory == V4L2_MEMORY_USERPTR) { 1880 if (copy_to_user((__u8 __user *) frame->v4l2_buf.m.userptr, 1881 frame->data, 1882 frame->v4l2_buf.bytesused)) { 1883 PDEBUG(D_ERR|D_STREAM, 1884 "dqbuf cp to user failed"); 1885 ret = -EFAULT; 1886 } 1887 } 1888 out: 1889 mutex_unlock(&gspca_dev->queue_lock); 1890 1891 if (ret == 0 && gspca_dev->sd_desc->dq_callback) { 1892 mutex_lock(&gspca_dev->usb_lock); 1893 gspca_dev->usb_err = 0; 1894 if (gspca_dev->present) 1895 gspca_dev->sd_desc->dq_callback(gspca_dev); 1896 mutex_unlock(&gspca_dev->usb_lock); 1897 } 1898 1899 return ret; 1900 } 1901 1902 /* 1903 * queue a video buffer 1904 * 1905 * Attempting to queue a buffer that has already been 1906 * queued will return -EINVAL. 1907 */ 1908 static int vidioc_qbuf(struct file *file, void *priv, 1909 struct v4l2_buffer *v4l2_buf) 1910 { 1911 struct gspca_dev *gspca_dev = video_drvdata(file); 1912 struct gspca_frame *frame; 1913 int i, index, ret; 1914 1915 PDEBUG(D_FRAM, "qbuf %d", v4l2_buf->index); 1916 1917 if (mutex_lock_interruptible(&gspca_dev->queue_lock)) 1918 return -ERESTARTSYS; 1919 1920 index = v4l2_buf->index; 1921 if ((unsigned) index >= gspca_dev->nframes) { 1922 PDEBUG(D_FRAM, 1923 "qbuf idx %d >= %d", index, gspca_dev->nframes); 1924 ret = -EINVAL; 1925 goto out; 1926 } 1927 if (v4l2_buf->memory != gspca_dev->memory) { 1928 PDEBUG(D_FRAM, "qbuf bad memory type"); 1929 ret = -EINVAL; 1930 goto out; 1931 } 1932 1933 frame = &gspca_dev->frame[index]; 1934 if (frame->v4l2_buf.flags & BUF_ALL_FLAGS) { 1935 PDEBUG(D_FRAM, "qbuf bad state"); 1936 ret = -EINVAL; 1937 goto out; 1938 } 1939 1940 frame->v4l2_buf.flags |= V4L2_BUF_FLAG_QUEUED; 1941 1942 if (frame->v4l2_buf.memory == V4L2_MEMORY_USERPTR) { 1943 frame->v4l2_buf.m.userptr = v4l2_buf->m.userptr; 1944 frame->v4l2_buf.length = v4l2_buf->length; 1945 } 1946 1947 /* put the buffer in the 'queued' queue */ 1948 i = atomic_read(&gspca_dev->fr_q); 1949 gspca_dev->fr_queue[i] = index; 1950 atomic_set(&gspca_dev->fr_q, (i + 1) % GSPCA_MAX_FRAMES); 1951 1952 v4l2_buf->flags |= V4L2_BUF_FLAG_QUEUED; 1953 v4l2_buf->flags &= ~V4L2_BUF_FLAG_DONE; 1954 ret = 0; 1955 out: 1956 mutex_unlock(&gspca_dev->queue_lock); 1957 return ret; 1958 } 1959 1960 /* 1961 * allocate the resources for read() 1962 */ 1963 static int read_alloc(struct gspca_dev *gspca_dev, 1964 struct file *file) 1965 { 1966 struct v4l2_buffer v4l2_buf; 1967 int i, ret; 1968 1969 PDEBUG(D_STREAM, "read alloc"); 1970 1971 if (mutex_lock_interruptible(&gspca_dev->usb_lock)) 1972 return -ERESTARTSYS; 1973 1974 if (gspca_dev->nframes == 0) { 1975 struct v4l2_requestbuffers rb; 1976 1977 memset(&rb, 0, sizeof rb); 1978 rb.count = gspca_dev->nbufread; 1979 rb.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1980 rb.memory = GSPCA_MEMORY_READ; 1981 ret = vidioc_reqbufs(file, gspca_dev, &rb); 1982 if (ret != 0) { 1983 PDEBUG(D_STREAM, "read reqbuf err %d", ret); 1984 goto out; 1985 } 1986 memset(&v4l2_buf, 0, sizeof v4l2_buf); 1987 v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1988 v4l2_buf.memory = GSPCA_MEMORY_READ; 1989 for (i = 0; i < gspca_dev->nbufread; i++) { 1990 v4l2_buf.index = i; 1991 ret = vidioc_qbuf(file, gspca_dev, &v4l2_buf); 1992 if (ret != 0) { 1993 PDEBUG(D_STREAM, "read qbuf err: %d", ret); 1994 goto out; 1995 } 1996 } 1997 } 1998 1999 /* start streaming */ 2000 ret = vidioc_streamon(file, gspca_dev, V4L2_BUF_TYPE_VIDEO_CAPTURE); 2001 if (ret != 0) 2002 PDEBUG(D_STREAM, "read streamon err %d", ret); 2003 out: 2004 mutex_unlock(&gspca_dev->usb_lock); 2005 return ret; 2006 } 2007 2008 static unsigned int dev_poll(struct file *file, poll_table *wait) 2009 { 2010 struct gspca_dev *gspca_dev = video_drvdata(file); 2011 unsigned long req_events = poll_requested_events(wait); 2012 int ret = 0; 2013 2014 PDEBUG(D_FRAM, "poll"); 2015 2016 if (req_events & POLLPRI) 2017 ret |= v4l2_ctrl_poll(file, wait); 2018 2019 if (req_events & (POLLIN | POLLRDNORM)) { 2020 /* if reqbufs is not done, the user would use read() */ 2021 if (gspca_dev->memory == GSPCA_MEMORY_NO) { 2022 if (read_alloc(gspca_dev, file) != 0) { 2023 ret |= POLLERR; 2024 goto out; 2025 } 2026 } 2027 2028 poll_wait(file, &gspca_dev->wq, wait); 2029 2030 /* check if an image has been received */ 2031 if (mutex_lock_interruptible(&gspca_dev->queue_lock) != 0) { 2032 ret |= POLLERR; 2033 goto out; 2034 } 2035 if (gspca_dev->fr_o != atomic_read(&gspca_dev->fr_i)) 2036 ret |= POLLIN | POLLRDNORM; 2037 mutex_unlock(&gspca_dev->queue_lock); 2038 } 2039 2040 out: 2041 if (!gspca_dev->present) 2042 ret |= POLLHUP; 2043 2044 return ret; 2045 } 2046 2047 static ssize_t dev_read(struct file *file, char __user *data, 2048 size_t count, loff_t *ppos) 2049 { 2050 struct gspca_dev *gspca_dev = video_drvdata(file); 2051 struct gspca_frame *frame; 2052 struct v4l2_buffer v4l2_buf; 2053 struct timeval timestamp; 2054 int n, ret, ret2; 2055 2056 PDEBUG(D_FRAM, "read (%zd)", count); 2057 if (gspca_dev->memory == GSPCA_MEMORY_NO) { /* first time ? */ 2058 ret = read_alloc(gspca_dev, file); 2059 if (ret != 0) 2060 return ret; 2061 } 2062 2063 /* get a frame */ 2064 timestamp = ktime_to_timeval(ktime_get()); 2065 timestamp.tv_sec--; 2066 n = 2; 2067 for (;;) { 2068 memset(&v4l2_buf, 0, sizeof v4l2_buf); 2069 v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2070 v4l2_buf.memory = GSPCA_MEMORY_READ; 2071 ret = vidioc_dqbuf(file, gspca_dev, &v4l2_buf); 2072 if (ret != 0) { 2073 PDEBUG(D_STREAM, "read dqbuf err %d", ret); 2074 return ret; 2075 } 2076 2077 /* if the process slept for more than 1 second, 2078 * get a newer frame */ 2079 frame = &gspca_dev->frame[v4l2_buf.index]; 2080 if (--n < 0) 2081 break; /* avoid infinite loop */ 2082 if (frame->v4l2_buf.timestamp.tv_sec >= timestamp.tv_sec) 2083 break; 2084 ret = vidioc_qbuf(file, gspca_dev, &v4l2_buf); 2085 if (ret != 0) { 2086 PDEBUG(D_STREAM, "read qbuf err %d", ret); 2087 return ret; 2088 } 2089 } 2090 2091 /* copy the frame */ 2092 if (count > frame->v4l2_buf.bytesused) 2093 count = frame->v4l2_buf.bytesused; 2094 ret = copy_to_user(data, frame->data, count); 2095 if (ret != 0) { 2096 PDEBUG(D_ERR|D_STREAM, 2097 "read cp to user lack %d / %zd", ret, count); 2098 ret = -EFAULT; 2099 goto out; 2100 } 2101 ret = count; 2102 out: 2103 /* in each case, requeue the buffer */ 2104 ret2 = vidioc_qbuf(file, gspca_dev, &v4l2_buf); 2105 if (ret2 != 0) 2106 return ret2; 2107 return ret; 2108 } 2109 2110 static struct v4l2_file_operations dev_fops = { 2111 .owner = THIS_MODULE, 2112 .open = dev_open, 2113 .release = dev_close, 2114 .read = dev_read, 2115 .mmap = dev_mmap, 2116 .unlocked_ioctl = video_ioctl2, 2117 .poll = dev_poll, 2118 }; 2119 2120 static const struct v4l2_ioctl_ops dev_ioctl_ops = { 2121 .vidioc_querycap = vidioc_querycap, 2122 .vidioc_dqbuf = vidioc_dqbuf, 2123 .vidioc_qbuf = vidioc_qbuf, 2124 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 2125 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 2126 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 2127 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 2128 .vidioc_streamon = vidioc_streamon, 2129 .vidioc_queryctrl = vidioc_queryctrl, 2130 .vidioc_g_ctrl = vidioc_g_ctrl, 2131 .vidioc_s_ctrl = vidioc_s_ctrl, 2132 .vidioc_querymenu = vidioc_querymenu, 2133 .vidioc_enum_input = vidioc_enum_input, 2134 .vidioc_g_input = vidioc_g_input, 2135 .vidioc_s_input = vidioc_s_input, 2136 .vidioc_reqbufs = vidioc_reqbufs, 2137 .vidioc_querybuf = vidioc_querybuf, 2138 .vidioc_streamoff = vidioc_streamoff, 2139 .vidioc_g_jpegcomp = vidioc_g_jpegcomp, 2140 .vidioc_s_jpegcomp = vidioc_s_jpegcomp, 2141 .vidioc_g_parm = vidioc_g_parm, 2142 .vidioc_s_parm = vidioc_s_parm, 2143 .vidioc_enum_framesizes = vidioc_enum_framesizes, 2144 .vidioc_enum_frameintervals = vidioc_enum_frameintervals, 2145 #ifdef CONFIG_VIDEO_ADV_DEBUG 2146 .vidioc_g_register = vidioc_g_register, 2147 .vidioc_s_register = vidioc_s_register, 2148 #endif 2149 .vidioc_g_chip_ident = vidioc_g_chip_ident, 2150 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 2151 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2152 }; 2153 2154 static const struct video_device gspca_template = { 2155 .name = "gspca main driver", 2156 .fops = &dev_fops, 2157 .ioctl_ops = &dev_ioctl_ops, 2158 .release = video_device_release_empty, /* We use v4l2_dev.release */ 2159 }; 2160 2161 /* initialize the controls */ 2162 static void ctrls_init(struct gspca_dev *gspca_dev) 2163 { 2164 struct gspca_ctrl *ctrl; 2165 int i; 2166 2167 for (i = 0, ctrl = gspca_dev->cam.ctrls; 2168 i < gspca_dev->sd_desc->nctrls; 2169 i++, ctrl++) { 2170 ctrl->def = gspca_dev->sd_desc->ctrls[i].qctrl.default_value; 2171 ctrl->val = ctrl->def; 2172 ctrl->min = gspca_dev->sd_desc->ctrls[i].qctrl.minimum; 2173 ctrl->max = gspca_dev->sd_desc->ctrls[i].qctrl.maximum; 2174 } 2175 } 2176 2177 /* 2178 * probe and create a new gspca device 2179 * 2180 * This function must be called by the sub-driver when it is 2181 * called for probing a new device. 2182 */ 2183 int gspca_dev_probe2(struct usb_interface *intf, 2184 const struct usb_device_id *id, 2185 const struct sd_desc *sd_desc, 2186 int dev_size, 2187 struct module *module) 2188 { 2189 struct gspca_dev *gspca_dev; 2190 struct usb_device *dev = interface_to_usbdev(intf); 2191 int ret; 2192 2193 pr_info("%s-" GSPCA_VERSION " probing %04x:%04x\n", 2194 sd_desc->name, id->idVendor, id->idProduct); 2195 2196 /* create the device */ 2197 if (dev_size < sizeof *gspca_dev) 2198 dev_size = sizeof *gspca_dev; 2199 gspca_dev = kzalloc(dev_size, GFP_KERNEL); 2200 if (!gspca_dev) { 2201 pr_err("couldn't kzalloc gspca struct\n"); 2202 return -ENOMEM; 2203 } 2204 gspca_dev->usb_buf = kmalloc(USB_BUF_SZ, GFP_KERNEL); 2205 if (!gspca_dev->usb_buf) { 2206 pr_err("out of memory\n"); 2207 ret = -ENOMEM; 2208 goto out; 2209 } 2210 gspca_dev->dev = dev; 2211 gspca_dev->iface = intf->cur_altsetting->desc.bInterfaceNumber; 2212 2213 /* check if any audio device */ 2214 if (dev->actconfig->desc.bNumInterfaces != 1) { 2215 int i; 2216 struct usb_interface *intf2; 2217 2218 for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) { 2219 intf2 = dev->actconfig->interface[i]; 2220 if (intf2 != NULL 2221 && intf2->altsetting != NULL 2222 && intf2->altsetting->desc.bInterfaceClass == 2223 USB_CLASS_AUDIO) { 2224 gspca_dev->audio = 1; 2225 break; 2226 } 2227 } 2228 } 2229 2230 gspca_dev->v4l2_dev.release = gspca_release; 2231 ret = v4l2_device_register(&intf->dev, &gspca_dev->v4l2_dev); 2232 if (ret) 2233 goto out; 2234 gspca_dev->sd_desc = sd_desc; 2235 gspca_dev->nbufread = 2; 2236 gspca_dev->empty_packet = -1; /* don't check the empty packets */ 2237 gspca_dev->vdev = gspca_template; 2238 gspca_dev->vdev.v4l2_dev = &gspca_dev->v4l2_dev; 2239 video_set_drvdata(&gspca_dev->vdev, gspca_dev); 2240 set_bit(V4L2_FL_USE_FH_PRIO, &gspca_dev->vdev.flags); 2241 gspca_dev->module = module; 2242 gspca_dev->present = 1; 2243 2244 mutex_init(&gspca_dev->usb_lock); 2245 gspca_dev->vdev.lock = &gspca_dev->usb_lock; 2246 mutex_init(&gspca_dev->queue_lock); 2247 init_waitqueue_head(&gspca_dev->wq); 2248 2249 /* configure the subdriver and initialize the USB device */ 2250 ret = sd_desc->config(gspca_dev, id); 2251 if (ret < 0) 2252 goto out; 2253 if (gspca_dev->cam.ctrls != NULL) 2254 ctrls_init(gspca_dev); 2255 ret = sd_desc->init(gspca_dev); 2256 if (ret < 0) 2257 goto out; 2258 if (sd_desc->init_controls) 2259 ret = sd_desc->init_controls(gspca_dev); 2260 if (ret < 0) 2261 goto out; 2262 gspca_set_default_mode(gspca_dev); 2263 2264 ret = gspca_input_connect(gspca_dev); 2265 if (ret) 2266 goto out; 2267 2268 /* 2269 * Don't take usb_lock for these ioctls. This improves latency if 2270 * usb_lock is taken for a long time, e.g. when changing a control 2271 * value, and a new frame is ready to be dequeued. 2272 */ 2273 v4l2_disable_ioctl_locking(&gspca_dev->vdev, VIDIOC_DQBUF); 2274 v4l2_disable_ioctl_locking(&gspca_dev->vdev, VIDIOC_QBUF); 2275 v4l2_disable_ioctl_locking(&gspca_dev->vdev, VIDIOC_QUERYBUF); 2276 if (!gspca_dev->sd_desc->get_chip_ident) 2277 v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_DBG_G_CHIP_IDENT); 2278 #ifdef CONFIG_VIDEO_ADV_DEBUG 2279 if (!gspca_dev->sd_desc->get_chip_ident || 2280 !gspca_dev->sd_desc->get_register) 2281 v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_DBG_G_REGISTER); 2282 if (!gspca_dev->sd_desc->get_chip_ident || 2283 !gspca_dev->sd_desc->set_register) 2284 v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_DBG_S_REGISTER); 2285 #endif 2286 if (!gspca_dev->sd_desc->get_jcomp) 2287 v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_G_JPEGCOMP); 2288 if (!gspca_dev->sd_desc->set_jcomp) 2289 v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_S_JPEGCOMP); 2290 2291 /* init video stuff */ 2292 ret = video_register_device(&gspca_dev->vdev, 2293 VFL_TYPE_GRABBER, 2294 -1); 2295 if (ret < 0) { 2296 pr_err("video_register_device err %d\n", ret); 2297 goto out; 2298 } 2299 2300 usb_set_intfdata(intf, gspca_dev); 2301 PDEBUG(D_PROBE, "%s created", video_device_node_name(&gspca_dev->vdev)); 2302 2303 gspca_input_create_urb(gspca_dev); 2304 2305 return 0; 2306 out: 2307 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE) 2308 if (gspca_dev->input_dev) 2309 input_unregister_device(gspca_dev->input_dev); 2310 #endif 2311 v4l2_ctrl_handler_free(gspca_dev->vdev.ctrl_handler); 2312 kfree(gspca_dev->usb_buf); 2313 kfree(gspca_dev); 2314 return ret; 2315 } 2316 EXPORT_SYMBOL(gspca_dev_probe2); 2317 2318 /* same function as the previous one, but check the interface */ 2319 int gspca_dev_probe(struct usb_interface *intf, 2320 const struct usb_device_id *id, 2321 const struct sd_desc *sd_desc, 2322 int dev_size, 2323 struct module *module) 2324 { 2325 struct usb_device *dev = interface_to_usbdev(intf); 2326 2327 /* we don't handle multi-config cameras */ 2328 if (dev->descriptor.bNumConfigurations != 1) { 2329 pr_err("%04x:%04x too many config\n", 2330 id->idVendor, id->idProduct); 2331 return -ENODEV; 2332 } 2333 2334 /* the USB video interface must be the first one */ 2335 if (dev->actconfig->desc.bNumInterfaces != 1 2336 && intf->cur_altsetting->desc.bInterfaceNumber != 0) 2337 return -ENODEV; 2338 2339 return gspca_dev_probe2(intf, id, sd_desc, dev_size, module); 2340 } 2341 EXPORT_SYMBOL(gspca_dev_probe); 2342 2343 /* 2344 * USB disconnection 2345 * 2346 * This function must be called by the sub-driver 2347 * when the device disconnects, after the specific resources are freed. 2348 */ 2349 void gspca_disconnect(struct usb_interface *intf) 2350 { 2351 struct gspca_dev *gspca_dev = usb_get_intfdata(intf); 2352 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE) 2353 struct input_dev *input_dev; 2354 #endif 2355 2356 PDEBUG(D_PROBE, "%s disconnect", 2357 video_device_node_name(&gspca_dev->vdev)); 2358 2359 mutex_lock(&gspca_dev->usb_lock); 2360 2361 gspca_dev->present = 0; 2362 destroy_urbs(gspca_dev); 2363 2364 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE) 2365 gspca_input_destroy_urb(gspca_dev); 2366 input_dev = gspca_dev->input_dev; 2367 if (input_dev) { 2368 gspca_dev->input_dev = NULL; 2369 input_unregister_device(input_dev); 2370 } 2371 #endif 2372 /* Free subdriver's streaming resources / stop sd workqueue(s) */ 2373 if (gspca_dev->sd_desc->stop0 && gspca_dev->streaming) 2374 gspca_dev->sd_desc->stop0(gspca_dev); 2375 gspca_dev->streaming = 0; 2376 gspca_dev->dev = NULL; 2377 wake_up_interruptible(&gspca_dev->wq); 2378 2379 v4l2_device_disconnect(&gspca_dev->v4l2_dev); 2380 video_unregister_device(&gspca_dev->vdev); 2381 2382 mutex_unlock(&gspca_dev->usb_lock); 2383 2384 /* (this will call gspca_release() immediately or on last close) */ 2385 v4l2_device_put(&gspca_dev->v4l2_dev); 2386 } 2387 EXPORT_SYMBOL(gspca_disconnect); 2388 2389 #ifdef CONFIG_PM 2390 int gspca_suspend(struct usb_interface *intf, pm_message_t message) 2391 { 2392 struct gspca_dev *gspca_dev = usb_get_intfdata(intf); 2393 2394 gspca_input_destroy_urb(gspca_dev); 2395 2396 if (!gspca_dev->streaming) 2397 return 0; 2398 2399 mutex_lock(&gspca_dev->usb_lock); 2400 gspca_dev->frozen = 1; /* avoid urb error messages */ 2401 gspca_dev->usb_err = 0; 2402 if (gspca_dev->sd_desc->stopN) 2403 gspca_dev->sd_desc->stopN(gspca_dev); 2404 destroy_urbs(gspca_dev); 2405 gspca_set_alt0(gspca_dev); 2406 if (gspca_dev->sd_desc->stop0) 2407 gspca_dev->sd_desc->stop0(gspca_dev); 2408 mutex_unlock(&gspca_dev->usb_lock); 2409 2410 return 0; 2411 } 2412 EXPORT_SYMBOL(gspca_suspend); 2413 2414 int gspca_resume(struct usb_interface *intf) 2415 { 2416 struct gspca_dev *gspca_dev = usb_get_intfdata(intf); 2417 int streaming, ret = 0; 2418 2419 mutex_lock(&gspca_dev->usb_lock); 2420 gspca_dev->frozen = 0; 2421 gspca_dev->usb_err = 0; 2422 gspca_dev->sd_desc->init(gspca_dev); 2423 /* 2424 * Most subdrivers send all ctrl values on sd_start and thus 2425 * only write to the device registers on s_ctrl when streaming -> 2426 * Clear streaming to avoid setting all ctrls twice. 2427 */ 2428 streaming = gspca_dev->streaming; 2429 gspca_dev->streaming = 0; 2430 if (streaming) 2431 ret = gspca_init_transfer(gspca_dev); 2432 else 2433 gspca_input_create_urb(gspca_dev); 2434 mutex_unlock(&gspca_dev->usb_lock); 2435 2436 return ret; 2437 } 2438 EXPORT_SYMBOL(gspca_resume); 2439 #endif 2440 2441 /* -- module insert / remove -- */ 2442 static int __init gspca_init(void) 2443 { 2444 pr_info("v" GSPCA_VERSION " registered\n"); 2445 return 0; 2446 } 2447 static void __exit gspca_exit(void) 2448 { 2449 } 2450 2451 module_init(gspca_init); 2452 module_exit(gspca_exit); 2453 2454 #ifdef GSPCA_DEBUG 2455 module_param_named(debug, gspca_debug, int, 0644); 2456 MODULE_PARM_DESC(debug, 2457 "Debug (bit) 0x01:error 0x02:probe 0x04:config" 2458 " 0x08:stream 0x10:frame 0x20:packet" 2459 " 0x0100: v4l2"); 2460 #endif 2461