1 /* $OpenBSD: uvideo.c,v 1.167 2012/06/18 15:43:30 mpi Exp $ */ 2 3 /* 4 * Copyright (c) 2008 Robert Nagy <robert@openbsd.org> 5 * Copyright (c) 2008 Marcus Glocker <mglocker@openbsd.org> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 #include <sys/param.h> 21 #include <sys/systm.h> 22 #include <sys/kernel.h> 23 #include <sys/malloc.h> 24 #include <sys/device.h> 25 #include <sys/ioctl.h> 26 #include <sys/tty.h> 27 #include <sys/file.h> 28 #include <sys/reboot.h> 29 #include <sys/selinfo.h> 30 #include <sys/proc.h> 31 #include <sys/namei.h> 32 #include <sys/vnode.h> 33 #include <sys/lock.h> 34 #include <sys/stat.h> 35 #include <sys/device.h> 36 #include <sys/poll.h> 37 #include <sys/timeout.h> 38 #include <sys/kthread.h> 39 #include <uvm/uvm.h> 40 41 #include <machine/bus.h> 42 43 #include <dev/usb/usb.h> 44 #include <dev/usb/usbdi.h> 45 #include <dev/usb/usbdivar.h> 46 #include <dev/usb/usbdi_util.h> 47 #include <dev/usb/usbdevs.h> 48 #include <dev/usb/uvideo.h> 49 50 #include <dev/video_if.h> 51 52 #ifdef UVIDEO_DEBUG 53 int uvideo_debug = 1; 54 #define DPRINTF(l, x...) do { if ((l) <= uvideo_debug) printf(x); } while (0) 55 #else 56 #define DPRINTF(l, x...) 57 #endif 58 59 #define DEVNAME(_s) ((_s)->sc_dev.dv_xname) 60 61 #define byteof(x) ((x) >> 3) 62 #define bitof(x) (1L << ((x) & 0x7)) 63 64 int uvideo_enable(void *); 65 void uvideo_disable(void *); 66 int uvideo_open(void *, int, int *, uint8_t *, void (*)(void *), 67 void *arg); 68 int uvideo_close(void *); 69 int uvideo_match(struct device *, void *, void *); 70 void uvideo_attach(struct device *, struct device *, void *); 71 void uvideo_attach_hook(void *); 72 int uvideo_detach(struct device *, int); 73 int uvideo_activate(struct device *, int); 74 75 usbd_status uvideo_vc_parse_desc(struct uvideo_softc *); 76 usbd_status uvideo_vc_parse_desc_header(struct uvideo_softc *, 77 const usb_descriptor_t *); 78 usbd_status uvideo_vc_parse_desc_pu(struct uvideo_softc *, 79 const usb_descriptor_t *); 80 usbd_status uvideo_vc_get_ctrl(struct uvideo_softc *, uint8_t *, uint8_t, 81 uint8_t, uint16_t, uint16_t); 82 usbd_status uvideo_vc_set_ctrl(struct uvideo_softc *, uint8_t *, uint8_t, 83 uint8_t, uint16_t, uint16_t); 84 int uvideo_find_ctrl(struct uvideo_softc *, int); 85 int uvideo_has_ctrl(struct usb_video_vc_processing_desc *, int); 86 87 usbd_status uvideo_vs_parse_desc(struct uvideo_softc *, 88 usb_config_descriptor_t *); 89 usbd_status uvideo_vs_parse_desc_input_header(struct uvideo_softc *, 90 const usb_descriptor_t *); 91 usbd_status uvideo_vs_parse_desc_format(struct uvideo_softc *); 92 usbd_status uvideo_vs_parse_desc_format_mjpeg(struct uvideo_softc *, 93 const usb_descriptor_t *); 94 usbd_status uvideo_vs_parse_desc_format_uncompressed(struct uvideo_softc *, 95 const usb_descriptor_t *); 96 usbd_status uvideo_vs_parse_desc_frame(struct uvideo_softc *); 97 usbd_status uvideo_vs_parse_desc_frame_sub(struct uvideo_softc *, 98 const usb_descriptor_t *); 99 usbd_status uvideo_vs_parse_desc_alt(struct uvideo_softc *, int, int, int); 100 usbd_status uvideo_vs_set_alt(struct uvideo_softc *, usbd_interface_handle, 101 int); 102 int uvideo_desc_len(const usb_descriptor_t *, int, int, int, int); 103 void uvideo_find_res(struct uvideo_softc *, int, int, int, 104 struct uvideo_res *); 105 usbd_status uvideo_vs_negotiation(struct uvideo_softc *, int); 106 usbd_status uvideo_vs_set_probe(struct uvideo_softc *, uint8_t *); 107 usbd_status uvideo_vs_get_probe(struct uvideo_softc *, uint8_t *, uint8_t); 108 usbd_status uvideo_vs_set_commit(struct uvideo_softc *, uint8_t *); 109 usbd_status uvideo_vs_alloc_frame(struct uvideo_softc *); 110 void uvideo_vs_free_frame(struct uvideo_softc *); 111 usbd_status uvideo_vs_alloc_isoc(struct uvideo_softc *); 112 usbd_status uvideo_vs_alloc_bulk(struct uvideo_softc *); 113 void uvideo_vs_free_isoc(struct uvideo_softc *); 114 void uvideo_vs_free_bulk(struct uvideo_softc *); 115 usbd_status uvideo_vs_open(struct uvideo_softc *); 116 void uvideo_vs_close(struct uvideo_softc *); 117 usbd_status uvideo_vs_init(struct uvideo_softc *); 118 int uvideo_vs_start_bulk(struct uvideo_softc *); 119 void uvideo_vs_start_bulk_thread(void *); 120 void uvideo_vs_start_isoc(struct uvideo_softc *); 121 void uvideo_vs_start_isoc_ixfer(struct uvideo_softc *, 122 struct uvideo_isoc_xfer *); 123 void uvideo_vs_cb(usbd_xfer_handle, usbd_private_handle, 124 usbd_status); 125 usbd_status uvideo_vs_decode_stream_header(struct uvideo_softc *, 126 uint8_t *, int); 127 usbd_status uvideo_vs_decode_stream_header_isight(struct uvideo_softc *, 128 uint8_t *, int); 129 void uvideo_mmap_queue(struct uvideo_softc *, uint8_t *, int); 130 void uvideo_read(struct uvideo_softc *, uint8_t *, int); 131 usbd_status uvideo_usb_control(struct uvideo_softc *sc, uint8_t rt, uint8_t r, 132 uint16_t value, uint8_t *data, size_t length); 133 134 #ifdef UVIDEO_DEBUG 135 void uvideo_dump_desc_all(struct uvideo_softc *); 136 void uvideo_dump_desc_vc_header(struct uvideo_softc *, 137 const usb_descriptor_t *); 138 void uvideo_dump_desc_input_header(struct uvideo_softc *, 139 const usb_descriptor_t *); 140 void uvideo_dump_desc_input(struct uvideo_softc *, 141 const usb_descriptor_t *); 142 void uvideo_dump_desc_output(struct uvideo_softc *, 143 const usb_descriptor_t *); 144 void uvideo_dump_desc_endpoint(struct uvideo_softc *, 145 const usb_descriptor_t *); 146 void uvideo_dump_desc_interface(struct uvideo_softc *, 147 const usb_descriptor_t *); 148 void uvideo_dump_desc_config(struct uvideo_softc *, 149 const usb_descriptor_t *); 150 void uvideo_dump_desc_cs_endpoint(struct uvideo_softc *, 151 const usb_descriptor_t *); 152 void uvideo_dump_desc_colorformat(struct uvideo_softc *, 153 const usb_descriptor_t *); 154 void uvideo_dump_desc_format_mjpeg(struct uvideo_softc *, 155 const usb_descriptor_t *); 156 void uvideo_dump_desc_format_uncompressed(struct uvideo_softc *, 157 const usb_descriptor_t *); 158 void uvideo_dump_desc_frame(struct uvideo_softc *, 159 const usb_descriptor_t *); 160 void uvideo_dump_desc_processing(struct uvideo_softc *, 161 const usb_descriptor_t *); 162 void uvideo_dump_desc_extension(struct uvideo_softc *, 163 const usb_descriptor_t *); 164 void uvideo_hexdump(void *, int, int); 165 int uvideo_debug_file_open(struct uvideo_softc *); 166 void uvideo_debug_file_write_frame(void *); 167 #endif 168 169 /* 170 * IOCTL's 171 */ 172 int uvideo_querycap(void *, struct v4l2_capability *); 173 int uvideo_enum_fmt(void *, struct v4l2_fmtdesc *); 174 int uvideo_enum_fsizes(void *, struct v4l2_frmsizeenum *); 175 int uvideo_enum_fivals(void *, struct v4l2_frmivalenum *); 176 int uvideo_s_fmt(void *, struct v4l2_format *); 177 int uvideo_g_fmt(void *, struct v4l2_format *); 178 int uvideo_s_parm(void *, struct v4l2_streamparm *); 179 int uvideo_g_parm(void *, struct v4l2_streamparm *); 180 int uvideo_enum_input(void *, struct v4l2_input *); 181 int uvideo_s_input(void *, int); 182 int uvideo_reqbufs(void *, struct v4l2_requestbuffers *); 183 int uvideo_querybuf(void *, struct v4l2_buffer *); 184 int uvideo_qbuf(void *, struct v4l2_buffer *); 185 int uvideo_dqbuf(void *, struct v4l2_buffer *); 186 int uvideo_streamon(void *, int); 187 int uvideo_streamoff(void *, int); 188 int uvideo_try_fmt(void *, struct v4l2_format *); 189 int uvideo_queryctrl(void *, struct v4l2_queryctrl *); 190 int uvideo_g_ctrl(void *, struct v4l2_control *); 191 int uvideo_s_ctrl(void *, struct v4l2_control *); 192 193 /* 194 * Other hardware interface related functions 195 */ 196 caddr_t uvideo_mappage(void *, off_t, int); 197 int uvideo_get_bufsize(void *); 198 int uvideo_start_read(void *); 199 200 /* 201 * Firmware 202 */ 203 usbd_status uvideo_ucode_loader_ricoh(struct uvideo_softc *); 204 usbd_status uvideo_ucode_loader_apple_isight(struct uvideo_softc *); 205 206 struct cfdriver uvideo_cd = { 207 NULL, "uvideo", DV_DULL 208 }; 209 210 const struct cfattach uvideo_ca = { 211 sizeof(struct uvideo_softc), 212 uvideo_match, 213 uvideo_attach, 214 uvideo_detach, 215 uvideo_activate, 216 }; 217 218 struct video_hw_if uvideo_hw_if = { 219 uvideo_open, /* open */ 220 uvideo_close, /* close */ 221 uvideo_querycap, /* VIDIOC_QUERYCAP */ 222 uvideo_enum_fmt, /* VIDIOC_ENUM_FMT */ 223 uvideo_enum_fsizes, /* VIDIOC_ENUM_FRAMESIZES */ 224 uvideo_enum_fivals, /* VIDIOC_ENUM_FRAMEINTERVALS */ 225 uvideo_s_fmt, /* VIDIOC_S_FMT */ 226 uvideo_g_fmt, /* VIDIOC_G_FMT */ 227 uvideo_s_parm, /* VIDIOC_S_PARM */ 228 uvideo_g_parm, /* VIDIOC_G_PARM */ 229 uvideo_enum_input, /* VIDIOC_ENUMINPUT */ 230 uvideo_s_input, /* VIDIOC_S_INPUT */ 231 uvideo_reqbufs, /* VIDIOC_REQBUFS */ 232 uvideo_querybuf, /* VIDIOC_QUERYBUF */ 233 uvideo_qbuf, /* VIDIOC_QBUF */ 234 uvideo_dqbuf, /* VIDIOC_DQBUF */ 235 uvideo_streamon, /* VIDIOC_STREAMON */ 236 uvideo_streamoff, /* VIDIOC_STREAMOFF */ 237 uvideo_try_fmt, /* VIDIOC_TRY_FMT */ 238 uvideo_queryctrl, /* VIDIOC_QUERYCTRL */ 239 uvideo_g_ctrl, /* VIDIOC_G_CTRL */ 240 uvideo_s_ctrl, /* VIDIOC_S_CTRL */ 241 uvideo_mappage, /* mmap */ 242 uvideo_get_bufsize, /* read */ 243 uvideo_start_read /* start stream for read */ 244 }; 245 246 /* 247 * Devices which either fail to declare themselves as UICLASS_VIDEO, 248 * or which need firmware uploads or other quirk handling later on. 249 */ 250 #define UVIDEO_FLAG_ISIGHT_STREAM_HEADER 0x1 251 #define UVIDEO_FLAG_REATTACH 0x2 252 #define UVIDEO_FLAG_VENDOR_CLASS 0x4 253 struct uvideo_devs { 254 struct usb_devno uv_dev; 255 char *ucode_name; 256 usbd_status (*ucode_loader)(struct uvideo_softc *); 257 int flags; 258 } uvideo_devs[] = { 259 { 260 /* Needs firmware */ 261 { USB_VENDOR_RICOH, USB_PRODUCT_RICOH_VGPVCC5 }, 262 "uvideo_r5u87x_05ca-1835", 263 uvideo_ucode_loader_ricoh, 264 0 265 }, 266 { 267 /* Needs firmware */ 268 { USB_VENDOR_RICOH, USB_PRODUCT_RICOH_VGPVCC4 }, 269 "uvideo_r5u87x_05ca-1836", 270 uvideo_ucode_loader_ricoh, 271 0 272 }, 273 { 274 /* Needs firmware */ 275 { USB_VENDOR_RICOH, USB_PRODUCT_RICOH_VGPVCC4_2 }, 276 "uvideo_r5u87x_05ca-1837", 277 uvideo_ucode_loader_ricoh, 278 0 279 }, 280 { 281 /* Needs firmware */ 282 { USB_VENDOR_RICOH, USB_PRODUCT_RICOH_VGPVCC6 }, 283 "uvideo_r5u87x_05ca-1839", 284 uvideo_ucode_loader_ricoh, 285 0 286 }, 287 { 288 /* Needs firmware */ 289 { USB_VENDOR_RICOH, USB_PRODUCT_RICOH_VGPVCC7 }, 290 "uvideo_r5u87x_05ca-183a", 291 uvideo_ucode_loader_ricoh, 292 0 293 }, 294 { 295 /* Needs firmware */ 296 { USB_VENDOR_RICOH, USB_PRODUCT_RICOH_VGPVCC8 }, 297 "uvideo_r5u87x_05ca-183b", 298 uvideo_ucode_loader_ricoh, 299 0 300 }, 301 { 302 /* Needs firmware */ 303 { USB_VENDOR_RICOH, USB_PRODUCT_RICOH_VGPVCC9 }, 304 "uvideo_r5u87x_05ca-183e", 305 uvideo_ucode_loader_ricoh, 306 0 307 }, 308 { 309 /* Needs firmware */ 310 { USB_VENDOR_APPLE, USB_PRODUCT_APPLE_BLUETOOTH }, 311 "uvideo_isight_05ac-8300", 312 uvideo_ucode_loader_apple_isight, 313 UVIDEO_FLAG_REATTACH 314 }, 315 { 316 /* Has a non-standard streaming header protocol */ 317 { USB_VENDOR_APPLE, USB_PRODUCT_APPLE_ISIGHT_1 }, 318 NULL, 319 NULL, 320 UVIDEO_FLAG_ISIGHT_STREAM_HEADER 321 }, 322 { /* Incorrectly reports as bInterfaceClass=UICLASS_VENDOR */ 323 { USB_VENDOR_LOGITECH, USB_PRODUCT_LOGITECH_QUICKCAMOEM_1 }, 324 NULL, 325 NULL, 326 UVIDEO_FLAG_VENDOR_CLASS 327 }, 328 }; 329 #define uvideo_lookup(v, p) \ 330 ((struct uvideo_devs *)usb_lookup(uvideo_devs, v, p)) 331 332 int 333 uvideo_enable(void *v) 334 { 335 struct uvideo_softc *sc = v; 336 337 DPRINTF(1, "%s: uvideo_enable sc=%p\n", DEVNAME(sc), sc); 338 339 if (sc->sc_dying) 340 return (EIO); 341 342 if (sc->sc_enabled) 343 return (EBUSY); 344 345 sc->sc_enabled = 1; 346 347 return (0); 348 } 349 350 void 351 uvideo_disable(void *v) 352 { 353 struct uvideo_softc *sc = v; 354 355 DPRINTF(1, "%s: uvideo_disable sc=%p\n", DEVNAME(sc), sc); 356 357 if (!sc->sc_enabled) { 358 printf("uvideo_disable: already disabled!\n"); 359 return; 360 } 361 362 sc->sc_enabled = 0; 363 } 364 365 int 366 uvideo_open(void *addr, int flags, int *size, uint8_t *buffer, 367 void (*intr)(void *), void *arg) 368 { 369 struct uvideo_softc *sc = addr; 370 371 DPRINTF(1, "%s: uvideo_open: sc=%p\n", DEVNAME(sc), sc); 372 373 if (sc->sc_dying) 374 return (EIO); 375 376 /* pointers to upper video layer */ 377 sc->sc_uplayer_arg = arg; 378 sc->sc_uplayer_fsize = size; 379 sc->sc_uplayer_fbuffer = buffer; 380 sc->sc_uplayer_intr = intr; 381 382 sc->sc_mmap_flag = 0; 383 sc->sc_negotiated_flag = 0; 384 385 return (0); 386 } 387 388 int 389 uvideo_close(void *addr) 390 { 391 struct uvideo_softc *sc = addr; 392 393 DPRINTF(1, "%s: uvideo_close: sc=%p\n", DEVNAME(sc), sc); 394 395 #ifdef UVIDEO_DUMP 396 usb_rem_task(sc->sc_udev, &sc->sc_task_write); 397 #endif 398 /* close video stream pipe */ 399 uvideo_vs_close(sc); 400 401 /* free video stream xfer buffer */ 402 if (sc->sc_vs_cur->bulk_endpoint) 403 uvideo_vs_free_bulk(sc); 404 else 405 uvideo_vs_free_isoc(sc); 406 407 /* free video stream frame buffer */ 408 uvideo_vs_free_frame(sc); 409 return (0); 410 } 411 412 int 413 uvideo_match(struct device *parent, void *match, void *aux) 414 { 415 struct usb_attach_arg *uaa = aux; 416 usb_interface_descriptor_t *id; 417 struct uvideo_devs *quirk; 418 419 if (uaa->iface == NULL) 420 return (UMATCH_NONE); 421 422 id = usbd_get_interface_descriptor(uaa->iface); 423 if (id == NULL) 424 return (UMATCH_NONE); 425 426 if (id->bInterfaceClass == UICLASS_VIDEO && 427 id->bInterfaceSubClass == UISUBCLASS_VIDEOCONTROL) 428 return (UMATCH_VENDOR_PRODUCT_CONF_IFACE); 429 430 /* quirk devices which we want to attach */ 431 quirk = uvideo_lookup(uaa->vendor, uaa->product); 432 if (quirk != NULL) { 433 if (quirk->flags & UVIDEO_FLAG_REATTACH) 434 return (UMATCH_VENDOR_PRODUCT_CONF_IFACE); 435 436 if (quirk->flags & UVIDEO_FLAG_VENDOR_CLASS && 437 id->bInterfaceClass == UICLASS_VENDOR && 438 id->bInterfaceSubClass == UISUBCLASS_VIDEOCONTROL) 439 return (UMATCH_VENDOR_PRODUCT_CONF_IFACE); 440 } 441 442 return (UMATCH_NONE); 443 } 444 445 void 446 uvideo_attach(struct device *parent, struct device *self, void *aux) 447 { 448 struct uvideo_softc *sc = (struct uvideo_softc *)self; 449 struct usb_attach_arg *uaa = aux; 450 usb_interface_descriptor_t *id; 451 int i; 452 453 sc->sc_udev = uaa->device; 454 sc->sc_nifaces = uaa->nifaces; 455 /* 456 * Claim all video interfaces. Interfaces must be claimed during 457 * attach, during attach hooks is too late. 458 */ 459 for (i = 0; i < sc->sc_nifaces; i++) { 460 if (usbd_iface_claimed(sc->sc_udev, i)) 461 continue; 462 id = usbd_get_interface_descriptor(&sc->sc_udev->ifaces[i]); 463 if (id == NULL) 464 continue; 465 if (id->bInterfaceClass == UICLASS_VIDEO) 466 usbd_claim_iface(sc->sc_udev, i); 467 } 468 469 /* maybe the device has quirks */ 470 sc->sc_quirk = uvideo_lookup(uaa->vendor, uaa->product); 471 472 /* if the device needs ucode do mountroothook */ 473 if ((sc->sc_quirk && sc->sc_quirk->ucode_name) && rootvp == NULL) 474 mountroothook_establish(uvideo_attach_hook, sc); 475 else 476 uvideo_attach_hook(sc); 477 } 478 479 void 480 uvideo_attach_hook(void *arg) 481 { 482 struct uvideo_softc *sc = arg; 483 usb_config_descriptor_t *cdesc; 484 usbd_status error; 485 486 /* maybe the device needs a firmware */ 487 if (sc->sc_quirk && sc->sc_quirk->ucode_name) { 488 error = (sc->sc_quirk->ucode_loader)(sc); 489 if (error != USBD_NORMAL_COMPLETION) 490 return; 491 } 492 493 /* map stream header decode function */ 494 if (sc->sc_quirk && 495 sc->sc_quirk->flags & UVIDEO_FLAG_ISIGHT_STREAM_HEADER) { 496 sc->sc_decode_stream_header = 497 uvideo_vs_decode_stream_header_isight; 498 } else { 499 sc->sc_decode_stream_header = 500 uvideo_vs_decode_stream_header; 501 } 502 503 /* get the config descriptor */ 504 cdesc = usbd_get_config_descriptor(sc->sc_udev); 505 if (cdesc == NULL) { 506 printf("%s: failed to get configuration descriptor\n", 507 DEVNAME(sc)); 508 return; 509 } 510 #ifdef UVIDEO_DEBUG 511 uvideo_dump_desc_all(sc); 512 #endif 513 /* parse video control descriptors */ 514 error = uvideo_vc_parse_desc(sc); 515 if (error != USBD_NORMAL_COMPLETION) 516 return; 517 518 /* parse video stream descriptors */ 519 error = uvideo_vs_parse_desc(sc, cdesc); 520 if (error != USBD_NORMAL_COMPLETION) 521 return; 522 523 /* set default video stream interface */ 524 error = usbd_set_interface(sc->sc_vs_cur->ifaceh, 0); 525 if (error != USBD_NORMAL_COMPLETION) 526 return; 527 528 /* do device negotiation without commit */ 529 error = uvideo_vs_negotiation(sc, 0); 530 if (error != USBD_NORMAL_COMPLETION) 531 return; 532 533 /* init mmap queue */ 534 SIMPLEQ_INIT(&sc->sc_mmap_q); 535 sc->sc_mmap_cur = -1; 536 sc->sc_mmap_count = 0; 537 538 DPRINTF(1, "uvideo_attach: doing video_attach_mi\n"); 539 sc->sc_videodev = video_attach_mi(&uvideo_hw_if, sc, &sc->sc_dev); 540 } 541 542 int 543 uvideo_detach(struct device *self, int flags) 544 { 545 struct uvideo_softc *sc = (struct uvideo_softc *)self; 546 int rv = 0; 547 548 /* Wait for outstanding requests to complete */ 549 usbd_delay_ms(sc->sc_udev, UVIDEO_NFRAMES_MAX); 550 551 uvideo_vs_free_frame(sc); 552 553 if (sc->sc_videodev != NULL) 554 rv = config_detach(sc->sc_videodev, flags); 555 556 return (rv); 557 } 558 559 int 560 uvideo_activate(struct device *self, int act) 561 { 562 struct uvideo_softc *sc = (struct uvideo_softc *) self; 563 int rv = 0; 564 565 DPRINTF(1, "uvideo_activate: sc=%p\n", sc); 566 567 switch (act) { 568 case DVACT_DEACTIVATE: 569 if (sc->sc_videodev != NULL) 570 config_deactivate(sc->sc_videodev); 571 sc->sc_dying = 1; 572 break; 573 } 574 575 return (rv); 576 } 577 578 usbd_status 579 uvideo_vc_parse_desc(struct uvideo_softc *sc) 580 { 581 usbd_desc_iter_t iter; 582 const usb_descriptor_t *desc; 583 int vc_header_found; 584 usbd_status error; 585 586 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 587 588 vc_header_found = 0; 589 590 usb_desc_iter_init(sc->sc_udev, &iter); 591 desc = usb_desc_iter_next(&iter); 592 while (desc) { 593 if (desc->bDescriptorType != UDESC_CS_INTERFACE) { 594 desc = usb_desc_iter_next(&iter); 595 continue; 596 } 597 598 switch (desc->bDescriptorSubtype) { 599 case UDESCSUB_VC_HEADER: 600 if (!uvideo_desc_len(desc, 12, 11, 1, 0)) 601 break; 602 if (vc_header_found) { 603 printf("%s: too many VC_HEADERs!\n", 604 DEVNAME(sc)); 605 return (USBD_INVAL); 606 } 607 error = uvideo_vc_parse_desc_header(sc, desc); 608 if (error != USBD_NORMAL_COMPLETION) 609 return (error); 610 vc_header_found = 1; 611 break; 612 case UDESCSUB_VC_PROCESSING_UNIT: 613 /* XXX do correct length calculation */ 614 if (desc->bLength < 615 sizeof(struct usb_video_frame_desc)) { 616 (void)uvideo_vc_parse_desc_pu(sc, desc); 617 } 618 break; 619 620 /* TODO: which VC descriptors do we need else? */ 621 } 622 623 desc = usb_desc_iter_next(&iter); 624 } 625 626 if (vc_header_found == 0) { 627 printf("%s: no VC_HEADER found!\n", DEVNAME(sc)); 628 return (USBD_INVAL); 629 } 630 631 return (USBD_NORMAL_COMPLETION); 632 } 633 634 usbd_status 635 uvideo_vc_parse_desc_header(struct uvideo_softc *sc, 636 const usb_descriptor_t *desc) 637 { 638 struct usb_video_header_desc *d; 639 640 d = (struct usb_video_header_desc *)(uint8_t *)desc; 641 642 if (d->bInCollection == 0) { 643 printf("%s: no VS interface found!\n", 644 DEVNAME(sc)); 645 return (USBD_INVAL); 646 } 647 648 sc->sc_desc_vc_header.fix = d; 649 sc->sc_desc_vc_header.baInterfaceNr = (uByte *)(d + 1); 650 651 return (USBD_NORMAL_COMPLETION); 652 } 653 654 usbd_status 655 uvideo_vc_parse_desc_pu(struct uvideo_softc *sc, 656 const usb_descriptor_t *desc) 657 { 658 struct usb_video_vc_processing_desc *d; 659 660 /* PU descriptor is variable sized */ 661 d = (void *)desc; 662 663 if (sc->sc_desc_vc_pu_num == UVIDEO_MAX_PU) { 664 printf("%s: too many PU descriptors found!\n", DEVNAME(sc)); 665 return (USBD_INVAL); 666 } 667 668 sc->sc_desc_vc_pu[sc->sc_desc_vc_pu_num] = d; 669 sc->sc_desc_vc_pu_num++; 670 671 return (USBD_NORMAL_COMPLETION); 672 } 673 674 usbd_status 675 uvideo_vc_get_ctrl(struct uvideo_softc *sc, uint8_t *ctrl_data, 676 uint8_t request, uint8_t unitid, uint16_t ctrl_selector, uint16_t ctrl_len) 677 { 678 usb_device_request_t req; 679 usbd_status error; 680 681 req.bmRequestType = UVIDEO_GET_IF; 682 req.bRequest = request; 683 USETW(req.wValue, (ctrl_selector << 8)); 684 USETW(req.wIndex, (unitid << 8)); 685 USETW(req.wLength, ctrl_len); 686 687 error = usbd_do_request(sc->sc_udev, &req, ctrl_data); 688 if (error) { 689 DPRINTF(1, "%s: %s: could not GET ctrl request: %s\n", 690 DEVNAME(sc), __func__, usbd_errstr(error)); 691 return (USBD_INVAL); 692 } 693 694 return (USBD_NORMAL_COMPLETION); 695 } 696 697 usbd_status 698 uvideo_vc_set_ctrl(struct uvideo_softc *sc, uint8_t *ctrl_data, 699 uint8_t request, uint8_t unitid, uint16_t ctrl_selector, uint16_t ctrl_len) 700 { 701 usb_device_request_t req; 702 usbd_status error; 703 704 req.bmRequestType = UVIDEO_SET_IF; 705 req.bRequest = request; 706 USETW(req.wValue, (ctrl_selector << 8)); 707 USETW(req.wIndex, (unitid << 8)); 708 USETW(req.wLength, ctrl_len); 709 710 error = usbd_do_request(sc->sc_udev, &req, ctrl_data); 711 if (error) { 712 DPRINTF(1, "%s: %s: could not SET ctrl request: %s\n", 713 DEVNAME(sc), __func__, usbd_errstr(error)); 714 return (USBD_INVAL); 715 } 716 717 return (USBD_NORMAL_COMPLETION); 718 } 719 720 int 721 uvideo_find_ctrl(struct uvideo_softc *sc, int id) 722 { 723 int i, j, found; 724 725 if (sc->sc_desc_vc_pu_num == 0) { 726 /* no processing unit descriptors found */ 727 DPRINTF(1, "%s: %s: no processing unit descriptors found!\n", 728 DEVNAME(sc), __func__); 729 return (EINVAL); 730 } 731 732 /* do we support this control? */ 733 for (found = 0, i = 0; uvideo_ctrls[i].cid != 0; i++) { 734 if (id == uvideo_ctrls[i].cid) { 735 found = 1; 736 break; 737 } 738 } 739 if (found == 0) { 740 DPRINTF(1, "%s: %s: control not supported by driver!\n", 741 DEVNAME(sc), __func__); 742 return (EINVAL); 743 } 744 745 /* does the device support this control? */ 746 for (found = 0, j = 0; j < sc->sc_desc_vc_pu_num; j++) { 747 if (uvideo_has_ctrl(sc->sc_desc_vc_pu[j], 748 uvideo_ctrls[i].ctrl_bit) != 0) { 749 found = 1; 750 break; 751 } 752 } 753 if (found == 0) { 754 DPRINTF(1, "%s: %s: control not supported by device!\n", 755 DEVNAME(sc), __func__); 756 return (EINVAL); 757 } 758 sc->sc_desc_vc_pu_cur = sc->sc_desc_vc_pu[j]; 759 760 return (i); 761 } 762 763 int 764 uvideo_has_ctrl(struct usb_video_vc_processing_desc *desc, int ctrl_bit) 765 { 766 if (desc->bControlSize * 8 <= ctrl_bit) 767 return (0); 768 769 return (desc->bmControls[byteof(ctrl_bit)] & bitof(ctrl_bit)); 770 } 771 772 usbd_status 773 uvideo_vs_parse_desc(struct uvideo_softc *sc, usb_config_descriptor_t *cdesc) 774 { 775 usbd_desc_iter_t iter; 776 const usb_descriptor_t *desc; 777 usb_interface_descriptor_t *id; 778 int i, iface, numalts; 779 usbd_status error; 780 781 DPRINTF(1, "%s: number of total interfaces=%d\n", 782 DEVNAME(sc), sc->sc_nifaces); 783 DPRINTF(1, "%s: number of VS interfaces=%d\n", 784 DEVNAME(sc), sc->sc_desc_vc_header.fix->bInCollection); 785 786 usb_desc_iter_init(sc->sc_udev, &iter); 787 desc = usb_desc_iter_next(&iter); 788 while (desc) { 789 if (desc->bDescriptorType != UDESC_CS_INTERFACE) { 790 desc = usb_desc_iter_next(&iter); 791 continue; 792 } 793 794 switch (desc->bDescriptorSubtype) { 795 case UDESCSUB_VS_INPUT_HEADER: 796 if (!uvideo_desc_len(desc, 13, 3, 0, 12)) 797 break; 798 error = uvideo_vs_parse_desc_input_header(sc, desc); 799 if (error != USBD_NORMAL_COMPLETION) 800 return (error); 801 break; 802 803 /* TODO: which VS descriptors do we need else? */ 804 } 805 806 desc = usb_desc_iter_next(&iter); 807 } 808 809 /* parse video stream format descriptors */ 810 error = uvideo_vs_parse_desc_format(sc); 811 if (error != USBD_NORMAL_COMPLETION) 812 return (error); 813 814 /* parse video stream frame descriptors */ 815 error = uvideo_vs_parse_desc_frame(sc); 816 if (error != USBD_NORMAL_COMPLETION) 817 return (error); 818 819 /* parse interface collection */ 820 for (i = 0; i < sc->sc_desc_vc_header.fix->bInCollection; i++) { 821 iface = sc->sc_desc_vc_header.baInterfaceNr[i]; 822 823 id = usbd_get_interface_descriptor(&sc->sc_udev->ifaces[iface]); 824 if (id == NULL) { 825 printf("%s: can't get VS interface %d!\n", 826 DEVNAME(sc), iface); 827 return (USBD_INVAL); 828 } 829 usbd_claim_iface(sc->sc_udev, iface); 830 831 numalts = usbd_get_no_alts(cdesc, id->bInterfaceNumber); 832 833 DPRINTF(1, "%s: VS interface %d, ", DEVNAME(sc), i); 834 DPRINTF(1, "bInterfaceNumber=0x%02x, numalts=%d\n", 835 id->bInterfaceNumber, numalts); 836 837 error = uvideo_vs_parse_desc_alt(sc, i, iface, numalts); 838 if (error != USBD_NORMAL_COMPLETION) 839 return (error); 840 } 841 842 /* XXX for now always use the first video stream */ 843 sc->sc_vs_cur = &sc->sc_vs_coll[0]; 844 845 return (USBD_NORMAL_COMPLETION); 846 } 847 848 usbd_status 849 uvideo_vs_parse_desc_input_header(struct uvideo_softc *sc, 850 const usb_descriptor_t *desc) 851 { 852 struct usb_video_input_header_desc *d; 853 854 d = (struct usb_video_input_header_desc *)(uint8_t *)desc; 855 856 /* on some devices bNumFormats is larger than the truth */ 857 if (d->bNumFormats == 0) { 858 printf("%s: no INPUT FORMAT descriptors found!\n", DEVNAME(sc)); 859 return (USBD_INVAL); 860 } 861 862 sc->sc_desc_vs_input_header.fix = d; 863 sc->sc_desc_vs_input_header.bmaControls = (uByte *)(d + 1); 864 865 return (USBD_NORMAL_COMPLETION); 866 } 867 868 usbd_status 869 uvideo_vs_parse_desc_format(struct uvideo_softc *sc) 870 { 871 usbd_desc_iter_t iter; 872 const usb_descriptor_t *desc; 873 874 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 875 876 usb_desc_iter_init(sc->sc_udev, &iter); 877 desc = usb_desc_iter_next(&iter); 878 while (desc) { 879 if (desc->bDescriptorType != UDESC_CS_INTERFACE) { 880 desc = usb_desc_iter_next(&iter); 881 continue; 882 } 883 884 switch (desc->bDescriptorSubtype) { 885 case UDESCSUB_VS_FORMAT_MJPEG: 886 if (desc->bLength == 11) { 887 (void)uvideo_vs_parse_desc_format_mjpeg( 888 sc, desc); 889 } 890 break; 891 case UDESCSUB_VS_FORMAT_UNCOMPRESSED: 892 if (desc->bLength == 27) { 893 (void)uvideo_vs_parse_desc_format_uncompressed( 894 sc, desc); 895 } 896 break; 897 } 898 899 desc = usb_desc_iter_next(&iter); 900 } 901 902 sc->sc_fmtgrp_idx = 0; 903 904 if (sc->sc_fmtgrp_num == 0) { 905 printf("%s: no format descriptors found!\n", DEVNAME(sc)); 906 return (USBD_INVAL); 907 } 908 DPRINTF(1, "%s: number of total format descriptors=%d\n", 909 DEVNAME(sc), sc->sc_fmtgrp_num); 910 911 return (USBD_NORMAL_COMPLETION); 912 } 913 914 usbd_status 915 uvideo_vs_parse_desc_format_mjpeg(struct uvideo_softc *sc, 916 const usb_descriptor_t *desc) 917 { 918 struct usb_video_format_mjpeg_desc *d; 919 920 d = (struct usb_video_format_mjpeg_desc *)(uint8_t *)desc; 921 922 if (d->bNumFrameDescriptors == 0) { 923 printf("%s: no MJPEG frame descriptors available!\n", 924 DEVNAME(sc)); 925 return (USBD_INVAL); 926 } 927 928 if (sc->sc_fmtgrp_idx > UVIDEO_MAX_FORMAT) { 929 printf("%s: too many format descriptors found!\n", DEVNAME(sc)); 930 return (USBD_INVAL); 931 } 932 933 sc->sc_fmtgrp[sc->sc_fmtgrp_idx].format = 934 (struct uvideo_format_desc *)d; 935 if (d->bDefaultFrameIndex > d->bNumFrameDescriptors || 936 d->bDefaultFrameIndex < 1) { 937 /* sanitize wrong bDefaultFrameIndex value */ 938 sc->sc_fmtgrp[sc->sc_fmtgrp_idx].format_dfidx = 1; 939 } else { 940 sc->sc_fmtgrp[sc->sc_fmtgrp_idx].format_dfidx = 941 d->bDefaultFrameIndex; 942 } 943 sc->sc_fmtgrp[sc->sc_fmtgrp_idx].pixelformat = V4L2_PIX_FMT_MJPEG; 944 945 if (sc->sc_fmtgrp_cur == NULL) 946 /* set MJPEG format */ 947 sc->sc_fmtgrp_cur = &sc->sc_fmtgrp[sc->sc_fmtgrp_idx]; 948 949 sc->sc_fmtgrp_idx++; 950 sc->sc_fmtgrp_num++; 951 952 return (USBD_NORMAL_COMPLETION); 953 } 954 955 usbd_status 956 uvideo_vs_parse_desc_format_uncompressed(struct uvideo_softc *sc, 957 const usb_descriptor_t *desc) 958 { 959 struct usb_video_format_uncompressed_desc *d; 960 int i; 961 962 d = (struct usb_video_format_uncompressed_desc *)(uint8_t *)desc; 963 964 if (d->bNumFrameDescriptors == 0) { 965 printf("%s: no UNCOMPRESSED frame descriptors available!\n", 966 DEVNAME(sc)); 967 return (USBD_INVAL); 968 } 969 970 if (sc->sc_fmtgrp_idx > UVIDEO_MAX_FORMAT) { 971 printf("%s: too many format descriptors found!\n", DEVNAME(sc)); 972 return (USBD_INVAL); 973 } 974 975 sc->sc_fmtgrp[sc->sc_fmtgrp_idx].format = 976 (struct uvideo_format_desc *)d; 977 if (d->bDefaultFrameIndex > d->bNumFrameDescriptors || 978 d->bDefaultFrameIndex < 1) { 979 /* sanitize wrong bDefaultFrameIndex value */ 980 sc->sc_fmtgrp[sc->sc_fmtgrp_idx].format_dfidx = 1; 981 } else { 982 sc->sc_fmtgrp[sc->sc_fmtgrp_idx].format_dfidx = 983 d->bDefaultFrameIndex; 984 } 985 i = sc->sc_fmtgrp_idx; 986 if (!strcmp(sc->sc_fmtgrp[i].format->u.uc.guidFormat, "YUY2")) { 987 sc->sc_fmtgrp[i].pixelformat = V4L2_PIX_FMT_YUYV; 988 } else if (!strcmp(sc->sc_fmtgrp[i].format->u.uc.guidFormat, "NV12")) { 989 sc->sc_fmtgrp[i].pixelformat = V4L2_PIX_FMT_NV12; 990 } else if (!strcmp(sc->sc_fmtgrp[i].format->u.uc.guidFormat, "UYVY")) { 991 sc->sc_fmtgrp[i].pixelformat = V4L2_PIX_FMT_UYVY; 992 } else { 993 sc->sc_fmtgrp[i].pixelformat = 0; 994 } 995 996 if (sc->sc_fmtgrp_cur == NULL) 997 /* set UNCOMPRESSED format */ 998 sc->sc_fmtgrp_cur = &sc->sc_fmtgrp[sc->sc_fmtgrp_idx]; 999 1000 sc->sc_fmtgrp_idx++; 1001 sc->sc_fmtgrp_num++; 1002 1003 return (USBD_NORMAL_COMPLETION); 1004 } 1005 1006 usbd_status 1007 uvideo_vs_parse_desc_frame(struct uvideo_softc *sc) 1008 { 1009 usbd_desc_iter_t iter; 1010 const usb_descriptor_t *desc; 1011 usbd_status error; 1012 1013 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1014 1015 usb_desc_iter_init(sc->sc_udev, &iter); 1016 desc = usb_desc_iter_next(&iter); 1017 while (desc) { 1018 if (desc->bDescriptorType == UDESC_CS_INTERFACE && 1019 desc->bLength > sizeof(struct usb_video_frame_desc) && 1020 (desc->bDescriptorSubtype == UDESCSUB_VS_FRAME_MJPEG || 1021 desc->bDescriptorSubtype == UDESCSUB_VS_FRAME_UNCOMPRESSED)) { 1022 error = uvideo_vs_parse_desc_frame_sub(sc, desc); 1023 if (error != USBD_NORMAL_COMPLETION) 1024 return (error); 1025 } 1026 desc = usb_desc_iter_next(&iter); 1027 } 1028 1029 return (USBD_NORMAL_COMPLETION); 1030 } 1031 1032 usbd_status 1033 uvideo_vs_parse_desc_frame_sub(struct uvideo_softc *sc, 1034 const usb_descriptor_t *desc) 1035 { 1036 struct usb_video_frame_desc *fd = 1037 (struct usb_video_frame_desc *)(uint8_t *)desc; 1038 int fmtidx, frame_num; 1039 uint32_t fbuf_size; 1040 1041 fmtidx = sc->sc_fmtgrp_idx; 1042 frame_num = sc->sc_fmtgrp[fmtidx].frame_num; 1043 if (frame_num >= UVIDEO_MAX_FRAME) { 1044 printf("%s: too many %s frame descriptors found!\n", 1045 DEVNAME(sc), 1046 desc->bDescriptorSubtype == UDESCSUB_VS_FRAME_MJPEG ? 1047 "MJPEG" : "UNCOMPRESSED"); 1048 return (USBD_INVAL); 1049 } 1050 sc->sc_fmtgrp[fmtidx].frame[frame_num] = fd; 1051 1052 if (sc->sc_fmtgrp[fmtidx].frame_cur == NULL || 1053 sc->sc_fmtgrp[fmtidx].format_dfidx == fd->bFrameIndex) 1054 sc->sc_fmtgrp[fmtidx].frame_cur = fd; 1055 1056 /* 1057 * On some devices, dwMaxVideoFrameBufferSize is not correct. 1058 * Version 1.1 of the UVC spec says this field is deprecated. 1059 * For uncompressed pixel formats, the frame buffer size can 1060 * be determined by multiplying width, height, and bytes per pixel. 1061 * Uncompressed formats have a fixed number of bytes per pixel. 1062 * Bytes per pixel can vary with compressed formats. 1063 */ 1064 if (desc->bDescriptorSubtype == UDESCSUB_VS_FRAME_UNCOMPRESSED) { 1065 fbuf_size = UGETW(fd->wWidth) * UGETW(fd->wHeight) * 1066 sc->sc_fmtgrp[fmtidx].format->u.uc.bBitsPerPixel / NBBY; 1067 DPRINTF(10, "%s: %s: frame buffer size=%d " 1068 "width=%d height=%d bpp=%d\n", DEVNAME(sc), __func__, 1069 fbuf_size, UGETW(fd->wWidth), UGETW(fd->wHeight), 1070 sc->sc_fmtgrp[fmtidx].format->u.uc.bBitsPerPixel); 1071 } else 1072 fbuf_size = UGETDW(fd->dwMaxVideoFrameBufferSize); 1073 1074 /* store max value */ 1075 if (fbuf_size > sc->sc_max_fbuf_size) 1076 sc->sc_max_fbuf_size = fbuf_size; 1077 1078 /* 1079 * Increment frame count. If this is the last frame in the 1080 * format group, go on to next group. 1081 */ 1082 if (++sc->sc_fmtgrp[fmtidx].frame_num == 1083 sc->sc_fmtgrp[fmtidx].format->bNumFrameDescriptors) { 1084 sc->sc_fmtgrp_idx++; 1085 } 1086 1087 return (USBD_NORMAL_COMPLETION); 1088 } 1089 1090 usbd_status 1091 uvideo_vs_parse_desc_alt(struct uvideo_softc *sc, int vs_nr, int iface, int numalts) 1092 { 1093 struct uvideo_vs_iface *vs; 1094 usbd_desc_iter_t iter; 1095 const usb_descriptor_t *desc; 1096 usb_interface_descriptor_t *id; 1097 usb_endpoint_descriptor_t *ed; 1098 uint8_t ep_dir, ep_type; 1099 1100 vs = &sc->sc_vs_coll[vs_nr]; 1101 1102 usb_desc_iter_init(sc->sc_udev, &iter); 1103 desc = usb_desc_iter_next(&iter); 1104 while (desc) { 1105 /* find video stream interface */ 1106 if (desc->bDescriptorType != UDESC_INTERFACE) 1107 goto next; 1108 id = (usb_interface_descriptor_t *)(uint8_t *)desc; 1109 if (id->bInterfaceNumber != iface) 1110 goto next; 1111 DPRINTF(1, "%s: bAlternateSetting=0x%02x, ", 1112 DEVNAME(sc), id->bAlternateSetting); 1113 if (id->bNumEndpoints == 0) { 1114 DPRINTF(1, "no endpoint descriptor\n"); 1115 goto next; 1116 } 1117 1118 /* jump to corresponding endpoint descriptor */ 1119 while ((desc = usb_desc_iter_next(&iter))) { 1120 if (desc->bDescriptorType == UDESC_ENDPOINT) 1121 break; 1122 } 1123 ed = (usb_endpoint_descriptor_t *)(uint8_t *)desc; 1124 DPRINTF(1, "bEndpointAddress=0x%02x, ", ed->bEndpointAddress); 1125 DPRINTF(1, "wMaxPacketSize=%d\n", UGETW(ed->wMaxPacketSize)); 1126 1127 /* locate endpoint type */ 1128 ep_dir = UE_GET_DIR(ed->bEndpointAddress); 1129 ep_type = UE_GET_XFERTYPE(ed->bmAttributes); 1130 if (ep_dir == UE_DIR_IN && ep_type == UE_ISOCHRONOUS) 1131 vs->bulk_endpoint = 0; 1132 else if (ep_dir == UE_DIR_IN && ep_type == UE_BULK) 1133 vs->bulk_endpoint = 1; 1134 else 1135 goto next; 1136 1137 /* save endpoint with largest bandwidth */ 1138 if (UGETW(ed->wMaxPacketSize) > vs->psize) { 1139 vs->ifaceh = &sc->sc_udev->ifaces[iface]; 1140 vs->endpoint = ed->bEndpointAddress; 1141 vs->numalts = numalts; 1142 vs->curalt = id->bAlternateSetting; 1143 vs->psize = UGETW(ed->wMaxPacketSize); 1144 vs->iface = iface; 1145 } 1146 next: 1147 desc = usb_desc_iter_next(&iter); 1148 } 1149 1150 /* check if we have found a valid alternate interface */ 1151 if (vs->ifaceh == NULL) { 1152 printf("%s: no valid alternate interface found!\n", 1153 DEVNAME(sc)); 1154 return (USBD_INVAL); 1155 } 1156 1157 return (USBD_NORMAL_COMPLETION); 1158 } 1159 1160 usbd_status 1161 uvideo_vs_set_alt(struct uvideo_softc *sc, usbd_interface_handle ifaceh, 1162 int max_packet_size) 1163 { 1164 usbd_desc_iter_t iter; 1165 const usb_descriptor_t *desc; 1166 usb_interface_descriptor_t *id; 1167 usb_endpoint_descriptor_t *ed; 1168 int i, diff, best_diff = INT_MAX; 1169 usbd_status error; 1170 uint32_t psize; 1171 1172 i = 0; 1173 usb_desc_iter_init(sc->sc_udev, &iter); 1174 desc = usb_desc_iter_next(&iter); 1175 while (desc) { 1176 /* find video stream interface */ 1177 if (desc->bDescriptorType != UDESC_INTERFACE) 1178 goto next; 1179 id = (usb_interface_descriptor_t *)(uint8_t *)desc; 1180 if (id->bInterfaceNumber != sc->sc_vs_cur->iface) 1181 goto next; 1182 if (id->bNumEndpoints == 0) 1183 goto next; 1184 1185 /* jump to corresponding endpoint descriptor */ 1186 desc = usb_desc_iter_next(&iter); 1187 if (desc->bDescriptorType != UDESC_ENDPOINT) 1188 goto next; 1189 ed = (usb_endpoint_descriptor_t *)(uint8_t *)desc; 1190 i++; 1191 1192 /* save endpoint with requested bandwidth */ 1193 psize = UGETW(ed->wMaxPacketSize); 1194 psize = UE_GET_SIZE(psize) * (1 + UE_GET_TRANS(psize)); 1195 if (psize >= max_packet_size) 1196 diff = psize - max_packet_size; 1197 else 1198 goto next; 1199 if (diff < best_diff) { 1200 best_diff = diff; 1201 sc->sc_vs_cur->endpoint = ed->bEndpointAddress; 1202 sc->sc_vs_cur->curalt = id->bAlternateSetting; 1203 sc->sc_vs_cur->psize = psize; 1204 if (diff == 0) 1205 break; 1206 } 1207 next: 1208 desc = usb_desc_iter_next(&iter); 1209 } 1210 1211 DPRINTF(1, "%s: set alternate iface to ", DEVNAME(sc)); 1212 DPRINTF(1, "bAlternateSetting=0x%02x psize=%d max_packet_size=%d\n", 1213 sc->sc_vs_cur->curalt, sc->sc_vs_cur->psize, max_packet_size); 1214 1215 /* set alternate video stream interface */ 1216 error = usbd_set_interface(ifaceh, i); 1217 if (error) { 1218 printf("%s: could not set alternate interface %d!\n", 1219 DEVNAME(sc), i); 1220 return (USBD_INVAL); 1221 } 1222 1223 return (USBD_NORMAL_COMPLETION); 1224 } 1225 1226 /* 1227 * Thanks to the retarded USB Video Class specs there are different 1228 * descriptors types with the same bDescriptorSubtype which makes 1229 * it necessary to differ between those types by doing descriptor 1230 * size dances :-( 1231 * 1232 * size_fix: total size of the fixed structure part 1233 * off_num_elements: offset which tells the number of following elements 1234 * size_element: size of a single element 1235 * off_size_element: if size_element is 0 the element size is taken from 1236 * this offset in the descriptor 1237 */ 1238 int 1239 uvideo_desc_len(const usb_descriptor_t *desc, 1240 int size_fix, int off_num_elements, int size_element, int off_size_element) 1241 { 1242 uint8_t *buf; 1243 int size_elements, size_total; 1244 1245 if (desc->bLength < size_fix) 1246 return (0); 1247 1248 buf = (uint8_t *)desc; 1249 1250 if (size_element == 0) 1251 size_element = buf[off_size_element]; 1252 1253 size_elements = buf[off_num_elements] * size_element; 1254 size_total = size_fix + size_elements; 1255 1256 if (desc->bLength == size_total && size_elements != 0) 1257 return (1); 1258 1259 return (0); 1260 } 1261 1262 /* 1263 * Find the next best matching resolution which we can offer and 1264 * return it. 1265 */ 1266 void 1267 uvideo_find_res(struct uvideo_softc *sc, int idx, int width, int height, 1268 struct uvideo_res *r) 1269 { 1270 int i, w, h, diff, diff_best, size_want, size_is; 1271 1272 size_want = width * height; 1273 1274 for (i = 0; i < sc->sc_fmtgrp[idx].frame_num; i++) { 1275 w = UGETW(sc->sc_fmtgrp[idx].frame[i]->wWidth); 1276 h = UGETW(sc->sc_fmtgrp[idx].frame[i]->wHeight); 1277 size_is = w * h; 1278 if (size_is > size_want) 1279 diff = size_is - size_want; 1280 else 1281 diff = size_want - size_is; 1282 if (i == 0) 1283 diff_best = diff; 1284 if (diff <= diff_best) { 1285 diff_best = diff; 1286 r->width = w; 1287 r->height = h; 1288 r->fidx = i; 1289 } 1290 DPRINTF(1, "%s: %s: frame index %d: width=%d, height=%d\n", 1291 DEVNAME(sc), __func__, i, w, h); 1292 } 1293 } 1294 1295 usbd_status 1296 uvideo_vs_negotiation(struct uvideo_softc *sc, int commit) 1297 { 1298 struct usb_video_probe_commit *pc; 1299 struct uvideo_format_group *fmtgrp; 1300 struct usb_video_header_desc *hd; 1301 struct usb_video_frame_desc *frame; 1302 uint8_t *p, *cur; 1303 uint8_t probe_data[34]; 1304 uint32_t frame_ival, nivals, min, max, step, diff; 1305 usbd_status error; 1306 int i, ival_bytes, changed = 0; 1307 1308 pc = (struct usb_video_probe_commit *)probe_data; 1309 1310 fmtgrp = sc->sc_fmtgrp_cur; 1311 1312 /* check if the format descriptor contains frame descriptors */ 1313 if (fmtgrp->frame_num == 0) { 1314 printf("%s: %s: no frame descriptors found!\n", 1315 __func__, DEVNAME(sc)); 1316 return (USBD_INVAL); 1317 } 1318 1319 /* set probe */ 1320 bzero(probe_data, sizeof(probe_data)); 1321 /* hint that dwFrameInterval should be favored over other parameters */ 1322 USETW(pc->bmHint, 0x1); 1323 pc->bFormatIndex = fmtgrp->format->bFormatIndex; 1324 pc->bFrameIndex = fmtgrp->frame_cur->bFrameIndex; 1325 /* dwFrameInterval: 30fps=333333, 15fps=666666, 10fps=1000000 */ 1326 frame_ival = UGETDW(fmtgrp->frame_cur->dwDefaultFrameInterval); 1327 if (sc->sc_frame_rate != 0) { 1328 frame_ival = 10000000 / sc->sc_frame_rate; 1329 /* find closest matching interval the device supports */ 1330 p = (uint8_t *)fmtgrp->frame_cur; 1331 p += sizeof(struct usb_video_frame_desc); 1332 nivals = fmtgrp->frame_cur->bFrameIntervalType; 1333 ival_bytes = fmtgrp->frame_cur->bLength - 1334 sizeof(struct usb_video_frame_desc); 1335 if (!nivals && (ival_bytes >= sizeof(uDWord) * 3)) { 1336 /* continuous */ 1337 min = UGETDW(p); 1338 p += sizeof(uDWord); 1339 max = UGETDW(p); 1340 p += sizeof(uDWord); 1341 step = UGETDW(p); 1342 p += sizeof(uDWord); 1343 if (frame_ival <= min) 1344 frame_ival = min; 1345 else if (frame_ival >= max) 1346 frame_ival = max; 1347 else { 1348 for (i = min; i + step/2 < frame_ival; i+= step) 1349 ; /* nothing */ 1350 frame_ival = i; 1351 } 1352 } else if (nivals > 0 && ival_bytes >= sizeof(uDWord)) { 1353 /* discrete */ 1354 cur = p; 1355 min = UINT_MAX; 1356 for (i = 0; i < nivals; i++) { 1357 if (ival_bytes < sizeof(uDWord)) { 1358 /* short descriptor ? */ 1359 break; 1360 } 1361 diff = abs(UGETDW(p) - frame_ival); 1362 if (diff < min) { 1363 min = diff; 1364 cur = p; 1365 if (diff == 0) 1366 break; 1367 } 1368 p += sizeof(uDWord); 1369 ival_bytes -= sizeof(uDWord); 1370 } 1371 frame_ival = UGETDW(cur); 1372 } else { 1373 DPRINTF(1, "%s: %s: bad frame ival descriptor\n", 1374 DEVNAME(sc), __func__); 1375 } 1376 } 1377 USETDW(pc->dwFrameInterval, frame_ival); 1378 error = uvideo_vs_set_probe(sc, probe_data); 1379 if (error != USBD_NORMAL_COMPLETION) 1380 return (error); 1381 1382 /* get probe */ 1383 bzero(probe_data, sizeof(probe_data)); 1384 error = uvideo_vs_get_probe(sc, probe_data, GET_CUR); 1385 if (error != USBD_NORMAL_COMPLETION) 1386 return (error); 1387 1388 /* check that the format and frame indexes are what we wanted */ 1389 if (pc->bFormatIndex != fmtgrp->format->bFormatIndex) { 1390 changed++; 1391 DPRINTF(1, "%s: %s: wanted format 0x%x, got format 0x%x\n", 1392 DEVNAME(sc), __func__, fmtgrp->format->bFormatIndex, 1393 pc->bFormatIndex); 1394 for (i = 0; i < sc->sc_fmtgrp_num; i++) { 1395 if (sc->sc_fmtgrp[i].format->bFormatIndex == 1396 pc->bFormatIndex) { 1397 fmtgrp = &sc->sc_fmtgrp[i]; 1398 break; 1399 } 1400 } 1401 if (i == sc->sc_fmtgrp_num) { 1402 DPRINTF(1, "%s: %s: invalid format index 0x%x\n", 1403 DEVNAME(sc), __func__, pc->bFormatIndex); 1404 return (USBD_INVAL); 1405 } 1406 } 1407 if (pc->bFrameIndex != fmtgrp->frame_cur->bFrameIndex) { 1408 changed++; 1409 DPRINTF(1, "%s: %s: wanted frame 0x%x, got frame 0x%x\n", 1410 DEVNAME(sc), __func__, fmtgrp->frame_cur->bFrameIndex, 1411 pc->bFrameIndex); 1412 for (i = 0; i < fmtgrp->frame_num; i++) { 1413 if (fmtgrp->frame[i]->bFrameIndex == pc->bFrameIndex) { 1414 frame = fmtgrp->frame[i]; 1415 break; 1416 } 1417 } 1418 if (i == fmtgrp->frame_num) { 1419 DPRINTF(1, "%s: %s: invalid frame index 0x%x\n", 1420 DEVNAME(sc), __func__, pc->bFrameIndex); 1421 return (USBD_INVAL); 1422 } 1423 } else 1424 frame = fmtgrp->frame_cur; 1425 1426 /* 1427 * Uncompressed formats have fixed bits per pixel, which means 1428 * the frame buffer size is fixed and can be calculated. Because 1429 * some devices return incorrect values, always override the 1430 * the frame size with a calculated value. 1431 */ 1432 if (frame->bDescriptorSubtype == UDESCSUB_VS_FRAME_UNCOMPRESSED) { 1433 USETDW(pc->dwMaxVideoFrameSize, 1434 UGETW(frame->wWidth) * UGETW(frame->wHeight) * 1435 fmtgrp->format->u.uc.bBitsPerPixel / NBBY); 1436 DPRINTF(1, "fixed dwMaxVideoFrameSize=%d, " 1437 "width=%d height=%d bpp=%d\n", 1438 UGETDW(pc->dwMaxVideoFrameSize), 1439 UGETW(frame->wWidth), UGETW(frame->wHeight), 1440 fmtgrp->format->u.uc.bBitsPerPixel); 1441 } else { 1442 /* 1443 * Some UVC 1.00 devices return dwMaxVideoFrameSize = 0. 1444 * If so, fix it by format/frame descriptors. 1445 */ 1446 hd = sc->sc_desc_vc_header.fix; 1447 if (UGETDW(pc->dwMaxVideoFrameSize) == 0 && 1448 UGETW(hd->bcdUVC) < 0x0110 ) { 1449 DPRINTF(1, "%s: dwMaxVideoFrameSize == 0, fixed\n", 1450 DEVNAME(sc)); 1451 USETDW(pc->dwMaxVideoFrameSize, 1452 UGETDW(frame->dwMaxVideoFrameBufferSize)); 1453 } 1454 } 1455 1456 /* commit */ 1457 if (commit) { 1458 if (changed > 0) { 1459 /* didn't get the frame format or size we wanted */ 1460 return (USBD_INVAL); 1461 } 1462 error = uvideo_vs_set_commit(sc, probe_data); 1463 if (error != USBD_NORMAL_COMPLETION) 1464 return (error); 1465 } 1466 1467 /* save a copy of probe commit */ 1468 bcopy(pc, &sc->sc_desc_probe, sizeof(sc->sc_desc_probe)); 1469 1470 return (USBD_NORMAL_COMPLETION); 1471 } 1472 1473 usbd_status 1474 uvideo_vs_set_probe(struct uvideo_softc *sc, uint8_t *probe_data) 1475 { 1476 usb_device_request_t req; 1477 usbd_status error; 1478 uint16_t tmp; 1479 struct usb_video_probe_commit *pc; 1480 1481 req.bmRequestType = UVIDEO_SET_IF; 1482 req.bRequest = SET_CUR; 1483 tmp = VS_PROBE_CONTROL; 1484 tmp = tmp << 8; 1485 USETW(req.wValue, tmp); 1486 USETW(req.wIndex, sc->sc_vs_cur->iface); 1487 USETW(req.wLength, 26); 1488 1489 pc = (struct usb_video_probe_commit *)probe_data; 1490 1491 error = usbd_do_request(sc->sc_udev, &req, probe_data); 1492 if (error) { 1493 printf("%s: could not SET probe request: %s\n", 1494 DEVNAME(sc), usbd_errstr(error)); 1495 return (USBD_INVAL); 1496 } 1497 DPRINTF(1, "%s: SET probe request successfully\n", DEVNAME(sc)); 1498 1499 DPRINTF(1, "bmHint=0x%02x\n", UGETW(pc->bmHint)); 1500 DPRINTF(1, "bFormatIndex=0x%02x\n", pc->bFormatIndex); 1501 DPRINTF(1, "bFrameIndex=0x%02x\n", pc->bFrameIndex); 1502 DPRINTF(1, "dwFrameInterval=%d (100ns units)\n", 1503 UGETDW(pc->dwFrameInterval)); 1504 DPRINTF(1, "wKeyFrameRate=%d\n", UGETW(pc->wKeyFrameRate)); 1505 DPRINTF(1, "wPFrameRate=%d\n", UGETW(pc->wPFrameRate)); 1506 DPRINTF(1, "wCompQuality=%d\n", UGETW(pc->wCompQuality)); 1507 DPRINTF(1, "wCompWindowSize=%d\n", UGETW(pc->wCompWindowSize)); 1508 DPRINTF(1, "wDelay=%d (ms)\n", UGETW(pc->wDelay)); 1509 DPRINTF(1, "dwMaxVideoFrameSize=%d (bytes)\n", 1510 UGETDW(pc->dwMaxVideoFrameSize)); 1511 DPRINTF(1, "dwMaxPayloadTransferSize=%d (bytes)\n", 1512 UGETDW(pc->dwMaxPayloadTransferSize)); 1513 1514 return (USBD_NORMAL_COMPLETION); 1515 } 1516 1517 usbd_status 1518 uvideo_vs_get_probe(struct uvideo_softc *sc, uint8_t *probe_data, 1519 uint8_t request) 1520 { 1521 usb_device_request_t req; 1522 usbd_status error; 1523 uint16_t tmp; 1524 struct usb_video_probe_commit *pc; 1525 1526 req.bmRequestType = UVIDEO_GET_IF; 1527 req.bRequest = request; 1528 tmp = VS_PROBE_CONTROL; 1529 tmp = tmp << 8; 1530 USETW(req.wValue, tmp); 1531 USETW(req.wIndex, sc->sc_vs_cur->iface); 1532 USETW(req.wLength, 26); 1533 1534 pc = (struct usb_video_probe_commit *)probe_data; 1535 1536 error = usbd_do_request(sc->sc_udev, &req, probe_data); 1537 if (error) { 1538 printf("%s: could not GET probe request: %s\n", 1539 DEVNAME(sc), usbd_errstr(error)); 1540 return (USBD_INVAL); 1541 } 1542 DPRINTF(1, "%s: GET probe request successfully\n", DEVNAME(sc)); 1543 1544 DPRINTF(1, "bmHint=0x%02x\n", UGETW(pc->bmHint)); 1545 DPRINTF(1, "bFormatIndex=0x%02x\n", pc->bFormatIndex); 1546 DPRINTF(1, "bFrameIndex=0x%02x\n", pc->bFrameIndex); 1547 DPRINTF(1, "dwFrameInterval=%d (100ns units)\n", 1548 UGETDW(pc->dwFrameInterval)); 1549 DPRINTF(1, "wKeyFrameRate=%d\n", UGETW(pc->wKeyFrameRate)); 1550 DPRINTF(1, "wPFrameRate=%d\n", UGETW(pc->wPFrameRate)); 1551 DPRINTF(1, "wCompQuality=%d\n", UGETW(pc->wCompQuality)); 1552 DPRINTF(1, "wCompWindowSize=%d\n", UGETW(pc->wCompWindowSize)); 1553 DPRINTF(1, "wDelay=%d (ms)\n", UGETW(pc->wDelay)); 1554 DPRINTF(1, "dwMaxVideoFrameSize=%d (bytes)\n", 1555 UGETDW(pc->dwMaxVideoFrameSize)); 1556 DPRINTF(1, "dwMaxPayloadTransferSize=%d (bytes)\n", 1557 UGETDW(pc->dwMaxPayloadTransferSize)); 1558 1559 return (USBD_NORMAL_COMPLETION); 1560 } 1561 1562 usbd_status 1563 uvideo_vs_set_commit(struct uvideo_softc *sc, uint8_t *probe_data) 1564 { 1565 usb_device_request_t req; 1566 usbd_status error; 1567 uint16_t tmp; 1568 1569 req.bmRequestType = UVIDEO_SET_IF; 1570 req.bRequest = SET_CUR; 1571 tmp = VS_COMMIT_CONTROL; 1572 tmp = tmp << 8; 1573 USETW(req.wValue, tmp); 1574 USETW(req.wIndex, sc->sc_vs_cur->iface); 1575 USETW(req.wLength, 26); 1576 1577 error = usbd_do_request(sc->sc_udev, &req, probe_data); 1578 if (error) { 1579 printf("%s: could not SET commit request: %s\n", 1580 DEVNAME(sc), usbd_errstr(error)); 1581 return (USBD_INVAL); 1582 } 1583 DPRINTF(1, "%s: SET commit request successfully\n", DEVNAME(sc)); 1584 1585 return (USBD_NORMAL_COMPLETION); 1586 } 1587 1588 usbd_status 1589 uvideo_vs_alloc_frame(struct uvideo_softc *sc) 1590 { 1591 struct uvideo_frame_buffer *fb = &sc->sc_frame_buffer; 1592 1593 fb->buf_size = UGETDW(sc->sc_desc_probe.dwMaxVideoFrameSize); 1594 1595 /* don't overflow the upper layer frame buffer */ 1596 if (sc->sc_max_fbuf_size < fb->buf_size && 1597 sc->sc_mmap_flag == 0) { 1598 printf("%s: software video buffer is too small!\n", 1599 DEVNAME(sc)); 1600 return (USBD_NOMEM); 1601 } 1602 1603 fb->buf = malloc(fb->buf_size, M_DEVBUF, M_NOWAIT); 1604 if (fb->buf == NULL) { 1605 printf("%s: can't allocate frame buffer!\n", DEVNAME(sc)); 1606 return (USBD_NOMEM); 1607 } 1608 1609 DPRINTF(1, "%s: %s: allocated %d bytes frame buffer\n", 1610 DEVNAME(sc), __func__, fb->buf_size); 1611 1612 fb->sample = 0; 1613 fb->fid = 0; 1614 fb->offset = 0; 1615 fb->fmt_flags = sc->sc_fmtgrp_cur->frame_cur->bDescriptorSubtype == 1616 UDESCSUB_VS_FRAME_UNCOMPRESSED ? 0 : V4L2_FMT_FLAG_COMPRESSED; 1617 1618 return (USBD_NORMAL_COMPLETION); 1619 } 1620 1621 void 1622 uvideo_vs_free_frame(struct uvideo_softc *sc) 1623 { 1624 struct uvideo_frame_buffer *fb = &sc->sc_frame_buffer; 1625 1626 if (fb->buf != NULL) { 1627 free(fb->buf, M_DEVBUF); 1628 fb->buf = NULL; 1629 } 1630 1631 if (sc->sc_mmap_buffer != NULL) { 1632 free(sc->sc_mmap_buffer, M_DEVBUF); 1633 sc->sc_mmap_buffer = NULL; 1634 } 1635 1636 while (!SIMPLEQ_EMPTY(&sc->sc_mmap_q)) 1637 SIMPLEQ_REMOVE_HEAD(&sc->sc_mmap_q, q_frames); 1638 1639 sc->sc_mmap_cur = -1; 1640 sc->sc_mmap_count = 0; 1641 } 1642 1643 usbd_status 1644 uvideo_vs_alloc_isoc(struct uvideo_softc *sc) 1645 { 1646 int size, i; 1647 1648 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1649 1650 for (i = 0; i < UVIDEO_IXFERS; i++) { 1651 sc->sc_vs_cur->ixfer[i].sc = sc; 1652 1653 sc->sc_vs_cur->ixfer[i].xfer = usbd_alloc_xfer(sc->sc_udev); 1654 if (sc->sc_vs_cur->ixfer[i].xfer == NULL) { 1655 printf("%s: could not allocate isoc VS xfer!\n", 1656 DEVNAME(sc)); 1657 return (USBD_NOMEM); 1658 } 1659 1660 size = sc->sc_vs_cur->psize * sc->sc_nframes; 1661 1662 sc->sc_vs_cur->ixfer[i].buf = 1663 usbd_alloc_buffer(sc->sc_vs_cur->ixfer[i].xfer, size); 1664 if (sc->sc_vs_cur->ixfer[i].buf == NULL) { 1665 printf("%s: could not allocate isoc VS buffer!\n", 1666 DEVNAME(sc)); 1667 return (USBD_NOMEM); 1668 } 1669 DPRINTF(1, "%s: allocated %d bytes isoc VS xfer buffer\n", 1670 DEVNAME(sc), size); 1671 } 1672 1673 return (USBD_NORMAL_COMPLETION); 1674 } 1675 1676 usbd_status 1677 uvideo_vs_alloc_bulk(struct uvideo_softc *sc) 1678 { 1679 int size; 1680 1681 sc->sc_vs_cur->bxfer.sc = sc; 1682 1683 sc->sc_vs_cur->bxfer.xfer = usbd_alloc_xfer(sc->sc_udev); 1684 if (sc->sc_vs_cur->bxfer.xfer == NULL) { 1685 printf("%s: could not allocate bulk VS xfer!\n", 1686 DEVNAME(sc)); 1687 return (USBD_NOMEM); 1688 } 1689 1690 size = UGETDW(sc->sc_desc_probe.dwMaxPayloadTransferSize); 1691 1692 sc->sc_vs_cur->bxfer.buf = 1693 usbd_alloc_buffer(sc->sc_vs_cur->bxfer.xfer, size); 1694 if (sc->sc_vs_cur->bxfer.buf == NULL) { 1695 printf("%s: could not allocate bulk VS buffer!\n", 1696 DEVNAME(sc)); 1697 return (USBD_NOMEM); 1698 } 1699 DPRINTF(1, "%s: allocated %d bytes bulk VS xfer buffer\n", 1700 DEVNAME(sc), size); 1701 1702 return (USBD_NORMAL_COMPLETION); 1703 } 1704 1705 void 1706 uvideo_vs_free_isoc(struct uvideo_softc *sc) 1707 { 1708 int i; 1709 1710 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1711 1712 for (i = 0; i < UVIDEO_IXFERS; i++) { 1713 if (sc->sc_vs_cur->ixfer[i].buf != NULL) { 1714 usbd_free_buffer(sc->sc_vs_cur->ixfer[i].xfer); 1715 sc->sc_vs_cur->ixfer[i].buf = NULL; 1716 } 1717 1718 if (sc->sc_vs_cur->ixfer[i].xfer != NULL) { 1719 usbd_free_xfer(sc->sc_vs_cur->ixfer[i].xfer); 1720 sc->sc_vs_cur->ixfer[i].xfer = NULL; 1721 } 1722 } 1723 } 1724 1725 void 1726 uvideo_vs_free_bulk(struct uvideo_softc *sc) 1727 { 1728 if (sc->sc_vs_cur->bxfer.buf != NULL) { 1729 usbd_free_buffer(sc->sc_vs_cur->bxfer.xfer); 1730 sc->sc_vs_cur->bxfer.buf = NULL; 1731 } 1732 1733 if (sc->sc_vs_cur->bxfer.xfer != NULL) { 1734 usbd_free_xfer(sc->sc_vs_cur->bxfer.xfer); 1735 sc->sc_vs_cur->bxfer.xfer = NULL; 1736 } 1737 } 1738 1739 usbd_status 1740 uvideo_vs_open(struct uvideo_softc *sc) 1741 { 1742 usb_endpoint_descriptor_t *ed; 1743 usbd_status error; 1744 uint32_t dwMaxVideoFrameSize; 1745 1746 DPRINTF(1, "%s: %s\n", DEVNAME(sc), __func__); 1747 1748 if (sc->sc_negotiated_flag == 0) { 1749 /* do device negotiation with commit */ 1750 error = uvideo_vs_negotiation(sc, 1); 1751 if (error != USBD_NORMAL_COMPLETION) 1752 return (error); 1753 } 1754 1755 error = uvideo_vs_set_alt(sc, sc->sc_vs_cur->ifaceh, 1756 UGETDW(sc->sc_desc_probe.dwMaxPayloadTransferSize)); 1757 if (error != USBD_NORMAL_COMPLETION) { 1758 printf("%s: could not set alternate interface!\n", 1759 DEVNAME(sc)); 1760 return (error); 1761 } 1762 1763 ed = usbd_interface2endpoint_descriptor(sc->sc_vs_cur->ifaceh, 0); 1764 if (ed == NULL) { 1765 printf("%s: no endpoint descriptor for VS iface\n", 1766 DEVNAME(sc)); 1767 return (USBD_INVAL); 1768 } 1769 DPRINTF(1, "%s: open pipe for ", DEVNAME(sc)); 1770 DPRINTF(1, "bEndpointAddress=0x%02x (0x%02x), wMaxPacketSize=%d (%d)\n", 1771 ed->bEndpointAddress, 1772 sc->sc_vs_cur->endpoint, 1773 UGETW(ed->wMaxPacketSize), 1774 sc->sc_vs_cur->psize); 1775 1776 error = usbd_open_pipe( 1777 sc->sc_vs_cur->ifaceh, 1778 sc->sc_vs_cur->endpoint, 1779 USBD_EXCLUSIVE_USE, 1780 &sc->sc_vs_cur->pipeh); 1781 if (error != USBD_NORMAL_COMPLETION) { 1782 printf("%s: could not open VS pipe: %s\n", 1783 DEVNAME(sc), usbd_errstr(error)); 1784 return (error); 1785 } 1786 1787 /* calculate optimal isoc xfer size */ 1788 if (strcmp(sc->sc_udev->bus->bdev.dv_cfdata->cf_driver->cd_name, 1789 "ohci") == 0) { 1790 /* ohci workaround */ 1791 sc->sc_nframes = 8; 1792 } else { 1793 dwMaxVideoFrameSize = 1794 UGETDW(sc->sc_desc_probe.dwMaxVideoFrameSize); 1795 sc->sc_nframes = (dwMaxVideoFrameSize + sc->sc_vs_cur->psize - 1796 1) / sc->sc_vs_cur->psize; 1797 } 1798 if (sc->sc_nframes > UVIDEO_NFRAMES_MAX) 1799 sc->sc_nframes = UVIDEO_NFRAMES_MAX; 1800 DPRINTF(1, "%s: nframes=%d\n", DEVNAME(sc), sc->sc_nframes); 1801 1802 return (USBD_NORMAL_COMPLETION); 1803 } 1804 1805 void 1806 uvideo_vs_close(struct uvideo_softc *sc) 1807 { 1808 if (sc->sc_vs_cur->bulk_running == 1) { 1809 sc->sc_vs_cur->bulk_running = 0; 1810 (void)tsleep(&sc->sc_vs_cur->bulk_running, 0, "vid_close", 0); 1811 } 1812 1813 if (sc->sc_vs_cur->pipeh) { 1814 usbd_abort_pipe(sc->sc_vs_cur->pipeh); 1815 usbd_close_pipe(sc->sc_vs_cur->pipeh); 1816 sc->sc_vs_cur->pipeh = NULL; 1817 } 1818 1819 /* 1820 * Some devices need time to shutdown before we switch back to 1821 * the default interface (0). Not doing so can leave the device 1822 * back in a undefined condition. 1823 */ 1824 usbd_delay_ms(sc->sc_udev, 100); 1825 1826 /* switch back to default interface (turns off cam LED) */ 1827 (void)usbd_set_interface(sc->sc_vs_cur->ifaceh, 0); 1828 } 1829 1830 usbd_status 1831 uvideo_vs_init(struct uvideo_softc *sc) 1832 { 1833 usbd_status error; 1834 1835 /* open video stream pipe */ 1836 error = uvideo_vs_open(sc); 1837 if (error != USBD_NORMAL_COMPLETION) 1838 return (USBD_INVAL); 1839 1840 /* allocate video stream xfer buffer */ 1841 if (sc->sc_vs_cur->bulk_endpoint) 1842 error = uvideo_vs_alloc_bulk(sc); 1843 else 1844 error = uvideo_vs_alloc_isoc(sc); 1845 if (error != USBD_NORMAL_COMPLETION) 1846 return (USBD_INVAL); 1847 1848 /* allocate video stream frame buffer */ 1849 error = uvideo_vs_alloc_frame(sc); 1850 if (error != USBD_NORMAL_COMPLETION) 1851 return (USBD_INVAL); 1852 #ifdef UVIDEO_DUMP 1853 if (uvideo_debug_file_open(sc) != 0) 1854 return (USBD_INVAL); 1855 usb_init_task(&sc->sc_task_write, uvideo_debug_file_write_frame, sc, 1856 USB_TASK_TYPE_GENERIC); 1857 #endif 1858 return (USBD_NORMAL_COMPLETION); 1859 } 1860 1861 int 1862 uvideo_vs_start_bulk(struct uvideo_softc *sc) 1863 { 1864 int error; 1865 1866 sc->sc_vs_cur->bulk_running = 1; 1867 1868 error = kthread_create(uvideo_vs_start_bulk_thread, sc, NULL, 1869 DEVNAME(sc)); 1870 if (error) { 1871 printf("%s: can't create kernel thread!", DEVNAME(sc)); 1872 return (error); 1873 } 1874 1875 return (0); 1876 } 1877 1878 void 1879 uvideo_vs_start_bulk_thread(void *arg) 1880 { 1881 struct uvideo_softc *sc = arg; 1882 usbd_status error; 1883 int size; 1884 1885 while (sc->sc_vs_cur->bulk_running) { 1886 size = UGETDW(sc->sc_desc_probe.dwMaxPayloadTransferSize); 1887 1888 error = usbd_bulk_transfer( 1889 sc->sc_vs_cur->bxfer.xfer, 1890 sc->sc_vs_cur->pipeh, 1891 USBD_NO_COPY | USBD_SHORT_XFER_OK, 1892 USBD_NO_TIMEOUT, 1893 sc->sc_vs_cur->bxfer.buf, 1894 &size, 1895 "vid_bulk"); 1896 if (error != USBD_NORMAL_COMPLETION) { 1897 DPRINTF(1, "%s: error in bulk xfer: %s!\n", 1898 DEVNAME(sc), usbd_errstr(error)); 1899 break; 1900 } 1901 1902 DPRINTF(2, "%s: *** buffer len = %d\n", DEVNAME(sc), size); 1903 1904 (void)sc->sc_decode_stream_header(sc, 1905 sc->sc_vs_cur->bxfer.buf, size); 1906 } 1907 wakeup(&sc->sc_vs_cur->bulk_running); 1908 1909 kthread_exit(0); 1910 } 1911 1912 void 1913 uvideo_vs_start_isoc(struct uvideo_softc *sc) 1914 { 1915 int i; 1916 1917 for (i = 0; i < UVIDEO_IXFERS; i++) 1918 uvideo_vs_start_isoc_ixfer(sc, &sc->sc_vs_cur->ixfer[i]); 1919 } 1920 1921 void 1922 uvideo_vs_start_isoc_ixfer(struct uvideo_softc *sc, 1923 struct uvideo_isoc_xfer *ixfer) 1924 { 1925 int i; 1926 usbd_status error; 1927 1928 DPRINTF(2, "%s: %s\n", DEVNAME(sc), __func__); 1929 1930 if (sc->sc_dying) 1931 return; 1932 1933 for (i = 0; i < sc->sc_nframes; i++) 1934 ixfer->size[i] = sc->sc_vs_cur->psize; 1935 1936 usbd_setup_isoc_xfer( 1937 ixfer->xfer, 1938 sc->sc_vs_cur->pipeh, 1939 ixfer, 1940 ixfer->size, 1941 sc->sc_nframes, 1942 USBD_NO_COPY | USBD_SHORT_XFER_OK, 1943 uvideo_vs_cb); 1944 1945 error = usbd_transfer(ixfer->xfer); 1946 if (error && error != USBD_IN_PROGRESS) { 1947 DPRINTF(1, "%s: usbd_transfer error=%s!\n", 1948 DEVNAME(sc), usbd_errstr(error)); 1949 } 1950 } 1951 1952 void 1953 uvideo_vs_cb(usbd_xfer_handle xfer, usbd_private_handle priv, 1954 usbd_status status) 1955 { 1956 struct uvideo_isoc_xfer *ixfer = priv; 1957 struct uvideo_softc *sc = ixfer->sc; 1958 int len, i, frame_size; 1959 uint8_t *frame; 1960 usbd_status error; 1961 1962 DPRINTF(2, "%s: %s\n", DEVNAME(sc), __func__); 1963 1964 if (status != USBD_NORMAL_COMPLETION) { 1965 DPRINTF(1, "%s: %s: %s\n", DEVNAME(sc), __func__, 1966 usbd_errstr(status)); 1967 return; 1968 } 1969 usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL); 1970 1971 DPRINTF(2, "%s: *** buffer len = %d\n", DEVNAME(sc), len); 1972 if (len == 0) 1973 goto skip; 1974 1975 for (i = 0; i < sc->sc_nframes; i++) { 1976 frame = ixfer->buf + (i * sc->sc_vs_cur->psize); 1977 frame_size = ixfer->size[i]; 1978 1979 if (frame_size == 0) 1980 /* frame is empty */ 1981 continue; 1982 1983 error = sc->sc_decode_stream_header(sc, frame, frame_size); 1984 if (error == USBD_CANCELLED) 1985 break; 1986 } 1987 1988 skip: /* setup new transfer */ 1989 uvideo_vs_start_isoc_ixfer(sc, ixfer); 1990 } 1991 1992 usbd_status 1993 uvideo_vs_decode_stream_header(struct uvideo_softc *sc, uint8_t *frame, 1994 int frame_size) 1995 { 1996 struct uvideo_frame_buffer *fb = &sc->sc_frame_buffer; 1997 struct usb_video_stream_header *sh; 1998 int sample_len; 1999 2000 if (frame_size < UVIDEO_SH_MIN_LEN) 2001 /* frame too small to contain a valid stream header */ 2002 return (USBD_INVAL); 2003 2004 sh = (struct usb_video_stream_header *)frame; 2005 2006 DPRINTF(2, "%s: stream header len = %d\n", DEVNAME(sc), sh->bLength); 2007 2008 if (sh->bLength > UVIDEO_SH_MAX_LEN || sh->bLength < UVIDEO_SH_MIN_LEN) 2009 /* invalid header size */ 2010 return (USBD_INVAL); 2011 if (sh->bLength == frame_size && !(sh->bFlags & UVIDEO_SH_FLAG_EOF)) { 2012 /* stream header without payload and no EOF */ 2013 return (USBD_INVAL); 2014 } 2015 if (sh->bFlags & UVIDEO_SH_FLAG_ERR) { 2016 /* stream error, skip xfer */ 2017 DPRINTF(1, "%s: %s: stream error!\n", DEVNAME(sc), __func__); 2018 return (USBD_CANCELLED); 2019 } 2020 2021 DPRINTF(2, "%s: frame_size = %d\n", DEVNAME(sc), frame_size); 2022 2023 if (sh->bFlags & UVIDEO_SH_FLAG_FID) { 2024 DPRINTF(2, "%s: %s: FID ON (0x%02x)\n", 2025 DEVNAME(sc), __func__, 2026 sh->bFlags & UVIDEO_SH_FLAG_FID); 2027 } else { 2028 DPRINTF(2, "%s: %s: FID OFF (0x%02x)\n", 2029 DEVNAME(sc), __func__, 2030 sh->bFlags & UVIDEO_SH_FLAG_FID); 2031 } 2032 2033 if (fb->sample == 0) { 2034 /* first sample for a frame */ 2035 fb->sample = 1; 2036 fb->fid = sh->bFlags & UVIDEO_SH_FLAG_FID; 2037 fb->offset = 0; 2038 } else { 2039 /* continues sample for a frame, check consistency */ 2040 if (fb->fid != (sh->bFlags & UVIDEO_SH_FLAG_FID)) { 2041 DPRINTF(1, "%s: %s: wrong FID, ignore last frame!\n", 2042 DEVNAME(sc), __func__); 2043 fb->sample = 1; 2044 fb->fid = sh->bFlags & UVIDEO_SH_FLAG_FID; 2045 fb->offset = 0; 2046 } 2047 } 2048 2049 /* save sample */ 2050 sample_len = frame_size - sh->bLength; 2051 if ((fb->offset + sample_len) <= fb->buf_size) { 2052 bcopy(frame + sh->bLength, fb->buf + fb->offset, sample_len); 2053 fb->offset += sample_len; 2054 } 2055 2056 if (sh->bFlags & UVIDEO_SH_FLAG_EOF) { 2057 /* got a full frame */ 2058 DPRINTF(2, "%s: %s: EOF (frame size = %d bytes)\n", 2059 DEVNAME(sc), __func__, fb->offset); 2060 2061 if (fb->offset > fb->buf_size) { 2062 DPRINTF(1, "%s: %s: frame too large, skipped!\n", 2063 DEVNAME(sc), __func__); 2064 } else if (fb->offset < fb->buf_size && 2065 !(fb->fmt_flags & V4L2_FMT_FLAG_COMPRESSED)) { 2066 DPRINTF(1, "%s: %s: frame too small, skipped!\n", 2067 DEVNAME(sc), __func__); 2068 } else { 2069 #ifdef UVIDEO_DUMP 2070 /* do the file write in process context */ 2071 usb_rem_task(sc->sc_udev, &sc->sc_task_write); 2072 usb_add_task(sc->sc_udev, &sc->sc_task_write); 2073 #endif 2074 if (sc->sc_mmap_flag) { 2075 /* mmap */ 2076 uvideo_mmap_queue(sc, fb->buf, fb->offset); 2077 } else { 2078 /* read */ 2079 uvideo_read(sc, fb->buf, fb->offset); 2080 } 2081 } 2082 2083 fb->sample = 0; 2084 fb->fid = 0; 2085 } 2086 2087 return (USBD_NORMAL_COMPLETION); 2088 } 2089 2090 /* 2091 * XXX Doesn't work yet. Fix it! 2092 * 2093 * The iSight first generation device uses a own, non-standard streaming 2094 * protocol. The stream header is just sent once per image and looks 2095 * like following: 2096 * 2097 * uByte header length 2098 * uByte flags 2099 * uByte magic1[4] always "11223344" 2100 * uByte magic2[8] always "deadbeefdeadface" 2101 * uByte unknown[16] 2102 * 2103 * Sometimes the stream header is prefixed by a unknown byte. Therefore 2104 * we check for the magic value on two offsets. 2105 */ 2106 usbd_status 2107 uvideo_vs_decode_stream_header_isight(struct uvideo_softc *sc, uint8_t *frame, 2108 int frame_size) 2109 { 2110 struct uvideo_frame_buffer *fb = &sc->sc_frame_buffer; 2111 int sample_len, header = 0; 2112 uint8_t magic[] = { 2113 0x11, 0x22, 0x33, 0x44, 2114 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xfa, 0xce }; 2115 2116 if (frame_size > 13 && !memcmp(&frame[2], magic, 12)) 2117 header = 1; 2118 if (frame_size > 14 && !memcmp(&frame[3], magic, 12)) 2119 header = 1; 2120 2121 if (header && fb->fid == 0) { 2122 fb->fid = 1; 2123 return (USBD_NORMAL_COMPLETION); 2124 } 2125 2126 if (header) { 2127 if (sc->sc_mmap_flag) { 2128 /* mmap */ 2129 uvideo_mmap_queue(sc, fb->buf, fb->offset); 2130 } else { 2131 /* read */ 2132 uvideo_read(sc, fb->buf, fb->offset); 2133 } 2134 fb->offset = 0; 2135 } else { 2136 /* save sample */ 2137 sample_len = frame_size; 2138 if ((fb->offset + sample_len) <= fb->buf_size) { 2139 bcopy(frame, fb->buf + fb->offset, sample_len); 2140 fb->offset += sample_len; 2141 } 2142 } 2143 2144 return (USBD_NORMAL_COMPLETION); 2145 } 2146 2147 void 2148 uvideo_mmap_queue(struct uvideo_softc *sc, uint8_t *buf, int len) 2149 { 2150 if (sc->sc_mmap_cur < 0 || sc->sc_mmap_count == 0 || 2151 sc->sc_mmap_buffer == NULL) 2152 panic("%s: mmap buffers not allocated", __func__); 2153 2154 /* find a buffer which is ready for queueing */ 2155 while (sc->sc_mmap_cur < sc->sc_mmap_count) { 2156 if (sc->sc_mmap[sc->sc_mmap_cur].v4l2_buf.flags & 2157 V4L2_BUF_FLAG_QUEUED) 2158 break; 2159 /* not ready for queueing, try next */ 2160 sc->sc_mmap_cur++; 2161 } 2162 if (sc->sc_mmap_cur == sc->sc_mmap_count) 2163 panic("uvideo_mmap_queue: mmap queue is full!"); 2164 2165 /* copy frame to mmap buffer and report length */ 2166 bcopy(buf, sc->sc_mmap[sc->sc_mmap_cur].buf, len); 2167 sc->sc_mmap[sc->sc_mmap_cur].v4l2_buf.bytesused = len; 2168 2169 /* timestamp it */ 2170 getmicrotime(&sc->sc_mmap[sc->sc_mmap_cur].v4l2_buf.timestamp); 2171 2172 /* queue it */ 2173 SIMPLEQ_INSERT_TAIL(&sc->sc_mmap_q, &sc->sc_mmap[sc->sc_mmap_cur], 2174 q_frames); 2175 DPRINTF(2, "%s: %s: frame queued on index %d\n", 2176 DEVNAME(sc), __func__, sc->sc_mmap_cur); 2177 2178 /* point to next mmap buffer */ 2179 sc->sc_mmap_cur++; 2180 if (sc->sc_mmap_cur == sc->sc_mmap_count) 2181 /* we reached the end of the mmap buffer, start over */ 2182 sc->sc_mmap_cur = 0; 2183 2184 wakeup(sc); 2185 2186 /* 2187 * In case userland uses poll(2), signal that we have a frame 2188 * ready to dequeue. 2189 */ 2190 sc->sc_uplayer_intr(sc->sc_uplayer_arg); 2191 } 2192 2193 void 2194 uvideo_read(struct uvideo_softc *sc, uint8_t *buf, int len) 2195 { 2196 /* 2197 * Copy video frame to upper layer buffer and call 2198 * upper layer interrupt. 2199 */ 2200 *sc->sc_uplayer_fsize = len; 2201 bcopy(buf, sc->sc_uplayer_fbuffer, len); 2202 sc->sc_uplayer_intr(sc->sc_uplayer_arg); 2203 } 2204 2205 #ifdef UVIDEO_DEBUG 2206 void 2207 uvideo_dump_desc_all(struct uvideo_softc *sc) 2208 { 2209 usbd_desc_iter_t iter; 2210 const usb_descriptor_t *desc; 2211 2212 usb_desc_iter_init(sc->sc_udev, &iter); 2213 desc = usb_desc_iter_next(&iter); 2214 while (desc) { 2215 printf("bLength=%d\n", desc->bLength); 2216 printf("bDescriptorType=0x%02x", desc->bDescriptorType); 2217 2218 switch (desc->bDescriptorType) { 2219 case UDESC_CS_INTERFACE: 2220 printf(" (CS_INTERFACE)\n"); 2221 2222 switch (desc->bDescriptorSubtype) { 2223 case UDESCSUB_VC_HEADER: 2224 printf("bDescriptorSubtype=0x%02x", 2225 desc->bDescriptorSubtype); 2226 if (uvideo_desc_len(desc, 12, 11, 1, 0)) { 2227 printf(" (UDESCSUB_VC_HEADER)\n"); 2228 printf("|\n"); 2229 uvideo_dump_desc_vc_header(sc, desc); 2230 break; 2231 } 2232 if (uvideo_desc_len(desc, 13, 3, 0, 12)) { 2233 printf(" (UDESCSUB_VS_INPUT_HEADER)\n"); 2234 printf("|\n"); 2235 uvideo_dump_desc_input_header(sc, desc); 2236 break; 2237 } 2238 printf(" (unknown)\n"); 2239 break; 2240 case UDESCSUB_VC_INPUT_TERMINAL: 2241 printf("bDescriptorSubtype=0x%02x", 2242 desc->bDescriptorSubtype); 2243 printf(" (UDESCSUB_VC_INPUT_TERMINAL)\n"); 2244 printf("|\n"); 2245 uvideo_dump_desc_input(sc, desc); 2246 break; 2247 case UDESCSUB_VC_OUTPUT_TERMINAL: 2248 printf("bDescriptorSubtype=0x%02x", 2249 desc->bDescriptorSubtype); 2250 printf(" (UDESCSUB_VC_OUTPUT)\n"); 2251 printf("|\n"); 2252 uvideo_dump_desc_output(sc, desc); 2253 break; 2254 case UDESCSUB_VC_SELECTOR_UNIT: 2255 printf("bDescriptorSubtype=0x%02x", 2256 desc->bDescriptorSubtype); 2257 if (desc->bLength == 27) { 2258 printf(" (UDESCSUB_VS_FORMAT_" 2259 "UNCOMPRESSED)\n"); 2260 uvideo_dump_desc_format_uncompressed( 2261 sc, desc); 2262 } else { 2263 printf(" (UDESCSUB_VC_SELECTOR_" 2264 "UNIT)\n"); 2265 /* TODO */ 2266 } 2267 break; 2268 case UDESCSUB_VC_PROCESSING_UNIT: 2269 printf("bDescriptorSubtype=0x%02x", 2270 desc->bDescriptorSubtype); 2271 if (desc->bLength > 2272 sizeof(struct usb_video_frame_desc)) { 2273 printf(" (UDESCSUB_VS_FRAME_" 2274 "UNCOMPRESSED)\n"); 2275 uvideo_dump_desc_frame(sc, desc); 2276 } else { 2277 printf(" (UDESCSUB_VC_PROCESSING_" 2278 "UNIT)\n"); 2279 printf("|\n"); 2280 uvideo_dump_desc_processing(sc, desc); 2281 } 2282 break; 2283 case UDESCSUB_VC_EXTENSION_UNIT: 2284 printf("bDescriptorSubtype=0x%02x", 2285 desc->bDescriptorSubtype); 2286 if (desc->bLength == 11) { 2287 printf(" (UDESCSUB_VS_FORMAT_MJPEG)\n"); 2288 printf("|\n"); 2289 uvideo_dump_desc_format_mjpeg(sc, desc); 2290 } else { 2291 printf(" (UDESCSUB_VC_EXTENSION_" 2292 "UNIT)\n"); 2293 printf("|\n"); 2294 uvideo_dump_desc_extension(sc, desc); 2295 } 2296 break; 2297 case UDESCSUB_VS_FRAME_MJPEG: 2298 printf("bDescriptorSubtype=0x%02x", 2299 desc->bDescriptorSubtype); 2300 printf(" (UDESCSUB_VS_FRAME_MJPEG)\n"); 2301 if (desc->bLength > 2302 sizeof(struct usb_video_frame_desc)) { 2303 printf("|\n"); 2304 uvideo_dump_desc_frame(sc, desc); 2305 } 2306 break; 2307 case UDESCSUB_VS_COLORFORMAT: 2308 printf("bDescriptorSubtype=0x%02x", 2309 desc->bDescriptorSubtype); 2310 printf(" (UDESCSUB_VS_COLORFORMAT)\n"); 2311 printf("|\n"); 2312 uvideo_dump_desc_colorformat(sc, desc); 2313 break; 2314 } 2315 2316 break; 2317 case UDESC_CS_ENDPOINT: 2318 printf(" (UDESC_CS_ENDPOINT)\n"); 2319 2320 switch (desc->bDescriptorSubtype) { 2321 case EP_INTERRUPT: 2322 printf("bDescriptorSubtype=0x%02x", 2323 desc->bDescriptorSubtype); 2324 printf(" (EP_INTERRUPT)\n"); 2325 printf("|\n"); 2326 uvideo_dump_desc_cs_endpoint(sc, desc); 2327 break; 2328 case EP_GENERAL: 2329 printf("bDescriptorSubtype=0x%02x", 2330 desc->bDescriptorSubtype); 2331 printf(" (EP_GENERAL)\n"); 2332 printf("|\n"); 2333 uvideo_dump_desc_cs_endpoint(sc, desc); 2334 break; 2335 } 2336 2337 break; 2338 case UDESC_CONFIG: 2339 printf(" (UDESC_CONFIG)\n"); 2340 printf("|\n"); 2341 uvideo_dump_desc_config(sc, desc); 2342 break; 2343 case UDESC_ENDPOINT: 2344 printf(" (UDESC_ENDPOINT)\n"); 2345 printf("|\n"); 2346 uvideo_dump_desc_endpoint(sc, desc); 2347 break; 2348 case UDESC_INTERFACE: 2349 printf(" (UDESC_INTERFACE)\n"); 2350 printf("|\n"); 2351 uvideo_dump_desc_interface(sc, desc); 2352 break; 2353 default: 2354 printf(" (unknown)\n"); 2355 break; 2356 } 2357 2358 printf("\n"); 2359 2360 desc = usb_desc_iter_next(&iter); 2361 } 2362 2363 } 2364 2365 void 2366 uvideo_dump_desc_vc_header(struct uvideo_softc *sc, 2367 const usb_descriptor_t *desc) 2368 { 2369 struct usb_video_header_desc *d; 2370 2371 d = (struct usb_video_header_desc *)(uint8_t *)desc; 2372 2373 printf("bLength=%d\n", d->bLength); 2374 printf("bDescriptorType=0x%02x\n", d->bDescriptorType); 2375 printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); 2376 printf("bcdUVC=0x%04x\n", UGETW(d->bcdUVC)); 2377 printf("wTotalLength=%d\n", UGETW(d->wTotalLength)); 2378 printf("dwClockFrequency=%d\n", UGETDW(d->dwClockFrequency)); 2379 printf("bInCollection=0x%02x\n", d->bInCollection); 2380 } 2381 2382 void 2383 uvideo_dump_desc_input_header(struct uvideo_softc *sc, 2384 const usb_descriptor_t *desc) 2385 { 2386 struct usb_video_input_header_desc *d; 2387 2388 d = (struct usb_video_input_header_desc *)(uint8_t *)desc; 2389 2390 printf("bLength=%d\n", d->bLength); 2391 printf("bDescriptorType=0x%02x\n", d->bDescriptorType); 2392 printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); 2393 printf("bNumFormats=%d\n", d->bNumFormats); 2394 printf("wTotalLength=%d\n", UGETW(d->wTotalLength)); 2395 printf("bEndpointAddress=0x%02x\n", d->bEndpointAddress); 2396 printf("bmInfo=0x%02x\n", d->bmInfo); 2397 printf("bTerminalLink=0x%02x\n", d->bTerminalLink); 2398 printf("bStillCaptureMethod=0x%02x\n", d->bStillCaptureMethod); 2399 printf("bTriggerSupport=0x%02x\n", d->bTriggerSupport); 2400 printf("bTriggerUsage=0x%02x\n", d->bTriggerUsage); 2401 printf("bControlSize=%d\n", d->bControlSize); 2402 } 2403 2404 void 2405 uvideo_dump_desc_input(struct uvideo_softc *sc, 2406 const usb_descriptor_t *desc) 2407 { 2408 struct usb_video_input_terminal_desc *d; 2409 2410 d = (struct usb_video_input_terminal_desc *)(uint8_t *)desc; 2411 2412 printf("bLength=%d\n", d->bLength); 2413 printf("bDescriptorType=0x%02x\n", d->bDescriptorType); 2414 printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); 2415 printf("bTerminalID=0x%02x\n", d->bTerminalID); 2416 printf("wTerminalType=0x%04x\n", UGETW(d->wTerminalType)); 2417 printf("bAssocTerminal=0x%02x\n", d->bAssocTerminal); 2418 printf("iTerminal=0x%02x\n", d->iTerminal); 2419 } 2420 2421 void 2422 uvideo_dump_desc_output(struct uvideo_softc *sc, 2423 const usb_descriptor_t *desc) 2424 { 2425 struct usb_video_output_terminal_desc *d; 2426 2427 d = (struct usb_video_output_terminal_desc *)(uint8_t *)desc; 2428 2429 printf("bLength=%d\n", d->bLength); 2430 printf("bDescriptorType=0x%02x\n", d->bDescriptorType); 2431 printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); 2432 printf("bTerminalID=0x%02x\n", d->bTerminalID); 2433 printf("bAssocTerminal=0x%02x\n", d->bAssocTerminal); 2434 printf("bSourceID=0x%02x\n", d->bSourceID); 2435 printf("iTerminal=0x%02x\n", d->iTerminal); 2436 2437 } 2438 2439 void 2440 uvideo_dump_desc_endpoint(struct uvideo_softc *sc, 2441 const usb_descriptor_t *desc) 2442 { 2443 usb_endpoint_descriptor_t *d; 2444 2445 d = (usb_endpoint_descriptor_t *)(uint8_t *)desc; 2446 2447 printf("bLength=%d\n", d->bLength); 2448 printf("bDescriptorType=0x%02x\n", d->bDescriptorType); 2449 printf("bEndpointAddress=0x%02x", d->bEndpointAddress); 2450 if (UE_GET_DIR(d->bEndpointAddress) == UE_DIR_IN) 2451 printf(" (IN)\n"); 2452 if (UE_GET_DIR(d->bEndpointAddress) == UE_DIR_OUT) 2453 printf(" (OUT)\n"); 2454 printf("bmAttributes=0x%02x", d->bmAttributes); 2455 if (UE_GET_XFERTYPE(d->bmAttributes) == UE_ISOCHRONOUS) { 2456 printf(" (UE_ISOCHRONOUS,"); 2457 if (UE_GET_ISO_TYPE(d->bmAttributes) == UE_ISO_ASYNC) 2458 printf(" UE_ISO_ASYNC)\n"); 2459 if (UE_GET_ISO_TYPE(d->bmAttributes) == UE_ISO_ADAPT) 2460 printf(" UE_ISO_ADAPT)\n"); 2461 if (UE_GET_ISO_TYPE(d->bmAttributes) == UE_ISO_SYNC) 2462 printf(" UE_ISO_SYNC)\n"); 2463 } 2464 if (UE_GET_XFERTYPE(d->bmAttributes) == UE_CONTROL) 2465 printf(" (UE_CONTROL)\n"); 2466 if (UE_GET_XFERTYPE(d->bmAttributes) == UE_BULK) 2467 printf(" (UE_BULK)\n"); 2468 if (UE_GET_XFERTYPE(d->bmAttributes) == UE_INTERRUPT) 2469 printf(" (UE_INTERRUPT)\n"); 2470 printf("wMaxPacketSize=%d\n", UGETW(d->wMaxPacketSize)); 2471 printf("bInterval=0x%02x\n", d->bInterval); 2472 } 2473 2474 void 2475 uvideo_dump_desc_interface(struct uvideo_softc *sc, 2476 const usb_descriptor_t *desc) 2477 { 2478 usb_interface_descriptor_t *d; 2479 2480 d = (usb_interface_descriptor_t *)(uint8_t *)desc; 2481 2482 printf("bLength=%d\n", d->bLength); 2483 printf("bDescriptorType=0x%02x\n", d->bDescriptorType); 2484 printf("bInterfaceNumber=0x%02x\n", d->bInterfaceNumber); 2485 printf("bAlternateSetting=0x%02x\n", d->bAlternateSetting); 2486 printf("bNumEndpoints=%d\n", d->bNumEndpoints); 2487 printf("bInterfaceClass=0x%02x\n", d->bInterfaceClass); 2488 printf("bInterfaceSubClass=0x%02x\n", d->bInterfaceSubClass); 2489 printf("bInterfaceProtocol=0x%02x\n", d->bInterfaceProtocol); 2490 printf("iInterface=0x%02x\n", d->iInterface); 2491 } 2492 2493 void 2494 uvideo_dump_desc_config(struct uvideo_softc *sc, 2495 const usb_descriptor_t *desc) 2496 { 2497 usb_config_descriptor_t *d; 2498 2499 d = (usb_config_descriptor_t *)(uint8_t *)desc; 2500 2501 printf("bLength=%d\n", d->bLength); 2502 printf("bDescriptorType=0x%02x\n", d->bDescriptorType); 2503 printf("wTotalLength=%d\n", UGETW(d->wTotalLength)); 2504 printf("bNumInterface=0x%02x\n", d->bNumInterface); 2505 printf("bConfigurationValue=0x%02x\n", d->bConfigurationValue); 2506 printf("iConfiguration=0x%02x\n", d->iConfiguration); 2507 printf("bmAttributes=0x%02x\n", d->bmAttributes); 2508 printf("bMaxPower=0x%02x\n", d->bMaxPower); 2509 } 2510 2511 void 2512 uvideo_dump_desc_cs_endpoint(struct uvideo_softc *sc, 2513 const usb_descriptor_t *desc) 2514 { 2515 struct usb_video_vc_endpoint_desc *d; 2516 2517 d = (struct usb_video_vc_endpoint_desc *)(uint8_t *)desc; 2518 2519 printf("bLength=%d\n", d->bLength); 2520 printf("bDescriptorType=0x%02x\n", d->bDescriptorType); 2521 printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); 2522 printf("wMaxTransferSize=%d\n", UGETW(d->wMaxTransferSize)); 2523 } 2524 2525 void 2526 uvideo_dump_desc_colorformat(struct uvideo_softc *sc, 2527 const usb_descriptor_t *desc) 2528 { 2529 struct usb_video_color_matching_descr *d; 2530 2531 d = (struct usb_video_color_matching_descr *)(uint8_t *)desc; 2532 2533 printf("bLength=%d\n", d->bLength); 2534 printf("bDescriptorType=0x%02x\n", d->bDescriptorType); 2535 printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); 2536 printf("bColorPrimaries=0x%02x\n", d->bColorPrimaries); 2537 printf("bTransferCharacteristics=0x%02x\n", 2538 d->bTransferCharacteristics); 2539 printf("bMatrixCoefficients=0x%02x\n", d->bMatrixCoefficients); 2540 } 2541 void 2542 uvideo_dump_desc_format_mjpeg(struct uvideo_softc *sc, 2543 const usb_descriptor_t *desc) 2544 { 2545 struct usb_video_format_mjpeg_desc *d; 2546 2547 d = (struct usb_video_format_mjpeg_desc *)(uint8_t *)desc; 2548 2549 printf("bLength=%d\n", d->bLength); 2550 printf("bDescriptorType=0x%02x\n", d->bDescriptorType); 2551 printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); 2552 printf("bFormatIndex=0x%02x\n", d->bFormatIndex); 2553 printf("bNumFrameDescriptors=0x%02x\n", d->bNumFrameDescriptors); 2554 printf("bmFlags=0x%02x\n", d->bmFlags); 2555 printf("bDefaultFrameIndex=0x%02x\n", d->bDefaultFrameIndex); 2556 printf("bAspectRatioX=0x%02x\n", d->bAspectRatioX); 2557 printf("bAspectRatioY=0x%02x\n", d->bAspectRatioY); 2558 printf("bmInterlaceFlags=0x%02x\n", d->bmInterlaceFlags); 2559 printf("bCopyProtect=0x%02x\n", d->bCopyProtect); 2560 } 2561 2562 void 2563 uvideo_dump_desc_frame(struct uvideo_softc *sc, const usb_descriptor_t *desc) 2564 { 2565 struct usb_video_frame_desc *d; 2566 uint8_t *p; 2567 int length, i; 2568 2569 d = (struct usb_video_frame_desc *)(uint8_t *)desc; 2570 2571 printf("bLength=%d\n", d->bLength); 2572 printf("bDescriptorType=0x%02x\n", d->bDescriptorType); 2573 printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); 2574 printf("bFrameIndex=0x%02x\n", d->bFrameIndex); 2575 printf("bmCapabilities=0x%02x\n", d->bmCapabilities); 2576 printf("wWidth=%d\n", UGETW(d->wWidth)); 2577 printf("wHeight=%d\n", UGETW(d->wHeight)); 2578 printf("dwMinBitRate=%d\n", UGETDW(d->dwMinBitRate)); 2579 printf("dwMaxBitRate=%d\n", UGETDW(d->dwMaxBitRate)); 2580 printf("dwMaxVideoFrameBufferSize=%d\n", 2581 UGETDW(d->dwMaxVideoFrameBufferSize)); 2582 printf("dwDefaultFrameInterval=%d\n", 2583 UGETDW(d->dwDefaultFrameInterval)); 2584 printf("bFrameIntervalType=0x%02x\n", d->bFrameIntervalType); 2585 2586 p = (uint8_t *)d; 2587 p += sizeof(struct usb_video_frame_desc); 2588 2589 if (!d->bFrameIntervalType) { 2590 /* continuous */ 2591 if (d->bLength < (sizeof(struct usb_video_frame_desc) + 2592 sizeof(uDWord) * 3)) { 2593 printf("invalid frame descriptor length\n"); 2594 } else { 2595 printf("dwMinFrameInterval = %d\n", UGETDW(p)); 2596 p += sizeof(uDWord); 2597 printf("dwMaxFrameInterval = %d\n", UGETDW(p)); 2598 p += sizeof(uDWord); 2599 printf("dwFrameIntervalStep = %d\n", UGETDW(p)); 2600 p += sizeof(uDWord); 2601 } 2602 } else { 2603 /* discrete */ 2604 length = d->bLength - sizeof(struct usb_video_frame_desc); 2605 for (i = 0; i < d->bFrameIntervalType; i++) { 2606 if (length <= 0) { 2607 printf("frame descriptor ended early\n"); 2608 break; 2609 } 2610 printf("dwFrameInterval = %d\n", UGETDW(p)); 2611 p += sizeof(uDWord); 2612 length -= sizeof(uDWord); 2613 } 2614 } 2615 } 2616 2617 void 2618 uvideo_dump_desc_format_uncompressed(struct uvideo_softc *sc, 2619 const usb_descriptor_t *desc) 2620 { 2621 struct usb_video_format_uncompressed_desc *d; 2622 2623 d = (struct usb_video_format_uncompressed_desc *)(uint8_t *)desc; 2624 2625 printf("bLength=%d\n", d->bLength); 2626 printf("bDescriptorType=0x%02x\n", d->bDescriptorType); 2627 printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); 2628 printf("bFormatIndex=0x%02x\n", d->bFormatIndex); 2629 printf("bNumFrameDescriptors=0x%02x\n", d->bNumFrameDescriptors); 2630 printf("guidFormat=%s\n", d->guidFormat); 2631 printf("bBitsPerPixel=0x%02x\n", d->bBitsPerPixel); 2632 printf("bDefaultFrameIndex=0x%02x\n", d->bDefaultFrameIndex); 2633 printf("bAspectRatioX=0x%02x\n", d->bAspectRatioX); 2634 printf("bAspectRatioY=0x%02x\n", d->bAspectRatioY); 2635 printf("bmInterlaceFlags=0x%02x\n", d->bmInterlaceFlags); 2636 printf("bCopyProtect=0x%02x\n", d->bCopyProtect); 2637 } 2638 2639 void 2640 uvideo_dump_desc_processing(struct uvideo_softc *sc, 2641 const usb_descriptor_t *desc) 2642 { 2643 struct usb_video_vc_processing_desc *d; 2644 2645 /* PU descriptor is variable sized */ 2646 d = (void *)desc; 2647 2648 printf("bLength=%d\n", d->bLength); 2649 printf("bDescriptorType=0x%02x\n", d->bDescriptorType); 2650 printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); 2651 printf("bUnitID=0x%02x\n", d->bUnitID); 2652 printf("bSourceID=0x%02x\n", d->bSourceID); 2653 printf("wMaxMultiplier=%d\n", UGETW(d->wMaxMultiplier)); 2654 printf("bControlSize=%d\n", d->bControlSize); 2655 printf("bmControls=0x"); 2656 uvideo_hexdump(d->bmControls, d->bControlSize, 1); 2657 printf("iProcessing=0x%02x\n", d->bmControls[d->bControlSize]); 2658 printf("bmVideoStandards=0x%02x\n", d->bmControls[d->bControlSize + 1]); 2659 } 2660 2661 void 2662 uvideo_dump_desc_extension(struct uvideo_softc *sc, 2663 const usb_descriptor_t *desc) 2664 { 2665 struct usb_video_vc_extension_desc *d; 2666 2667 d = (struct usb_video_vc_extension_desc *)(uint8_t *)desc; 2668 2669 printf("bLength=%d\n", d->bLength); 2670 printf("bDescriptorType=0x%02x\n", d->bDescriptorType); 2671 printf("bDescriptorSubtype=0x%02x\n", d->bDescriptorSubtype); 2672 printf("bUnitID=0x%02x\n", d->bUnitID); 2673 printf("guidExtensionCode=0x"); 2674 uvideo_hexdump(d->guidExtensionCode, sizeof(d->guidExtensionCode), 1); 2675 printf("bNumControls=0x%02x\n", d->bNumControls); 2676 printf("bNrInPins=0x%02x\n", d->bNrInPins); 2677 } 2678 2679 void 2680 uvideo_hexdump(void *buf, int len, int quiet) 2681 { 2682 int i; 2683 2684 for (i = 0; i < len; i++) { 2685 if (quiet == 0) { 2686 if (i % 16 == 0) 2687 printf("%s%5i:", i ? "\n" : "", i); 2688 if (i % 4 == 0) 2689 printf(" "); 2690 } 2691 printf("%02x", (int)*((u_char *)buf + i)); 2692 } 2693 printf("\n"); 2694 } 2695 2696 int 2697 uvideo_debug_file_open(struct uvideo_softc *sc) 2698 { 2699 struct proc *p = curproc; 2700 struct nameidata nd; 2701 char name[] = "/tmp/uvideo.mjpeg"; 2702 int error; 2703 2704 NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, name, p); 2705 error = vn_open(&nd, O_CREAT | FWRITE | O_NOFOLLOW, S_IRUSR | S_IWUSR); 2706 if (error) { 2707 DPRINTF(1, "%s: %s: can't create debug file %s!\n", 2708 DEVNAME(sc), __func__, name); 2709 return (error); 2710 } 2711 2712 sc->sc_vp = nd.ni_vp; 2713 VOP_UNLOCK(sc->sc_vp, 0, p); 2714 if (nd.ni_vp->v_type != VREG) { 2715 vn_close(nd.ni_vp, FWRITE, p->p_ucred, p); 2716 return (EIO); 2717 } 2718 2719 DPRINTF(1, "%s: %s: created debug file %s\n", 2720 DEVNAME(sc), __func__, name); 2721 2722 return (0); 2723 } 2724 2725 void 2726 uvideo_debug_file_write_frame(void *arg) 2727 { 2728 struct uvideo_softc *sc = arg; 2729 struct uvideo_frame_buffer *sb = &sc->sc_frame_buffer; 2730 struct proc *p = curproc; 2731 int error; 2732 2733 if (sc->sc_vp == NULL) { 2734 printf("%s: %s: no file open!\n", DEVNAME(sc)); 2735 return; 2736 } 2737 2738 error = vn_rdwr(UIO_WRITE, sc->sc_vp, sb->buf, sb->offset, (off_t)0, 2739 UIO_SYSSPACE, IO_APPEND|IO_UNIT, p->p_ucred, NULL, p); 2740 2741 if (error) 2742 DPRINTF(1, "vn_rdwr error!\n"); 2743 } 2744 #endif 2745 2746 /* 2747 * IOCTL's 2748 */ 2749 int 2750 uvideo_querycap(void *v, struct v4l2_capability *caps) 2751 { 2752 struct uvideo_softc *sc = v; 2753 2754 bzero(caps, sizeof(*caps)); 2755 strlcpy(caps->driver, DEVNAME(sc), sizeof(caps->driver)); 2756 strlcpy(caps->card, "Generic USB video class device", 2757 sizeof(caps->card)); 2758 strlcpy(caps->bus_info, "usb", sizeof(caps->bus_info)); 2759 2760 caps->version = 1; 2761 caps->capabilities = V4L2_CAP_VIDEO_CAPTURE 2762 | V4L2_CAP_STREAMING 2763 | V4L2_CAP_READWRITE; 2764 2765 return (0); 2766 } 2767 2768 int 2769 uvideo_enum_fmt(void *v, struct v4l2_fmtdesc *fmtdesc) 2770 { 2771 struct uvideo_softc *sc = v; 2772 int idx; 2773 2774 if (fmtdesc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 2775 /* type not supported */ 2776 return (EINVAL); 2777 2778 if (fmtdesc->index >= sc->sc_fmtgrp_num) 2779 /* no more formats left */ 2780 return (EINVAL); 2781 idx = fmtdesc->index; 2782 2783 switch (sc->sc_fmtgrp[idx].format->bDescriptorSubtype) { 2784 case UDESCSUB_VS_FORMAT_MJPEG: 2785 fmtdesc->flags = V4L2_FMT_FLAG_COMPRESSED; 2786 (void)strlcpy(fmtdesc->description, "MJPEG", 2787 sizeof(fmtdesc->description)); 2788 fmtdesc->pixelformat = V4L2_PIX_FMT_MJPEG; 2789 bzero(fmtdesc->reserved, sizeof(fmtdesc->reserved)); 2790 break; 2791 case UDESCSUB_VS_FORMAT_UNCOMPRESSED: 2792 fmtdesc->flags = 0; 2793 if (sc->sc_fmtgrp[idx].pixelformat == 2794 V4L2_PIX_FMT_YUYV) { 2795 (void)strlcpy(fmtdesc->description, "YUYV", 2796 sizeof(fmtdesc->description)); 2797 fmtdesc->pixelformat = V4L2_PIX_FMT_YUYV; 2798 } else if (sc->sc_fmtgrp[idx].pixelformat == 2799 V4L2_PIX_FMT_NV12) { 2800 (void)strlcpy(fmtdesc->description, "NV12", 2801 sizeof(fmtdesc->description)); 2802 fmtdesc->pixelformat = V4L2_PIX_FMT_NV12; 2803 } else if (sc->sc_fmtgrp[idx].pixelformat == 2804 V4L2_PIX_FMT_UYVY) { 2805 (void)strlcpy(fmtdesc->description, "UYVY", 2806 sizeof(fmtdesc->description)); 2807 fmtdesc->pixelformat = V4L2_PIX_FMT_UYVY; 2808 } else { 2809 (void)strlcpy(fmtdesc->description, "Unknown UC Format", 2810 sizeof(fmtdesc->description)); 2811 fmtdesc->pixelformat = 0; 2812 } 2813 bzero(fmtdesc->reserved, sizeof(fmtdesc->reserved)); 2814 break; 2815 default: 2816 fmtdesc->flags = 0; 2817 (void)strlcpy(fmtdesc->description, "Unknown Format", 2818 sizeof(fmtdesc->description)); 2819 fmtdesc->pixelformat = 0; 2820 bzero(fmtdesc->reserved, sizeof(fmtdesc->reserved)); 2821 break; 2822 } 2823 2824 return (0); 2825 } 2826 2827 int 2828 uvideo_enum_fsizes(void *v, struct v4l2_frmsizeenum *fsizes) 2829 { 2830 struct uvideo_softc *sc = v; 2831 int idx, found = 0; 2832 2833 for (idx = 0; idx < sc->sc_fmtgrp_num; idx++) { 2834 if (sc->sc_fmtgrp[idx].pixelformat == fsizes->pixel_format) { 2835 found = 1; 2836 break; 2837 } 2838 } 2839 if (found == 0) 2840 return (EINVAL); 2841 2842 if (fsizes->index >= sc->sc_fmtgrp[idx].frame_num) 2843 return (EINVAL); 2844 2845 fsizes->type = V4L2_FRMSIZE_TYPE_DISCRETE; 2846 fsizes->un.discrete.width = 2847 UGETW(sc->sc_fmtgrp[idx].frame[fsizes->index]->wWidth); 2848 fsizes->un.discrete.height = 2849 UGETW(sc->sc_fmtgrp[idx].frame[fsizes->index]->wHeight); 2850 2851 return (0); 2852 } 2853 2854 int 2855 uvideo_enum_fivals(void *v, struct v4l2_frmivalenum *fivals) 2856 { 2857 struct uvideo_softc *sc = v; 2858 int idx; 2859 struct uvideo_format_group *fmtgrp = NULL; 2860 struct usb_video_frame_desc *frame = NULL; 2861 uint8_t *p; 2862 2863 for (idx = 0; idx < sc->sc_fmtgrp_num; idx++) { 2864 if (sc->sc_fmtgrp[idx].pixelformat == fivals->pixel_format) { 2865 fmtgrp = &sc->sc_fmtgrp[idx]; 2866 break; 2867 } 2868 } 2869 if (fmtgrp == NULL) 2870 return (EINVAL); 2871 2872 for (idx = 0; idx < fmtgrp->frame_num; idx++) { 2873 if (UGETW(fmtgrp->frame[idx]->wWidth) == fivals->width && 2874 UGETW(fmtgrp->frame[idx]->wHeight) == fivals->height) { 2875 frame = fmtgrp->frame[idx]; 2876 break; 2877 } 2878 } 2879 if (frame == NULL) 2880 return (EINVAL); 2881 2882 /* byte-wise pointer to start of frame intervals */ 2883 p = (uint8_t *)frame; 2884 p += sizeof(struct usb_video_frame_desc); 2885 2886 if (frame->bFrameIntervalType == 0) { 2887 if (fivals->index != 0) 2888 return (EINVAL); 2889 fivals->type = V4L2_FRMIVAL_TYPE_STEPWISE; 2890 fivals->un.stepwise.min.numerator = UGETDW(p); 2891 fivals->un.stepwise.min.denominator = 10000000; 2892 p += sizeof(uDWord); 2893 fivals->un.stepwise.max.numerator = UGETDW(p); 2894 fivals->un.stepwise.max.denominator = 10000000; 2895 p += sizeof(uDWord); 2896 fivals->un.stepwise.step.numerator = UGETDW(p); 2897 fivals->un.stepwise.step.denominator = 10000000; 2898 p += sizeof(uDWord); 2899 } else { 2900 if (fivals->index >= frame->bFrameIntervalType) 2901 return (EINVAL); 2902 p += sizeof(uDWord) * fivals->index; 2903 if (p > frame->bLength + (uint8_t *)frame) { 2904 printf("%s: frame desc too short?\n", __func__); 2905 return (EINVAL); 2906 } 2907 fivals->type = V4L2_FRMIVAL_TYPE_DISCRETE; 2908 fivals->un.discrete.numerator = UGETDW(p); 2909 fivals->un.discrete.denominator = 10000000; 2910 } 2911 2912 return (0); 2913 } 2914 2915 int 2916 uvideo_s_fmt(void *v, struct v4l2_format *fmt) 2917 { 2918 struct uvideo_softc *sc = v; 2919 struct uvideo_format_group *fmtgrp_save; 2920 struct usb_video_frame_desc *frame_save; 2921 struct uvideo_res r; 2922 int found, i; 2923 usbd_status error; 2924 2925 if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 2926 return (EINVAL); 2927 2928 DPRINTF(1, "%s: %s: requested width=%d, height=%d\n", 2929 DEVNAME(sc), __func__, fmt->fmt.pix.width, fmt->fmt.pix.height); 2930 2931 /* search requested pixel format */ 2932 for (found = 0, i = 0; i < sc->sc_fmtgrp_num; i++) { 2933 if (fmt->fmt.pix.pixelformat == sc->sc_fmtgrp[i].pixelformat) { 2934 found = 1; 2935 break; 2936 } 2937 } 2938 if (found == 0) 2939 return (EINVAL); 2940 2941 /* check if the format descriptor contains frame descriptors */ 2942 if (sc->sc_fmtgrp[i].frame_num == 0) { 2943 printf("%s: %s: no frame descriptors found!\n", 2944 __func__, DEVNAME(sc)); 2945 return (EINVAL); 2946 } 2947 2948 /* search requested frame resolution */ 2949 uvideo_find_res(sc, i, fmt->fmt.pix.width, fmt->fmt.pix.height, &r); 2950 2951 /* 2952 * Do negotiation. 2953 */ 2954 /* save a copy of current fromat group in case of negotiation fails */ 2955 fmtgrp_save = sc->sc_fmtgrp_cur; 2956 frame_save = sc->sc_fmtgrp_cur->frame_cur; 2957 /* set new format group */ 2958 sc->sc_fmtgrp_cur = &sc->sc_fmtgrp[i]; 2959 sc->sc_fmtgrp[i].frame_cur = sc->sc_fmtgrp[i].frame[r.fidx]; 2960 2961 /* do device negotiation with commit */ 2962 error = uvideo_vs_negotiation(sc, 1); 2963 if (error != USBD_NORMAL_COMPLETION) { 2964 sc->sc_fmtgrp_cur = fmtgrp_save; 2965 sc->sc_fmtgrp_cur->frame_cur = frame_save; 2966 return (EINVAL); 2967 } 2968 sc->sc_negotiated_flag = 1; 2969 2970 /* offer closest resolution which we have found */ 2971 fmt->fmt.pix.width = r.width; 2972 fmt->fmt.pix.height = r.height; 2973 2974 DPRINTF(1, "%s: %s: offered width=%d, height=%d\n", 2975 DEVNAME(sc), __func__, r.width, r.height); 2976 2977 /* tell our frame buffer size */ 2978 fmt->fmt.pix.sizeimage = UGETDW(sc->sc_desc_probe.dwMaxVideoFrameSize); 2979 2980 return (0); 2981 } 2982 2983 int 2984 uvideo_g_fmt(void *v, struct v4l2_format *fmt) 2985 { 2986 struct uvideo_softc *sc = v; 2987 2988 if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 2989 return (EINVAL); 2990 2991 fmt->fmt.pix.pixelformat = sc->sc_fmtgrp_cur->pixelformat; 2992 fmt->fmt.pix.width = UGETW(sc->sc_fmtgrp_cur->frame_cur->wWidth); 2993 fmt->fmt.pix.height = UGETW(sc->sc_fmtgrp_cur->frame_cur->wHeight); 2994 fmt->fmt.pix.sizeimage = UGETDW(sc->sc_desc_probe.dwMaxVideoFrameSize); 2995 2996 DPRINTF(1, "%s: %s: current width=%d, height=%d\n", 2997 DEVNAME(sc), __func__, fmt->fmt.pix.width, fmt->fmt.pix.height); 2998 2999 return (0); 3000 } 3001 3002 int 3003 uvideo_s_parm(void *v, struct v4l2_streamparm *parm) 3004 { 3005 struct uvideo_softc *sc = v; 3006 usbd_status error; 3007 3008 if (parm->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 3009 /* 3010 * XXX Only whole number frame rates for now. Frame 3011 * rate is the inverse of time per frame. 3012 */ 3013 if (parm->parm.capture.timeperframe.numerator == 0 || 3014 parm->parm.capture.timeperframe.denominator == 0) { 3015 sc->sc_frame_rate = 0; 3016 } else { 3017 sc->sc_frame_rate = 3018 parm->parm.capture.timeperframe.denominator / 3019 parm->parm.capture.timeperframe.numerator; 3020 } 3021 } else 3022 return (EINVAL); 3023 3024 /* renegotiate if necessary */ 3025 if (sc->sc_negotiated_flag) { 3026 error = uvideo_vs_negotiation(sc, 1); 3027 if (error != USBD_NORMAL_COMPLETION) 3028 return (error); 3029 } 3030 3031 return (0); 3032 } 3033 3034 int 3035 uvideo_g_parm(void *v, struct v4l2_streamparm *parm) 3036 { 3037 struct uvideo_softc *sc = v; 3038 3039 if (parm->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) { 3040 parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME; 3041 parm->parm.capture.capturemode = 0; 3042 parm->parm.capture.timeperframe.numerator = 3043 UGETDW(sc->sc_desc_probe.dwFrameInterval); 3044 parm->parm.capture.timeperframe.denominator = 10000000; 3045 } else 3046 return (EINVAL); 3047 3048 return (0); 3049 } 3050 3051 int 3052 uvideo_enum_input(void *v, struct v4l2_input *input) 3053 { 3054 if (input->index != 0) 3055 /* XXX we just support one input for now */ 3056 return (EINVAL); 3057 3058 strlcpy(input->name, "Camera Terminal", sizeof(input->name)); 3059 input->type = V4L2_INPUT_TYPE_CAMERA; 3060 3061 return (0); 3062 } 3063 3064 int 3065 uvideo_s_input(void *v, int input) 3066 { 3067 if (input != 0) 3068 /* XXX we just support one input for now */ 3069 return (EINVAL); 3070 3071 return (0); 3072 } 3073 3074 int 3075 uvideo_reqbufs(void *v, struct v4l2_requestbuffers *rb) 3076 { 3077 struct uvideo_softc *sc = v; 3078 int i, buf_size, buf_size_total; 3079 3080 DPRINTF(1, "%s: %s: count=%d\n", DEVNAME(sc), __func__, rb->count); 3081 3082 if (sc->sc_mmap_count > 0 || sc->sc_mmap_buffer != NULL) 3083 panic("%s: mmap buffers already allocated", __func__); 3084 3085 /* limit the buffers */ 3086 if (rb->count > UVIDEO_MAX_BUFFERS) 3087 sc->sc_mmap_count = UVIDEO_MAX_BUFFERS; 3088 else 3089 sc->sc_mmap_count = rb->count; 3090 3091 /* allocate the total mmap buffer */ 3092 buf_size = UGETDW(sc->sc_desc_probe.dwMaxVideoFrameSize); 3093 buf_size_total = sc->sc_mmap_count * buf_size; 3094 buf_size_total = round_page(buf_size_total); /* page align buffer */ 3095 sc->sc_mmap_buffer = malloc(buf_size_total, M_DEVBUF, M_NOWAIT); 3096 if (sc->sc_mmap_buffer == NULL) { 3097 printf("%s: can't allocate mmap buffer!\n", DEVNAME(sc)); 3098 return (EINVAL); 3099 } 3100 DPRINTF(1, "%s: allocated %d bytes mmap buffer\n", 3101 DEVNAME(sc), buf_size_total); 3102 3103 /* fill the v4l2_buffer structure */ 3104 for (i = 0; i < sc->sc_mmap_count; i++) { 3105 sc->sc_mmap[i].buf = sc->sc_mmap_buffer + (i * buf_size); 3106 3107 sc->sc_mmap[i].v4l2_buf.index = i; 3108 sc->sc_mmap[i].v4l2_buf.m.offset = i * buf_size; 3109 sc->sc_mmap[i].v4l2_buf.length = buf_size; 3110 sc->sc_mmap[i].v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 3111 sc->sc_mmap[i].v4l2_buf.sequence = 0; 3112 sc->sc_mmap[i].v4l2_buf.field = V4L2_FIELD_NONE; 3113 sc->sc_mmap[i].v4l2_buf.memory = V4L2_MEMORY_MMAP; 3114 sc->sc_mmap[i].v4l2_buf.flags = V4L2_MEMORY_MMAP; 3115 3116 DPRINTF(1, "%s: %s: index=%d, offset=%d, length=%d\n", 3117 DEVNAME(sc), __func__, 3118 sc->sc_mmap[i].v4l2_buf.index, 3119 sc->sc_mmap[i].v4l2_buf.m.offset, 3120 sc->sc_mmap[i].v4l2_buf.length); 3121 } 3122 3123 /* tell how many buffers we have really allocated */ 3124 rb->count = sc->sc_mmap_count; 3125 3126 /* start with the first buffer */ 3127 sc->sc_mmap_cur = 0; 3128 3129 return (0); 3130 } 3131 3132 int 3133 uvideo_querybuf(void *v, struct v4l2_buffer *qb) 3134 { 3135 struct uvideo_softc *sc = v; 3136 3137 if (qb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE || 3138 qb->memory != V4L2_MEMORY_MMAP) 3139 return (EINVAL); 3140 3141 bcopy(&sc->sc_mmap[qb->index].v4l2_buf, qb, 3142 sizeof(struct v4l2_buffer)); 3143 3144 DPRINTF(1, "%s: %s: index=%d, offset=%d, length=%d\n", 3145 DEVNAME(sc), __func__, 3146 qb->index, 3147 qb->m.offset, 3148 qb->length); 3149 3150 return (0); 3151 } 3152 3153 int 3154 uvideo_qbuf(void *v, struct v4l2_buffer *qb) 3155 { 3156 struct uvideo_softc *sc = v; 3157 3158 sc->sc_mmap[qb->index].v4l2_buf.flags &= ~V4L2_BUF_FLAG_DONE; 3159 sc->sc_mmap[qb->index].v4l2_buf.flags |= V4L2_BUF_FLAG_MAPPED; 3160 sc->sc_mmap[qb->index].v4l2_buf.flags |= V4L2_BUF_FLAG_QUEUED; 3161 3162 DPRINTF(2, "%s: %s: buffer on index %d ready for queueing\n", 3163 DEVNAME(sc), __func__, qb->index); 3164 3165 return (0); 3166 } 3167 3168 int 3169 uvideo_dqbuf(void *v, struct v4l2_buffer *dqb) 3170 { 3171 struct uvideo_softc *sc = v; 3172 struct uvideo_mmap *mmap; 3173 int error; 3174 3175 if (SIMPLEQ_EMPTY(&sc->sc_mmap_q)) { 3176 /* mmap queue is empty, block until first frame is queued */ 3177 error = tsleep(sc, 0, "vid_mmap", 10 * hz); 3178 if (error) 3179 return (EINVAL); 3180 } 3181 3182 mmap = SIMPLEQ_FIRST(&sc->sc_mmap_q); 3183 if (mmap == NULL) 3184 panic("uvideo_dqbuf: NULL pointer!"); 3185 3186 bcopy(&mmap->v4l2_buf, dqb, sizeof(struct v4l2_buffer)); 3187 3188 mmap->v4l2_buf.flags |= V4L2_BUF_FLAG_MAPPED | V4L2_BUF_FLAG_DONE; 3189 3190 DPRINTF(2, "%s: %s: frame dequeued from index %d\n", 3191 DEVNAME(sc), __func__, mmap->v4l2_buf.index); 3192 SIMPLEQ_REMOVE_HEAD(&sc->sc_mmap_q, q_frames); 3193 3194 return (0); 3195 } 3196 3197 int 3198 uvideo_streamon(void *v, int type) 3199 { 3200 struct uvideo_softc *sc = v; 3201 usbd_status error; 3202 3203 error = uvideo_vs_init(sc); 3204 if (error != USBD_NORMAL_COMPLETION) 3205 return (EINVAL); 3206 3207 if (sc->sc_vs_cur->bulk_endpoint) 3208 uvideo_vs_start_bulk(sc); 3209 else 3210 uvideo_vs_start_isoc(sc); 3211 3212 return (0); 3213 } 3214 3215 int 3216 uvideo_streamoff(void *v, int type) 3217 { 3218 struct uvideo_softc *sc = v; 3219 3220 uvideo_vs_close(sc); 3221 3222 return (0); 3223 } 3224 3225 int 3226 uvideo_queryctrl(void *v, struct v4l2_queryctrl *qctrl) 3227 { 3228 struct uvideo_softc *sc = v; 3229 int i, ret = 0; 3230 usbd_status error; 3231 uint8_t *ctrl_data; 3232 uint16_t ctrl_len; 3233 3234 i = uvideo_find_ctrl(sc, qctrl->id); 3235 if (i == EINVAL) 3236 return (i); 3237 3238 ctrl_len = uvideo_ctrls[i].ctrl_len; 3239 if (ctrl_len < 1 || ctrl_len > 2) { 3240 printf("%s: invalid control length: %d\n", __func__, ctrl_len); 3241 return (EINVAL); 3242 } 3243 3244 ctrl_data = malloc(ctrl_len, M_USBDEV, M_WAITOK | M_CANFAIL); 3245 if (ctrl_data == NULL) { 3246 printf("%s: could not allocate control data\n", __func__); 3247 return (ENOMEM); 3248 } 3249 3250 /* set type */ 3251 qctrl->type = uvideo_ctrls[i].type; 3252 3253 /* set description name */ 3254 strlcpy(qctrl->name, uvideo_ctrls[i].name, sizeof(qctrl->name)); 3255 3256 /* set minimum */ 3257 error = uvideo_vc_get_ctrl(sc, ctrl_data, GET_MIN, 3258 sc->sc_desc_vc_pu_cur->bUnitID, 3259 uvideo_ctrls[i].ctrl_selector, uvideo_ctrls[i].ctrl_len); 3260 if (error != USBD_NORMAL_COMPLETION) { 3261 ret = EINVAL; 3262 goto out; 3263 } 3264 switch (ctrl_len) { 3265 case 1: 3266 qctrl->minimum = uvideo_ctrls[i].sig ? 3267 *(int8_t *)ctrl_data : 3268 *ctrl_data; 3269 break; 3270 case 2: 3271 qctrl->minimum = uvideo_ctrls[i].sig ? 3272 (int16_t)UGETW(ctrl_data) : 3273 UGETW(ctrl_data); 3274 break; 3275 } 3276 3277 /* set maximum */ 3278 error = uvideo_vc_get_ctrl(sc, ctrl_data, GET_MAX, 3279 sc->sc_desc_vc_pu_cur->bUnitID, 3280 uvideo_ctrls[i].ctrl_selector, uvideo_ctrls[i].ctrl_len); 3281 if (error != USBD_NORMAL_COMPLETION) { 3282 ret = EINVAL; 3283 goto out; 3284 } 3285 switch(ctrl_len) { 3286 case 1: 3287 qctrl->maximum = uvideo_ctrls[i].sig ? 3288 *(int8_t *)ctrl_data : 3289 *ctrl_data; 3290 break; 3291 case 2: 3292 qctrl->maximum = uvideo_ctrls[i].sig ? 3293 (int16_t)UGETW(ctrl_data) : 3294 UGETW(ctrl_data); 3295 break; 3296 } 3297 3298 /* set resolution */ 3299 error = uvideo_vc_get_ctrl(sc, ctrl_data, GET_RES, 3300 sc->sc_desc_vc_pu_cur->bUnitID, 3301 uvideo_ctrls[i].ctrl_selector, uvideo_ctrls[i].ctrl_len); 3302 if (error != USBD_NORMAL_COMPLETION) { 3303 ret = EINVAL; 3304 goto out; 3305 } 3306 switch(ctrl_len) { 3307 case 1: 3308 qctrl->step = uvideo_ctrls[i].sig ? 3309 *(int8_t *)ctrl_data: 3310 *ctrl_data; 3311 break; 3312 case 2: 3313 qctrl->step = uvideo_ctrls[i].sig ? 3314 (int16_t)UGETW(ctrl_data) : 3315 UGETW(ctrl_data); 3316 break; 3317 } 3318 3319 /* set default */ 3320 error = uvideo_vc_get_ctrl(sc, ctrl_data, GET_DEF, 3321 sc->sc_desc_vc_pu_cur->bUnitID, 3322 uvideo_ctrls[i].ctrl_selector, uvideo_ctrls[i].ctrl_len); 3323 if (error != USBD_NORMAL_COMPLETION) { 3324 ret = EINVAL; 3325 goto out; 3326 } 3327 switch(ctrl_len) { 3328 case 1: 3329 qctrl->default_value = uvideo_ctrls[i].sig ? 3330 *(int8_t *)ctrl_data : 3331 *ctrl_data; 3332 break; 3333 case 2: 3334 qctrl->default_value = uvideo_ctrls[i].sig ? 3335 (int16_t)UGETW(ctrl_data) : 3336 UGETW(ctrl_data); 3337 break; 3338 } 3339 3340 /* set flags */ 3341 qctrl->flags = 0; 3342 3343 out: 3344 free(ctrl_data, M_USBDEV); 3345 3346 return (ret); 3347 } 3348 3349 int 3350 uvideo_g_ctrl(void *v, struct v4l2_control *gctrl) 3351 { 3352 struct uvideo_softc *sc = v; 3353 int i, ret = 0; 3354 usbd_status error; 3355 uint8_t *ctrl_data; 3356 uint16_t ctrl_len; 3357 3358 i = uvideo_find_ctrl(sc, gctrl->id); 3359 if (i == EINVAL) 3360 return (i); 3361 3362 ctrl_len = uvideo_ctrls[i].ctrl_len; 3363 if (ctrl_len < 1 || ctrl_len > 2) { 3364 printf("%s: invalid control length: %d\n", __func__, ctrl_len); 3365 return (EINVAL); 3366 } 3367 3368 ctrl_data = malloc(ctrl_len, M_USBDEV, M_WAITOK | M_CANFAIL); 3369 if (ctrl_data == NULL) { 3370 printf("%s: could not allocate control data\n", __func__); 3371 return (ENOMEM); 3372 } 3373 3374 error = uvideo_vc_get_ctrl(sc, ctrl_data, GET_CUR, 3375 sc->sc_desc_vc_pu_cur->bUnitID, 3376 uvideo_ctrls[i].ctrl_selector, uvideo_ctrls[i].ctrl_len); 3377 if (error != USBD_NORMAL_COMPLETION) { 3378 ret = EINVAL; 3379 goto out; 3380 } 3381 switch(ctrl_len) { 3382 case 1: 3383 gctrl->value = uvideo_ctrls[i].sig ? 3384 *(int8_t *)ctrl_data : 3385 *ctrl_data; 3386 break; 3387 case 2: 3388 gctrl->value = uvideo_ctrls[i].sig ? 3389 (int16_t)UGETW(ctrl_data) : 3390 UGETW(ctrl_data); 3391 break; 3392 } 3393 3394 out: 3395 free(ctrl_data, M_USBDEV); 3396 3397 return (0); 3398 } 3399 3400 int 3401 uvideo_s_ctrl(void *v, struct v4l2_control *sctrl) 3402 { 3403 struct uvideo_softc *sc = v; 3404 int i, ret = 0; 3405 usbd_status error; 3406 uint8_t *ctrl_data; 3407 uint16_t ctrl_len; 3408 3409 i = uvideo_find_ctrl(sc, sctrl->id); 3410 if (i == EINVAL) 3411 return (i); 3412 3413 ctrl_len = uvideo_ctrls[i].ctrl_len; 3414 if (ctrl_len < 1 || ctrl_len > 2) { 3415 printf("%s: invalid control length: %d\n", __func__, ctrl_len); 3416 return (EINVAL); 3417 } 3418 3419 ctrl_data = malloc(ctrl_len, M_USBDEV, M_WAITOK | M_CANFAIL); 3420 if (ctrl_data == NULL) { 3421 printf("%s: could not allocate control data\n", __func__); 3422 return (ENOMEM); 3423 } 3424 3425 switch(ctrl_len) { 3426 case 1: 3427 if (uvideo_ctrls[i].sig) 3428 *(int8_t *)ctrl_data = sctrl->value; 3429 else 3430 *ctrl_data = sctrl->value; 3431 break; 3432 case 2: 3433 USETW(ctrl_data, sctrl->value); 3434 break; 3435 } 3436 error = uvideo_vc_set_ctrl(sc, ctrl_data, SET_CUR, 3437 sc->sc_desc_vc_pu_cur->bUnitID, 3438 uvideo_ctrls[i].ctrl_selector, uvideo_ctrls[i].ctrl_len); 3439 if (error != USBD_NORMAL_COMPLETION) 3440 ret = EINVAL; 3441 3442 free(ctrl_data, M_USBDEV); 3443 3444 return (ret); 3445 } 3446 3447 int 3448 uvideo_try_fmt(void *v, struct v4l2_format *fmt) 3449 { 3450 struct uvideo_softc *sc = v; 3451 struct uvideo_res r; 3452 int found, i; 3453 3454 if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 3455 return (EINVAL); 3456 3457 DPRINTF(1, "%s: %s: requested width=%d, height=%d\n", 3458 DEVNAME(sc), __func__, fmt->fmt.pix.width, fmt->fmt.pix.height); 3459 3460 /* search requested pixel format */ 3461 for (found = 0, i = 0; i < sc->sc_fmtgrp_num; i++) { 3462 if (fmt->fmt.pix.pixelformat == sc->sc_fmtgrp[i].pixelformat) { 3463 found = 1; 3464 break; 3465 } 3466 } 3467 if (found == 0) 3468 return (EINVAL); 3469 3470 /* search requested frame resolution */ 3471 uvideo_find_res(sc, i, fmt->fmt.pix.width, fmt->fmt.pix.height, &r); 3472 3473 /* offer closest resolution which we have found */ 3474 fmt->fmt.pix.width = r.width; 3475 fmt->fmt.pix.height = r.height; 3476 3477 DPRINTF(1, "%s: %s: offered width=%d, height=%d\n", 3478 DEVNAME(sc), __func__, r.width, r.height); 3479 3480 /* tell our frame buffer size */ 3481 fmt->fmt.pix.sizeimage = sc->sc_frame_buffer.buf_size; 3482 3483 return (0); 3484 } 3485 3486 caddr_t 3487 uvideo_mappage(void *v, off_t off, int prot) 3488 { 3489 struct uvideo_softc *sc = v; 3490 caddr_t p; 3491 3492 if (!sc->sc_mmap_flag) 3493 sc->sc_mmap_flag = 1; 3494 3495 p = sc->sc_mmap_buffer + off; 3496 3497 return (p); 3498 } 3499 3500 int 3501 uvideo_get_bufsize(void *v) 3502 { 3503 struct uvideo_softc *sc = v; 3504 3505 return (sc->sc_max_fbuf_size); 3506 } 3507 3508 int 3509 uvideo_start_read(void *v) 3510 { 3511 struct uvideo_softc *sc = v; 3512 usbd_status error; 3513 3514 if (sc->sc_mmap_flag) 3515 sc->sc_mmap_flag = 0; 3516 3517 error = uvideo_vs_init(sc); 3518 if (error != USBD_NORMAL_COMPLETION) 3519 return (EINVAL); 3520 3521 if (sc->sc_vs_cur->bulk_endpoint) 3522 uvideo_vs_start_bulk(sc); 3523 else 3524 uvideo_vs_start_isoc(sc); 3525 3526 return (0); 3527 } 3528 3529 usbd_status 3530 uvideo_usb_control(struct uvideo_softc *sc, uint8_t rt, uint8_t r, 3531 uint16_t value, uint8_t *data, size_t length) 3532 { 3533 usb_device_request_t req; 3534 usbd_status err; 3535 3536 req.bmRequestType = rt; 3537 req.bRequest = r; 3538 USETW(req.wIndex, 0); 3539 USETW(req.wValue, value); 3540 USETW(req.wLength, length); 3541 3542 err = usbd_do_request(sc->sc_udev, &req, data); 3543 if (err != USBD_NORMAL_COMPLETION) 3544 return (err); 3545 3546 return (USBD_NORMAL_COMPLETION); 3547 } 3548 3549 usbd_status 3550 uvideo_ucode_loader_ricoh(struct uvideo_softc *sc) 3551 { 3552 usbd_status error; 3553 uint8_t *ucode, len, cbuf; 3554 size_t ucode_size; 3555 uint16_t addr; 3556 int offset = 0, remain; 3557 3558 /* get device microcode status */ 3559 cbuf = 0; 3560 error = uvideo_usb_control(sc, UT_READ_VENDOR_DEVICE, 3561 0xa4, 0, &cbuf, sizeof cbuf); 3562 if (error != USBD_NORMAL_COMPLETION) { 3563 printf("%s: ucode status error=%s!\n", 3564 DEVNAME(sc), usbd_errstr(error)); 3565 return (USBD_INVAL); 3566 } 3567 if (cbuf) { 3568 DPRINTF(1, "%s: microcode already loaded\n", DEVNAME(sc)); 3569 return (USBD_NORMAL_COMPLETION); 3570 } else { 3571 DPRINTF(1, "%s: microcode not loaded\n", DEVNAME(sc)); 3572 } 3573 3574 /* open microcode file */ 3575 error = loadfirmware(sc->sc_quirk->ucode_name, &ucode, &ucode_size); 3576 if (error != 0) { 3577 printf("%s: loadfirmware error=%d!\n", DEVNAME(sc), error); 3578 return (USBD_INVAL); 3579 } 3580 3581 /* upload microcode */ 3582 remain = ucode_size; 3583 while (remain > 0) { 3584 if (remain < 3) { 3585 printf("%s: ucode file incomplete!\n", DEVNAME(sc)); 3586 free(ucode, M_DEVBUF); 3587 return (USBD_INVAL); 3588 } 3589 3590 len = ucode[offset]; 3591 addr = ucode[offset + 1] | (ucode[offset + 2] << 8); 3592 offset += 3; 3593 remain -= 3; 3594 3595 error = uvideo_usb_control(sc, UT_WRITE_VENDOR_DEVICE, 3596 0xa0, addr, &ucode[offset], len); 3597 if (error != USBD_NORMAL_COMPLETION) { 3598 printf("%s: ucode upload error=%s!\n", 3599 DEVNAME(sc), usbd_errstr(error)); 3600 free(ucode, M_DEVBUF); 3601 return (USBD_INVAL); 3602 } 3603 DPRINTF(1, "%s: uploaded %d bytes ucode to addr 0x%x\n", 3604 DEVNAME(sc), len, addr); 3605 3606 offset += len; 3607 remain -= len; 3608 } 3609 free(ucode, M_DEVBUF); 3610 3611 /* activate microcode */ 3612 cbuf = 0; 3613 error = uvideo_usb_control(sc, UT_WRITE_VENDOR_DEVICE, 3614 0xa1, 0, &cbuf, sizeof cbuf); 3615 if (error != USBD_NORMAL_COMPLETION) { 3616 printf("%s: ucode activate error=%s!\n", 3617 DEVNAME(sc), usbd_errstr(error)); 3618 return (USBD_INVAL); 3619 } 3620 DPRINTF(1, "%s: ucode activated\n", DEVNAME(sc)); 3621 3622 return (USBD_NORMAL_COMPLETION); 3623 } 3624 3625 /* 3626 * The iSight first generation device will first attach as 3627 * 0x8300 non-UVC. After the firmware gots uploaded, the device 3628 * will reset and come back as 0x8501 UVC compatible. 3629 */ 3630 usbd_status 3631 uvideo_ucode_loader_apple_isight(struct uvideo_softc *sc) 3632 { 3633 usbd_status error; 3634 uint8_t *ucode, *code, cbuf; 3635 size_t ucode_size; 3636 uint16_t len, req, off, llen; 3637 3638 /* open microcode file */ 3639 error = loadfirmware(sc->sc_quirk->ucode_name, &ucode, &ucode_size); 3640 if (error != 0) { 3641 printf("%s: loadfirmware error=%d!\n", DEVNAME(sc), error); 3642 return (USBD_INVAL); 3643 } 3644 3645 /* send init request */ 3646 cbuf = 1; 3647 error = uvideo_usb_control(sc, UT_WRITE_VENDOR_DEVICE, 0xa0, 0xe600, 3648 &cbuf, sizeof(cbuf)); 3649 if (error) { 3650 printf("%s: failed to init firmware loading state: %s\n", 3651 DEVNAME(sc), usbd_errstr(error)); 3652 return (error); 3653 } 3654 3655 code = ucode; 3656 while (code < ucode + ucode_size) { 3657 /* get header information */ 3658 len = (code[0] << 8) | code[1]; 3659 req = (code[2] << 8) | code[3]; 3660 DPRINTF(1, "%s: ucode data len=%d, request=0x%x\n", 3661 DEVNAME(sc), len, req); 3662 if (len < 1 || len > 1023) { 3663 printf("%s: ucode header contains wrong value!\n", 3664 DEVNAME(sc)); 3665 free(ucode, M_DEVBUF); 3666 return (USBD_INVAL); 3667 } 3668 code += 4; 3669 3670 /* send data to device */ 3671 for (off = 0; len > 0; req += 50, off += 50) { 3672 llen = len > 50 ? 50 : len; 3673 len -= llen; 3674 3675 DPRINTF(1, "%s: send %d bytes data to offset 0x%x\n", 3676 DEVNAME(sc), llen, req); 3677 error = uvideo_usb_control(sc, UT_WRITE_VENDOR_DEVICE, 3678 0xa0, req, code, llen); 3679 if (error) { 3680 printf("%s: ucode load failed: %s\n", 3681 DEVNAME(sc), usbd_errstr(error)); 3682 free(ucode, M_DEVBUF); 3683 return (USBD_INVAL); 3684 } 3685 3686 code += llen; 3687 } 3688 } 3689 free(ucode, M_DEVBUF); 3690 3691 /* send finished request */ 3692 cbuf = 0; 3693 error = uvideo_usb_control(sc, UT_WRITE_VENDOR_DEVICE, 0xa0, 0xe600, 3694 &cbuf, sizeof(cbuf)); 3695 if (error != USBD_NORMAL_COMPLETION) { 3696 printf("%s: ucode activate error=%s!\n", 3697 DEVNAME(sc), usbd_errstr(error)); 3698 return (USBD_INVAL); 3699 } 3700 DPRINTF(1, "%s: ucode activated\n", DEVNAME(sc)); 3701 3702 /* 3703 * We will always return from the attach routine since the device 3704 * will reset and re-attach at this point. 3705 */ 3706 return (USBD_INVAL); 3707 } 3708