uvideo.c revision 1.21.2.2
1 /* $NetBSD: uvideo.c,v 1.21.2.2 2008/09/24 16:38:56 wrstuden Exp $ */ 2 3 /* 4 * Copyright (c) 2008 Patrick Mahoney 5 * All rights reserved. 6 * 7 * This code was written by Patrick Mahoney (pat (at) polycrystal.org) as 8 * part of Google Summer of Code 2008. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 /* 40 * USB video specs: 41 * http://www.usb.org/developers/devclass_docs/USB_Video_Class_1_1.zip 42 */ 43 44 #include <sys/cdefs.h> 45 __KERNEL_RCSID(0, "$NetBSD: uvideo.c,v 1.21.2.2 2008/09/24 16:38:56 wrstuden Exp $"); 46 47 #ifdef _MODULE 48 #include <sys/module.h> 49 #endif 50 51 #include <sys/param.h> 52 #include <sys/systm.h> 53 #include <sys/kernel.h> 54 /* #include <sys/malloc.h> */ 55 #include <sys/kmem.h> 56 #include <sys/device.h> 57 #include <sys/ioctl.h> 58 #include <sys/uio.h> 59 #include <sys/tty.h> 60 #include <sys/file.h> 61 #include <sys/select.h> 62 #include <sys/proc.h> 63 #include <sys/conf.h> 64 #include <sys/vnode.h> 65 #include <sys/poll.h> 66 #include <sys/queue.h> /* SLIST */ 67 68 #include <sys/videoio.h> 69 #include <dev/video_if.h> 70 71 #include <dev/usb/usb.h> 72 #include <dev/usb/usbdi.h> 73 #include <dev/usb/usbdi_util.h> 74 #include <dev/usb/usb_quirks.h> 75 76 #include <dev/usb/uvideoreg.h> 77 78 #if !defined(_MODULE) 79 #include "opt_uvideo.h" 80 #endif 81 82 #define UVIDEO_NXFERS 3 83 84 /* #define UVIDEO_DISABLE_MJPEG */ 85 86 #ifdef UVIDEO_DEBUG 87 #define DPRINTF(x) do { if (uvideodebug) logprintf x; } while (0) 88 #define DPRINTFN(n,x) do { if (uvideodebug>(n)) logprintf x; } while (0) 89 int uvideodebug = 20; 90 #else 91 #define DPRINTF(x) 92 #define DPRINTFN(n,x) 93 #endif 94 95 typedef enum { 96 UVIDEO_STATE_CLOSED, 97 UVIDEO_STATE_OPENING, 98 UVIDEO_STATE_IDLE 99 } uvideo_state; 100 101 struct uvideo_camera_terminal { 102 uint16_t ct_objective_focal_min; 103 uint16_t ct_objective_focal_max; 104 uint16_t ct_ocular_focal_length; 105 }; 106 107 struct uvideo_processing_unit { 108 uint16_t pu_max_multiplier; /* digital zoom */ 109 uint8_t pu_video_standards; 110 }; 111 112 struct uvideo_extension_unit { 113 guid_t xu_guid; 114 }; 115 116 /* For simplicity, we consider a Terminal a special case of Unit 117 * rather than a separate entity. */ 118 struct uvideo_unit { 119 uint8_t vu_id; 120 uint8_t vu_type; 121 uint8_t vu_dst_id; 122 uint8_t vu_nsrcs; 123 union { 124 uint8_t vu_src_id; /* vu_nsrcs = 1 */ 125 uint8_t *vu_src_id_ary; /* vu_nsrcs > 1 */ 126 } s; 127 128 /* fields for individual unit/terminal types */ 129 union { 130 struct uvideo_camera_terminal vu_camera; 131 struct uvideo_processing_unit vu_processing; 132 struct uvideo_extension_unit vu_extension; 133 } u; 134 135 /* Used by camera terminal, processing and extention units. */ 136 uint8_t vu_control_size; /* number of bytes in vu_controls */ 137 uint8_t *vu_controls; /* array of bytes. bits are 138 * numbered from 0 at least 139 * significant bit to 140 * (8*vu_control_size - 1)*/ 141 }; 142 143 struct uvideo_alternate { 144 uint8_t altno; 145 uint8_t interval; 146 uint16_t max_packet_size; 147 SLIST_ENTRY(uvideo_alternate) entries; 148 }; 149 SLIST_HEAD(altlist, uvideo_alternate); 150 151 #define UVIDEO_FORMAT_GET_FORMAT_INDEX(fmt) \ 152 ((fmt)->format.priv & 0xff) 153 #define UVIDEO_FORMAT_GET_FRAME_INDEX(fmt) \ 154 (((fmt)->format.priv >> 8) & 0xff) 155 /* TODO: find a better way to set bytes within this 32 bit value? */ 156 #define UVIDEO_FORMAT_SET_FORMAT_INDEX(fmt, index) do { \ 157 (fmt)->format.priv &= ~0xff; \ 158 (fmt)->format.priv |= ((index) & 0xff); \ 159 } while (0) 160 #define UVIDEO_FORMAT_SET_FRAME_INDEX(fmt, index) do { \ 161 (fmt)->format.priv &= ~(0xff << 8); \ 162 ((fmt)->format.priv |= (((index) & 0xff) << 8)); \ 163 } while (0) 164 165 struct uvideo_pixel_format { 166 enum video_pixel_format pixel_format; 167 SIMPLEQ_ENTRY(uvideo_pixel_format) entries; 168 }; 169 SIMPLEQ_HEAD(uvideo_pixel_format_list, uvideo_pixel_format); 170 171 struct uvideo_format { 172 struct video_format format; 173 SIMPLEQ_ENTRY(uvideo_format) entries; 174 }; 175 SIMPLEQ_HEAD(uvideo_format_list, uvideo_format); 176 177 struct uvideo_isoc_xfer; 178 struct uvideo_stream; 179 180 struct uvideo_isoc { 181 struct uvideo_isoc_xfer *i_ix; 182 struct uvideo_stream *i_vs; 183 usbd_xfer_handle i_xfer; 184 uint8_t *i_buf; 185 uint16_t *i_frlengths; 186 }; 187 188 struct uvideo_isoc_xfer { 189 uint8_t ix_endpt; 190 usbd_pipe_handle ix_pipe; 191 struct uvideo_isoc ix_i[UVIDEO_NXFERS]; 192 uint32_t ix_nframes; 193 uint32_t ix_uframe_len; 194 195 struct altlist ix_altlist; 196 }; 197 198 struct uvideo_bulk_xfer { 199 uint8_t bx_endpt; 200 usbd_pipe_handle bx_pipe; 201 usbd_xfer_handle bx_xfer; 202 uint8_t *bx_buffer; 203 int bx_buflen; 204 int bx_datalen; 205 }; 206 207 struct uvideo_stream { 208 struct uvideo_softc *vs_parent; 209 usbd_interface_handle vs_iface; 210 uint8_t vs_ifaceno; 211 uint8_t vs_subtype; /* input or output */ 212 uint16_t vs_probelen; /* length of probe and 213 * commit data; varies 214 * depending on version 215 * of spec. */ 216 struct uvideo_format_list vs_formats; 217 struct uvideo_pixel_format_list vs_pixel_formats; 218 struct video_format *vs_default_format; 219 struct video_format vs_current_format; 220 221 /* usb transfer details */ 222 uint8_t vs_xfer_type; 223 union { 224 struct uvideo_bulk_xfer bulk; 225 struct uvideo_isoc_xfer isoc; 226 } vs_xfer; 227 228 int vs_frameno; /* toggles between 0 and 1 */ 229 230 /* current video format */ 231 uint32_t vs_max_payload_size; 232 uint32_t vs_max_frame_size; 233 uint32_t vs_frame_interval; 234 SLIST_ENTRY(uvideo_stream) entries; 235 }; 236 SLIST_HEAD(uvideo_stream_list, uvideo_stream); 237 238 struct uvideo_softc { 239 USBBASEDEVICE sc_dev; /* base device */ 240 usbd_device_handle sc_udev; /* device */ 241 usbd_interface_handle sc_iface; /* interface handle */ 242 int sc_ifaceno; /* interface number */ 243 char *sc_devname; 244 245 device_ptr_t sc_videodev; 246 247 int sc_dying; 248 uvideo_state sc_state; 249 250 uint8_t sc_nunits; 251 struct uvideo_unit **sc_unit; 252 253 struct uvideo_stream *sc_stream_in; 254 255 struct uvideo_stream_list sc_stream_list; 256 }; 257 258 int uvideo_match(device_t, cfdata_t, void *); 259 void uvideo_attach(device_t, device_t, void *); 260 int uvideo_detach(device_t, int); 261 void uvideo_childdet(device_t, device_t); 262 int uvideo_activate(device_t, enum devact); 263 264 static int uvideo_open(void *, int); 265 static void uvideo_close(void *); 266 static const char * uvideo_get_devname(void *); 267 268 static int uvideo_enum_format(void *, uint32_t, struct video_format *); 269 static int uvideo_get_format(void *, struct video_format *); 270 static int uvideo_set_format(void *, struct video_format *); 271 static int uvideo_try_format(void *, struct video_format *); 272 static int uvideo_start_transfer(void *); 273 static int uvideo_stop_transfer(void *); 274 275 static int uvideo_get_control_group(void *, 276 struct video_control_group *); 277 static int uvideo_set_control_group(void *, 278 const struct video_control_group *); 279 280 static usbd_status uvideo_init_control( 281 struct uvideo_softc *, 282 const usb_interface_descriptor_t *, 283 usbd_desc_iter_t *); 284 static usbd_status uvideo_init_collection( 285 struct uvideo_softc *, 286 const usb_interface_descriptor_t *, 287 usbd_desc_iter_t *); 288 289 /* Functions for unit & terminal descriptors */ 290 static struct uvideo_unit * uvideo_unit_alloc(const uvideo_descriptor_t *); 291 static usbd_status uvideo_unit_init(struct uvideo_unit *, 292 const uvideo_descriptor_t *); 293 static void uvideo_unit_free(struct uvideo_unit *); 294 static usbd_status uvideo_unit_alloc_controls(struct uvideo_unit *, 295 uint8_t, 296 const uint8_t *); 297 static void uvideo_unit_free_controls(struct uvideo_unit *); 298 static usbd_status uvideo_unit_alloc_sources(struct uvideo_unit *, 299 uint8_t, 300 const uint8_t *); 301 static void uvideo_unit_free_sources(struct uvideo_unit *); 302 303 304 305 306 /* Functions for uvideo_stream, primary unit associated with a video 307 * driver or device file. */ 308 static struct uvideo_stream * uvideo_find_stream(struct uvideo_softc *, 309 uint8_t); 310 #if 0 311 static struct uvideo_format * uvideo_stream_find_format( 312 struct uvideo_stream *, 313 uint8_t, uint8_t); 314 #endif 315 static struct uvideo_format * uvideo_stream_guess_format( 316 struct uvideo_stream *, 317 enum video_pixel_format, uint32_t, uint32_t); 318 static struct uvideo_stream * uvideo_stream_alloc(void); 319 static usbd_status uvideo_stream_init( 320 struct uvideo_stream *stream, 321 struct uvideo_softc *sc, 322 const usb_interface_descriptor_t *ifdesc, 323 uint8_t idx); 324 static usbd_status uvideo_stream_init_desc( 325 struct uvideo_stream *, 326 const usb_interface_descriptor_t *ifdesc, 327 usbd_desc_iter_t *iter); 328 static usbd_status uvideo_stream_init_frame_based_format( 329 struct uvideo_stream *, 330 const uvideo_descriptor_t *, 331 usbd_desc_iter_t *); 332 static void uvideo_stream_free(struct uvideo_stream *); 333 334 static int uvideo_stream_start_xfer(struct uvideo_stream *); 335 static int uvideo_stream_stop_xfer(struct uvideo_stream *); 336 static usbd_status uvideo_stream_recv_isoc_start(struct uvideo_stream *); 337 static usbd_status uvideo_stream_recv_isoc_start1(struct uvideo_isoc *); 338 static void uvideo_stream_recv_isoc_complete(usbd_xfer_handle, 339 usbd_private_handle, 340 usbd_status); 341 342 /* format probe and commit */ 343 #define uvideo_stream_probe(vs, act, data) \ 344 (uvideo_stream_probe_and_commit((vs), (act), \ 345 UVIDEO_VS_PROBE_CONTROL, (data))) 346 #define uvideo_stream_commit(vs, act, data) \ 347 (uvideo_stream_probe_and_commit((vs), (act), \ 348 UVIDEO_VS_COMMIT_CONTROL, (data))) 349 static usbd_status uvideo_stream_probe_and_commit(struct uvideo_stream *, 350 uint8_t, uint8_t, 351 void *); 352 static void uvideo_init_probe_data(uvideo_probe_and_commit_data_t *); 353 354 355 static const usb_descriptor_t * usb_desc_iter_peek_next(usbd_desc_iter_t *); 356 static const usb_interface_descriptor_t * usb_desc_iter_next_interface( 357 usbd_desc_iter_t *); 358 static const usb_descriptor_t * usb_desc_iter_next_non_interface( 359 usbd_desc_iter_t *); 360 361 static int usb_guid_cmp(const usb_guid_t *, const guid_t *); 362 363 364 CFATTACH_DECL2_NEW(uvideo, sizeof(struct uvideo_softc), 365 uvideo_match, uvideo_attach, uvideo_detach, uvideo_activate, NULL, 366 uvideo_childdet); 367 368 extern struct cfdriver uvideo_cd; 369 370 371 static const struct video_hw_if uvideo_hw_if = { 372 .open = uvideo_open, 373 .close = uvideo_close, 374 .get_devname = uvideo_get_devname, 375 .enum_format = uvideo_enum_format, 376 .get_format = uvideo_get_format, 377 .set_format = uvideo_set_format, 378 .try_format = uvideo_try_format, 379 .start_transfer = uvideo_start_transfer, 380 .stop_transfer = uvideo_stop_transfer, 381 .control_iter_init = NULL, 382 .control_iter_next = NULL, 383 .get_control_desc_group = NULL, 384 .get_control_group = uvideo_get_control_group, 385 .set_control_group = uvideo_set_control_group, 386 }; 387 388 #ifdef UVIDEO_DEBUG 389 /* Some functions to print out descriptors. Mostly useless other than 390 * debugging/exploration purposes. */ 391 static void usb_guid_print(const usb_guid_t *); 392 static void print_descriptor(const usb_descriptor_t *); 393 static void print_interface_descriptor(const usb_interface_descriptor_t *); 394 static void print_endpoint_descriptor(const usb_endpoint_descriptor_t *); 395 396 static void print_vc_descriptor(const usb_descriptor_t *); 397 static void print_vs_descriptor(const usb_descriptor_t *); 398 399 static void print_vc_header_descriptor( 400 const uvideo_vc_header_descriptor_t *); 401 static void print_input_terminal_descriptor( 402 const uvideo_input_terminal_descriptor_t *); 403 static void print_output_terminal_descriptor( 404 const uvideo_output_terminal_descriptor_t *); 405 static void print_camera_terminal_descriptor( 406 const uvideo_camera_terminal_descriptor_t *); 407 static void print_selector_unit_descriptor( 408 const uvideo_selector_unit_descriptor_t *); 409 static void print_processing_unit_descriptor( 410 const uvideo_processing_unit_descriptor_t *); 411 static void print_extension_unit_descriptor( 412 const uvideo_extension_unit_descriptor_t *); 413 static void print_interrupt_endpoint_descriptor( 414 const uvideo_vc_interrupt_endpoint_descriptor_t *); 415 416 static void print_vs_input_header_descriptor( 417 const uvideo_vs_input_header_descriptor_t *); 418 static void print_vs_output_header_descriptor( 419 const uvideo_vs_output_header_descriptor_t *); 420 421 static void print_vs_format_uncompressed_descriptor( 422 const uvideo_vs_format_uncompressed_descriptor_t *); 423 static void print_vs_frame_uncompressed_descriptor( 424 const uvideo_vs_frame_uncompressed_descriptor_t *); 425 static void print_vs_format_mjpeg_descriptor( 426 const uvideo_vs_format_mjpeg_descriptor_t *); 427 static void print_vs_frame_mjpeg_descriptor( 428 const uvideo_vs_frame_mjpeg_descriptor_t *); 429 static void print_vs_format_dv_descriptor( 430 const uvideo_vs_format_dv_descriptor_t *); 431 #endif /* !UVIDEO_DEBUG */ 432 433 #define GET(type, descp, field) (((const type *)(descp))->field) 434 #define GETP(type, descp, field) (&(((const type *)(descp))->field)) 435 436 /* Given a format descriptor and frame descriptor, copy values common 437 * to all formats into a struct uvideo_format. */ 438 #define UVIDEO_FORMAT_INIT_FRAME_BASED(format_type, format_desc, \ 439 frame_type, frame_desc, \ 440 format) \ 441 do { \ 442 UVIDEO_FORMAT_SET_FORMAT_INDEX( \ 443 format, \ 444 GET(format_type, format_desc, bFormatIndex)); \ 445 UVIDEO_FORMAT_SET_FRAME_INDEX( \ 446 format, \ 447 GET(frame_type, frame_desc, bFrameIndex)); \ 448 format->format.width = \ 449 UGETW(GET(frame_type, frame_desc, wWidth)); \ 450 format->format.height = \ 451 UGETW(GET(frame_type, frame_desc, wHeight)); \ 452 format->format.aspect_x = \ 453 GET(format_type, format_desc, bAspectRatioX); \ 454 format->format.aspect_y = \ 455 GET(format_type, format_desc, bAspectRatioY); \ 456 } while (0) 457 458 459 USB_MATCH(uvideo) 460 { 461 USB_IFMATCH_START(uvideo, uaa); 462 463 /* TODO: May need to change in the future to work with 464 * Interface Association Descriptor. */ 465 466 /* Trigger on the Video Control Interface which must be present */ 467 if (uaa->class == UICLASS_VIDEO && 468 uaa->subclass == UISUBCLASS_VIDEOCONTROL) 469 return UMATCH_IFACECLASS_IFACESUBCLASS; 470 471 return UMATCH_NONE; 472 } 473 474 USB_ATTACH(uvideo) 475 { 476 USB_IFATTACH_START(uvideo, sc, uaa); 477 usbd_desc_iter_t iter; 478 const usb_interface_descriptor_t *ifdesc; 479 struct uvideo_stream *vs; 480 usbd_status err; 481 uint8_t ifaceidx; 482 483 sc->sc_dev = self; 484 485 sc->sc_devname = usbd_devinfo_alloc(uaa->device, 0); 486 487 aprint_naive("\n"); 488 aprint_normal(": %s\n", sc->sc_devname); 489 490 sc->sc_udev = uaa->device; 491 sc->sc_iface = uaa->iface; 492 sc->sc_ifaceno = uaa->ifaceno; 493 sc->sc_dying = 0; 494 sc->sc_state = UVIDEO_STATE_CLOSED; 495 SLIST_INIT(&sc->sc_stream_list); 496 497 #ifdef UVIDEO_DEBUG 498 /* Debugging dump of descriptors. TODO: move this to userspace 499 * via a custom IOCTL or something. */ 500 const usb_descriptor_t *desc; 501 usb_desc_iter_init(sc->sc_udev, &iter); 502 while ((desc = usb_desc_iter_next(&iter)) != NULL) { 503 /* print out all descriptors */ 504 printf("uvideo_attach: "); 505 print_descriptor(desc); 506 } 507 #endif /* !UVIDEO_DEBUG */ 508 509 /* iterate through interface descriptors and initialize softc */ 510 usb_desc_iter_init(sc->sc_udev, &iter); 511 for (ifaceidx = 0; 512 (ifdesc = usb_desc_iter_next_interface(&iter)) != NULL; 513 ++ifaceidx) 514 { 515 if (ifdesc->bInterfaceClass != UICLASS_VIDEO) { 516 DPRINTFN(50, ("uvideo_attach: " 517 "ignoring non-uvc interface: " 518 "len=%d type=0x%02x " 519 "class=0x%02x subclass=0x%02x\n", 520 ifdesc->bLength, 521 ifdesc->bDescriptorType, 522 ifdesc->bInterfaceClass, 523 ifdesc->bInterfaceSubClass)); 524 continue; 525 } 526 527 switch (ifdesc->bInterfaceSubClass) { 528 case UISUBCLASS_VIDEOCONTROL: 529 err = uvideo_init_control(sc, ifdesc, &iter); 530 if (err != USBD_NORMAL_COMPLETION) { 531 DPRINTF(("uvideo_attach: error with interface " 532 "%d, VideoControl, " 533 "descriptor len=%d type=0x%02x: " 534 "%s (%d)\n", 535 ifdesc->bInterfaceNumber, 536 ifdesc->bLength, 537 ifdesc->bDescriptorType, 538 usbd_errstr(err), err)); 539 } 540 break; 541 case UISUBCLASS_VIDEOSTREAMING: 542 vs = uvideo_find_stream(sc, ifdesc->bInterfaceNumber); 543 if (vs == NULL) { 544 vs = uvideo_stream_alloc(); 545 if (vs == NULL) { 546 DPRINTF(("uvideo_attach: " 547 "failed to alloc stream\n")); 548 err = USBD_NOMEM; 549 goto bad; 550 } 551 err = uvideo_stream_init(vs, sc, ifdesc, 552 ifaceidx); 553 if (err != USBD_NORMAL_COMPLETION) { 554 DPRINTF(("uvideo_attach: " 555 "error initializing stream: " 556 "%s (%d)\n", 557 usbd_errstr(err), err)); 558 goto bad; 559 } 560 } 561 err = uvideo_stream_init_desc(vs, ifdesc, &iter); 562 if (err != USBD_NORMAL_COMPLETION) { 563 DPRINTF(("uvideo_attach: " 564 "error initializing stream descriptor: " 565 "%s (%d)\n", 566 usbd_errstr(err), err)); 567 goto bad; 568 } 569 /* TODO: for now, set (each) stream to stream_in. */ 570 sc->sc_stream_in = vs; 571 break; 572 case UISUBCLASS_VIDEOCOLLECTION: 573 err = uvideo_init_collection(sc, ifdesc, &iter); 574 if (err != USBD_NORMAL_COMPLETION) { 575 DPRINTF(("uvideo_attach: error with interface " 576 "%d, VideoCollection, " 577 "descriptor len=%d type=0x%02x: " 578 "%s (%d)\n", 579 ifdesc->bInterfaceNumber, 580 ifdesc->bLength, 581 ifdesc->bDescriptorType, 582 usbd_errstr(err), err)); 583 goto bad; 584 } 585 break; 586 default: 587 DPRINTF(("uvideo_attach: unknown UICLASS_VIDEO " 588 "subclass=0x%02x\n", 589 ifdesc->bInterfaceSubClass)); 590 break; 591 } 592 593 } 594 595 596 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, 597 USBDEV(sc->sc_dev)); 598 599 sc->sc_videodev = video_attach_mi(&uvideo_hw_if, sc->sc_dev); 600 DPRINTF(("uvideo_attach: attached video driver at %p\n", 601 sc->sc_videodev)); 602 603 USB_ATTACH_SUCCESS_RETURN; 604 605 bad: 606 if (err != USBD_NORMAL_COMPLETION) { 607 DPRINTF(("uvideo_attach: error: %s (%d)\n", 608 usbd_errstr(err), err)); 609 } 610 USB_ATTACH_ERROR_RETURN; 611 } 612 613 614 int 615 uvideo_activate(device_t self, enum devact act) 616 { 617 struct uvideo_softc *sc; 618 int rv; 619 620 sc = device_private(self); 621 rv = 0; 622 switch (act) { 623 case DVACT_ACTIVATE: 624 return EOPNOTSUPP; 625 626 case DVACT_DEACTIVATE: 627 DPRINTF(("uvideo_activate: deactivating\n")); 628 if (sc->sc_videodev != NULL) 629 rv = config_deactivate(sc->sc_videodev); 630 sc->sc_dying = 1; 631 break; 632 } 633 return rv; 634 } 635 636 637 /* Detach child (video interface) */ 638 void 639 uvideo_childdet(device_t self, device_t child) 640 { 641 struct uvideo_softc *sc = device_private(self); 642 643 KASSERT(sc->sc_videodev == child); 644 sc->sc_videodev = NULL; 645 } 646 647 648 int 649 uvideo_detach(device_t self, int flags) 650 { 651 struct uvideo_softc *sc; 652 struct uvideo_stream *vs; 653 int rv; 654 655 sc = device_private(self); 656 rv = 0; 657 658 sc->sc_dying = 1; 659 660 usbd_devinfo_free(sc->sc_devname); 661 662 /* TODO: close the device if it is currently opened? Or will 663 * close be called automatically? */ 664 665 while (!SLIST_EMPTY(&sc->sc_stream_list)) { 666 vs = SLIST_FIRST(&sc->sc_stream_list); 667 SLIST_REMOVE_HEAD(&sc->sc_stream_list, entries); 668 uvideo_stream_free(vs); 669 } 670 671 /* Wait for outstanding request to complete. TODO: what is 672 * appropriate here? */ 673 usbd_delay_ms(sc->sc_udev, 1000); 674 675 DPRINTFN(15, ("uvideo: detaching from %s\n", 676 USBDEVNAME(sc->sc_dev))); 677 678 if (sc->sc_videodev != NULL) 679 rv = config_detach(sc->sc_videodev, flags); 680 681 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 682 USBDEV(sc->sc_dev)); 683 684 return rv; 685 } 686 687 /* Search the stream list for a stream matching the interface number. 688 * This is an O(n) search, but most devices should have only one or at 689 * most two streams. */ 690 static struct uvideo_stream * 691 uvideo_find_stream(struct uvideo_softc *sc, uint8_t ifaceno) 692 { 693 struct uvideo_stream *vs; 694 695 SLIST_FOREACH(vs, &sc->sc_stream_list, entries) { 696 if (vs->vs_ifaceno == ifaceno) 697 return vs; 698 } 699 700 return NULL; 701 } 702 703 /* Search the format list for the given format and frame index. This 704 * might be improved through indexing, but the format and frame count 705 * is unknown ahead of time (only after iterating through the 706 * usb device descriptors). */ 707 #if 0 708 static struct uvideo_format * 709 uvideo_stream_find_format(struct uvideo_stream *vs, 710 uint8_t format_index, uint8_t frame_index) 711 { 712 struct uvideo_format *format; 713 714 SIMPLEQ_FOREACH(format, &vs->vs_formats, entries) { 715 if (UVIDEO_FORMAT_GET_FORMAT_INDEX(format) == format_index && 716 UVIDEO_FORMAT_GET_FRAME_INDEX(format) == frame_index) 717 return format; 718 } 719 return NULL; 720 } 721 #endif 722 723 static struct uvideo_format * 724 uvideo_stream_guess_format(struct uvideo_stream *vs, 725 enum video_pixel_format pixel_format, 726 uint32_t width, uint32_t height) 727 { 728 struct uvideo_format *format, *gformat = NULL; 729 730 SIMPLEQ_FOREACH(format, &vs->vs_formats, entries) { 731 if (format->format.pixel_format != pixel_format) 732 continue; 733 if (format->format.width <= width && 734 format->format.height <= height) { 735 if (gformat == NULL || 736 (gformat->format.width < format->format.width && 737 gformat->format.height < format->format.height)) 738 gformat = format; 739 } 740 } 741 742 return gformat; 743 } 744 745 static struct uvideo_stream * 746 uvideo_stream_alloc(void) 747 { 748 return (kmem_alloc(sizeof(struct uvideo_stream), KM_NOSLEEP)); 749 } 750 751 752 static usbd_status 753 uvideo_init_control(struct uvideo_softc *sc, 754 const usb_interface_descriptor_t *ifdesc, 755 usbd_desc_iter_t *iter) 756 { 757 const usb_descriptor_t *desc; 758 const uvideo_descriptor_t *uvdesc; 759 usbd_desc_iter_t orig; 760 uint8_t i, j, nunits; 761 762 /* save original iterator state */ 763 memcpy(&orig, iter, sizeof(orig)); 764 765 /* count number of units and terminals */ 766 nunits = 0; 767 while ((desc = usb_desc_iter_next_non_interface(iter)) != NULL) { 768 uvdesc = (const uvideo_descriptor_t *)desc; 769 770 if (uvdesc->bDescriptorType != UDESC_CS_INTERFACE) 771 continue; 772 773 switch (uvdesc->bDescriptorSubtype) { 774 case UDESC_INPUT_TERMINAL: 775 case UDESC_OUTPUT_TERMINAL: 776 case UDESC_SELECTOR_UNIT: 777 case UDESC_PROCESSING_UNIT: 778 case UDESC_EXTENSION_UNIT: 779 ++nunits; 780 break; 781 default: 782 break; 783 } 784 } 785 786 /* allocate space for units */ 787 sc->sc_nunits = nunits; 788 sc->sc_unit = kmem_alloc(sizeof(*sc->sc_unit) * nunits, KM_SLEEP); 789 if (sc->sc_unit == NULL) 790 goto enomem; 791 792 /* restore original iterator state */ 793 memcpy(iter, &orig, sizeof(orig)); 794 795 /* iterate again, initializing the units */ 796 i = 0; 797 while ((desc = usb_desc_iter_next_non_interface(iter)) != NULL) { 798 uvdesc = (const uvideo_descriptor_t *)desc; 799 800 sc->sc_unit[i] = uvideo_unit_alloc(uvdesc); 801 /* TODO: free other units before returning? */ 802 if (sc->sc_unit[i] == NULL) 803 goto enomem; 804 ++i; 805 } 806 807 return USBD_NORMAL_COMPLETION; 808 809 enomem: 810 if (sc->sc_unit != NULL) { 811 for (j = 0; j < i; ++j) { 812 uvideo_unit_free(sc->sc_unit[j]); 813 sc->sc_unit[j] = NULL; 814 } 815 kmem_free(sc->sc_unit, sizeof(*sc->sc_unit) * nunits); 816 sc->sc_unit = NULL; 817 } 818 sc->sc_nunits = 0; 819 820 return USBD_NOMEM; 821 } 822 823 static usbd_status 824 uvideo_init_collection(struct uvideo_softc *sc, 825 const usb_interface_descriptor_t *ifdesc, 826 usbd_desc_iter_t *iter) 827 { 828 DPRINTF(("uvideo: ignoring Video Collection\n")); 829 return USBD_NORMAL_COMPLETION; 830 } 831 832 /* Allocates space for and initializes a uvideo unit based on the 833 * given descriptor. Returns NULL with bad descriptor or ENOMEM. */ 834 static struct uvideo_unit * 835 uvideo_unit_alloc(const uvideo_descriptor_t *desc) 836 { 837 struct uvideo_unit *vu; 838 usbd_status err; 839 840 if (desc->bDescriptorType != UDESC_CS_INTERFACE) 841 return NULL; 842 843 vu = kmem_alloc(sizeof(*vu), KM_SLEEP); 844 if (vu == NULL) 845 return NULL; 846 847 err = uvideo_unit_init(vu, desc); 848 if (err != USBD_NORMAL_COMPLETION) { 849 DPRINTF(("uvideo_unit_alloc: error initializing unit: " 850 "%s (%d)\n", usbd_errstr(err), err)); 851 kmem_free(vu, sizeof(*vu)); 852 return NULL; 853 } 854 855 return vu; 856 } 857 858 static usbd_status 859 uvideo_unit_init(struct uvideo_unit *vu, const uvideo_descriptor_t *desc) 860 { 861 struct uvideo_camera_terminal *ct; 862 struct uvideo_processing_unit *pu; 863 struct uvideo_extension_unit *xu; 864 865 const uvideo_input_terminal_descriptor_t *input; 866 const uvideo_output_terminal_descriptor_t *output; 867 const uvideo_camera_terminal_descriptor_t *camera; 868 const uvideo_selector_unit_descriptor_t *selector; 869 const uvideo_processing_unit_descriptor_t *processing; 870 const uvideo_extension_unit_descriptor_t *extension; 871 872 memset(vu, 0, sizeof(*vu)); 873 874 switch (desc->bDescriptorSubtype) { 875 case UDESC_INPUT_TERMINAL: 876 input = (const uvideo_input_terminal_descriptor_t *)desc; 877 switch (UGETW(input->wTerminalType)) { 878 case UVIDEO_ITT_CAMERA: 879 camera = 880 (const uvideo_camera_terminal_descriptor_t *)desc; 881 ct = &vu->u.vu_camera; 882 883 ct->ct_objective_focal_min = 884 UGETW(camera->wObjectiveFocalLengthMin); 885 ct->ct_objective_focal_max = 886 UGETW(camera->wObjectiveFocalLengthMax); 887 ct->ct_ocular_focal_length = 888 UGETW(camera->wOcularFocalLength); 889 890 uvideo_unit_alloc_controls(vu, camera->bControlSize, 891 camera->bmControls); 892 break; 893 default: 894 DPRINTF(("uvideo_unit_init: " 895 "unknown input terminal type 0x%04x\n", 896 UGETW(input->wTerminalType))); 897 return USBD_INVAL; 898 } 899 break; 900 case UDESC_OUTPUT_TERMINAL: 901 output = (const uvideo_output_terminal_descriptor_t *)desc; 902 break; 903 case UDESC_SELECTOR_UNIT: 904 selector = (const uvideo_selector_unit_descriptor_t *)desc; 905 906 uvideo_unit_alloc_sources(vu, selector->bNrInPins, 907 selector->baSourceID); 908 break; 909 case UDESC_PROCESSING_UNIT: 910 processing = (const uvideo_processing_unit_descriptor_t *)desc; 911 pu = &vu->u.vu_processing; 912 913 pu->pu_video_standards = PU_GET_VIDEO_STANDARDS(processing); 914 pu->pu_max_multiplier = UGETW(processing->wMaxMultiplier); 915 916 uvideo_unit_alloc_sources(vu, 1, &processing->bSourceID); 917 uvideo_unit_alloc_controls(vu, processing->bControlSize, 918 processing->bmControls); 919 break; 920 case UDESC_EXTENSION_UNIT: 921 extension = (const uvideo_extension_unit_descriptor_t *)desc; 922 xu = &vu->u.vu_extension; 923 /* TODO: copy guid */ 924 925 uvideo_unit_alloc_sources(vu, extension->bNrInPins, 926 extension->baSourceID); 927 uvideo_unit_alloc_controls(vu, XU_GET_CONTROL_SIZE(extension), 928 XU_GET_CONTROLS(extension)); 929 break; 930 default: 931 DPRINTF(("uvideo_unit_alloc: unknown descriptor " 932 "type=0x%02x subtype=0x%02x\n", 933 desc->bDescriptorType, desc->bDescriptorSubtype)); 934 return USBD_INVAL; 935 } 936 937 return USBD_NORMAL_COMPLETION; 938 } 939 940 static void 941 uvideo_unit_free(struct uvideo_unit *vu) 942 { 943 uvideo_unit_free_sources(vu); 944 uvideo_unit_free_controls(vu); 945 kmem_free(vu, sizeof(*vu)); 946 } 947 948 static usbd_status 949 uvideo_unit_alloc_sources(struct uvideo_unit *vu, 950 uint8_t nsrcs, const uint8_t *src_ids) 951 { 952 vu->vu_nsrcs = nsrcs; 953 954 if (nsrcs == 0) { 955 /* do nothing */ 956 } else if (nsrcs == 1) { 957 vu->s.vu_src_id = src_ids[0]; 958 } else { 959 vu->s.vu_src_id_ary = 960 kmem_alloc(sizeof(*vu->s.vu_src_id_ary) * nsrcs, KM_SLEEP); 961 if (vu->s.vu_src_id_ary == NULL) { 962 vu->vu_nsrcs = 0; 963 return USBD_NOMEM; 964 } 965 966 memcpy(vu->s.vu_src_id_ary, src_ids, nsrcs); 967 } 968 969 return USBD_NORMAL_COMPLETION; 970 } 971 972 static void 973 uvideo_unit_free_sources(struct uvideo_unit *vu) 974 { 975 if (vu->vu_nsrcs == 1) 976 return; 977 978 kmem_free(vu->s.vu_src_id_ary, 979 sizeof(*vu->s.vu_src_id_ary) * vu->vu_nsrcs); 980 vu->vu_nsrcs = 0; 981 vu->s.vu_src_id_ary = NULL; 982 } 983 984 static usbd_status 985 uvideo_unit_alloc_controls(struct uvideo_unit *vu, uint8_t size, 986 const uint8_t *controls) 987 { 988 vu->vu_controls = kmem_alloc(sizeof(*vu->vu_controls) * size, KM_SLEEP); 989 if (vu->vu_controls == NULL) 990 return USBD_NOMEM; 991 992 vu->vu_control_size = size; 993 memcpy(vu->vu_controls, controls, size); 994 995 return USBD_NORMAL_COMPLETION; 996 } 997 998 static void 999 uvideo_unit_free_controls(struct uvideo_unit *vu) 1000 { 1001 kmem_free(vu->vu_controls, 1002 sizeof(*vu->vu_controls) * vu->vu_control_size); 1003 vu->vu_controls = NULL; 1004 vu->vu_control_size = 0; 1005 } 1006 1007 1008 /* Initialize a stream from a Video Streaming interface 1009 * descriptor. Adds the stream to the stream_list in uvideo_softc. 1010 * This should be called once for new streams, and 1011 * uvideo_stream_init_desc() should then be called for this and each 1012 * additional interface with the same interface number. */ 1013 static usbd_status 1014 uvideo_stream_init(struct uvideo_stream *vs, 1015 struct uvideo_softc *sc, 1016 const usb_interface_descriptor_t *ifdesc, 1017 uint8_t idx) 1018 { 1019 uWord len; 1020 usbd_status err; 1021 1022 SLIST_INSERT_HEAD(&sc->sc_stream_list, vs, entries); 1023 memset(vs, 0, sizeof(*vs)); 1024 vs->vs_parent = sc; 1025 vs->vs_ifaceno = ifdesc->bInterfaceNumber; 1026 vs->vs_subtype = 0; 1027 SIMPLEQ_INIT(&vs->vs_formats); 1028 SIMPLEQ_INIT(&vs->vs_pixel_formats); 1029 vs->vs_default_format = NULL; 1030 vs->vs_current_format.priv = -1; 1031 vs->vs_xfer_type = 0; 1032 1033 err = usbd_device2interface_handle(sc->sc_udev, idx, &vs->vs_iface); 1034 if (err != USBD_NORMAL_COMPLETION) { 1035 DPRINTF(("uvideo_stream_init: " 1036 "error getting vs interface: " 1037 "%s (%d)\n", 1038 usbd_errstr(err), err)); 1039 return err; 1040 } 1041 1042 /* For Xbox Live Vision camera, linux-uvc folk say we need to 1043 * set an alternate interface and wait ~3 seconds prior to 1044 * doing the format probe/commit. We set to alternate 1045 * interface 0, which is the default, zero bandwidth 1046 * interface. This should not have adverse affects on other 1047 * cameras. Errors are ignored. */ 1048 err = usbd_set_interface(vs->vs_iface, 0); 1049 if (err != USBD_NORMAL_COMPLETION) { 1050 DPRINTF(("uvideo_stream_init: error setting alt interface: " 1051 "%s (%d)\n", 1052 usbd_errstr(err), err)); 1053 } 1054 1055 /* Initialize probe and commit data size. This value is 1056 * dependent on the version of the spec the hardware 1057 * implements. */ 1058 err = uvideo_stream_probe(vs, UR_GET_LEN, len); 1059 if (err != USBD_NORMAL_COMPLETION) { 1060 DPRINTF(("uvideo_stream_init: " 1061 "error getting probe data len: " 1062 "%s (%d)\n", 1063 usbd_errstr(err), err)); 1064 vs->vs_probelen = 26; /* conservative v1.0 length */ 1065 } else { 1066 DPRINTFN(15,("uvideo_stream_init: probelen=%d\n", UGETW(len))); 1067 vs->vs_probelen = UGETW(len); 1068 } 1069 1070 return USBD_NORMAL_COMPLETION; 1071 } 1072 1073 /* Further stream initialization based on a Video Streaming interface 1074 * descriptor and following descriptors belonging to that interface. 1075 * Iterates through all descriptors belonging to this particular 1076 * interface descriptor, modifying the iterator. This may be called 1077 * multiple times because there may be several alternate interfaces 1078 * associated with the same interface number. */ 1079 static usbd_status 1080 uvideo_stream_init_desc(struct uvideo_stream *vs, 1081 const usb_interface_descriptor_t *ifdesc, 1082 usbd_desc_iter_t *iter) 1083 { 1084 const usb_descriptor_t *desc; 1085 const uvideo_descriptor_t *uvdesc; 1086 struct uvideo_bulk_xfer *bx; 1087 struct uvideo_isoc_xfer *ix; 1088 struct uvideo_alternate *alt; 1089 uint8_t xfer_type; 1090 int i; 1091 1092 /* Iterate until the next interface descriptor. All 1093 * descriptors until then belong to this streaming 1094 * interface. */ 1095 while ((desc = usb_desc_iter_next_non_interface(iter)) != NULL) { 1096 uvdesc = (const uvideo_descriptor_t *)desc; 1097 1098 switch (uvdesc->bDescriptorType) { 1099 case UDESC_ENDPOINT: 1100 xfer_type = UE_GET_XFERTYPE(GET(usb_endpoint_descriptor_t, 1101 desc, bmAttributes)); 1102 if (xfer_type == UE_BULK) { 1103 bx = &vs->vs_xfer.bulk; 1104 if (vs->vs_xfer_type == 0) { 1105 DPRINTFN(15, ("uvideo_attach: " 1106 "BULK stream *\n")); 1107 vs->vs_xfer_type = UE_BULK; 1108 bx->bx_endpt = 1109 GET(usb_endpoint_descriptor_t, 1110 desc, bEndpointAddress); 1111 } 1112 } else if (xfer_type == UE_ISOCHRONOUS) { 1113 ix = &vs->vs_xfer.isoc; 1114 for (i = 0; i < UVIDEO_NXFERS; i++) { 1115 ix->ix_i[i].i_ix = ix; 1116 ix->ix_i[i].i_vs = vs; 1117 } 1118 if (vs->vs_xfer_type == 0) { 1119 DPRINTFN(15, ("uvideo_attach: " 1120 "ISOC stream *\n")); 1121 SLIST_INIT(&ix->ix_altlist); 1122 vs->vs_xfer_type = UE_ISOCHRONOUS; 1123 ix->ix_endpt = 1124 GET(usb_endpoint_descriptor_t, 1125 desc, bEndpointAddress); 1126 } 1127 1128 alt = kmem_alloc(sizeof(*alt), KM_NOSLEEP); 1129 if (alt == NULL) 1130 return USBD_NOMEM; 1131 1132 alt->altno = ifdesc->bAlternateSetting; 1133 alt->interval = 1134 GET(usb_endpoint_descriptor_t, 1135 desc, bInterval); 1136 alt->max_packet_size = 1137 UGETW(GET(usb_endpoint_descriptor_t, 1138 desc, wMaxPacketSize)); 1139 SLIST_INSERT_HEAD(&ix->ix_altlist, 1140 alt, entries); 1141 } 1142 break; 1143 case UDESC_CS_INTERFACE: 1144 if (ifdesc->bAlternateSetting != 0) { 1145 DPRINTF(("uvideo_stream_init_alternate: " 1146 "unexpected class-specific descriptor " 1147 "len=%d type=0x%02x subtype=0x%02x\n", 1148 uvdesc->bLength, 1149 uvdesc->bDescriptorType, 1150 uvdesc->bDescriptorSubtype)); 1151 break; 1152 } 1153 1154 switch (uvdesc->bDescriptorSubtype) { 1155 case UDESC_VS_INPUT_HEADER: 1156 vs->vs_subtype = UDESC_VS_INPUT_HEADER; 1157 break; 1158 case UDESC_VS_OUTPUT_HEADER: 1159 /* TODO: handle output stream */ 1160 DPRINTF(("uvideo: VS output not implemented\n")); 1161 vs->vs_subtype = UDESC_VS_OUTPUT_HEADER; 1162 return USBD_INVAL; 1163 case UDESC_VS_FORMAT_UNCOMPRESSED: 1164 case UDESC_VS_FORMAT_FRAME_BASED: 1165 case UDESC_VS_FORMAT_MJPEG: 1166 uvideo_stream_init_frame_based_format(vs, 1167 uvdesc, 1168 iter); 1169 break; 1170 case UDESC_VS_FORMAT_MPEG2TS: 1171 case UDESC_VS_FORMAT_DV: 1172 case UDESC_VS_FORMAT_STREAM_BASED: 1173 default: 1174 DPRINTF(("uvideo: unimplemented VS CS " 1175 "descriptor len=%d type=0x%02x " 1176 "subtype=0x%02x\n", 1177 uvdesc->bLength, 1178 uvdesc->bDescriptorType, 1179 uvdesc->bDescriptorSubtype)); 1180 break; 1181 } 1182 break; 1183 default: 1184 DPRINTF(("uvideo_stream_init_desc: " 1185 "unknown descriptor " 1186 "len=%d type=0x%02x\n", 1187 uvdesc->bLength, 1188 uvdesc->bDescriptorType)); 1189 break; 1190 } 1191 } 1192 1193 return USBD_NORMAL_COMPLETION; 1194 } 1195 1196 /* Finialize and free memory associated with this stream. */ 1197 static void 1198 uvideo_stream_free(struct uvideo_stream *vs) 1199 { 1200 struct uvideo_alternate *alt; 1201 struct uvideo_pixel_format *pixel_format; 1202 struct uvideo_format *format; 1203 1204 /* free linked list of alternate interfaces */ 1205 if (vs->vs_xfer_type == UE_ISOCHRONOUS) { 1206 while (!SLIST_EMPTY(&vs->vs_xfer.isoc.ix_altlist)) { 1207 alt = SLIST_FIRST(&vs->vs_xfer.isoc.ix_altlist); 1208 SLIST_REMOVE_HEAD(&vs->vs_xfer.isoc.ix_altlist, 1209 entries); 1210 kmem_free(alt, sizeof(*alt)); 1211 } 1212 } 1213 1214 /* free linked-list of formats and pixel formats */ 1215 while ((format = SIMPLEQ_FIRST(&vs->vs_formats)) != NULL) { 1216 SIMPLEQ_REMOVE_HEAD(&vs->vs_formats, entries); 1217 kmem_free(format, sizeof(struct uvideo_format)); 1218 } 1219 while ((pixel_format = SIMPLEQ_FIRST(&vs->vs_pixel_formats)) != NULL) { 1220 SIMPLEQ_REMOVE_HEAD(&vs->vs_pixel_formats, entries); 1221 kmem_free(pixel_format, sizeof(struct uvideo_pixel_format)); 1222 } 1223 1224 kmem_free(vs, sizeof(*vs)); 1225 } 1226 1227 1228 static usbd_status 1229 uvideo_stream_init_frame_based_format(struct uvideo_stream *vs, 1230 const uvideo_descriptor_t *format_desc, 1231 usbd_desc_iter_t *iter) 1232 { 1233 struct uvideo_pixel_format *pformat, *pfiter; 1234 enum video_pixel_format pixel_format; 1235 struct uvideo_format *format; 1236 const uvideo_descriptor_t *uvdesc; 1237 uint8_t subtype, default_index, index; 1238 uint32_t frame_interval; 1239 const usb_guid_t *guid; 1240 1241 pixel_format = VIDEO_FORMAT_UNDEFINED; 1242 1243 switch (format_desc->bDescriptorSubtype) { 1244 case UDESC_VS_FORMAT_UNCOMPRESSED: 1245 subtype = UDESC_VS_FRAME_UNCOMPRESSED; 1246 default_index = GET(uvideo_vs_format_uncompressed_descriptor_t, 1247 format_desc, 1248 bDefaultFrameIndex); 1249 guid = GETP(uvideo_vs_format_uncompressed_descriptor_t, 1250 format_desc, 1251 guidFormat); 1252 if (usb_guid_cmp(guid, &uvideo_guid_format_yuy2) == 0) 1253 pixel_format = VIDEO_FORMAT_YUY2; 1254 else if (usb_guid_cmp(guid, &uvideo_guid_format_nv12) == 0) 1255 pixel_format = VIDEO_FORMAT_NV12; 1256 break; 1257 case UDESC_VS_FORMAT_FRAME_BASED: 1258 subtype = UDESC_VS_FRAME_FRAME_BASED; 1259 default_index = GET(uvideo_format_frame_based_descriptor_t, 1260 format_desc, 1261 bDefaultFrameIndex); 1262 break; 1263 case UDESC_VS_FORMAT_MJPEG: 1264 subtype = UDESC_VS_FRAME_MJPEG; 1265 default_index = GET(uvideo_vs_format_mjpeg_descriptor_t, 1266 format_desc, 1267 bDefaultFrameIndex); 1268 pixel_format = VIDEO_FORMAT_MJPEG; 1269 break; 1270 default: 1271 DPRINTF(("uvideo: unknown frame based format %d\n", 1272 format_desc->bDescriptorSubtype)); 1273 return USBD_INVAL; 1274 } 1275 1276 pformat = NULL; 1277 SIMPLEQ_FOREACH(pfiter, &vs->vs_pixel_formats, entries) { 1278 if (pfiter->pixel_format == pixel_format) { 1279 pformat = pfiter; 1280 break; 1281 } 1282 } 1283 if (pixel_format != VIDEO_FORMAT_UNDEFINED && pformat == NULL) { 1284 pformat = kmem_zalloc(sizeof(*pformat), KM_SLEEP); 1285 pformat->pixel_format = pixel_format; 1286 DPRINTF(("uvideo: Adding pixel format %d\n", 1287 pixel_format)); 1288 SIMPLEQ_INSERT_TAIL(&vs->vs_pixel_formats, 1289 pformat, entries); 1290 } 1291 1292 /* Iterate through frame descriptors directly following the 1293 * format descriptor, and add a format to the format list for 1294 * each frame descriptor. */ 1295 while ((uvdesc = (const uvideo_descriptor_t *) usb_desc_iter_peek_next(iter)) && 1296 (uvdesc != NULL) && (uvdesc->bDescriptorSubtype == subtype)) 1297 { 1298 uvdesc = (const uvideo_descriptor_t *) usb_desc_iter_next(iter); 1299 1300 format = kmem_zalloc(sizeof(struct uvideo_format), KM_SLEEP); 1301 if (format == NULL) { 1302 DPRINTF(("uvideo: failed to alloc video format\n")); 1303 return USBD_NOMEM; 1304 } 1305 1306 format->format.pixel_format = pixel_format; 1307 1308 switch (format_desc->bDescriptorSubtype) { 1309 case UDESC_VS_FORMAT_UNCOMPRESSED: 1310 #ifdef UVIDEO_DEBUG 1311 if (pixel_format == VIDEO_FORMAT_UNDEFINED && 1312 uvideodebug) { 1313 guid = GETP( 1314 uvideo_vs_format_uncompressed_descriptor_t, 1315 format_desc, 1316 guidFormat); 1317 1318 DPRINTF(("uvideo: format undefined ")); 1319 usb_guid_print(guid); 1320 DPRINTF(("\n")); 1321 } 1322 #endif 1323 1324 UVIDEO_FORMAT_INIT_FRAME_BASED( 1325 uvideo_vs_format_uncompressed_descriptor_t, 1326 format_desc, 1327 uvideo_vs_frame_uncompressed_descriptor_t, 1328 uvdesc, 1329 format); 1330 format->format.sample_size = 1331 UGETDW( 1332 ((const uvideo_vs_frame_uncompressed_descriptor_t *) 1333 uvdesc)->dwMaxVideoFrameBufferSize); 1334 format->format.stride = 1335 format->format.sample_size / format->format.height; 1336 index = GET(uvideo_vs_frame_uncompressed_descriptor_t, 1337 uvdesc, 1338 bFrameIndex); 1339 frame_interval = 1340 UGETDW( 1341 GET(uvideo_vs_frame_uncompressed_descriptor_t, 1342 uvdesc, 1343 dwDefaultFrameInterval)); 1344 break; 1345 case UDESC_VS_FORMAT_MJPEG: 1346 UVIDEO_FORMAT_INIT_FRAME_BASED( 1347 uvideo_vs_format_mjpeg_descriptor_t, 1348 format_desc, 1349 uvideo_vs_frame_mjpeg_descriptor_t, 1350 uvdesc, 1351 format); 1352 format->format.sample_size = 1353 UGETDW(((const uvideo_vs_frame_mjpeg_descriptor_t *) 1354 uvdesc)->dwMaxVideoFrameBufferSize); 1355 format->format.stride = 1356 format->format.sample_size / format->format.height; 1357 index = GET(uvideo_vs_frame_mjpeg_descriptor_t, 1358 uvdesc, 1359 bFrameIndex); 1360 frame_interval = 1361 UGETDW( 1362 GET(uvideo_vs_frame_mjpeg_descriptor_t, 1363 uvdesc, 1364 dwDefaultFrameInterval)); 1365 break; 1366 case UDESC_VS_FORMAT_FRAME_BASED: 1367 format->format.pixel_format = VIDEO_FORMAT_UNDEFINED; 1368 UVIDEO_FORMAT_INIT_FRAME_BASED( 1369 uvideo_format_frame_based_descriptor_t, 1370 format_desc, 1371 uvideo_frame_frame_based_descriptor_t, 1372 uvdesc, 1373 format); 1374 index = GET(uvideo_frame_frame_based_descriptor_t, 1375 uvdesc, 1376 bFrameIndex); 1377 format->format.stride = 1378 UGETDW(((const uvideo_frame_frame_based_descriptor_t *) 1379 uvdesc)->dwBytesPerLine); 1380 format->format.sample_size = 1381 format->format.stride * format->format.height; 1382 frame_interval = 1383 UGETDW( 1384 GET(uvideo_frame_frame_based_descriptor_t, 1385 uvdesc, 1386 dwDefaultFrameInterval)); 1387 break; 1388 default: 1389 /* shouldn't ever get here */ 1390 DPRINTF(("uvideo: unknown frame based format %d\n", 1391 format_desc->bDescriptorSubtype)); 1392 kmem_free(format, sizeof(struct uvideo_format)); 1393 return USBD_INVAL; 1394 } 1395 1396 DPRINTF(("UVC: Found format (index %d) %d: %dx%d\n", 1397 index, format->format.pixel_format, format->format.width, 1398 format->format.height)); 1399 1400 SIMPLEQ_INSERT_TAIL(&vs->vs_formats, format, entries); 1401 1402 if (vs->vs_default_format == NULL && index == default_index 1403 #ifdef UVIDEO_DISABLE_MJPEG 1404 && subtype != UDESC_VS_FRAME_MJPEG 1405 #endif 1406 ) { 1407 DPRINTF((" ^ picking this one\n")); 1408 vs->vs_default_format = &format->format; 1409 vs->vs_frame_interval = frame_interval; 1410 } 1411 1412 } 1413 1414 return USBD_NORMAL_COMPLETION; 1415 } 1416 1417 static int 1418 uvideo_stream_start_xfer(struct uvideo_stream *vs) 1419 { 1420 struct uvideo_softc *sc = vs->vs_parent; 1421 struct uvideo_bulk_xfer *bx; 1422 struct uvideo_isoc_xfer *ix; 1423 uint32_t vframe_len; /* rough bytes per video frame */ 1424 uint32_t uframe_len; /* bytes per usb frame (TODO: or microframe?) */ 1425 uint32_t nframes; /* number of usb frames (TODO: or microframs?) */ 1426 int i; 1427 1428 struct uvideo_alternate *alt, *alt_maybe; 1429 usbd_status err; 1430 1431 switch (vs->vs_xfer_type) { 1432 case UE_BULK: 1433 bx = &vs->vs_xfer.bulk; 1434 return 0; 1435 case UE_ISOCHRONOUS: 1436 ix = &vs->vs_xfer.isoc; 1437 1438 vframe_len = vs->vs_current_format.sample_size; 1439 uframe_len = UVIDEO_FRAME_INTERVAL_UNITS_PER_USB_FRAME * 1440 vframe_len / vs->vs_frame_interval; 1441 nframes = (vframe_len / uframe_len); 1442 if (nframes == 0) 1443 nframes++; 1444 1445 DPRINTF(("uvideo_stream_start_xfer: nframes=%d\n", nframes)); 1446 1447 /* Choose an alternate interface most suitable for 1448 * this format. Choose the smallest size that can 1449 * contain max_payload_size. 1450 * 1451 * It is assumed that the list is sorted in descending 1452 * order from largest to smallest packet size. 1453 * 1454 * TODO: what should the strategy be for choosing an 1455 * alt interface? 1456 */ 1457 alt = NULL; 1458 SLIST_FOREACH(alt_maybe, &ix->ix_altlist, entries) { 1459 /* TODO: define "packet" and "payload". I think 1460 * several packets can make up one payload which would 1461 * call into question this method of selecting an 1462 * alternate interface... */ 1463 1464 /* XXXJDM don't allow packet size > 1024 for now */ 1465 if (alt_maybe->max_packet_size > 1024) 1466 continue; 1467 1468 if (alt == NULL || 1469 alt_maybe->max_packet_size >= alt->max_packet_size) 1470 alt = alt_maybe; 1471 } 1472 1473 if (alt == NULL) { 1474 DPRINTF(("uvideo_stream_start_xfer: " 1475 "no suitable alternate interface found\n")); 1476 return EINVAL; 1477 } 1478 1479 DPRINTFN(15,("uvideo_stream_start_xfer: " 1480 "choosing alternate interface " 1481 "%d wMaxPacketSize=%d bInterval=%d\n", 1482 alt->altno, alt->max_packet_size, alt->interval)); 1483 1484 err = usbd_set_interface(vs->vs_iface, alt->altno); 1485 if (err != USBD_NORMAL_COMPLETION) { 1486 DPRINTF(("uvideo_stream_start_xfer: " 1487 "error setting alt interface: %s (%d)\n", 1488 usbd_errstr(err), err)); 1489 return EIO; 1490 } 1491 1492 /* TODO: "packet" not same as frame */ 1493 uframe_len = alt->max_packet_size; 1494 nframes = (vframe_len + uframe_len - 1) / uframe_len; 1495 DPRINTF(("uvideo_stream_start_xfer: nframes2=%d\n", nframes)); 1496 1497 ix->ix_nframes = nframes; 1498 ix->ix_uframe_len = uframe_len; 1499 for (i = 0; i < UVIDEO_NXFERS; i++) { 1500 struct uvideo_isoc *isoc = &ix->ix_i[i]; 1501 isoc->i_frlengths = 1502 kmem_alloc(sizeof(isoc->i_frlengths[0]) * nframes, 1503 KM_SLEEP); 1504 if (isoc->i_frlengths == NULL) { 1505 DPRINTF(("uvideo: failed to alloc frlengths:" 1506 "%s (%d)\n", 1507 usbd_errstr(err), err)); 1508 return ENOMEM; 1509 } 1510 } 1511 1512 err = usbd_open_pipe(vs->vs_iface, ix->ix_endpt, 1513 USBD_EXCLUSIVE_USE, &ix->ix_pipe); 1514 if (err != USBD_NORMAL_COMPLETION) { 1515 DPRINTF(("uvideo: error opening pipe: %s (%d)\n", 1516 usbd_errstr(err), err)); 1517 return EIO; 1518 } 1519 1520 for (i = 0; i < UVIDEO_NXFERS; i++) { 1521 struct uvideo_isoc *isoc = &ix->ix_i[i]; 1522 isoc->i_xfer = usbd_alloc_xfer(sc->sc_udev); 1523 if (isoc->i_xfer == NULL) { 1524 DPRINTF(("uvideo: failed to alloc xfer: %s" 1525 " (%d)\n", 1526 usbd_errstr(err), err)); 1527 return ENOMEM; 1528 } 1529 1530 isoc->i_buf = usbd_alloc_buffer(isoc->i_xfer, 1531 nframes * uframe_len); 1532 if (isoc->i_xfer == NULL) { 1533 DPRINTF(("uvideo: failed to alloc buf: %s" 1534 " (%d)\n", 1535 usbd_errstr(err), err)); 1536 return ENOMEM; 1537 } 1538 } 1539 1540 uvideo_stream_recv_isoc_start(vs); 1541 1542 return 0; 1543 default: 1544 /* should never get here */ 1545 DPRINTF(("uvideo_stream_start_xfer: unknown xfer type 0x%x\n", 1546 vs->vs_xfer_type)); 1547 return EINVAL; 1548 } 1549 } 1550 1551 static int 1552 uvideo_stream_stop_xfer(struct uvideo_stream *vs) 1553 { 1554 struct uvideo_bulk_xfer *bx; 1555 struct uvideo_isoc_xfer *ix; 1556 usbd_status err; 1557 int i; 1558 1559 switch (vs->vs_xfer_type) { 1560 case UE_BULK: 1561 bx = &vs->vs_xfer.bulk; 1562 return 0; 1563 case UE_ISOCHRONOUS: 1564 ix = &vs->vs_xfer.isoc; 1565 if (ix->ix_pipe != NULL) { 1566 usbd_abort_pipe(ix->ix_pipe); 1567 usbd_close_pipe(ix->ix_pipe); 1568 ix->ix_pipe = NULL; 1569 } 1570 1571 for (i = 0; i < UVIDEO_NXFERS; i++) { 1572 struct uvideo_isoc *isoc = &ix->ix_i[i]; 1573 if (isoc->i_xfer != NULL) { 1574 usbd_free_buffer(isoc->i_xfer); 1575 usbd_free_xfer(isoc->i_xfer); 1576 isoc->i_xfer = NULL; 1577 } 1578 1579 if (isoc->i_frlengths != NULL) { 1580 kmem_free(isoc->i_frlengths, 1581 sizeof(isoc->i_frlengths[0]) * 1582 ix->ix_nframes); 1583 isoc->i_frlengths = NULL; 1584 } 1585 } 1586 1587 /* Give it some time to settle */ 1588 usbd_delay_ms(vs->vs_parent->sc_udev, 1000); 1589 1590 /* Set to zero bandwidth alternate interface zero */ 1591 err = usbd_set_interface(vs->vs_iface, 0); 1592 if (err != USBD_NORMAL_COMPLETION) { 1593 DPRINTF(("uvideo_stream_stop_transfer: " 1594 "error setting zero bandwidth interface: " 1595 "%s (%d)\n", 1596 usbd_errstr(err), err)); 1597 return EIO; 1598 } 1599 1600 return 0; 1601 default: 1602 /* should never get here */ 1603 DPRINTF(("uvideo_stream_stop_xfer: unknown xfer type 0x%x\n", 1604 vs->vs_xfer_type)); 1605 return EINVAL; 1606 } 1607 } 1608 1609 static usbd_status 1610 uvideo_stream_recv_isoc_start(struct uvideo_stream *vs) 1611 { 1612 int i; 1613 1614 for (i = 0; i < UVIDEO_NXFERS; i++) 1615 uvideo_stream_recv_isoc_start1(&vs->vs_xfer.isoc.ix_i[i]); 1616 1617 return USBD_NORMAL_COMPLETION; 1618 } 1619 1620 /* Initiate a usb transfer. */ 1621 static usbd_status 1622 uvideo_stream_recv_isoc_start1(struct uvideo_isoc *isoc) 1623 { 1624 struct uvideo_isoc_xfer *ix; 1625 usbd_status err; 1626 int i; 1627 1628 ix = isoc->i_ix; 1629 1630 for (i = 0; i < ix->ix_nframes; ++i) 1631 isoc->i_frlengths[i] = ix->ix_uframe_len; 1632 1633 usbd_setup_isoc_xfer(isoc->i_xfer, 1634 ix->ix_pipe, 1635 isoc, 1636 isoc->i_frlengths, 1637 ix->ix_nframes, 1638 USBD_NO_COPY | USBD_SHORT_XFER_OK, 1639 uvideo_stream_recv_isoc_complete); 1640 1641 err = usbd_transfer(isoc->i_xfer); 1642 if (err != USBD_IN_PROGRESS) { 1643 DPRINTF(("uvideo_stream_recv_start: " 1644 "usbd_transfer status=%s (%d)\n", 1645 usbd_errstr(err), err)); 1646 } 1647 return err; 1648 } 1649 1650 /* Callback on completion of usb isoc transfer */ 1651 static void 1652 uvideo_stream_recv_isoc_complete(usbd_xfer_handle xfer, 1653 usbd_private_handle priv, 1654 usbd_status status) 1655 { 1656 struct uvideo_stream *vs; 1657 struct uvideo_isoc_xfer *ix; 1658 struct uvideo_isoc *isoc; 1659 int i; 1660 uint32_t count; 1661 const uvideo_payload_header_t *hdr; 1662 uint8_t *buf; 1663 struct video_payload payload; 1664 1665 isoc = priv; 1666 vs = isoc->i_vs; 1667 ix = isoc->i_ix; 1668 1669 if (status != USBD_NORMAL_COMPLETION) { 1670 DPRINTF(("uvideo_stream_recv_isoc_complete: status=%s (%d)\n", 1671 usbd_errstr(status), status)); 1672 1673 if (status == USBD_STALLED) 1674 usbd_clear_endpoint_stall_async(ix->ix_pipe); 1675 else 1676 return; 1677 } else { 1678 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1679 1680 if (count == 0) { 1681 /* DPRINTF(("uvideo: zero length transfer\n")); */ 1682 /* return; */ /* TODO: what to do here? restarting 1683 * can lead to infinite loop */ 1684 } 1685 1686 hdr = (const uvideo_payload_header_t *)isoc->i_buf; 1687 1688 for (i = 0, buf = isoc->i_buf; 1689 i < ix->ix_nframes; 1690 ++i, buf += ix->ix_uframe_len) 1691 { 1692 if (isoc->i_frlengths[i] == 0) 1693 continue; 1694 1695 hdr = (uvideo_payload_header_t *)buf; 1696 if (hdr->bHeaderLength == 0) 1697 continue; 1698 1699 payload.data = buf + hdr->bHeaderLength; 1700 payload.size = isoc->i_frlengths[i] - 1701 hdr->bHeaderLength; 1702 payload.frameno = hdr->bmHeaderInfo & UV_FRAME_ID; 1703 payload.end_of_frame = 1704 hdr->bmHeaderInfo & UV_END_OF_FRAME; 1705 1706 video_submit_payload(vs->vs_parent->sc_videodev, 1707 &payload); 1708 } 1709 } 1710 1711 uvideo_stream_recv_isoc_start1(isoc); 1712 } 1713 1714 1715 /* 1716 * uvideo_open - probe and commit video format and start receiving 1717 * video data 1718 */ 1719 static int 1720 uvideo_open(void *addr, int flags) 1721 { 1722 struct uvideo_softc *sc; 1723 struct uvideo_stream *vs; 1724 struct video_format fmt; 1725 1726 sc = addr; 1727 vs = sc->sc_stream_in; 1728 1729 DPRINTF(("uvideo_open: sc=%p\n", sc)); 1730 if (sc->sc_dying) 1731 return EIO; 1732 1733 /* XXX select default format */ 1734 fmt = *vs->vs_default_format; 1735 return uvideo_set_format(addr, &fmt); 1736 } 1737 1738 1739 static void 1740 uvideo_close(void *addr) 1741 { 1742 struct uvideo_softc *sc; 1743 1744 sc = addr; 1745 1746 if (sc->sc_state != UVIDEO_STATE_CLOSED) { 1747 sc->sc_state = UVIDEO_STATE_CLOSED; 1748 } 1749 } 1750 1751 static const char * 1752 uvideo_get_devname(void *addr) 1753 { 1754 struct uvideo_softc *sc = addr; 1755 return sc->sc_devname; 1756 } 1757 1758 static int 1759 uvideo_enum_format(void *addr, uint32_t index, struct video_format *format) 1760 { 1761 struct uvideo_softc *sc = addr; 1762 struct uvideo_stream *vs = sc->sc_stream_in; 1763 struct uvideo_pixel_format *pixel_format; 1764 int off; 1765 1766 if (sc->sc_dying) 1767 return EIO; 1768 1769 off = 0; 1770 SIMPLEQ_FOREACH(pixel_format, &vs->vs_pixel_formats, entries) { 1771 if (off++ != index) 1772 continue; 1773 format->pixel_format = pixel_format->pixel_format; 1774 return 0; 1775 } 1776 1777 return EINVAL; 1778 } 1779 1780 /* 1781 * uvideo_get_format 1782 */ 1783 static int 1784 uvideo_get_format(void *addr, struct video_format *format) 1785 { 1786 struct uvideo_softc *sc = addr; 1787 struct uvideo_stream *vs = sc->sc_stream_in; 1788 1789 if (sc->sc_dying) 1790 return EIO; 1791 1792 *format = vs->vs_current_format; 1793 1794 return 0; 1795 } 1796 1797 /* 1798 * uvideo_set_format - TODO: this is boken and does nothing 1799 */ 1800 static int 1801 uvideo_set_format(void *addr, struct video_format *format) 1802 { 1803 struct uvideo_softc *sc; 1804 struct uvideo_stream *vs; 1805 struct uvideo_format *uvfmt; 1806 uvideo_probe_and_commit_data_t probe; 1807 uint8_t ifaceno; 1808 usbd_status err; 1809 1810 sc = addr; 1811 1812 DPRINTF(("uvideo_set_format: sc=%p\n", sc)); 1813 if (sc->sc_dying) 1814 return EIO; 1815 1816 vs = sc->sc_stream_in; 1817 ifaceno = vs->vs_ifaceno; 1818 1819 /* probe/GET_CUR to see what the hardware is offering */ 1820 uvideo_init_probe_data(&probe); 1821 1822 err = uvideo_stream_probe(vs, UR_GET_CUR, &probe); 1823 if (err != USBD_NORMAL_COMPLETION) { 1824 DPRINTF(("uvideo: error probe/GET_CUR: %s (%d)\n", 1825 usbd_errstr(err), err)); 1826 } 1827 1828 uvfmt = uvideo_stream_guess_format(vs, format->pixel_format, 1829 format->width, format->height); 1830 if (uvfmt == NULL) { 1831 DPRINTF(("uvideo: uvideo_stream_guess_format couldn't find " 1832 "%dx%d format %d\n", format->width, format->height, 1833 format->pixel_format)); 1834 return EINVAL; 1835 } 1836 1837 probe.bFormatIndex = UVIDEO_FORMAT_GET_FORMAT_INDEX(uvfmt); 1838 probe.bFrameIndex = UVIDEO_FORMAT_GET_FRAME_INDEX(uvfmt); 1839 USETDW(probe.dwFrameInterval, vs->vs_frame_interval); /* XXX */ 1840 1841 /* commit/SET_CUR. Fourth step is to set the alternate 1842 * interface. Currently the fourth step is in 1843 * uvideo_start_transfer. Maybe move it here? */ 1844 err = uvideo_stream_commit(vs, UR_SET_CUR, &probe); 1845 if (err != USBD_NORMAL_COMPLETION) { 1846 DPRINTF(("uvideo: error commit/SET_CUR: %s (%d)\n", 1847 usbd_errstr(err), err)); 1848 return EIO; 1849 } 1850 1851 DPRINTFN(15, ("uvideo_set_format: committing to format: " 1852 "bmHint=0x%04x bFormatIndex=%d bFrameIndex=%d " 1853 "dwFrameInterval=%d wKeyFrameRate=%d wPFrameRate=%d " 1854 "wCompQuality=%d wCompWindowSize=%d wDelay=%d " 1855 "dwMaxVideoFrameSize=%d dwMaxPayloadTransferSize=%d", 1856 UGETW(probe.bmHint), 1857 probe.bFormatIndex, 1858 probe.bFrameIndex, 1859 UGETDW(probe.dwFrameInterval), 1860 UGETW(probe.wKeyFrameRate), 1861 UGETW(probe.wPFrameRate), 1862 UGETW(probe.wCompQuality), 1863 UGETW(probe.wCompWindowSize), 1864 UGETW(probe.wDelay), 1865 UGETDW(probe.dwMaxVideoFrameSize), 1866 UGETDW(probe.dwMaxPayloadTransferSize))); 1867 if (vs->vs_probelen == 34) { 1868 DPRINTFN(15, (" dwClockFrequency=%d bmFramingInfo=0x%02x " 1869 "bPreferedVersion=%d bMinVersion=%d " 1870 "bMaxVersion=%d", 1871 UGETDW(probe.dwClockFrequency), 1872 probe.bmFramingInfo, 1873 probe.bPreferedVersion, 1874 probe.bMinVersion, 1875 probe.bMaxVersion)); 1876 } 1877 DPRINTFN(15, ("\n")); 1878 1879 vs->vs_frame_interval = UGETDW(probe.dwFrameInterval); 1880 vs->vs_max_payload_size = UGETDW(probe.dwMaxPayloadTransferSize); 1881 1882 #if 0 1883 uvfmt = uvideo_stream_find_format(vs, probe.bFormatIndex, 1884 probe.bFrameIndex); 1885 if (uvfmt != NULL) { 1886 *format = uvfmt->format; 1887 } else { 1888 DPRINTF(("uvideo_set_format: matching format not found\n")); 1889 *format = *vs->vs_default_format; 1890 } 1891 #else 1892 *format = uvfmt->format; 1893 #endif 1894 1895 DPRINTF(("uvideo_set_format: pixeltype is %d\n", format->pixel_format)); 1896 1897 /* format->sample_size = UGETDW(probe.dwMaxVideoFrameSize); */ 1898 /* format->stride = format->sample_size / format->height; */ 1899 /* format->color.primaries = */ 1900 /* format->color.gamma_function = */ 1901 /* format->color.matrix_coeff = */ 1902 /* format->interlace_flags = */ 1903 1904 vs->vs_current_format = *format; 1905 1906 return 0; 1907 } 1908 1909 static int 1910 uvideo_try_format(void *addr, struct video_format *format) 1911 { 1912 struct uvideo_softc *sc = addr; 1913 struct uvideo_stream *vs = sc->sc_stream_in; 1914 struct uvideo_format *uvfmt; 1915 1916 uvfmt = uvideo_stream_guess_format(vs, format->pixel_format, 1917 format->width, format->height); 1918 if (uvfmt == NULL) 1919 return EINVAL; 1920 1921 *format = uvfmt->format; 1922 return 0; 1923 } 1924 1925 static int 1926 uvideo_start_transfer(void *addr) 1927 { 1928 struct uvideo_softc *sc = addr; 1929 struct uvideo_stream *vs; 1930 int s, err; 1931 1932 /* FIXME: this functions should be stream specific */ 1933 vs = SLIST_FIRST(&sc->sc_stream_list); 1934 s = splusb(); 1935 err = uvideo_stream_start_xfer(vs); 1936 splx(s); 1937 1938 return err; 1939 } 1940 1941 static int 1942 uvideo_stop_transfer(void *addr) 1943 { 1944 struct uvideo_softc *sc; 1945 int err, s; 1946 1947 sc = addr; 1948 1949 s = splusb(); 1950 err = uvideo_stream_stop_xfer(sc->sc_stream_in); 1951 splx(s); 1952 1953 return err; 1954 } 1955 1956 1957 static int 1958 uvideo_get_control_group(void *addr, struct video_control_group *group) 1959 { 1960 struct uvideo_softc *sc; 1961 usb_device_request_t req; 1962 usbd_status err; 1963 uint8_t control_id, ent_id, data[16]; 1964 uint16_t len; 1965 int s; 1966 1967 sc = addr; 1968 1969 /* request setup */ 1970 switch (group->group_id) { 1971 case VIDEO_CONTROL_PANTILT_RELATIVE: 1972 if (group->length != 4) 1973 return EINVAL; 1974 1975 return EINVAL; 1976 case VIDEO_CONTROL_SHARPNESS: 1977 if (group->length != 1) 1978 return EINVAL; 1979 1980 control_id = UVIDEO_PU_SHARPNESS_CONTROL; 1981 ent_id = 2; /* TODO: hardcoded logitech processing unit */ 1982 len = 2; 1983 break; 1984 default: 1985 return EINVAL; 1986 } 1987 1988 /* do request */ 1989 req.bmRequestType = UVIDEO_REQUEST_TYPE_INTERFACE | 1990 UVIDEO_REQUEST_TYPE_CLASS_SPECIFIC | 1991 UVIDEO_REQUEST_TYPE_GET; 1992 req.bRequest = UR_GET_CUR; 1993 USETW(req.wValue, control_id << 8); 1994 USETW(req.wIndex, (ent_id << 8) | sc->sc_ifaceno); 1995 USETW(req.wLength, len); 1996 1997 s = splusb(); 1998 err = usbd_do_request(sc->sc_udev, &req, data); 1999 splx(s); 2000 if (err != USBD_NORMAL_COMPLETION) { 2001 DPRINTF(("uvideo_set_control: error %s (%d)\n", 2002 usbd_errstr(err), err)); 2003 return EIO; /* TODO: more detail here? */ 2004 } 2005 2006 /* extract request data */ 2007 switch (group->group_id) { 2008 case VIDEO_CONTROL_SHARPNESS: 2009 group->control[0].value = UGETW(data); 2010 break; 2011 default: 2012 return EINVAL; 2013 } 2014 2015 return 0; 2016 } 2017 2018 2019 static int 2020 uvideo_set_control_group(void *addr, const struct video_control_group *group) 2021 { 2022 struct uvideo_softc *sc; 2023 usb_device_request_t req; 2024 usbd_status err; 2025 uint8_t control_id, ent_id, data[16]; /* long enough for all controls */ 2026 uint16_t len; 2027 int s; 2028 2029 sc = addr; 2030 2031 switch (group->group_id) { 2032 case VIDEO_CONTROL_PANTILT_RELATIVE: 2033 if (group->length != 4) 2034 return EINVAL; 2035 2036 if (group->control[0].value != 0 || 2037 group->control[0].value != 1 || 2038 group->control[0].value != 0xff) 2039 return ERANGE; 2040 2041 if (group->control[2].value != 0 || 2042 group->control[2].value != 1 || 2043 group->control[2].value != 0xff) 2044 return ERANGE; 2045 2046 control_id = UVIDEO_CT_PANTILT_RELATIVE_CONTROL; 2047 ent_id = 1; /* TODO: hardcoded logitech camera terminal */ 2048 len = 4; 2049 data[0] = group->control[0].value; 2050 data[1] = group->control[1].value; 2051 data[2] = group->control[2].value; 2052 data[3] = group->control[3].value; 2053 break; 2054 case VIDEO_CONTROL_BRIGHTNESS: 2055 if (group->length != 1) 2056 return EINVAL; 2057 control_id = UVIDEO_PU_BRIGHTNESS_CONTROL; 2058 ent_id = 2; 2059 len = 2; 2060 USETW(data, group->control[0].value); 2061 break; 2062 case VIDEO_CONTROL_GAIN: 2063 if (group->length != 1) 2064 return EINVAL; 2065 control_id = UVIDEO_PU_GAIN_CONTROL; 2066 ent_id = 2; 2067 len = 2; 2068 USETW(data, group->control[0].value); 2069 break; 2070 case VIDEO_CONTROL_SHARPNESS: 2071 if (group->length != 1) 2072 return EINVAL; 2073 control_id = UVIDEO_PU_SHARPNESS_CONTROL; 2074 ent_id = 2; /* TODO: hardcoded logitech processing unit */ 2075 len = 2; 2076 USETW(data, group->control[0].value); 2077 break; 2078 default: 2079 return EINVAL; 2080 } 2081 2082 req.bmRequestType = UVIDEO_REQUEST_TYPE_INTERFACE | 2083 UVIDEO_REQUEST_TYPE_CLASS_SPECIFIC | 2084 UVIDEO_REQUEST_TYPE_SET; 2085 req.bRequest = UR_SET_CUR; 2086 USETW(req.wValue, control_id << 8); 2087 USETW(req.wIndex, (ent_id << 8) | sc->sc_ifaceno); 2088 USETW(req.wLength, len); 2089 2090 s = splusb(); 2091 err = usbd_do_request(sc->sc_udev, &req, data); 2092 splx(s); 2093 if (err != USBD_NORMAL_COMPLETION) { 2094 DPRINTF(("uvideo_set_control: error %s (%d)\n", 2095 usbd_errstr(err), err)); 2096 return EIO; /* TODO: more detail here? */ 2097 } 2098 2099 return 0; 2100 } 2101 2102 static usbd_status 2103 uvideo_stream_probe_and_commit(struct uvideo_stream *vs, 2104 uint8_t action, uint8_t control, 2105 void *data) 2106 { 2107 usb_device_request_t req; 2108 2109 switch (action) { 2110 case UR_SET_CUR: 2111 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 2112 USETW(req.wLength, vs->vs_probelen); 2113 break; 2114 case UR_GET_CUR: 2115 case UR_GET_MIN: 2116 case UR_GET_MAX: 2117 case UR_GET_DEF: 2118 req.bmRequestType = UT_READ_CLASS_INTERFACE; 2119 USETW(req.wLength, vs->vs_probelen); 2120 break; 2121 case UR_GET_INFO: 2122 req.bmRequestType = UT_READ_CLASS_INTERFACE; 2123 USETW(req.wLength, sizeof(uByte)); 2124 break; 2125 case UR_GET_LEN: 2126 req.bmRequestType = UT_READ_CLASS_INTERFACE; 2127 USETW(req.wLength, sizeof(uWord)); /* is this right? */ 2128 break; 2129 default: 2130 DPRINTF(("uvideo_probe_and_commit: " 2131 "unknown request action %d\n", action)); 2132 return USBD_NOT_STARTED; 2133 } 2134 2135 req.bRequest = action; 2136 USETW2(req.wValue, control, 0); 2137 USETW2(req.wIndex, 0, vs->vs_ifaceno); 2138 2139 return (usbd_do_request_flags(vs->vs_parent->sc_udev, &req, data, 2140 0, 0, 2141 USBD_DEFAULT_TIMEOUT)); 2142 } 2143 2144 static void 2145 uvideo_init_probe_data(uvideo_probe_and_commit_data_t *probe) 2146 { 2147 /* all zeroes tells camera to choose what it wants */ 2148 memset(probe, 0, sizeof(*probe)); 2149 } 2150 2151 2152 #ifdef _MODULE 2153 2154 MODULE(MODULE_CLASS_DRIVER, uvideo, NULL); 2155 static const struct cfiattrdata videobuscf_iattrdata = { 2156 "videobus", 0, { 2157 { NULL, NULL, 0 }, 2158 } 2159 }; 2160 static const struct cfiattrdata * const uvideo_attrs[] = { 2161 &videobuscf_iattrdata, NULL 2162 }; 2163 CFDRIVER_DECL(uvideo, DV_DULL, uvideo_attrs); 2164 extern struct cfattach uvideo_ca; 2165 extern struct cfattach uvideo_ca; 2166 static int uvideoloc[6] = { -1, -1, -1, -1, -1, -1 }; 2167 static struct cfparent uhubparent = { 2168 "usbifif", NULL, DVUNIT_ANY 2169 }; 2170 static struct cfdata uvideo_cfdata[] = { 2171 { 2172 .cf_name = "uvideo", 2173 .cf_atname = "uvideo", 2174 .cf_unit = 0, 2175 .cf_fstate = FSTATE_STAR, 2176 .cf_loc = uvideoloc, 2177 .cf_flags = 0, 2178 .cf_pspec = &uhubparent, 2179 }, 2180 { NULL } 2181 }; 2182 2183 static int 2184 uvideo_modcmd(modcmd_t cmd, void *arg) 2185 { 2186 int err; 2187 2188 2189 switch (cmd) { 2190 case MODULE_CMD_INIT: 2191 DPRINTF(("uvideo: attempting to load\n")); 2192 2193 err = config_cfdriver_attach(&uvideo_cd); 2194 if (err) 2195 return err; 2196 err = config_cfattach_attach("uvideo", &uvideo_ca); 2197 if (err) { 2198 config_cfdriver_detach(&uvideo_cd); 2199 return err; 2200 } 2201 err = config_cfdata_attach(uvideo_cfdata, 1); 2202 if (err) { 2203 config_cfattach_detach("uvideo", &uvideo_ca); 2204 config_cfdriver_detach(&uvideo_cd); 2205 return err; 2206 } 2207 DPRINTF(("uvideo: loaded module\n")); 2208 return 0; 2209 case MODULE_CMD_FINI: 2210 DPRINTF(("uvideo: attempting to unload module\n")); 2211 err = config_cfdata_detach(uvideo_cfdata); 2212 if (err) 2213 return err; 2214 config_cfattach_detach("uvideo", &uvideo_ca); 2215 config_cfdriver_detach(&uvideo_cd); 2216 DPRINTF(("uvideo: module unload\n")); 2217 return 0; 2218 default: 2219 return ENOTTY; 2220 } 2221 } 2222 2223 #endif /* _MODULE */ 2224 2225 2226 #ifdef UVIDEO_DEBUG 2227 /* Some functions to print out descriptors. Mostly useless other than 2228 * debugging/exploration purposes. */ 2229 2230 2231 static void 2232 print_bitmap(const uByte *start, uByte nbytes) 2233 { 2234 int byte, bit; 2235 2236 /* most significant first */ 2237 for (byte = nbytes-1; byte >= 0; --byte) { 2238 if (byte < nbytes-1) printf("-"); 2239 for (bit = 7; bit >= 0; --bit) 2240 printf("%01d", (start[byte] >> bit) &1); 2241 } 2242 } 2243 2244 static void 2245 print_descriptor(const usb_descriptor_t *desc) 2246 { 2247 static int current_class = -1; 2248 static int current_subclass = -1; 2249 2250 if (desc->bDescriptorType == UDESC_INTERFACE) { 2251 const usb_interface_descriptor_t *id; 2252 id = (const usb_interface_descriptor_t *)desc; 2253 current_class = id->bInterfaceClass; 2254 current_subclass = id->bInterfaceSubClass; 2255 print_interface_descriptor(id); 2256 printf("\n"); 2257 return; 2258 } 2259 2260 printf(" "); /* indent */ 2261 2262 if (current_class == UICLASS_VIDEO) { 2263 switch (current_subclass) { 2264 case UISUBCLASS_VIDEOCONTROL: 2265 print_vc_descriptor(desc); 2266 break; 2267 case UISUBCLASS_VIDEOSTREAMING: 2268 print_vs_descriptor(desc); 2269 break; 2270 case UISUBCLASS_VIDEOCOLLECTION: 2271 printf("uvc collection: len=%d type=0x%02x", 2272 desc->bLength, desc->bDescriptorType); 2273 break; 2274 } 2275 } else { 2276 printf("non uvc descriptor len=%d type=0x%02x", 2277 desc->bLength, desc->bDescriptorType); 2278 } 2279 2280 printf("\n"); 2281 } 2282 2283 static void 2284 print_vc_descriptor(const usb_descriptor_t *desc) 2285 { 2286 const uvideo_descriptor_t *vcdesc; 2287 2288 printf("VC "); 2289 2290 switch (desc->bDescriptorType) { 2291 case UDESC_ENDPOINT: 2292 print_endpoint_descriptor( 2293 (const usb_endpoint_descriptor_t *)desc); 2294 break; 2295 case UDESC_CS_INTERFACE: 2296 vcdesc = (const uvideo_descriptor_t *)desc; 2297 switch (vcdesc->bDescriptorSubtype) { 2298 case UDESC_VC_HEADER: 2299 print_vc_header_descriptor( 2300 (const uvideo_vc_header_descriptor_t *) 2301 vcdesc); 2302 break; 2303 case UDESC_INPUT_TERMINAL: 2304 switch (UGETW( 2305 ((const uvideo_input_terminal_descriptor_t *) 2306 vcdesc)->wTerminalType)) { 2307 case UVIDEO_ITT_CAMERA: 2308 print_camera_terminal_descriptor( 2309 (const uvideo_camera_terminal_descriptor_t *)vcdesc); 2310 break; 2311 default: 2312 print_input_terminal_descriptor( 2313 (const uvideo_input_terminal_descriptor_t *)vcdesc); 2314 break; 2315 } 2316 break; 2317 case UDESC_OUTPUT_TERMINAL: 2318 print_output_terminal_descriptor( 2319 (const uvideo_output_terminal_descriptor_t *) 2320 vcdesc); 2321 break; 2322 case UDESC_SELECTOR_UNIT: 2323 print_selector_unit_descriptor( 2324 (const uvideo_selector_unit_descriptor_t *) 2325 vcdesc); 2326 break; 2327 case UDESC_PROCESSING_UNIT: 2328 print_processing_unit_descriptor( 2329 (const uvideo_processing_unit_descriptor_t *) 2330 vcdesc); 2331 break; 2332 case UDESC_EXTENSION_UNIT: 2333 print_extension_unit_descriptor( 2334 (const uvideo_extension_unit_descriptor_t *) 2335 vcdesc); 2336 break; 2337 default: 2338 printf("class specific interface " 2339 "len=%d type=0x%02x subtype=0x%02x", 2340 vcdesc->bLength, 2341 vcdesc->bDescriptorType, 2342 vcdesc->bDescriptorSubtype); 2343 break; 2344 } 2345 break; 2346 case UDESC_CS_ENDPOINT: 2347 vcdesc = (const uvideo_descriptor_t *)desc; 2348 switch (vcdesc->bDescriptorSubtype) { 2349 case UDESC_VC_INTERRUPT_ENDPOINT: 2350 print_interrupt_endpoint_descriptor( 2351 (const uvideo_vc_interrupt_endpoint_descriptor_t *) 2352 vcdesc); 2353 break; 2354 default: 2355 printf("class specific endpoint " 2356 "len=%d type=0x%02x subtype=0x%02x", 2357 vcdesc->bLength, 2358 vcdesc->bDescriptorType, 2359 vcdesc->bDescriptorSubtype); 2360 break; 2361 } 2362 break; 2363 default: 2364 printf("unknown: len=%d type=0x%02x", 2365 desc->bLength, desc->bDescriptorType); 2366 break; 2367 } 2368 } 2369 2370 static void 2371 print_vs_descriptor(const usb_descriptor_t *desc) 2372 { 2373 const uvideo_descriptor_t * vsdesc; 2374 printf("VS "); 2375 2376 switch (desc->bDescriptorType) { 2377 case UDESC_ENDPOINT: 2378 print_endpoint_descriptor( 2379 (const usb_endpoint_descriptor_t *)desc); 2380 break; 2381 case UDESC_CS_INTERFACE: 2382 vsdesc = (const uvideo_descriptor_t *)desc; 2383 switch (vsdesc->bDescriptorSubtype) { 2384 case UDESC_VS_INPUT_HEADER: 2385 print_vs_input_header_descriptor( 2386 (const uvideo_vs_input_header_descriptor_t *) 2387 vsdesc); 2388 break; 2389 case UDESC_VS_OUTPUT_HEADER: 2390 print_vs_output_header_descriptor( 2391 (const uvideo_vs_output_header_descriptor_t *) 2392 vsdesc); 2393 break; 2394 case UDESC_VS_FORMAT_UNCOMPRESSED: 2395 print_vs_format_uncompressed_descriptor( 2396 (const uvideo_vs_format_uncompressed_descriptor_t *) 2397 vsdesc); 2398 break; 2399 case UDESC_VS_FRAME_UNCOMPRESSED: 2400 print_vs_frame_uncompressed_descriptor( 2401 (const uvideo_vs_frame_uncompressed_descriptor_t *) 2402 vsdesc); 2403 break; 2404 case UDESC_VS_FORMAT_MJPEG: 2405 print_vs_format_mjpeg_descriptor( 2406 (const uvideo_vs_format_mjpeg_descriptor_t *) 2407 vsdesc); 2408 break; 2409 case UDESC_VS_FRAME_MJPEG: 2410 print_vs_frame_mjpeg_descriptor( 2411 (const uvideo_vs_frame_mjpeg_descriptor_t *) 2412 vsdesc); 2413 break; 2414 case UDESC_VS_FORMAT_DV: 2415 print_vs_format_dv_descriptor( 2416 (const uvideo_vs_format_dv_descriptor_t *) 2417 vsdesc); 2418 break; 2419 default: 2420 printf("unknown cs interface: len=%d type=0x%02x " 2421 "subtype=0x%02x", 2422 vsdesc->bLength, vsdesc->bDescriptorType, 2423 vsdesc->bDescriptorSubtype); 2424 } 2425 break; 2426 default: 2427 printf("unknown: len=%d type=0x%02x", 2428 desc->bLength, desc->bDescriptorType); 2429 break; 2430 } 2431 } 2432 2433 static void 2434 print_interface_descriptor(const usb_interface_descriptor_t *id) 2435 { 2436 printf("Interface: Len=%d Type=0x%02x " 2437 "bInterfaceNumber=0x%02x " 2438 "bAlternateSetting=0x%02x bNumEndpoints=0x%02x " 2439 "bInterfaceClass=0x%02x bInterfaceSubClass=0x%02x " 2440 "bInterfaceProtocol=0x%02x iInterface=0x%02x", 2441 id->bLength, 2442 id->bDescriptorType, 2443 id->bInterfaceNumber, 2444 id->bAlternateSetting, 2445 id->bNumEndpoints, 2446 id->bInterfaceClass, 2447 id->bInterfaceSubClass, 2448 id->bInterfaceProtocol, 2449 id->iInterface); 2450 } 2451 2452 static void 2453 print_endpoint_descriptor(const usb_endpoint_descriptor_t *desc) 2454 { 2455 printf("Endpoint: Len=%d Type=0x%02x " 2456 "bEndpointAddress=0x%02x ", 2457 desc->bLength, 2458 desc->bDescriptorType, 2459 desc->bEndpointAddress); 2460 printf("bmAttributes="); 2461 print_bitmap(&desc->bmAttributes, 1); 2462 printf(" wMaxPacketSize=%d bInterval=%d", 2463 UGETW(desc->wMaxPacketSize), 2464 desc->bInterval); 2465 } 2466 2467 static void 2468 print_vc_header_descriptor( 2469 const uvideo_vc_header_descriptor_t *desc) 2470 { 2471 printf("Interface Header: " 2472 "Len=%d Type=0x%02x Subtype=0x%02x " 2473 "bcdUVC=%d wTotalLength=%d " 2474 "dwClockFrequency=%d bInCollection=%d", 2475 desc->bLength, 2476 desc->bDescriptorType, 2477 desc->bDescriptorSubtype, 2478 UGETW(desc->bcdUVC), 2479 UGETW(desc->wTotalLength), 2480 UGETDW(desc->dwClockFrequency), 2481 desc->bInCollection); 2482 } 2483 2484 static void 2485 print_input_terminal_descriptor( 2486 const uvideo_input_terminal_descriptor_t *desc) 2487 { 2488 printf("Input Terminal: " 2489 "Len=%d Type=0x%02x Subtype=0x%02x " 2490 "bTerminalID=%d wTerminalType=%x bAssocTerminal=%d " 2491 "iTerminal=%d", 2492 desc->bLength, 2493 desc->bDescriptorType, 2494 desc->bDescriptorSubtype, 2495 desc->bTerminalID, 2496 UGETW(desc->wTerminalType), 2497 desc->bAssocTerminal, 2498 desc->iTerminal); 2499 } 2500 2501 static void 2502 print_output_terminal_descriptor( 2503 const uvideo_output_terminal_descriptor_t *desc) 2504 { 2505 printf("Output Terminal: " 2506 "Len=%d Type=0x%02x Subtype=0x%02x " 2507 "bTerminalID=%d wTerminalType=%x bAssocTerminal=%d " 2508 "bSourceID=%d iTerminal=%d", 2509 desc->bLength, 2510 desc->bDescriptorType, 2511 desc->bDescriptorSubtype, 2512 desc->bTerminalID, 2513 UGETW(desc->wTerminalType), 2514 desc->bAssocTerminal, 2515 desc->bSourceID, 2516 desc->iTerminal); 2517 } 2518 2519 static void 2520 print_camera_terminal_descriptor( 2521 const uvideo_camera_terminal_descriptor_t *desc) 2522 { 2523 printf("Camera Terminal: " 2524 "Len=%d Type=0x%02x Subtype=0x%02x " 2525 "bTerminalID=%d wTerminalType=%x bAssocTerminal=%d " 2526 "iTerminal=%d " 2527 "wObjectiveFocalLengthMin/Max=%d/%d " 2528 "wOcularFocalLength=%d " 2529 "bControlSize=%d ", 2530 desc->bLength, 2531 desc->bDescriptorType, 2532 desc->bDescriptorSubtype, 2533 desc->bTerminalID, 2534 UGETW(desc->wTerminalType), 2535 desc->bAssocTerminal, 2536 desc->iTerminal, 2537 UGETW(desc->wObjectiveFocalLengthMin), 2538 UGETW(desc->wObjectiveFocalLengthMax), 2539 UGETW(desc->wOcularFocalLength), 2540 desc->bControlSize); 2541 printf("bmControls="); 2542 print_bitmap(desc->bmControls, desc->bControlSize); 2543 } 2544 2545 static void 2546 print_selector_unit_descriptor( 2547 const uvideo_selector_unit_descriptor_t *desc) 2548 { 2549 int i; 2550 const uByte *b; 2551 printf("Selector Unit: " 2552 "Len=%d Type=0x%02x Subtype=0x%02x " 2553 "bUnitID=%d bNrInPins=%d ", 2554 desc->bLength, 2555 desc->bDescriptorType, 2556 desc->bDescriptorSubtype, 2557 desc->bUnitID, 2558 desc->bNrInPins); 2559 printf("baSourceIDs="); 2560 b = &desc->baSourceID[0]; 2561 for (i = 0; i < desc->bNrInPins; ++i) 2562 printf("%d ", *b++); 2563 printf("iSelector=%d", *b); 2564 } 2565 2566 static void 2567 print_processing_unit_descriptor( 2568 const uvideo_processing_unit_descriptor_t *desc) 2569 { 2570 const uByte *b; 2571 2572 printf("Processing Unit: " 2573 "Len=%d Type=0x%02x Subtype=0x%02x " 2574 "bUnitID=%d bSourceID=%d wMaxMultiplier=%d bControlSize=%d ", 2575 desc->bLength, 2576 desc->bDescriptorType, 2577 desc->bDescriptorSubtype, 2578 desc->bUnitID, 2579 desc->bSourceID, 2580 UGETW(desc->wMaxMultiplier), 2581 desc->bControlSize); 2582 printf("bmControls="); 2583 print_bitmap(desc->bmControls, desc->bControlSize); 2584 b = &desc->bControlSize + desc->bControlSize + 1; 2585 printf(" iProcessing=%d bmVideoStandards=", *b); 2586 b += 1; 2587 print_bitmap(b, 1); 2588 } 2589 2590 static void 2591 print_extension_unit_descriptor( 2592 const uvideo_extension_unit_descriptor_t *desc) 2593 { 2594 const uByte * byte; 2595 uByte controlbytes; 2596 int i; 2597 2598 printf("Extension Unit: " 2599 "Len=%d Type=0x%02x Subtype=0x%02x " 2600 "bUnitID=%d ", 2601 desc->bLength, 2602 desc->bDescriptorType, 2603 desc->bDescriptorSubtype, 2604 desc->bUnitID); 2605 2606 printf("guidExtensionCode="); 2607 usb_guid_print(&desc->guidExtensionCode); 2608 printf(" "); 2609 2610 printf("bNumControls=%d bNrInPins=%d ", 2611 desc->bNumControls, 2612 desc->bNrInPins); 2613 2614 printf("baSourceIDs="); 2615 byte = &desc->baSourceID[0]; 2616 for (i = 0; i < desc->bNrInPins; ++i) 2617 printf("%d ", *byte++); 2618 2619 controlbytes = *byte++; 2620 printf("bControlSize=%d ", controlbytes); 2621 printf("bmControls="); 2622 print_bitmap(byte, controlbytes); 2623 2624 byte += controlbytes; 2625 printf(" iExtension=%d", *byte); 2626 } 2627 2628 static void 2629 print_interrupt_endpoint_descriptor( 2630 const uvideo_vc_interrupt_endpoint_descriptor_t *desc) 2631 { 2632 printf("Interrupt Endpoint: " 2633 "Len=%d Type=0x%02x Subtype=0x%02x " 2634 "wMaxTransferSize=%d ", 2635 desc->bLength, 2636 desc->bDescriptorType, 2637 desc->bDescriptorSubtype, 2638 UGETW(desc->wMaxTransferSize)); 2639 } 2640 2641 2642 static void 2643 print_vs_output_header_descriptor( 2644 const uvideo_vs_output_header_descriptor_t *desc) 2645 { 2646 printf("Interface Output Header: " 2647 "Len=%d Type=0x%02x Subtype=0x%02x " 2648 "bNumFormats=%d wTotalLength=%d bEndpointAddress=%d " 2649 "bTerminalLink=%d bControlSize=%d", 2650 desc->bLength, 2651 desc->bDescriptorType, 2652 desc->bDescriptorSubtype, 2653 desc->bNumFormats, 2654 UGETW(desc->wTotalLength), 2655 desc->bEndpointAddress, 2656 desc->bTerminalLink, 2657 desc->bControlSize); 2658 } 2659 2660 static void 2661 print_vs_input_header_descriptor( 2662 const uvideo_vs_input_header_descriptor_t *desc) 2663 { 2664 printf("Interface Input Header: " 2665 "Len=%d Type=0x%02x Subtype=0x%02x " 2666 "bNumFormats=%d wTotalLength=%d bEndpointAddress=%d " 2667 "bmInfo=%x bTerminalLink=%d bStillCaptureMethod=%d " 2668 "bTriggerSupport=%d bTriggerUsage=%d bControlSize=%d ", 2669 desc->bLength, 2670 desc->bDescriptorType, 2671 desc->bDescriptorSubtype, 2672 desc->bNumFormats, 2673 UGETW(desc->wTotalLength), 2674 desc->bEndpointAddress, 2675 desc->bmInfo, 2676 desc->bTerminalLink, 2677 desc->bStillCaptureMethod, 2678 desc->bTriggerSupport, 2679 desc->bTriggerUsage, 2680 desc->bControlSize); 2681 print_bitmap(desc->bmaControls, desc->bControlSize); 2682 } 2683 2684 static void 2685 print_vs_format_uncompressed_descriptor( 2686 const uvideo_vs_format_uncompressed_descriptor_t *desc) 2687 { 2688 printf("Format Uncompressed: " 2689 "Len=%d Type=0x%02x Subtype=0x%02x " 2690 "bFormatIndex=%d bNumFrameDescriptors=%d ", 2691 desc->bLength, 2692 desc->bDescriptorType, 2693 desc->bDescriptorSubtype, 2694 desc->bFormatIndex, 2695 desc->bNumFrameDescriptors); 2696 usb_guid_print(&desc->guidFormat); 2697 printf(" bBitsPerPixel=%d bDefaultFrameIndex=%d " 2698 "bAspectRatioX=%d bAspectRatioY=%d " 2699 "bmInterlaceFlags=0x%02x bCopyProtect=%d", 2700 desc->bBitsPerPixel, 2701 desc->bDefaultFrameIndex, 2702 desc->bAspectRatioX, 2703 desc->bAspectRatioY, 2704 desc->bmInterlaceFlags, 2705 desc->bCopyProtect); 2706 } 2707 2708 static void 2709 print_vs_frame_uncompressed_descriptor( 2710 const uvideo_vs_frame_uncompressed_descriptor_t *desc) 2711 { 2712 printf("Frame Uncompressed: " 2713 "Len=%d Type=0x%02x Subtype=0x%02x " 2714 "bFrameIndex=%d bmCapabilities=0x%02x " 2715 "wWidth=%d wHeight=%d dwMinBitRate=%d dwMaxBitRate=%d " 2716 "dwMaxVideoFrameBufferSize=%d dwDefaultFrameInterval=%d " 2717 "bFrameIntervalType=%d", 2718 desc->bLength, 2719 desc->bDescriptorType, 2720 desc->bDescriptorSubtype, 2721 desc->bFrameIndex, 2722 desc->bmCapabilities, 2723 UGETW(desc->wWidth), 2724 UGETW(desc->wHeight), 2725 UGETDW(desc->dwMinBitRate), 2726 UGETDW(desc->dwMaxBitRate), 2727 UGETDW(desc->dwMaxVideoFrameBufferSize), 2728 UGETDW(desc->dwDefaultFrameInterval), 2729 desc->bFrameIntervalType); 2730 } 2731 2732 static void 2733 print_vs_format_mjpeg_descriptor( 2734 const uvideo_vs_format_mjpeg_descriptor_t *desc) 2735 { 2736 printf("MJPEG format: " 2737 "Len=%d Type=0x%02x Subtype=0x%02x " 2738 "bFormatIndex=%d bNumFrameDescriptors=%d bmFlags=0x%02x " 2739 "bDefaultFrameIndex=%d bAspectRatioX=%d bAspectRatioY=%d " 2740 "bmInterlaceFlags=0x%02x bCopyProtect=%d", 2741 desc->bLength, 2742 desc->bDescriptorType, 2743 desc->bDescriptorSubtype, 2744 desc->bFormatIndex, 2745 desc->bNumFrameDescriptors, 2746 desc->bmFlags, 2747 desc->bDefaultFrameIndex, 2748 desc->bAspectRatioX, 2749 desc->bAspectRatioY, 2750 desc->bmInterlaceFlags, 2751 desc->bCopyProtect); 2752 } 2753 2754 static void 2755 print_vs_frame_mjpeg_descriptor( 2756 const uvideo_vs_frame_mjpeg_descriptor_t *desc) 2757 { 2758 printf("MJPEG frame: " 2759 "Len=%d Type=0x%02x Subtype=0x%02x " 2760 "bFrameIndex=%d bmCapabilities=0x%02x " 2761 "wWidth=%d wHeight=%d dwMinBitRate=%d dwMaxBitRate=%d " 2762 "dwMaxVideoFrameBufferSize=%d dwDefaultFrameInterval=%d " 2763 "bFrameIntervalType=%d", 2764 desc->bLength, 2765 desc->bDescriptorType, 2766 desc->bDescriptorSubtype, 2767 desc->bFrameIndex, 2768 desc->bmCapabilities, 2769 UGETW(desc->wWidth), 2770 UGETW(desc->wHeight), 2771 UGETDW(desc->dwMinBitRate), 2772 UGETDW(desc->dwMaxBitRate), 2773 UGETDW(desc->dwMaxVideoFrameBufferSize), 2774 UGETDW(desc->dwDefaultFrameInterval), 2775 desc->bFrameIntervalType); 2776 } 2777 2778 static void 2779 print_vs_format_dv_descriptor( 2780 const uvideo_vs_format_dv_descriptor_t *desc) 2781 { 2782 printf("MJPEG format: " 2783 "Len=%d Type=0x%02x Subtype=0x%02x " 2784 "bFormatIndex=%d dwMaxVideoFrameBufferSize=%d " 2785 "bFormatType/Rate=%d bFormatType/Format=%d", 2786 desc->bLength, 2787 desc->bDescriptorType, 2788 desc->bDescriptorSubtype, 2789 desc->bFormatIndex, 2790 UGETDW(desc->dwMaxVideoFrameBufferSize), 2791 UVIDEO_GET_DV_FREQ(desc->bFormatType), 2792 UVIDEO_GET_DV_FORMAT(desc->bFormatType)); 2793 } 2794 2795 #endif /* !UVIDEO_DEBUG */ 2796 2797 static const usb_descriptor_t * 2798 usb_desc_iter_peek_next(usbd_desc_iter_t *iter) 2799 { 2800 const usb_descriptor_t *desc; 2801 2802 if (iter->cur + sizeof(usb_descriptor_t) >= iter->end) { 2803 if (iter->cur != iter->end) 2804 printf("usb_desc_iter_peek_next: bad descriptor\n"); 2805 return NULL; 2806 } 2807 desc = (const usb_descriptor_t *)iter->cur; 2808 if (desc->bLength == 0) { 2809 printf("usb_desc_iter_peek_next: descriptor length = 0\n"); 2810 return NULL; 2811 } 2812 if (iter->cur + desc->bLength > iter->end) { 2813 printf("usb_desc_iter_peek_next: descriptor length too large\n"); 2814 return NULL; 2815 } 2816 return desc; 2817 } 2818 2819 /* Return the next interface descriptor, skipping over any other 2820 * descriptors. Returns NULL at the end or on error. */ 2821 static const usb_interface_descriptor_t * 2822 usb_desc_iter_next_interface(usbd_desc_iter_t *iter) 2823 { 2824 const usb_descriptor_t *desc; 2825 2826 while ((desc = usb_desc_iter_peek_next(iter)) != NULL && 2827 desc->bDescriptorType != UDESC_INTERFACE) 2828 { 2829 usb_desc_iter_next(iter); 2830 } 2831 2832 return (const usb_interface_descriptor_t *)usb_desc_iter_next(iter); 2833 } 2834 2835 /* Returns the next non-interface descriptor, returning NULL when the 2836 * next descriptor would be an interface descriptor. */ 2837 static const usb_descriptor_t * 2838 usb_desc_iter_next_non_interface(usbd_desc_iter_t *iter) 2839 { 2840 const usb_descriptor_t *desc; 2841 2842 if ((desc = usb_desc_iter_peek_next(iter)) != NULL && 2843 desc->bDescriptorType != UDESC_INTERFACE) 2844 { 2845 return (usb_desc_iter_next(iter)); 2846 } else { 2847 return NULL; 2848 } 2849 } 2850 2851 #ifdef UVIDEO_DEBUG 2852 static void 2853 usb_guid_print(const usb_guid_t *guid) 2854 { 2855 printf("%04X-%02X-%02X-", 2856 UGETDW(guid->data1), 2857 UGETW(guid->data2), 2858 UGETW(guid->data3)); 2859 printf("%02X%02X-", 2860 guid->data4[0], 2861 guid->data4[1]); 2862 printf("%02X%02X%02X%02X%02X%02X", 2863 guid->data4[2], 2864 guid->data4[3], 2865 guid->data4[4], 2866 guid->data4[5], 2867 guid->data4[6], 2868 guid->data4[7]); 2869 } 2870 #endif /* !UVIDEO_DEBUG */ 2871 2872 /* Returns less than zero, zero, or greater than zero if uguid is less 2873 * than, equal to, or greater than guid. */ 2874 static int 2875 usb_guid_cmp(const usb_guid_t *uguid, const guid_t *guid) 2876 { 2877 if (guid->data1 > UGETDW(uguid->data1)) 2878 return 1; 2879 else if (guid->data1 < UGETDW(uguid->data1)) 2880 return -1; 2881 2882 if (guid->data2 > UGETW(uguid->data2)) 2883 return 1; 2884 else if (guid->data2 < UGETW(uguid->data2)) 2885 return -1; 2886 2887 if (guid->data3 > UGETW(uguid->data3)) 2888 return 1; 2889 else if (guid->data3 < UGETW(uguid->data3)) 2890 return -1; 2891 2892 return (memcmp(guid->data4, uguid->data4, 8)); 2893 } 2894
Indexes created Wed Oct 22 13:09:56 GMT 2025