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