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