1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Main USB camera driver 4 * 5 * Copyright (C) 2008-2011 Jean-François Moine <http://moinejf.free.fr> 6 * 7 * Camera button input handling by Márton Németh 8 * Copyright (C) 2009-2010 Márton Németh <nm127@freemail.hu> 9 */ 10 11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 12 13 #define GSPCA_VERSION "2.14.0" 14 15 #include <linux/init.h> 16 #include <linux/fs.h> 17 #include <linux/vmalloc.h> 18 #include <linux/sched.h> 19 #include <linux/slab.h> 20 #include <linux/mm.h> 21 #include <linux/string.h> 22 #include <linux/pagemap.h> 23 #include <linux/io.h> 24 #include <asm/page.h> 25 #include <linux/uaccess.h> 26 #include <linux/ktime.h> 27 #include <media/v4l2-ioctl.h> 28 #include <media/v4l2-ctrls.h> 29 #include <media/v4l2-fh.h> 30 #include <media/v4l2-event.h> 31 32 #include "gspca.h" 33 34 #if IS_ENABLED(CONFIG_INPUT) 35 #include <linux/input.h> 36 #include <linux/usb/input.h> 37 #endif 38 39 /* global values */ 40 #define DEF_NURBS 3 /* default number of URBs */ 41 #if DEF_NURBS > MAX_NURBS 42 #error "DEF_NURBS too big" 43 #endif 44 45 MODULE_AUTHOR("Jean-François Moine <http://moinejf.free.fr>"); 46 MODULE_DESCRIPTION("GSPCA USB Camera Driver"); 47 MODULE_LICENSE("GPL"); 48 MODULE_VERSION(GSPCA_VERSION); 49 50 int gspca_debug; 51 EXPORT_SYMBOL(gspca_debug); 52 53 static void PDEBUG_MODE(struct gspca_dev *gspca_dev, int debug, char *txt, 54 __u32 pixfmt, int w, int h) 55 { 56 if ((pixfmt >> 24) >= '0' && (pixfmt >> 24) <= 'z') { 57 gspca_dbg(gspca_dev, debug, "%s %c%c%c%c %dx%d\n", 58 txt, 59 pixfmt & 0xff, 60 (pixfmt >> 8) & 0xff, 61 (pixfmt >> 16) & 0xff, 62 pixfmt >> 24, 63 w, h); 64 } else { 65 gspca_dbg(gspca_dev, debug, "%s 0x%08x %dx%d\n", 66 txt, 67 pixfmt, 68 w, h); 69 } 70 } 71 72 /* specific memory types - !! should be different from V4L2_MEMORY_xxx */ 73 #define GSPCA_MEMORY_NO 0 /* V4L2_MEMORY_xxx starts from 1 */ 74 #define GSPCA_MEMORY_READ 7 75 76 /* 77 * Input and interrupt endpoint handling functions 78 */ 79 #if IS_ENABLED(CONFIG_INPUT) 80 static void int_irq(struct urb *urb) 81 { 82 struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context; 83 int ret; 84 85 ret = urb->status; 86 switch (ret) { 87 case 0: 88 if (gspca_dev->sd_desc->int_pkt_scan(gspca_dev, 89 urb->transfer_buffer, urb->actual_length) < 0) { 90 gspca_err(gspca_dev, "Unknown packet received\n"); 91 } 92 break; 93 94 case -ENOENT: 95 case -ECONNRESET: 96 case -ENODEV: 97 case -ESHUTDOWN: 98 /* Stop is requested either by software or hardware is gone, 99 * keep the ret value non-zero and don't resubmit later. 100 */ 101 break; 102 103 default: 104 gspca_err(gspca_dev, "URB error %i, resubmitting\n", 105 urb->status); 106 urb->status = 0; 107 ret = 0; 108 } 109 110 if (ret == 0) { 111 ret = usb_submit_urb(urb, GFP_ATOMIC); 112 if (ret < 0) 113 pr_err("Resubmit URB failed with error %i\n", ret); 114 } 115 } 116 117 static int gspca_input_connect(struct gspca_dev *dev) 118 { 119 struct input_dev *input_dev; 120 int err = 0; 121 122 dev->input_dev = NULL; 123 if (dev->sd_desc->int_pkt_scan || dev->sd_desc->other_input) { 124 input_dev = input_allocate_device(); 125 if (!input_dev) 126 return -ENOMEM; 127 128 usb_make_path(dev->dev, dev->phys, sizeof(dev->phys)); 129 strlcat(dev->phys, "/input0", sizeof(dev->phys)); 130 131 input_dev->name = dev->sd_desc->name; 132 input_dev->phys = dev->phys; 133 134 usb_to_input_id(dev->dev, &input_dev->id); 135 136 input_dev->evbit[0] = BIT_MASK(EV_KEY); 137 input_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA); 138 input_dev->dev.parent = &dev->dev->dev; 139 140 err = input_register_device(input_dev); 141 if (err) { 142 pr_err("Input device registration failed with error %i\n", 143 err); 144 input_dev->dev.parent = NULL; 145 input_free_device(input_dev); 146 } else { 147 dev->input_dev = input_dev; 148 } 149 } 150 151 return err; 152 } 153 154 static int alloc_and_submit_int_urb(struct gspca_dev *gspca_dev, 155 struct usb_endpoint_descriptor *ep) 156 { 157 unsigned int buffer_len; 158 int interval; 159 struct urb *urb; 160 struct usb_device *dev; 161 void *buffer = NULL; 162 int ret = -EINVAL; 163 164 buffer_len = le16_to_cpu(ep->wMaxPacketSize); 165 interval = ep->bInterval; 166 gspca_dbg(gspca_dev, D_CONF, "found int in endpoint: 0x%x, buffer_len=%u, interval=%u\n", 167 ep->bEndpointAddress, buffer_len, interval); 168 169 dev = gspca_dev->dev; 170 171 urb = usb_alloc_urb(0, GFP_KERNEL); 172 if (!urb) { 173 ret = -ENOMEM; 174 goto error; 175 } 176 177 buffer = usb_alloc_coherent(dev, buffer_len, 178 GFP_KERNEL, &urb->transfer_dma); 179 if (!buffer) { 180 ret = -ENOMEM; 181 goto error_buffer; 182 } 183 usb_fill_int_urb(urb, dev, 184 usb_rcvintpipe(dev, ep->bEndpointAddress), 185 buffer, buffer_len, 186 int_irq, (void *)gspca_dev, interval); 187 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 188 ret = usb_submit_urb(urb, GFP_KERNEL); 189 if (ret < 0) { 190 gspca_err(gspca_dev, "submit int URB failed with error %i\n", 191 ret); 192 goto error_submit; 193 } 194 gspca_dev->int_urb = urb; 195 return ret; 196 197 error_submit: 198 usb_free_coherent(dev, 199 urb->transfer_buffer_length, 200 urb->transfer_buffer, 201 urb->transfer_dma); 202 error_buffer: 203 usb_free_urb(urb); 204 error: 205 return ret; 206 } 207 208 static void gspca_input_create_urb(struct gspca_dev *gspca_dev) 209 { 210 struct usb_interface *intf; 211 struct usb_endpoint_descriptor *ep; 212 int ret; 213 214 if (gspca_dev->sd_desc->int_pkt_scan) { 215 intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface); 216 217 ret = usb_find_int_in_endpoint(intf->cur_altsetting, &ep); 218 if (ret) 219 return; 220 221 alloc_and_submit_int_urb(gspca_dev, ep); 222 } 223 } 224 225 static void gspca_input_destroy_urb(struct gspca_dev *gspca_dev) 226 { 227 struct urb *urb; 228 229 urb = gspca_dev->int_urb; 230 if (urb) { 231 gspca_dev->int_urb = NULL; 232 usb_kill_urb(urb); 233 usb_free_coherent(gspca_dev->dev, 234 urb->transfer_buffer_length, 235 urb->transfer_buffer, 236 urb->transfer_dma); 237 usb_free_urb(urb); 238 } 239 } 240 #else 241 static inline void gspca_input_destroy_urb(struct gspca_dev *gspca_dev) 242 { 243 } 244 245 static inline void gspca_input_create_urb(struct gspca_dev *gspca_dev) 246 { 247 } 248 249 static inline int gspca_input_connect(struct gspca_dev *dev) 250 { 251 return 0; 252 } 253 #endif 254 255 /* 256 * fill a video frame from an URB and resubmit 257 */ 258 static void fill_frame(struct gspca_dev *gspca_dev, 259 struct urb *urb) 260 { 261 u8 *data; /* address of data in the iso message */ 262 int i, len, st; 263 cam_pkt_op pkt_scan; 264 265 if (urb->status != 0) { 266 if (urb->status == -ESHUTDOWN) 267 return; /* disconnection */ 268 #ifdef CONFIG_PM 269 if (gspca_dev->frozen) 270 return; 271 #endif 272 gspca_err(gspca_dev, "urb status: %d\n", urb->status); 273 urb->status = 0; 274 goto resubmit; 275 } 276 pkt_scan = gspca_dev->sd_desc->pkt_scan; 277 for (i = 0; i < urb->number_of_packets; i++) { 278 len = urb->iso_frame_desc[i].actual_length; 279 280 /* check the packet status and length */ 281 st = urb->iso_frame_desc[i].status; 282 if (st) { 283 gspca_dbg(gspca_dev, D_PACK, "ISOC data error: [%d] len=%d, status=%d\n", 284 i, len, st); 285 gspca_dev->last_packet_type = DISCARD_PACKET; 286 continue; 287 } 288 if (len == 0) { 289 if (gspca_dev->empty_packet == 0) 290 gspca_dev->empty_packet = 1; 291 continue; 292 } 293 294 /* let the packet be analyzed by the subdriver */ 295 gspca_dbg(gspca_dev, D_PACK, "packet [%d] o:%d l:%d\n", 296 i, urb->iso_frame_desc[i].offset, len); 297 data = (u8 *) urb->transfer_buffer 298 + urb->iso_frame_desc[i].offset; 299 pkt_scan(gspca_dev, data, len); 300 } 301 302 resubmit: 303 if (!gspca_dev->streaming) 304 return; 305 /* resubmit the URB */ 306 st = usb_submit_urb(urb, GFP_ATOMIC); 307 if (st < 0) 308 pr_err("usb_submit_urb() ret %d\n", st); 309 } 310 311 /* 312 * ISOC message interrupt from the USB device 313 * 314 * Analyse each packet and call the subdriver for copy to the frame buffer. 315 */ 316 static void isoc_irq(struct urb *urb) 317 { 318 struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context; 319 320 gspca_dbg(gspca_dev, D_PACK, "isoc irq\n"); 321 if (!gspca_dev->streaming) 322 return; 323 fill_frame(gspca_dev, urb); 324 } 325 326 /* 327 * bulk message interrupt from the USB device 328 */ 329 static void bulk_irq(struct urb *urb) 330 { 331 struct gspca_dev *gspca_dev = (struct gspca_dev *) urb->context; 332 int st; 333 334 gspca_dbg(gspca_dev, D_PACK, "bulk irq\n"); 335 if (!gspca_dev->streaming) 336 return; 337 switch (urb->status) { 338 case 0: 339 break; 340 case -ESHUTDOWN: 341 return; /* disconnection */ 342 default: 343 #ifdef CONFIG_PM 344 if (gspca_dev->frozen) 345 return; 346 #endif 347 gspca_err(gspca_dev, "urb status: %d\n", urb->status); 348 urb->status = 0; 349 goto resubmit; 350 } 351 352 gspca_dbg(gspca_dev, D_PACK, "packet l:%d\n", urb->actual_length); 353 gspca_dev->sd_desc->pkt_scan(gspca_dev, 354 urb->transfer_buffer, 355 urb->actual_length); 356 357 resubmit: 358 if (!gspca_dev->streaming) 359 return; 360 /* resubmit the URB */ 361 if (gspca_dev->cam.bulk_nurbs != 0) { 362 st = usb_submit_urb(urb, GFP_ATOMIC); 363 if (st < 0) 364 pr_err("usb_submit_urb() ret %d\n", st); 365 } 366 } 367 368 /* 369 * add data to the current frame 370 * 371 * This function is called by the subdrivers at interrupt level. 372 * 373 * To build a frame, these ones must add 374 * - one FIRST_PACKET 375 * - 0 or many INTER_PACKETs 376 * - one LAST_PACKET 377 * DISCARD_PACKET invalidates the whole frame. 378 */ 379 void gspca_frame_add(struct gspca_dev *gspca_dev, 380 enum gspca_packet_type packet_type, 381 const u8 *data, 382 int len) 383 { 384 struct gspca_buffer *buf; 385 unsigned long flags; 386 387 gspca_dbg(gspca_dev, D_PACK, "add t:%d l:%d\n", packet_type, len); 388 389 spin_lock_irqsave(&gspca_dev->qlock, flags); 390 buf = list_first_entry_or_null(&gspca_dev->buf_list, 391 typeof(*buf), list); 392 spin_unlock_irqrestore(&gspca_dev->qlock, flags); 393 394 if (packet_type == FIRST_PACKET) { 395 /* if there is no queued buffer, discard the whole frame */ 396 if (!buf) { 397 gspca_dev->last_packet_type = DISCARD_PACKET; 398 gspca_dev->sequence++; 399 return; 400 } 401 gspca_dev->image = vb2_plane_vaddr(&buf->vb.vb2_buf, 0); 402 gspca_dev->image_len = 0; 403 } else { 404 switch (gspca_dev->last_packet_type) { 405 case DISCARD_PACKET: 406 if (packet_type == LAST_PACKET) { 407 gspca_dev->last_packet_type = packet_type; 408 gspca_dev->image = NULL; 409 gspca_dev->image_len = 0; 410 } 411 return; 412 case LAST_PACKET: 413 return; 414 } 415 } 416 417 /* append the packet to the frame buffer */ 418 if (len > 0) { 419 if (gspca_dev->image_len + len > PAGE_ALIGN(gspca_dev->pixfmt.sizeimage)) { 420 gspca_err(gspca_dev, "frame overflow %d > %d\n", 421 gspca_dev->image_len + len, 422 PAGE_ALIGN(gspca_dev->pixfmt.sizeimage)); 423 packet_type = DISCARD_PACKET; 424 } else { 425 /* !! image is NULL only when last pkt is LAST or DISCARD 426 if (gspca_dev->image == NULL) { 427 pr_err("gspca_frame_add() image == NULL\n"); 428 return; 429 } 430 */ 431 memcpy(gspca_dev->image + gspca_dev->image_len, 432 data, len); 433 gspca_dev->image_len += len; 434 } 435 } 436 gspca_dev->last_packet_type = packet_type; 437 438 /* if last packet, invalidate packet concatenation until 439 * next first packet, wake up the application and advance 440 * in the queue */ 441 if (packet_type == LAST_PACKET) { 442 if (gspca_dev->image_len > gspca_dev->pixfmt.sizeimage) 443 gspca_dev->image_len = gspca_dev->pixfmt.sizeimage; 444 spin_lock_irqsave(&gspca_dev->qlock, flags); 445 list_del(&buf->list); 446 spin_unlock_irqrestore(&gspca_dev->qlock, flags); 447 buf->vb.vb2_buf.timestamp = ktime_get_ns(); 448 vb2_set_plane_payload(&buf->vb.vb2_buf, 0, 449 gspca_dev->image_len); 450 buf->vb.sequence = gspca_dev->sequence++; 451 buf->vb.field = V4L2_FIELD_NONE; 452 gspca_dbg(gspca_dev, D_FRAM, "frame complete len:%d\n", 453 gspca_dev->image_len); 454 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE); 455 gspca_dev->image = NULL; 456 gspca_dev->image_len = 0; 457 } 458 } 459 EXPORT_SYMBOL(gspca_frame_add); 460 461 static void destroy_urbs(struct gspca_dev *gspca_dev) 462 { 463 struct urb *urb; 464 unsigned int i; 465 466 gspca_dbg(gspca_dev, D_STREAM, "kill transfer\n"); 467 468 /* Killing all URBs guarantee that no URB completion 469 * handler is running. Therefore, there shouldn't 470 * be anyone trying to access gspca_dev->urb[i] 471 */ 472 for (i = 0; i < MAX_NURBS; i++) 473 usb_kill_urb(gspca_dev->urb[i]); 474 475 gspca_dbg(gspca_dev, D_STREAM, "releasing urbs\n"); 476 for (i = 0; i < MAX_NURBS; i++) { 477 urb = gspca_dev->urb[i]; 478 if (!urb) 479 continue; 480 gspca_dev->urb[i] = NULL; 481 usb_free_coherent(gspca_dev->dev, 482 urb->transfer_buffer_length, 483 urb->transfer_buffer, 484 urb->transfer_dma); 485 usb_free_urb(urb); 486 } 487 } 488 489 static int gspca_set_alt0(struct gspca_dev *gspca_dev) 490 { 491 int ret; 492 493 if (gspca_dev->alt == 0) 494 return 0; 495 ret = usb_set_interface(gspca_dev->dev, gspca_dev->iface, 0); 496 if (ret < 0) 497 pr_err("set alt 0 err %d\n", ret); 498 return ret; 499 } 500 501 /* 502 * look for an input transfer endpoint in an alternate setting. 503 * 504 * If xfer_ep is invalid, return the first valid ep found, otherwise 505 * look for exactly the ep with address equal to xfer_ep. 506 */ 507 static struct usb_host_endpoint *alt_xfer(struct usb_host_interface *alt, 508 int xfer, int xfer_ep) 509 { 510 struct usb_host_endpoint *ep; 511 int i, attr; 512 513 for (i = 0; i < alt->desc.bNumEndpoints; i++) { 514 ep = &alt->endpoint[i]; 515 attr = ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; 516 if (attr == xfer 517 && ep->desc.wMaxPacketSize != 0 518 && usb_endpoint_dir_in(&ep->desc) 519 && (xfer_ep < 0 || ep->desc.bEndpointAddress == xfer_ep)) 520 return ep; 521 } 522 return NULL; 523 } 524 525 /* compute the minimum bandwidth for the current transfer */ 526 static u32 which_bandwidth(struct gspca_dev *gspca_dev) 527 { 528 u32 bandwidth; 529 530 /* get the (max) image size */ 531 bandwidth = gspca_dev->pixfmt.sizeimage; 532 533 /* if the image is compressed, estimate its mean size */ 534 if (!gspca_dev->cam.needs_full_bandwidth && 535 bandwidth < gspca_dev->pixfmt.width * 536 gspca_dev->pixfmt.height) 537 bandwidth = bandwidth * 3 / 8; /* 0.375 */ 538 539 /* estimate the frame rate */ 540 if (gspca_dev->sd_desc->get_streamparm) { 541 struct v4l2_streamparm parm; 542 543 gspca_dev->sd_desc->get_streamparm(gspca_dev, &parm); 544 bandwidth *= parm.parm.capture.timeperframe.denominator; 545 bandwidth /= parm.parm.capture.timeperframe.numerator; 546 } else { 547 548 /* don't hope more than 15 fps with USB 1.1 and 549 * image resolution >= 640x480 */ 550 if (gspca_dev->pixfmt.width >= 640 551 && gspca_dev->dev->speed == USB_SPEED_FULL) 552 bandwidth *= 15; /* 15 fps */ 553 else 554 bandwidth *= 30; /* 30 fps */ 555 } 556 557 gspca_dbg(gspca_dev, D_STREAM, "min bandwidth: %d\n", bandwidth); 558 return bandwidth; 559 } 560 561 /* endpoint table */ 562 #define MAX_ALT 16 563 struct ep_tb_s { 564 u32 alt; 565 u32 bandwidth; 566 }; 567 568 /* 569 * build the table of the endpoints 570 * and compute the minimum bandwidth for the image transfer 571 */ 572 static int build_isoc_ep_tb(struct gspca_dev *gspca_dev, 573 struct usb_interface *intf, 574 struct ep_tb_s *ep_tb) 575 { 576 struct usb_host_endpoint *ep; 577 int i, j, nbalt, psize, found; 578 u32 bandwidth, last_bw; 579 580 nbalt = intf->num_altsetting; 581 if (nbalt > MAX_ALT) 582 nbalt = MAX_ALT; /* fixme: should warn */ 583 584 /* build the endpoint table */ 585 i = 0; 586 last_bw = 0; 587 for (;;) { 588 ep_tb->bandwidth = 2000 * 2000 * 120; 589 found = 0; 590 for (j = 0; j < nbalt; j++) { 591 ep = alt_xfer(&intf->altsetting[j], 592 USB_ENDPOINT_XFER_ISOC, 593 gspca_dev->xfer_ep); 594 if (ep == NULL) 595 continue; 596 if (ep->desc.bInterval == 0) { 597 pr_err("alt %d iso endp with 0 interval\n", j); 598 continue; 599 } 600 psize = le16_to_cpu(ep->desc.wMaxPacketSize); 601 psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3)); 602 bandwidth = psize * 1000; 603 if (gspca_dev->dev->speed == USB_SPEED_HIGH 604 || gspca_dev->dev->speed >= USB_SPEED_SUPER) 605 bandwidth *= 8; 606 bandwidth /= 1 << (ep->desc.bInterval - 1); 607 if (bandwidth <= last_bw) 608 continue; 609 if (bandwidth < ep_tb->bandwidth) { 610 ep_tb->bandwidth = bandwidth; 611 ep_tb->alt = j; 612 found = 1; 613 } 614 } 615 if (!found) 616 break; 617 gspca_dbg(gspca_dev, D_STREAM, "alt %d bandwidth %d\n", 618 ep_tb->alt, ep_tb->bandwidth); 619 last_bw = ep_tb->bandwidth; 620 i++; 621 ep_tb++; 622 } 623 624 /* 625 * If the camera: 626 * has a usb audio class interface (a built in usb mic); and 627 * is a usb 1 full speed device; and 628 * uses the max full speed iso bandwidth; and 629 * and has more than 1 alt setting 630 * then skip the highest alt setting to spare bandwidth for the mic 631 */ 632 if (gspca_dev->audio && 633 gspca_dev->dev->speed == USB_SPEED_FULL && 634 last_bw >= 1000000 && 635 i > 1) { 636 gspca_dbg(gspca_dev, D_STREAM, "dev has usb audio, skipping highest alt\n"); 637 i--; 638 ep_tb--; 639 } 640 641 /* get the requested bandwidth and start at the highest atlsetting */ 642 bandwidth = which_bandwidth(gspca_dev); 643 ep_tb--; 644 while (i > 1) { 645 ep_tb--; 646 if (ep_tb->bandwidth < bandwidth) 647 break; 648 i--; 649 } 650 return i; 651 } 652 653 /* 654 * create the URBs for image transfer 655 */ 656 static int create_urbs(struct gspca_dev *gspca_dev, 657 struct usb_host_endpoint *ep) 658 { 659 struct urb *urb; 660 int n, nurbs, i, psize, npkt, bsize; 661 662 /* calculate the packet size and the number of packets */ 663 psize = le16_to_cpu(ep->desc.wMaxPacketSize); 664 665 if (!gspca_dev->cam.bulk) { /* isoc */ 666 667 /* See paragraph 5.9 / table 5-11 of the usb 2.0 spec. */ 668 if (gspca_dev->pkt_size == 0) 669 psize = (psize & 0x07ff) * (1 + ((psize >> 11) & 3)); 670 else 671 psize = gspca_dev->pkt_size; 672 npkt = gspca_dev->cam.npkt; 673 if (npkt == 0) 674 npkt = 32; /* default value */ 675 bsize = psize * npkt; 676 gspca_dbg(gspca_dev, D_STREAM, 677 "isoc %d pkts size %d = bsize:%d\n", 678 npkt, psize, bsize); 679 nurbs = DEF_NURBS; 680 } else { /* bulk */ 681 npkt = 0; 682 bsize = gspca_dev->cam.bulk_size; 683 if (bsize == 0) 684 bsize = psize; 685 gspca_dbg(gspca_dev, D_STREAM, "bulk bsize:%d\n", bsize); 686 if (gspca_dev->cam.bulk_nurbs != 0) 687 nurbs = gspca_dev->cam.bulk_nurbs; 688 else 689 nurbs = 1; 690 } 691 692 for (n = 0; n < nurbs; n++) { 693 urb = usb_alloc_urb(npkt, GFP_KERNEL); 694 if (!urb) 695 return -ENOMEM; 696 gspca_dev->urb[n] = urb; 697 urb->transfer_buffer = usb_alloc_coherent(gspca_dev->dev, 698 bsize, 699 GFP_KERNEL, 700 &urb->transfer_dma); 701 702 if (urb->transfer_buffer == NULL) { 703 pr_err("usb_alloc_coherent failed\n"); 704 return -ENOMEM; 705 } 706 urb->dev = gspca_dev->dev; 707 urb->context = gspca_dev; 708 urb->transfer_buffer_length = bsize; 709 if (npkt != 0) { /* ISOC */ 710 urb->pipe = usb_rcvisocpipe(gspca_dev->dev, 711 ep->desc.bEndpointAddress); 712 urb->transfer_flags = URB_ISO_ASAP 713 | URB_NO_TRANSFER_DMA_MAP; 714 urb->interval = 1 << (ep->desc.bInterval - 1); 715 urb->complete = isoc_irq; 716 urb->number_of_packets = npkt; 717 for (i = 0; i < npkt; i++) { 718 urb->iso_frame_desc[i].length = psize; 719 urb->iso_frame_desc[i].offset = psize * i; 720 } 721 } else { /* bulk */ 722 urb->pipe = usb_rcvbulkpipe(gspca_dev->dev, 723 ep->desc.bEndpointAddress); 724 urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP; 725 urb->complete = bulk_irq; 726 } 727 } 728 return 0; 729 } 730 731 /* Note: both the queue and the usb locks should be held when calling this */ 732 static void gspca_stream_off(struct gspca_dev *gspca_dev) 733 { 734 gspca_dev->streaming = false; 735 gspca_dev->usb_err = 0; 736 if (gspca_dev->sd_desc->stopN) 737 gspca_dev->sd_desc->stopN(gspca_dev); 738 destroy_urbs(gspca_dev); 739 gspca_input_destroy_urb(gspca_dev); 740 gspca_set_alt0(gspca_dev); 741 if (gspca_dev->present) 742 gspca_input_create_urb(gspca_dev); 743 if (gspca_dev->sd_desc->stop0) 744 gspca_dev->sd_desc->stop0(gspca_dev); 745 gspca_dbg(gspca_dev, D_STREAM, "stream off OK\n"); 746 } 747 748 /* 749 * start the USB transfer 750 */ 751 static int gspca_init_transfer(struct gspca_dev *gspca_dev) 752 { 753 struct usb_interface *intf; 754 struct usb_host_endpoint *ep; 755 struct urb *urb; 756 struct ep_tb_s ep_tb[MAX_ALT]; 757 int n, ret, xfer, alt, alt_idx; 758 759 /* reset the streaming variables */ 760 gspca_dev->image = NULL; 761 gspca_dev->image_len = 0; 762 gspca_dev->last_packet_type = DISCARD_PACKET; 763 764 gspca_dev->usb_err = 0; 765 766 /* do the specific subdriver stuff before endpoint selection */ 767 intf = usb_ifnum_to_if(gspca_dev->dev, gspca_dev->iface); 768 gspca_dev->alt = gspca_dev->cam.bulk ? intf->num_altsetting : 0; 769 if (gspca_dev->sd_desc->isoc_init) { 770 ret = gspca_dev->sd_desc->isoc_init(gspca_dev); 771 if (ret < 0) 772 return ret; 773 } 774 xfer = gspca_dev->cam.bulk ? USB_ENDPOINT_XFER_BULK 775 : USB_ENDPOINT_XFER_ISOC; 776 777 /* if bulk or the subdriver forced an altsetting, get the endpoint */ 778 if (gspca_dev->alt != 0) { 779 gspca_dev->alt--; /* (previous version compatibility) */ 780 ep = alt_xfer(&intf->altsetting[gspca_dev->alt], xfer, 781 gspca_dev->xfer_ep); 782 if (ep == NULL) { 783 pr_err("bad altsetting %d\n", gspca_dev->alt); 784 return -EIO; 785 } 786 ep_tb[0].alt = gspca_dev->alt; 787 alt_idx = 1; 788 } else { 789 /* else, compute the minimum bandwidth 790 * and build the endpoint table */ 791 alt_idx = build_isoc_ep_tb(gspca_dev, intf, ep_tb); 792 if (alt_idx <= 0) { 793 pr_err("no transfer endpoint found\n"); 794 return -EIO; 795 } 796 } 797 798 /* set the highest alternate setting and 799 * loop until urb submit succeeds */ 800 gspca_input_destroy_urb(gspca_dev); 801 802 gspca_dev->alt = ep_tb[--alt_idx].alt; 803 alt = -1; 804 for (;;) { 805 if (alt != gspca_dev->alt) { 806 alt = gspca_dev->alt; 807 if (intf->num_altsetting > 1) { 808 ret = usb_set_interface(gspca_dev->dev, 809 gspca_dev->iface, 810 alt); 811 if (ret < 0) { 812 if (ret == -ENOSPC) 813 goto retry; /*fixme: ugly*/ 814 pr_err("set alt %d err %d\n", alt, ret); 815 goto out; 816 } 817 } 818 } 819 if (!gspca_dev->cam.no_urb_create) { 820 gspca_dbg(gspca_dev, D_STREAM, "init transfer alt %d\n", 821 alt); 822 ret = create_urbs(gspca_dev, 823 alt_xfer(&intf->altsetting[alt], xfer, 824 gspca_dev->xfer_ep)); 825 if (ret < 0) { 826 destroy_urbs(gspca_dev); 827 goto out; 828 } 829 } 830 831 /* clear the bulk endpoint */ 832 if (gspca_dev->cam.bulk) 833 usb_clear_halt(gspca_dev->dev, 834 gspca_dev->urb[0]->pipe); 835 836 /* start the cam */ 837 ret = gspca_dev->sd_desc->start(gspca_dev); 838 if (ret < 0) { 839 destroy_urbs(gspca_dev); 840 goto out; 841 } 842 v4l2_ctrl_handler_setup(gspca_dev->vdev.ctrl_handler); 843 gspca_dev->streaming = true; 844 845 /* some bulk transfers are started by the subdriver */ 846 if (gspca_dev->cam.bulk && gspca_dev->cam.bulk_nurbs == 0) 847 break; 848 849 /* submit the URBs */ 850 for (n = 0; n < MAX_NURBS; n++) { 851 urb = gspca_dev->urb[n]; 852 if (urb == NULL) 853 break; 854 ret = usb_submit_urb(urb, GFP_KERNEL); 855 if (ret < 0) 856 break; 857 } 858 if (ret >= 0) 859 break; /* transfer is started */ 860 861 /* something when wrong 862 * stop the webcam and free the transfer resources */ 863 gspca_stream_off(gspca_dev); 864 if (ret != -ENOSPC) { 865 pr_err("usb_submit_urb alt %d err %d\n", 866 gspca_dev->alt, ret); 867 goto out; 868 } 869 870 /* the bandwidth is not wide enough 871 * negotiate or try a lower alternate setting */ 872 retry: 873 gspca_err(gspca_dev, "alt %d - bandwidth not wide enough, trying again\n", 874 alt); 875 msleep(20); /* wait for kill complete */ 876 if (gspca_dev->sd_desc->isoc_nego) { 877 ret = gspca_dev->sd_desc->isoc_nego(gspca_dev); 878 if (ret < 0) 879 goto out; 880 } else { 881 if (alt_idx <= 0) { 882 pr_err("no transfer endpoint found\n"); 883 ret = -EIO; 884 goto out; 885 } 886 gspca_dev->alt = ep_tb[--alt_idx].alt; 887 } 888 } 889 out: 890 gspca_input_create_urb(gspca_dev); 891 return ret; 892 } 893 894 static void gspca_set_default_mode(struct gspca_dev *gspca_dev) 895 { 896 int i; 897 898 i = gspca_dev->cam.nmodes - 1; /* take the highest mode */ 899 gspca_dev->curr_mode = i; 900 gspca_dev->pixfmt = gspca_dev->cam.cam_mode[i]; 901 902 /* does nothing if ctrl_handler == NULL */ 903 v4l2_ctrl_handler_setup(gspca_dev->vdev.ctrl_handler); 904 } 905 906 static int wxh_to_mode(struct gspca_dev *gspca_dev, 907 int width, int height, u32 pixelformat) 908 { 909 int i; 910 911 for (i = 0; i < gspca_dev->cam.nmodes; i++) { 912 if (width == gspca_dev->cam.cam_mode[i].width 913 && height == gspca_dev->cam.cam_mode[i].height 914 && pixelformat == gspca_dev->cam.cam_mode[i].pixelformat) 915 return i; 916 } 917 return -EINVAL; 918 } 919 920 static int wxh_to_nearest_mode(struct gspca_dev *gspca_dev, 921 int width, int height, u32 pixelformat) 922 { 923 int i; 924 925 for (i = gspca_dev->cam.nmodes; --i >= 0; ) { 926 if (width >= gspca_dev->cam.cam_mode[i].width 927 && height >= gspca_dev->cam.cam_mode[i].height 928 && pixelformat == gspca_dev->cam.cam_mode[i].pixelformat) 929 return i; 930 } 931 for (i = gspca_dev->cam.nmodes; --i > 0; ) { 932 if (width >= gspca_dev->cam.cam_mode[i].width 933 && height >= gspca_dev->cam.cam_mode[i].height) 934 break; 935 } 936 return i; 937 } 938 939 /* 940 * search a mode with the right pixel format 941 */ 942 static int gspca_get_mode(struct gspca_dev *gspca_dev, 943 int mode, 944 int pixfmt) 945 { 946 int modeU, modeD; 947 948 modeU = modeD = mode; 949 while ((modeU < gspca_dev->cam.nmodes) || modeD >= 0) { 950 if (--modeD >= 0) { 951 if (gspca_dev->cam.cam_mode[modeD].pixelformat 952 == pixfmt) 953 return modeD; 954 } 955 if (++modeU < gspca_dev->cam.nmodes) { 956 if (gspca_dev->cam.cam_mode[modeU].pixelformat 957 == pixfmt) 958 return modeU; 959 } 960 } 961 return -EINVAL; 962 } 963 964 #ifdef CONFIG_VIDEO_ADV_DEBUG 965 static int vidioc_g_chip_info(struct file *file, void *priv, 966 struct v4l2_dbg_chip_info *chip) 967 { 968 struct gspca_dev *gspca_dev = video_drvdata(file); 969 970 gspca_dev->usb_err = 0; 971 if (gspca_dev->sd_desc->get_chip_info) 972 return gspca_dev->sd_desc->get_chip_info(gspca_dev, chip); 973 return chip->match.addr ? -EINVAL : 0; 974 } 975 976 static int vidioc_g_register(struct file *file, void *priv, 977 struct v4l2_dbg_register *reg) 978 { 979 struct gspca_dev *gspca_dev = video_drvdata(file); 980 981 gspca_dev->usb_err = 0; 982 return gspca_dev->sd_desc->get_register(gspca_dev, reg); 983 } 984 985 static int vidioc_s_register(struct file *file, void *priv, 986 const struct v4l2_dbg_register *reg) 987 { 988 struct gspca_dev *gspca_dev = video_drvdata(file); 989 990 gspca_dev->usb_err = 0; 991 return gspca_dev->sd_desc->set_register(gspca_dev, reg); 992 } 993 #endif 994 995 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv, 996 struct v4l2_fmtdesc *fmtdesc) 997 { 998 struct gspca_dev *gspca_dev = video_drvdata(file); 999 int i, j, index; 1000 __u32 fmt_tb[8]; 1001 1002 /* give an index to each format */ 1003 index = 0; 1004 for (i = gspca_dev->cam.nmodes; --i >= 0; ) { 1005 fmt_tb[index] = gspca_dev->cam.cam_mode[i].pixelformat; 1006 j = 0; 1007 for (;;) { 1008 if (fmt_tb[j] == fmt_tb[index]) 1009 break; 1010 j++; 1011 } 1012 if (j == index) { 1013 if (fmtdesc->index == index) 1014 break; /* new format */ 1015 index++; 1016 if (index >= ARRAY_SIZE(fmt_tb)) 1017 return -EINVAL; 1018 } 1019 } 1020 if (i < 0) 1021 return -EINVAL; /* no more format */ 1022 1023 fmtdesc->pixelformat = fmt_tb[index]; 1024 return 0; 1025 } 1026 1027 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv, 1028 struct v4l2_format *fmt) 1029 { 1030 struct gspca_dev *gspca_dev = video_drvdata(file); 1031 u32 fmt_priv = fmt->fmt.pix.priv; 1032 1033 fmt->fmt.pix = gspca_dev->pixfmt; 1034 /* some drivers use priv internally, so keep the original value */ 1035 fmt->fmt.pix.priv = fmt_priv; 1036 return 0; 1037 } 1038 1039 static int try_fmt_vid_cap(struct gspca_dev *gspca_dev, 1040 struct v4l2_format *fmt) 1041 { 1042 int w, h, mode, mode2; 1043 1044 w = fmt->fmt.pix.width; 1045 h = fmt->fmt.pix.height; 1046 1047 PDEBUG_MODE(gspca_dev, D_CONF, "try fmt cap", 1048 fmt->fmt.pix.pixelformat, w, h); 1049 1050 /* search the nearest mode for width and height */ 1051 mode = wxh_to_nearest_mode(gspca_dev, w, h, fmt->fmt.pix.pixelformat); 1052 1053 /* OK if right palette */ 1054 if (gspca_dev->cam.cam_mode[mode].pixelformat 1055 != fmt->fmt.pix.pixelformat) { 1056 1057 /* else, search the closest mode with the same pixel format */ 1058 mode2 = gspca_get_mode(gspca_dev, mode, 1059 fmt->fmt.pix.pixelformat); 1060 if (mode2 >= 0) 1061 mode = mode2; 1062 } 1063 fmt->fmt.pix = gspca_dev->cam.cam_mode[mode]; 1064 if (gspca_dev->sd_desc->try_fmt) { 1065 /* pass original resolution to subdriver try_fmt */ 1066 fmt->fmt.pix.width = w; 1067 fmt->fmt.pix.height = h; 1068 gspca_dev->sd_desc->try_fmt(gspca_dev, fmt); 1069 } 1070 return mode; /* used when s_fmt */ 1071 } 1072 1073 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv, 1074 struct v4l2_format *fmt) 1075 { 1076 struct gspca_dev *gspca_dev = video_drvdata(file); 1077 u32 fmt_priv = fmt->fmt.pix.priv; 1078 1079 if (try_fmt_vid_cap(gspca_dev, fmt) < 0) 1080 return -EINVAL; 1081 /* some drivers use priv internally, so keep the original value */ 1082 fmt->fmt.pix.priv = fmt_priv; 1083 return 0; 1084 } 1085 1086 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, 1087 struct v4l2_format *fmt) 1088 { 1089 struct gspca_dev *gspca_dev = video_drvdata(file); 1090 u32 fmt_priv = fmt->fmt.pix.priv; 1091 int mode; 1092 1093 if (vb2_is_busy(&gspca_dev->queue)) 1094 return -EBUSY; 1095 1096 mode = try_fmt_vid_cap(gspca_dev, fmt); 1097 if (mode < 0) 1098 return -EINVAL; 1099 1100 gspca_dev->curr_mode = mode; 1101 if (gspca_dev->sd_desc->try_fmt) 1102 /* subdriver try_fmt can modify format parameters */ 1103 gspca_dev->pixfmt = fmt->fmt.pix; 1104 else 1105 gspca_dev->pixfmt = gspca_dev->cam.cam_mode[mode]; 1106 /* some drivers use priv internally, so keep the original value */ 1107 fmt->fmt.pix.priv = fmt_priv; 1108 return 0; 1109 } 1110 1111 static int vidioc_enum_framesizes(struct file *file, void *priv, 1112 struct v4l2_frmsizeenum *fsize) 1113 { 1114 struct gspca_dev *gspca_dev = video_drvdata(file); 1115 int i; 1116 __u32 index = 0; 1117 1118 if (gspca_dev->sd_desc->enum_framesizes) 1119 return gspca_dev->sd_desc->enum_framesizes(gspca_dev, fsize); 1120 1121 for (i = 0; i < gspca_dev->cam.nmodes; i++) { 1122 if (fsize->pixel_format != 1123 gspca_dev->cam.cam_mode[i].pixelformat) 1124 continue; 1125 1126 if (fsize->index == index) { 1127 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE; 1128 fsize->discrete.width = 1129 gspca_dev->cam.cam_mode[i].width; 1130 fsize->discrete.height = 1131 gspca_dev->cam.cam_mode[i].height; 1132 return 0; 1133 } 1134 index++; 1135 } 1136 1137 return -EINVAL; 1138 } 1139 1140 static int vidioc_enum_frameintervals(struct file *filp, void *priv, 1141 struct v4l2_frmivalenum *fival) 1142 { 1143 struct gspca_dev *gspca_dev = video_drvdata(filp); 1144 int mode; 1145 __u32 i; 1146 1147 mode = wxh_to_mode(gspca_dev, fival->width, fival->height, 1148 fival->pixel_format); 1149 if (mode < 0) 1150 return -EINVAL; 1151 1152 if (gspca_dev->cam.mode_framerates == NULL || 1153 gspca_dev->cam.mode_framerates[mode].nrates == 0) 1154 return -EINVAL; 1155 1156 if (fival->pixel_format != 1157 gspca_dev->cam.cam_mode[mode].pixelformat) 1158 return -EINVAL; 1159 1160 for (i = 0; i < gspca_dev->cam.mode_framerates[mode].nrates; i++) { 1161 if (fival->index == i) { 1162 fival->type = V4L2_FRMIVAL_TYPE_DISCRETE; 1163 fival->discrete.numerator = 1; 1164 fival->discrete.denominator = 1165 gspca_dev->cam.mode_framerates[mode].rates[i]; 1166 return 0; 1167 } 1168 } 1169 1170 return -EINVAL; 1171 } 1172 1173 static void gspca_release(struct v4l2_device *v4l2_device) 1174 { 1175 struct gspca_dev *gspca_dev = 1176 container_of(v4l2_device, struct gspca_dev, v4l2_dev); 1177 1178 v4l2_ctrl_handler_free(gspca_dev->vdev.ctrl_handler); 1179 v4l2_device_unregister(&gspca_dev->v4l2_dev); 1180 kfree(gspca_dev->usb_buf); 1181 kfree(gspca_dev); 1182 } 1183 1184 static int vidioc_querycap(struct file *file, void *priv, 1185 struct v4l2_capability *cap) 1186 { 1187 struct gspca_dev *gspca_dev = video_drvdata(file); 1188 1189 strscpy((char *)cap->driver, gspca_dev->sd_desc->name, 1190 sizeof(cap->driver)); 1191 if (gspca_dev->dev->product != NULL) { 1192 strscpy((char *)cap->card, gspca_dev->dev->product, 1193 sizeof(cap->card)); 1194 } else { 1195 snprintf((char *) cap->card, sizeof cap->card, 1196 "USB Camera (%04x:%04x)", 1197 le16_to_cpu(gspca_dev->dev->descriptor.idVendor), 1198 le16_to_cpu(gspca_dev->dev->descriptor.idProduct)); 1199 } 1200 usb_make_path(gspca_dev->dev, (char *) cap->bus_info, 1201 sizeof(cap->bus_info)); 1202 return 0; 1203 } 1204 1205 static int vidioc_enum_input(struct file *file, void *priv, 1206 struct v4l2_input *input) 1207 { 1208 struct gspca_dev *gspca_dev = video_drvdata(file); 1209 1210 if (input->index != 0) 1211 return -EINVAL; 1212 input->type = V4L2_INPUT_TYPE_CAMERA; 1213 input->status = gspca_dev->cam.input_flags; 1214 strscpy(input->name, gspca_dev->sd_desc->name, 1215 sizeof input->name); 1216 return 0; 1217 } 1218 1219 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) 1220 { 1221 *i = 0; 1222 return 0; 1223 } 1224 1225 static int vidioc_s_input(struct file *file, void *priv, unsigned int i) 1226 { 1227 if (i > 0) 1228 return -EINVAL; 1229 return 0; 1230 } 1231 1232 static int vidioc_g_jpegcomp(struct file *file, void *priv, 1233 struct v4l2_jpegcompression *jpegcomp) 1234 { 1235 struct gspca_dev *gspca_dev = video_drvdata(file); 1236 1237 gspca_dev->usb_err = 0; 1238 return gspca_dev->sd_desc->get_jcomp(gspca_dev, jpegcomp); 1239 } 1240 1241 static int vidioc_s_jpegcomp(struct file *file, void *priv, 1242 const struct v4l2_jpegcompression *jpegcomp) 1243 { 1244 struct gspca_dev *gspca_dev = video_drvdata(file); 1245 1246 gspca_dev->usb_err = 0; 1247 return gspca_dev->sd_desc->set_jcomp(gspca_dev, jpegcomp); 1248 } 1249 1250 static int vidioc_g_parm(struct file *filp, void *priv, 1251 struct v4l2_streamparm *parm) 1252 { 1253 struct gspca_dev *gspca_dev = video_drvdata(filp); 1254 1255 parm->parm.capture.readbuffers = gspca_dev->queue.min_queued_buffers; 1256 1257 if (!gspca_dev->sd_desc->get_streamparm) 1258 return 0; 1259 1260 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME; 1261 gspca_dev->usb_err = 0; 1262 gspca_dev->sd_desc->get_streamparm(gspca_dev, parm); 1263 return gspca_dev->usb_err; 1264 } 1265 1266 static int vidioc_s_parm(struct file *filp, void *priv, 1267 struct v4l2_streamparm *parm) 1268 { 1269 struct gspca_dev *gspca_dev = video_drvdata(filp); 1270 1271 parm->parm.capture.readbuffers = gspca_dev->queue.min_queued_buffers; 1272 1273 if (!gspca_dev->sd_desc->set_streamparm) { 1274 parm->parm.capture.capability = 0; 1275 return 0; 1276 } 1277 1278 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME; 1279 gspca_dev->usb_err = 0; 1280 gspca_dev->sd_desc->set_streamparm(gspca_dev, parm); 1281 return gspca_dev->usb_err; 1282 } 1283 1284 static int gspca_queue_setup(struct vb2_queue *vq, 1285 unsigned int *nbuffers, unsigned int *nplanes, 1286 unsigned int sizes[], struct device *alloc_devs[]) 1287 { 1288 struct gspca_dev *gspca_dev = vb2_get_drv_priv(vq); 1289 unsigned int size = PAGE_ALIGN(gspca_dev->pixfmt.sizeimage); 1290 1291 if (*nplanes) 1292 return sizes[0] < size ? -EINVAL : 0; 1293 *nplanes = 1; 1294 sizes[0] = size; 1295 return 0; 1296 } 1297 1298 static int gspca_buffer_prepare(struct vb2_buffer *vb) 1299 { 1300 struct gspca_dev *gspca_dev = vb2_get_drv_priv(vb->vb2_queue); 1301 unsigned long size = PAGE_ALIGN(gspca_dev->pixfmt.sizeimage); 1302 1303 if (vb2_plane_size(vb, 0) < size) { 1304 gspca_err(gspca_dev, "buffer too small (%lu < %lu)\n", 1305 vb2_plane_size(vb, 0), size); 1306 return -EINVAL; 1307 } 1308 return 0; 1309 } 1310 1311 static void gspca_buffer_finish(struct vb2_buffer *vb) 1312 { 1313 struct gspca_dev *gspca_dev = vb2_get_drv_priv(vb->vb2_queue); 1314 1315 if (!gspca_dev->sd_desc->dq_callback) 1316 return; 1317 1318 gspca_dev->usb_err = 0; 1319 if (gspca_dev->present) 1320 gspca_dev->sd_desc->dq_callback(gspca_dev); 1321 } 1322 1323 static void gspca_buffer_queue(struct vb2_buffer *vb) 1324 { 1325 struct gspca_dev *gspca_dev = vb2_get_drv_priv(vb->vb2_queue); 1326 struct gspca_buffer *buf = to_gspca_buffer(vb); 1327 unsigned long flags; 1328 1329 spin_lock_irqsave(&gspca_dev->qlock, flags); 1330 list_add_tail(&buf->list, &gspca_dev->buf_list); 1331 spin_unlock_irqrestore(&gspca_dev->qlock, flags); 1332 } 1333 1334 static void gspca_return_all_buffers(struct gspca_dev *gspca_dev, 1335 enum vb2_buffer_state state) 1336 { 1337 struct gspca_buffer *buf, *node; 1338 unsigned long flags; 1339 1340 spin_lock_irqsave(&gspca_dev->qlock, flags); 1341 list_for_each_entry_safe(buf, node, &gspca_dev->buf_list, list) { 1342 vb2_buffer_done(&buf->vb.vb2_buf, state); 1343 list_del(&buf->list); 1344 } 1345 spin_unlock_irqrestore(&gspca_dev->qlock, flags); 1346 } 1347 1348 static int gspca_start_streaming(struct vb2_queue *vq, unsigned int count) 1349 { 1350 struct gspca_dev *gspca_dev = vb2_get_drv_priv(vq); 1351 int ret; 1352 1353 gspca_dev->sequence = 0; 1354 1355 ret = gspca_init_transfer(gspca_dev); 1356 if (ret) 1357 gspca_return_all_buffers(gspca_dev, VB2_BUF_STATE_QUEUED); 1358 return ret; 1359 } 1360 1361 static void gspca_stop_streaming(struct vb2_queue *vq) 1362 { 1363 struct gspca_dev *gspca_dev = vb2_get_drv_priv(vq); 1364 1365 gspca_stream_off(gspca_dev); 1366 1367 /* Release all active buffers */ 1368 gspca_return_all_buffers(gspca_dev, VB2_BUF_STATE_ERROR); 1369 } 1370 1371 static const struct vb2_ops gspca_qops = { 1372 .queue_setup = gspca_queue_setup, 1373 .buf_prepare = gspca_buffer_prepare, 1374 .buf_finish = gspca_buffer_finish, 1375 .buf_queue = gspca_buffer_queue, 1376 .start_streaming = gspca_start_streaming, 1377 .stop_streaming = gspca_stop_streaming, 1378 }; 1379 1380 static const struct v4l2_file_operations dev_fops = { 1381 .owner = THIS_MODULE, 1382 .open = v4l2_fh_open, 1383 .release = vb2_fop_release, 1384 .unlocked_ioctl = video_ioctl2, 1385 .read = vb2_fop_read, 1386 .mmap = vb2_fop_mmap, 1387 .poll = vb2_fop_poll, 1388 }; 1389 1390 static const struct v4l2_ioctl_ops dev_ioctl_ops = { 1391 .vidioc_querycap = vidioc_querycap, 1392 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 1393 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 1394 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 1395 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 1396 .vidioc_enum_input = vidioc_enum_input, 1397 .vidioc_g_input = vidioc_g_input, 1398 .vidioc_s_input = vidioc_s_input, 1399 .vidioc_g_jpegcomp = vidioc_g_jpegcomp, 1400 .vidioc_s_jpegcomp = vidioc_s_jpegcomp, 1401 .vidioc_g_parm = vidioc_g_parm, 1402 .vidioc_s_parm = vidioc_s_parm, 1403 .vidioc_enum_framesizes = vidioc_enum_framesizes, 1404 .vidioc_enum_frameintervals = vidioc_enum_frameintervals, 1405 1406 .vidioc_reqbufs = vb2_ioctl_reqbufs, 1407 .vidioc_create_bufs = vb2_ioctl_create_bufs, 1408 .vidioc_querybuf = vb2_ioctl_querybuf, 1409 .vidioc_qbuf = vb2_ioctl_qbuf, 1410 .vidioc_dqbuf = vb2_ioctl_dqbuf, 1411 .vidioc_expbuf = vb2_ioctl_expbuf, 1412 .vidioc_streamon = vb2_ioctl_streamon, 1413 .vidioc_streamoff = vb2_ioctl_streamoff, 1414 1415 #ifdef CONFIG_VIDEO_ADV_DEBUG 1416 .vidioc_g_chip_info = vidioc_g_chip_info, 1417 .vidioc_g_register = vidioc_g_register, 1418 .vidioc_s_register = vidioc_s_register, 1419 #endif 1420 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 1421 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 1422 }; 1423 1424 static const struct video_device gspca_template = { 1425 .name = "gspca main driver", 1426 .fops = &dev_fops, 1427 .ioctl_ops = &dev_ioctl_ops, 1428 .release = video_device_release_empty, /* We use v4l2_dev.release */ 1429 }; 1430 1431 /* 1432 * probe and create a new gspca device 1433 * 1434 * This function must be called by the sub-driver when it is 1435 * called for probing a new device. 1436 */ 1437 int gspca_dev_probe2(struct usb_interface *intf, 1438 const struct usb_device_id *id, 1439 const struct sd_desc *sd_desc, 1440 int dev_size, 1441 struct module *module) 1442 { 1443 struct gspca_dev *gspca_dev; 1444 struct usb_device *dev = interface_to_usbdev(intf); 1445 struct vb2_queue *q; 1446 int ret; 1447 1448 pr_info("%s-" GSPCA_VERSION " probing %04x:%04x\n", 1449 sd_desc->name, id->idVendor, id->idProduct); 1450 1451 /* create the device */ 1452 if (dev_size < sizeof *gspca_dev) 1453 dev_size = sizeof *gspca_dev; 1454 gspca_dev = kzalloc(dev_size, GFP_KERNEL); 1455 if (!gspca_dev) { 1456 pr_err("couldn't kzalloc gspca struct\n"); 1457 return -ENOMEM; 1458 } 1459 gspca_dev->usb_buf = kzalloc(USB_BUF_SZ, GFP_KERNEL); 1460 if (!gspca_dev->usb_buf) { 1461 pr_err("out of memory\n"); 1462 ret = -ENOMEM; 1463 goto out; 1464 } 1465 gspca_dev->dev = dev; 1466 gspca_dev->iface = intf->cur_altsetting->desc.bInterfaceNumber; 1467 gspca_dev->xfer_ep = -1; 1468 1469 /* check if any audio device */ 1470 if (dev->actconfig->desc.bNumInterfaces != 1) { 1471 int i; 1472 struct usb_interface *intf2; 1473 1474 for (i = 0; i < dev->actconfig->desc.bNumInterfaces; i++) { 1475 intf2 = dev->actconfig->interface[i]; 1476 if (intf2 != NULL 1477 && intf2->altsetting != NULL 1478 && intf2->altsetting->desc.bInterfaceClass == 1479 USB_CLASS_AUDIO) { 1480 gspca_dev->audio = 1; 1481 break; 1482 } 1483 } 1484 } 1485 1486 gspca_dev->v4l2_dev.release = gspca_release; 1487 ret = v4l2_device_register(&intf->dev, &gspca_dev->v4l2_dev); 1488 if (ret) 1489 goto out; 1490 gspca_dev->present = true; 1491 gspca_dev->sd_desc = sd_desc; 1492 gspca_dev->empty_packet = -1; /* don't check the empty packets */ 1493 gspca_dev->vdev = gspca_template; 1494 gspca_dev->vdev.v4l2_dev = &gspca_dev->v4l2_dev; 1495 gspca_dev->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | 1496 V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; 1497 video_set_drvdata(&gspca_dev->vdev, gspca_dev); 1498 gspca_dev->module = module; 1499 1500 mutex_init(&gspca_dev->usb_lock); 1501 gspca_dev->vdev.lock = &gspca_dev->usb_lock; 1502 init_waitqueue_head(&gspca_dev->wq); 1503 1504 /* Initialize the vb2 queue */ 1505 q = &gspca_dev->queue; 1506 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1507 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ; 1508 q->drv_priv = gspca_dev; 1509 q->buf_struct_size = sizeof(struct gspca_buffer); 1510 q->ops = &gspca_qops; 1511 q->mem_ops = &vb2_vmalloc_memops; 1512 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1513 q->min_queued_buffers = 2; 1514 q->lock = &gspca_dev->usb_lock; 1515 ret = vb2_queue_init(q); 1516 if (ret) 1517 goto out; 1518 gspca_dev->vdev.queue = q; 1519 1520 INIT_LIST_HEAD(&gspca_dev->buf_list); 1521 spin_lock_init(&gspca_dev->qlock); 1522 1523 /* configure the subdriver and initialize the USB device */ 1524 ret = sd_desc->config(gspca_dev, id); 1525 if (ret < 0) 1526 goto out; 1527 ret = sd_desc->init(gspca_dev); 1528 if (ret < 0) 1529 goto out; 1530 if (sd_desc->init_controls) 1531 ret = sd_desc->init_controls(gspca_dev); 1532 if (ret < 0) 1533 goto out; 1534 gspca_set_default_mode(gspca_dev); 1535 1536 ret = gspca_input_connect(gspca_dev); 1537 if (ret) 1538 goto out; 1539 1540 #ifdef CONFIG_VIDEO_ADV_DEBUG 1541 if (!gspca_dev->sd_desc->get_register) 1542 v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_DBG_G_REGISTER); 1543 if (!gspca_dev->sd_desc->set_register) 1544 v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_DBG_S_REGISTER); 1545 #endif 1546 if (!gspca_dev->sd_desc->get_jcomp) 1547 v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_G_JPEGCOMP); 1548 if (!gspca_dev->sd_desc->set_jcomp) 1549 v4l2_disable_ioctl(&gspca_dev->vdev, VIDIOC_S_JPEGCOMP); 1550 1551 /* init video stuff */ 1552 ret = video_register_device(&gspca_dev->vdev, 1553 VFL_TYPE_VIDEO, 1554 -1); 1555 if (ret < 0) { 1556 pr_err("video_register_device err %d\n", ret); 1557 goto out; 1558 } 1559 1560 usb_set_intfdata(intf, gspca_dev); 1561 gspca_dbg(gspca_dev, D_PROBE, "%s created\n", 1562 video_device_node_name(&gspca_dev->vdev)); 1563 1564 gspca_input_create_urb(gspca_dev); 1565 1566 return 0; 1567 out: 1568 #if IS_ENABLED(CONFIG_INPUT) 1569 if (gspca_dev->input_dev) 1570 input_unregister_device(gspca_dev->input_dev); 1571 #endif 1572 v4l2_ctrl_handler_free(gspca_dev->vdev.ctrl_handler); 1573 v4l2_device_unregister(&gspca_dev->v4l2_dev); 1574 if (sd_desc->probe_error) 1575 sd_desc->probe_error(gspca_dev); 1576 kfree(gspca_dev->usb_buf); 1577 kfree(gspca_dev); 1578 return ret; 1579 } 1580 EXPORT_SYMBOL(gspca_dev_probe2); 1581 1582 /* same function as the previous one, but check the interface */ 1583 int gspca_dev_probe(struct usb_interface *intf, 1584 const struct usb_device_id *id, 1585 const struct sd_desc *sd_desc, 1586 int dev_size, 1587 struct module *module) 1588 { 1589 struct usb_device *dev = interface_to_usbdev(intf); 1590 1591 /* we don't handle multi-config cameras */ 1592 if (dev->descriptor.bNumConfigurations != 1) { 1593 pr_err("%04x:%04x too many config\n", 1594 id->idVendor, id->idProduct); 1595 return -ENODEV; 1596 } 1597 1598 /* the USB video interface must be the first one */ 1599 if (dev->actconfig->desc.bNumInterfaces != 1 1600 && intf->cur_altsetting->desc.bInterfaceNumber != 0) 1601 return -ENODEV; 1602 1603 return gspca_dev_probe2(intf, id, sd_desc, dev_size, module); 1604 } 1605 EXPORT_SYMBOL(gspca_dev_probe); 1606 1607 /* 1608 * USB disconnection 1609 * 1610 * This function must be called by the sub-driver 1611 * when the device disconnects, after the specific resources are freed. 1612 */ 1613 void gspca_disconnect(struct usb_interface *intf) 1614 { 1615 struct gspca_dev *gspca_dev = usb_get_intfdata(intf); 1616 #if IS_ENABLED(CONFIG_INPUT) 1617 struct input_dev *input_dev; 1618 #endif 1619 1620 gspca_dbg(gspca_dev, D_PROBE, "%s disconnect\n", 1621 video_device_node_name(&gspca_dev->vdev)); 1622 1623 mutex_lock(&gspca_dev->usb_lock); 1624 gspca_dev->present = false; 1625 destroy_urbs(gspca_dev); 1626 gspca_input_destroy_urb(gspca_dev); 1627 1628 vb2_queue_error(&gspca_dev->queue); 1629 1630 #if IS_ENABLED(CONFIG_INPUT) 1631 input_dev = gspca_dev->input_dev; 1632 if (input_dev) { 1633 gspca_dev->input_dev = NULL; 1634 input_unregister_device(input_dev); 1635 } 1636 #endif 1637 1638 v4l2_device_disconnect(&gspca_dev->v4l2_dev); 1639 video_unregister_device(&gspca_dev->vdev); 1640 1641 mutex_unlock(&gspca_dev->usb_lock); 1642 1643 /* (this will call gspca_release() immediately or on last close) */ 1644 v4l2_device_put(&gspca_dev->v4l2_dev); 1645 } 1646 EXPORT_SYMBOL(gspca_disconnect); 1647 1648 #ifdef CONFIG_PM 1649 int gspca_suspend(struct usb_interface *intf, pm_message_t message) 1650 { 1651 struct gspca_dev *gspca_dev = usb_get_intfdata(intf); 1652 1653 gspca_input_destroy_urb(gspca_dev); 1654 1655 if (!vb2_start_streaming_called(&gspca_dev->queue)) 1656 return 0; 1657 1658 mutex_lock(&gspca_dev->usb_lock); 1659 gspca_dev->frozen = 1; /* avoid urb error messages */ 1660 gspca_dev->usb_err = 0; 1661 if (gspca_dev->sd_desc->stopN) 1662 gspca_dev->sd_desc->stopN(gspca_dev); 1663 destroy_urbs(gspca_dev); 1664 gspca_set_alt0(gspca_dev); 1665 if (gspca_dev->sd_desc->stop0) 1666 gspca_dev->sd_desc->stop0(gspca_dev); 1667 mutex_unlock(&gspca_dev->usb_lock); 1668 1669 return 0; 1670 } 1671 EXPORT_SYMBOL(gspca_suspend); 1672 1673 int gspca_resume(struct usb_interface *intf) 1674 { 1675 struct gspca_dev *gspca_dev = usb_get_intfdata(intf); 1676 int streaming, ret = 0; 1677 1678 mutex_lock(&gspca_dev->usb_lock); 1679 gspca_dev->frozen = 0; 1680 gspca_dev->usb_err = 0; 1681 gspca_dev->sd_desc->init(gspca_dev); 1682 /* 1683 * Most subdrivers send all ctrl values on sd_start and thus 1684 * only write to the device registers on s_ctrl when streaming -> 1685 * Clear streaming to avoid setting all ctrls twice. 1686 */ 1687 streaming = vb2_start_streaming_called(&gspca_dev->queue); 1688 if (streaming) 1689 ret = gspca_init_transfer(gspca_dev); 1690 else 1691 gspca_input_create_urb(gspca_dev); 1692 mutex_unlock(&gspca_dev->usb_lock); 1693 1694 return ret; 1695 } 1696 EXPORT_SYMBOL(gspca_resume); 1697 #endif 1698 1699 module_param_named(debug, gspca_debug, int, 0644); 1700 MODULE_PARM_DESC(debug, 1701 "1:probe 2:config 3:stream 4:frame 5:packet 6:usbi 7:usbo"); 1702