uvideo.c revision 1.14
1 /* $NetBSD: uvideo.c,v 1.14 2008/09/20 15:55:38 jmcneill 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.14 2008/09/20 15:55:38 jmcneill 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 if (uvdesc->bDescriptorSubtype < UDESC_INPUT_TERMINAL || 773 uvdesc->bDescriptorSubtype > UDESC_EXTENSION_UNIT) 774 ++nunits; 775 } 776 777 if (nunits == 0) { 778 DPRINTF(("uvideo_init_control: no units\n")); 779 return USBD_NORMAL_COMPLETION; 780 } 781 782 /* allocate space for units */ 783 sc->sc_nunits = nunits; 784 sc->sc_unit = kmem_alloc(sizeof(*sc->sc_unit) * nunits, KM_SLEEP); 785 if (sc->sc_unit == NULL) 786 goto enomem; 787 788 /* restore original iterator state */ 789 memcpy(iter, &orig, sizeof(orig)); 790 791 /* iterate again, initializing the units */ 792 i = 0; 793 while ((desc = usb_desc_iter_next_non_interface(iter)) != NULL) { 794 uvdesc = (const uvideo_descriptor_t *)desc; 795 796 if (uvdesc->bDescriptorType != UDESC_CS_INTERFACE) 797 continue; 798 if (uvdesc->bDescriptorSubtype < UDESC_INPUT_TERMINAL || 799 uvdesc->bDescriptorSubtype > UDESC_EXTENSION_UNIT) 800 continue; 801 802 sc->sc_unit[i] = uvideo_unit_alloc(uvdesc); 803 /* TODO: free other units before returning? */ 804 if (sc->sc_unit[i] == NULL) 805 goto enomem; 806 ++i; 807 } 808 809 return USBD_NORMAL_COMPLETION; 810 811 enomem: 812 if (sc->sc_unit != NULL) { 813 for (j = 0; j < i; ++j) { 814 uvideo_unit_free(sc->sc_unit[j]); 815 sc->sc_unit[j] = NULL; 816 } 817 kmem_free(sc->sc_unit, sizeof(*sc->sc_unit) * nunits); 818 sc->sc_unit = NULL; 819 } 820 sc->sc_nunits = 0; 821 822 return USBD_NOMEM; 823 } 824 825 static usbd_status 826 uvideo_init_collection(struct uvideo_softc *sc, 827 const usb_interface_descriptor_t *ifdesc, 828 usbd_desc_iter_t *iter) 829 { 830 DPRINTF(("uvideo: ignoring Video Collection\n")); 831 return USBD_NORMAL_COMPLETION; 832 } 833 834 /* Allocates space for and initializes a uvideo unit based on the 835 * given descriptor. Returns NULL with bad descriptor or ENOMEM. */ 836 static struct uvideo_unit * 837 uvideo_unit_alloc(const uvideo_descriptor_t *desc) 838 { 839 struct uvideo_unit *vu; 840 usbd_status err; 841 842 if (desc->bDescriptorType != UDESC_CS_INTERFACE) 843 return NULL; 844 845 vu = kmem_alloc(sizeof(*vu), KM_SLEEP); 846 if (vu == NULL) 847 return NULL; 848 849 err = uvideo_unit_init(vu, desc); 850 if (err != USBD_NORMAL_COMPLETION) { 851 DPRINTF(("uvideo_unit_alloc: error initializing unit: " 852 "%s (%d)\n", usbd_errstr(err), err)); 853 kmem_free(vu, sizeof(*vu)); 854 return NULL; 855 } 856 857 return vu; 858 } 859 860 static usbd_status 861 uvideo_unit_init(struct uvideo_unit *vu, const uvideo_descriptor_t *desc) 862 { 863 struct uvideo_camera_terminal *ct; 864 struct uvideo_processing_unit *pu; 865 struct uvideo_extension_unit *xu; 866 867 const uvideo_input_terminal_descriptor_t *input; 868 const uvideo_output_terminal_descriptor_t *output; 869 const uvideo_camera_terminal_descriptor_t *camera; 870 const uvideo_selector_unit_descriptor_t *selector; 871 const uvideo_processing_unit_descriptor_t *processing; 872 const uvideo_extension_unit_descriptor_t *extension; 873 874 memset(vu, 0, sizeof(*vu)); 875 876 switch (desc->bDescriptorSubtype) { 877 case UDESC_INPUT_TERMINAL: 878 input = (const uvideo_input_terminal_descriptor_t *)desc; 879 switch (UGETW(input->wTerminalType)) { 880 case UVIDEO_ITT_CAMERA: 881 camera = 882 (const uvideo_camera_terminal_descriptor_t *)desc; 883 ct = &vu->u.vu_camera; 884 885 ct->ct_objective_focal_min = 886 UGETW(camera->wObjectiveFocalLengthMin); 887 ct->ct_objective_focal_max = 888 UGETW(camera->wObjectiveFocalLengthMax); 889 ct->ct_ocular_focal_length = 890 UGETW(camera->wOcularFocalLength); 891 892 uvideo_unit_alloc_controls(vu, camera->bControlSize, 893 camera->bmControls); 894 break; 895 default: 896 DPRINTF(("uvideo_unit_init: " 897 "unknown input terminal type 0x%04x\n", 898 UGETW(input->wTerminalType))); 899 return USBD_INVAL; 900 } 901 break; 902 case UDESC_OUTPUT_TERMINAL: 903 output = (const uvideo_output_terminal_descriptor_t *)desc; 904 break; 905 case UDESC_SELECTOR_UNIT: 906 selector = (const uvideo_selector_unit_descriptor_t *)desc; 907 908 uvideo_unit_alloc_sources(vu, selector->bNrInPins, 909 selector->baSourceID); 910 break; 911 case UDESC_PROCESSING_UNIT: 912 processing = (const uvideo_processing_unit_descriptor_t *)desc; 913 pu = &vu->u.vu_processing; 914 915 pu->pu_video_standards = PU_GET_VIDEO_STANDARDS(processing); 916 pu->pu_max_multiplier = UGETW(processing->wMaxMultiplier); 917 918 uvideo_unit_alloc_sources(vu, 1, &processing->bSourceID); 919 uvideo_unit_alloc_controls(vu, processing->bControlSize, 920 processing->bmControls); 921 break; 922 case UDESC_EXTENSION_UNIT: 923 extension = (const uvideo_extension_unit_descriptor_t *)desc; 924 xu = &vu->u.vu_extension; 925 /* TODO: copy guid */ 926 927 uvideo_unit_alloc_sources(vu, extension->bNrInPins, 928 extension->baSourceID); 929 uvideo_unit_alloc_controls(vu, XU_GET_CONTROL_SIZE(extension), 930 XU_GET_CONTROLS(extension)); 931 break; 932 default: 933 DPRINTF(("uvideo_unit_alloc: unknown descriptor " 934 "type=0x%02x subtype=0x%02x\n", 935 desc->bDescriptorType, desc->bDescriptorSubtype)); 936 return USBD_INVAL; 937 } 938 939 return USBD_NORMAL_COMPLETION; 940 } 941 942 static void 943 uvideo_unit_free(struct uvideo_unit *vu) 944 { 945 uvideo_unit_free_sources(vu); 946 uvideo_unit_free_controls(vu); 947 kmem_free(vu, sizeof(*vu)); 948 } 949 950 static usbd_status 951 uvideo_unit_alloc_sources(struct uvideo_unit *vu, 952 uint8_t nsrcs, const uint8_t *src_ids) 953 { 954 vu->vu_nsrcs = nsrcs; 955 956 if (nsrcs == 0) { 957 /* do nothing */ 958 } else if (nsrcs == 1) { 959 vu->s.vu_src_id = src_ids[0]; 960 } else { 961 vu->s.vu_src_id_ary = 962 kmem_alloc(sizeof(*vu->s.vu_src_id_ary) * nsrcs, KM_SLEEP); 963 if (vu->s.vu_src_id_ary == NULL) { 964 vu->vu_nsrcs = 0; 965 return USBD_NOMEM; 966 } 967 968 memcpy(vu->s.vu_src_id_ary, src_ids, nsrcs); 969 } 970 971 return USBD_NORMAL_COMPLETION; 972 } 973 974 static void 975 uvideo_unit_free_sources(struct uvideo_unit *vu) 976 { 977 if (vu->vu_nsrcs == 1) 978 return; 979 980 kmem_free(vu->s.vu_src_id_ary, 981 sizeof(*vu->s.vu_src_id_ary) * vu->vu_nsrcs); 982 vu->vu_nsrcs = 0; 983 vu->s.vu_src_id_ary = NULL; 984 } 985 986 static usbd_status 987 uvideo_unit_alloc_controls(struct uvideo_unit *vu, uint8_t size, 988 const uint8_t *controls) 989 { 990 vu->vu_controls = kmem_alloc(sizeof(*vu->vu_controls) * size, KM_SLEEP); 991 if (vu->vu_controls == NULL) 992 return USBD_NOMEM; 993 994 vu->vu_control_size = size; 995 memcpy(vu->vu_controls, controls, size); 996 997 return USBD_NORMAL_COMPLETION; 998 } 999 1000 static void 1001 uvideo_unit_free_controls(struct uvideo_unit *vu) 1002 { 1003 kmem_free(vu->vu_controls, 1004 sizeof(*vu->vu_controls) * vu->vu_control_size); 1005 vu->vu_controls = NULL; 1006 vu->vu_control_size = 0; 1007 } 1008 1009 1010 /* Initialize a stream from a Video Streaming interface 1011 * descriptor. Adds the stream to the stream_list in uvideo_softc. 1012 * This should be called once for new streams, and 1013 * uvideo_stream_init_desc() should then be called for this and each 1014 * additional interface with the same interface number. */ 1015 static usbd_status 1016 uvideo_stream_init(struct uvideo_stream *vs, 1017 struct uvideo_softc *sc, 1018 const usb_interface_descriptor_t *ifdesc, 1019 uint8_t idx) 1020 { 1021 uWord len; 1022 usbd_status err; 1023 1024 SLIST_INSERT_HEAD(&sc->sc_stream_list, vs, entries); 1025 memset(vs, 0, sizeof(*vs)); 1026 vs->vs_parent = sc; 1027 vs->vs_ifaceno = ifdesc->bInterfaceNumber; 1028 vs->vs_subtype = 0; 1029 SIMPLEQ_INIT(&vs->vs_formats); 1030 SIMPLEQ_INIT(&vs->vs_pixel_formats); 1031 vs->vs_default_format = NULL; 1032 vs->vs_current_format.priv = -1; 1033 vs->vs_xfer_type = 0; 1034 1035 err = usbd_device2interface_handle(sc->sc_udev, idx, &vs->vs_iface); 1036 if (err != USBD_NORMAL_COMPLETION) { 1037 DPRINTF(("uvideo_stream_init: " 1038 "error getting vs interface: " 1039 "%s (%d)\n", 1040 usbd_errstr(err), err)); 1041 return err; 1042 } 1043 1044 /* For Xbox Live Vision camera, linux-uvc folk say we need to 1045 * set an alternate interface and wait ~3 seconds prior to 1046 * doing the format probe/commit. We set to alternate 1047 * interface 0, which is the default, zero bandwidth 1048 * interface. This should not have adverse affects on other 1049 * cameras. Errors are ignored. */ 1050 err = usbd_set_interface(vs->vs_iface, 0); 1051 if (err != USBD_NORMAL_COMPLETION) { 1052 DPRINTF(("uvideo_stream_init: error setting alt interface: " 1053 "%s (%d)\n", 1054 usbd_errstr(err), err)); 1055 } 1056 1057 /* Initialize probe and commit data size. This value is 1058 * dependent on the version of the spec the hardware 1059 * implements. */ 1060 err = uvideo_stream_probe(vs, UR_GET_LEN, len); 1061 if (err != USBD_NORMAL_COMPLETION) { 1062 DPRINTF(("uvideo_stream_init: " 1063 "error getting probe data len: " 1064 "%s (%d)\n", 1065 usbd_errstr(err), err)); 1066 vs->vs_probelen = 26; /* conservative v1.0 length */ 1067 } else { 1068 DPRINTFN(15,("uvideo_stream_init: probelen=%d\n", UGETW(len))); 1069 vs->vs_probelen = UGETW(len); 1070 } 1071 1072 return USBD_NORMAL_COMPLETION; 1073 } 1074 1075 /* Further stream initialization based on a Video Streaming interface 1076 * descriptor and following descriptors belonging to that interface. 1077 * Iterates through all descriptors belonging to this particular 1078 * interface descriptor, modifying the iterator. This may be called 1079 * multiple times because there may be several alternate interfaces 1080 * associated with the same interface number. */ 1081 static usbd_status 1082 uvideo_stream_init_desc(struct uvideo_stream *vs, 1083 const usb_interface_descriptor_t *ifdesc, 1084 usbd_desc_iter_t *iter) 1085 { 1086 const usb_descriptor_t *desc; 1087 const uvideo_descriptor_t *uvdesc; 1088 struct uvideo_bulk_xfer *bx; 1089 struct uvideo_isoc_xfer *ix; 1090 struct uvideo_alternate *alt; 1091 uint8_t xfer_type; 1092 int i; 1093 1094 /* Iterate until the next interface descriptor. All 1095 * descriptors until then belong to this streaming 1096 * interface. */ 1097 while ((desc = usb_desc_iter_next_non_interface(iter)) != NULL) { 1098 uvdesc = (const uvideo_descriptor_t *)desc; 1099 1100 switch (uvdesc->bDescriptorType) { 1101 case UDESC_ENDPOINT: 1102 xfer_type = UE_GET_XFERTYPE(GET(usb_endpoint_descriptor_t, 1103 desc, bmAttributes)); 1104 if (xfer_type == UE_BULK) { 1105 bx = &vs->vs_xfer.bulk; 1106 if (vs->vs_xfer_type == 0) { 1107 DPRINTFN(15, ("uvideo_attach: " 1108 "BULK stream *\n")); 1109 vs->vs_xfer_type = UE_BULK; 1110 bx->bx_endpt = 1111 GET(usb_endpoint_descriptor_t, 1112 desc, bEndpointAddress); 1113 } 1114 } else if (xfer_type == UE_ISOCHRONOUS) { 1115 ix = &vs->vs_xfer.isoc; 1116 for (i = 0; i < UVIDEO_NXFERS; i++) { 1117 ix->ix_i[i].i_ix = ix; 1118 ix->ix_i[i].i_vs = vs; 1119 } 1120 if (vs->vs_xfer_type == 0) { 1121 DPRINTFN(15, ("uvideo_attach: " 1122 "ISOC stream *\n")); 1123 SLIST_INIT(&ix->ix_altlist); 1124 vs->vs_xfer_type = UE_ISOCHRONOUS; 1125 ix->ix_endpt = 1126 GET(usb_endpoint_descriptor_t, 1127 desc, bEndpointAddress); 1128 } 1129 1130 alt = kmem_alloc(sizeof(*alt), KM_NOSLEEP); 1131 if (alt == NULL) 1132 return USBD_NOMEM; 1133 1134 alt->altno = ifdesc->bAlternateSetting; 1135 alt->interval = 1136 GET(usb_endpoint_descriptor_t, 1137 desc, bInterval); 1138 alt->max_packet_size = 1139 UGETW(GET(usb_endpoint_descriptor_t, 1140 desc, wMaxPacketSize)); 1141 SLIST_INSERT_HEAD(&ix->ix_altlist, 1142 alt, entries); 1143 } 1144 break; 1145 case UDESC_CS_INTERFACE: 1146 if (ifdesc->bAlternateSetting != 0) { 1147 DPRINTF(("uvideo_stream_init_alternate: " 1148 "unexpected class-specific descriptor " 1149 "len=%d type=0x%02x subtype=0x%02x\n", 1150 uvdesc->bLength, 1151 uvdesc->bDescriptorType, 1152 uvdesc->bDescriptorSubtype)); 1153 break; 1154 } 1155 1156 switch (uvdesc->bDescriptorSubtype) { 1157 case UDESC_VS_INPUT_HEADER: 1158 vs->vs_subtype = UDESC_VS_INPUT_HEADER; 1159 break; 1160 case UDESC_VS_OUTPUT_HEADER: 1161 /* TODO: handle output stream */ 1162 DPRINTF(("uvideo: VS output not implemented\n")); 1163 vs->vs_subtype = UDESC_VS_OUTPUT_HEADER; 1164 return USBD_INVAL; 1165 case UDESC_VS_FORMAT_UNCOMPRESSED: 1166 case UDESC_VS_FORMAT_FRAME_BASED: 1167 case UDESC_VS_FORMAT_MJPEG: 1168 uvideo_stream_init_frame_based_format(vs, 1169 uvdesc, 1170 iter); 1171 break; 1172 case UDESC_VS_FORMAT_MPEG2TS: 1173 case UDESC_VS_FORMAT_DV: 1174 case UDESC_VS_FORMAT_STREAM_BASED: 1175 default: 1176 DPRINTF(("uvideo: unimplemented VS CS " 1177 "descriptor len=%d type=0x%02x " 1178 "subtype=0x%02x\n", 1179 uvdesc->bLength, 1180 uvdesc->bDescriptorType, 1181 uvdesc->bDescriptorSubtype)); 1182 break; 1183 } 1184 break; 1185 default: 1186 DPRINTF(("uvideo_stream_init_desc: " 1187 "unknown descriptor " 1188 "len=%d type=0x%02x\n", 1189 uvdesc->bLength, 1190 uvdesc->bDescriptorType)); 1191 break; 1192 } 1193 } 1194 1195 return USBD_NORMAL_COMPLETION; 1196 } 1197 1198 /* Finialize and free memory associated with this stream. */ 1199 static void 1200 uvideo_stream_free(struct uvideo_stream *vs) 1201 { 1202 struct uvideo_alternate *alt; 1203 struct uvideo_pixel_format *pixel_format; 1204 struct uvideo_format *format; 1205 1206 /* free linked list of alternate interfaces */ 1207 if (vs->vs_xfer_type == UE_ISOCHRONOUS) { 1208 while (!SLIST_EMPTY(&vs->vs_xfer.isoc.ix_altlist)) { 1209 alt = SLIST_FIRST(&vs->vs_xfer.isoc.ix_altlist); 1210 SLIST_REMOVE_HEAD(&vs->vs_xfer.isoc.ix_altlist, 1211 entries); 1212 kmem_free(alt, sizeof(*alt)); 1213 } 1214 } 1215 1216 /* free linked-list of formats and pixel formats */ 1217 while ((format = SIMPLEQ_FIRST(&vs->vs_formats)) != NULL) { 1218 SIMPLEQ_REMOVE_HEAD(&vs->vs_formats, entries); 1219 kmem_free(format, sizeof(struct uvideo_format)); 1220 } 1221 while ((pixel_format = SIMPLEQ_FIRST(&vs->vs_pixel_formats)) != NULL) { 1222 SIMPLEQ_REMOVE_HEAD(&vs->vs_pixel_formats, entries); 1223 kmem_free(pixel_format, sizeof(struct uvideo_pixel_format)); 1224 } 1225 1226 kmem_free(vs, sizeof(*vs)); 1227 } 1228 1229 1230 static usbd_status 1231 uvideo_stream_init_frame_based_format(struct uvideo_stream *vs, 1232 const uvideo_descriptor_t *format_desc, 1233 usbd_desc_iter_t *iter) 1234 { 1235 struct uvideo_pixel_format *pformat, *pfiter; 1236 enum video_pixel_format pixel_format; 1237 struct uvideo_format *format; 1238 const uvideo_descriptor_t *uvdesc; 1239 uint8_t subtype, default_index, index; 1240 uint32_t frame_interval; 1241 const usb_guid_t *guid; 1242 1243 pixel_format = VIDEO_FORMAT_UNDEFINED; 1244 1245 switch (format_desc->bDescriptorSubtype) { 1246 case UDESC_VS_FORMAT_UNCOMPRESSED: 1247 subtype = UDESC_VS_FRAME_UNCOMPRESSED; 1248 default_index = GET(uvideo_vs_format_uncompressed_descriptor_t, 1249 format_desc, 1250 bDefaultFrameIndex); 1251 guid = GETP(uvideo_vs_format_uncompressed_descriptor_t, 1252 format_desc, 1253 guidFormat); 1254 if (usb_guid_cmp(guid, &uvideo_guid_format_yuy2) == 0) 1255 pixel_format = VIDEO_FORMAT_YUY2; 1256 else if (usb_guid_cmp(guid, &uvideo_guid_format_nv12) == 0) 1257 pixel_format = VIDEO_FORMAT_NV12; 1258 break; 1259 case UDESC_VS_FORMAT_FRAME_BASED: 1260 subtype = UDESC_VS_FRAME_FRAME_BASED; 1261 default_index = GET(uvideo_format_frame_based_descriptor_t, 1262 format_desc, 1263 bDefaultFrameIndex); 1264 break; 1265 case UDESC_VS_FORMAT_MJPEG: 1266 subtype = UDESC_VS_FRAME_MJPEG; 1267 default_index = GET(uvideo_vs_format_mjpeg_descriptor_t, 1268 format_desc, 1269 bDefaultFrameIndex); 1270 pixel_format = VIDEO_FORMAT_MJPEG; 1271 break; 1272 default: 1273 DPRINTF(("uvideo: unknown frame based format %d\n", 1274 format_desc->bDescriptorSubtype)); 1275 return USBD_INVAL; 1276 } 1277 1278 pformat = NULL; 1279 SIMPLEQ_FOREACH(pfiter, &vs->vs_pixel_formats, entries) { 1280 if (pfiter->pixel_format == pixel_format) { 1281 pformat = pfiter; 1282 break; 1283 } 1284 } 1285 if (pixel_format != VIDEO_FORMAT_UNDEFINED && pformat == NULL) { 1286 pformat = kmem_zalloc(sizeof(*pformat), KM_SLEEP); 1287 pformat->pixel_format = pixel_format; 1288 DPRINTF(("uvideo: Adding pixel format %d\n", 1289 pixel_format)); 1290 SIMPLEQ_INSERT_TAIL(&vs->vs_pixel_formats, 1291 pformat, entries); 1292 } 1293 1294 /* Iterate through frame descriptors directly following the 1295 * format descriptor, and add a format to the format list for 1296 * each frame descriptor. */ 1297 while ((uvdesc = (const uvideo_descriptor_t *) usb_desc_iter_peek_next(iter)) && 1298 (uvdesc != NULL) && (uvdesc->bDescriptorSubtype == subtype)) 1299 { 1300 uvdesc = (const uvideo_descriptor_t *) usb_desc_iter_next(iter); 1301 1302 format = kmem_zalloc(sizeof(struct uvideo_format), KM_SLEEP); 1303 if (format == NULL) { 1304 DPRINTF(("uvideo: failed to alloc video format\n")); 1305 return USBD_NOMEM; 1306 } 1307 1308 format->format.pixel_format = pixel_format; 1309 1310 switch (format_desc->bDescriptorSubtype) { 1311 case UDESC_VS_FORMAT_UNCOMPRESSED: 1312 #ifdef UVIDEO_DEBUG 1313 if (pixel_format == VIDEO_FORMAT_UNDEFINED && 1314 uvideodebug) { 1315 guid = GETP( 1316 uvideo_vs_format_uncompressed_descriptor_t, 1317 format_desc, 1318 guidFormat); 1319 1320 DPRINTF(("uvideo: format undefined ")); 1321 usb_guid_print(guid); 1322 DPRINTF(("\n")); 1323 } 1324 #endif 1325 1326 UVIDEO_FORMAT_INIT_FRAME_BASED( 1327 uvideo_vs_format_uncompressed_descriptor_t, 1328 format_desc, 1329 uvideo_vs_frame_uncompressed_descriptor_t, 1330 uvdesc, 1331 format); 1332 format->format.sample_size = 1333 UGETDW( 1334 GET(uvideo_vs_frame_uncompressed_descriptor_t, 1335 uvdesc, dwMaxVideoFrameBufferSize)); 1336 format->format.stride = 1337 format->format.sample_size / format->format.height; 1338 index = GET(uvideo_vs_frame_uncompressed_descriptor_t, 1339 uvdesc, 1340 bFrameIndex); 1341 frame_interval = 1342 UGETDW( 1343 GET(uvideo_vs_frame_uncompressed_descriptor_t, 1344 uvdesc, 1345 dwDefaultFrameInterval)); 1346 break; 1347 case UDESC_VS_FORMAT_MJPEG: 1348 UVIDEO_FORMAT_INIT_FRAME_BASED( 1349 uvideo_vs_format_mjpeg_descriptor_t, 1350 format_desc, 1351 uvideo_vs_frame_mjpeg_descriptor_t, 1352 uvdesc, 1353 format); 1354 format->format.sample_size = 1355 UGETDW( 1356 GET(uvideo_vs_frame_mjpeg_descriptor_t, 1357 uvdesc, dwMaxVideoFrameBufferSize)); 1358 format->format.stride = 1359 format->format.sample_size / format->format.height; 1360 index = GET(uvideo_vs_frame_mjpeg_descriptor_t, 1361 uvdesc, 1362 bFrameIndex); 1363 frame_interval = 1364 UGETDW( 1365 GET(uvideo_vs_frame_mjpeg_descriptor_t, 1366 uvdesc, 1367 dwDefaultFrameInterval)); 1368 break; 1369 case UDESC_VS_FORMAT_FRAME_BASED: 1370 format->format.pixel_format = VIDEO_FORMAT_UNDEFINED; 1371 UVIDEO_FORMAT_INIT_FRAME_BASED( 1372 uvideo_format_frame_based_descriptor_t, 1373 format_desc, 1374 uvideo_frame_frame_based_descriptor_t, 1375 uvdesc, 1376 format); 1377 index = GET(uvideo_frame_frame_based_descriptor_t, 1378 uvdesc, 1379 bFrameIndex); 1380 format->format.stride = 1381 UGETDW( 1382 GET(uvideo_frame_frame_based_descriptor_t, 1383 uvdesc, dwBytesPerLine)); 1384 format->format.sample_size = 1385 format->format.stride * format->format.height; 1386 frame_interval = 1387 UGETDW( 1388 GET(uvideo_frame_frame_based_descriptor_t, 1389 uvdesc, dwDefaultFrameInterval)); 1390 break; 1391 default: 1392 /* shouldn't ever get here */ 1393 DPRINTF(("uvideo: unknown frame based format %d\n", 1394 format_desc->bDescriptorSubtype)); 1395 kmem_free(format, sizeof(struct uvideo_format)); 1396 return USBD_INVAL; 1397 } 1398 1399 DPRINTF(("uvideo: found format (index %d) type %d " 1400 "size %ux%u size %u stride %u interval %u\n", 1401 index, format->format.pixel_format, format->format.width, 1402 format->format.height, format->format.sample_size, 1403 format->format.stride, frame_interval)); 1404 1405 SIMPLEQ_INSERT_TAIL(&vs->vs_formats, format, entries); 1406 1407 if (vs->vs_default_format == NULL && index == default_index 1408 #ifdef UVIDEO_DISABLE_MJPEG 1409 && subtype != UDESC_VS_FRAME_MJPEG 1410 #endif 1411 ) { 1412 DPRINTF((" ^ picking this one\n")); 1413 vs->vs_default_format = &format->format; 1414 vs->vs_frame_interval = frame_interval; 1415 } 1416 1417 } 1418 1419 return USBD_NORMAL_COMPLETION; 1420 } 1421 1422 static int 1423 uvideo_stream_start_xfer(struct uvideo_stream *vs) 1424 { 1425 struct uvideo_softc *sc = vs->vs_parent; 1426 struct uvideo_bulk_xfer *bx; 1427 struct uvideo_isoc_xfer *ix; 1428 uint32_t vframe_len; /* rough bytes per video frame */ 1429 uint32_t uframe_len; /* bytes per usb frame (TODO: or microframe?) */ 1430 uint32_t nframes; /* number of usb frames (TODO: or microframs?) */ 1431 int i; 1432 1433 struct uvideo_alternate *alt, *alt_maybe; 1434 usbd_status err; 1435 1436 switch (vs->vs_xfer_type) { 1437 case UE_BULK: 1438 bx = &vs->vs_xfer.bulk; 1439 return 0; 1440 case UE_ISOCHRONOUS: 1441 ix = &vs->vs_xfer.isoc; 1442 1443 /* Choose an alternate interface most suitable for 1444 * this format. Choose the smallest size that can 1445 * contain max_payload_size. 1446 * 1447 * It is assumed that the list is sorted in descending 1448 * order from largest to smallest packet size. 1449 * 1450 * TODO: what should the strategy be for choosing an 1451 * alt interface? 1452 */ 1453 alt = NULL; 1454 SLIST_FOREACH(alt_maybe, &ix->ix_altlist, entries) { 1455 /* TODO: define "packet" and "payload". I think 1456 * several packets can make up one payload which would 1457 * call into question this method of selecting an 1458 * alternate interface... */ 1459 1460 /* XXXJDM don't allow packet size > 1024 for now */ 1461 if (alt_maybe->max_packet_size > 1024) 1462 continue; 1463 1464 if (alt == NULL || 1465 alt_maybe->max_packet_size >= alt->max_packet_size) 1466 alt = alt_maybe; 1467 } 1468 1469 if (alt == NULL) { 1470 DPRINTF(("uvideo_stream_start_xfer: " 1471 "no suitable alternate interface found\n")); 1472 return EINVAL; 1473 } 1474 1475 DPRINTFN(15,("uvideo_stream_start_xfer: " 1476 "choosing alternate interface " 1477 "%d wMaxPacketSize=%d bInterval=%d\n", 1478 alt->altno, alt->max_packet_size, alt->interval)); 1479 1480 err = usbd_set_interface(vs->vs_iface, alt->altno); 1481 if (err != USBD_NORMAL_COMPLETION) { 1482 DPRINTF(("uvideo_stream_start_xfer: " 1483 "error setting alt interface: %s (%d)\n", 1484 usbd_errstr(err), err)); 1485 return EIO; 1486 } 1487 1488 /* TODO: "packet" not same as frame */ 1489 vframe_len = vs->vs_current_format.sample_size; 1490 uframe_len = alt->max_packet_size; 1491 nframes = (vframe_len + uframe_len - 1) / uframe_len; 1492 DPRINTF(("uvideo_stream_start_xfer: nframes=%d\n", nframes)); 1493 1494 ix->ix_nframes = nframes; 1495 ix->ix_uframe_len = uframe_len; 1496 for (i = 0; i < UVIDEO_NXFERS; i++) { 1497 struct uvideo_isoc *isoc = &ix->ix_i[i]; 1498 isoc->i_frlengths = 1499 kmem_alloc(sizeof(isoc->i_frlengths[0]) * nframes, 1500 KM_SLEEP); 1501 if (isoc->i_frlengths == NULL) { 1502 DPRINTF(("uvideo: failed to alloc frlengths:" 1503 "%s (%d)\n", 1504 usbd_errstr(err), err)); 1505 return ENOMEM; 1506 } 1507 } 1508 1509 err = usbd_open_pipe(vs->vs_iface, ix->ix_endpt, 1510 USBD_EXCLUSIVE_USE, &ix->ix_pipe); 1511 if (err != USBD_NORMAL_COMPLETION) { 1512 DPRINTF(("uvideo: error opening pipe: %s (%d)\n", 1513 usbd_errstr(err), err)); 1514 return EIO; 1515 } 1516 1517 for (i = 0; i < UVIDEO_NXFERS; i++) { 1518 struct uvideo_isoc *isoc = &ix->ix_i[i]; 1519 isoc->i_xfer = usbd_alloc_xfer(sc->sc_udev); 1520 if (isoc->i_xfer == NULL) { 1521 DPRINTF(("uvideo: failed to alloc xfer: %s" 1522 " (%d)\n", 1523 usbd_errstr(err), err)); 1524 return ENOMEM; 1525 } 1526 1527 isoc->i_buf = usbd_alloc_buffer(isoc->i_xfer, 1528 nframes * uframe_len); 1529 if (isoc->i_xfer == NULL) { 1530 DPRINTF(("uvideo: failed to alloc buf: %s" 1531 " (%d)\n", 1532 usbd_errstr(err), err)); 1533 return ENOMEM; 1534 } 1535 } 1536 1537 uvideo_stream_recv_isoc_start(vs); 1538 1539 return 0; 1540 default: 1541 /* should never get here */ 1542 DPRINTF(("uvideo_stream_start_xfer: unknown xfer type 0x%x\n", 1543 vs->vs_xfer_type)); 1544 return EINVAL; 1545 } 1546 } 1547 1548 static int 1549 uvideo_stream_stop_xfer(struct uvideo_stream *vs) 1550 { 1551 struct uvideo_bulk_xfer *bx; 1552 struct uvideo_isoc_xfer *ix; 1553 usbd_status err; 1554 int i; 1555 1556 switch (vs->vs_xfer_type) { 1557 case UE_BULK: 1558 bx = &vs->vs_xfer.bulk; 1559 return 0; 1560 case UE_ISOCHRONOUS: 1561 ix = &vs->vs_xfer.isoc; 1562 if (ix->ix_pipe != NULL) { 1563 usbd_abort_pipe(ix->ix_pipe); 1564 usbd_close_pipe(ix->ix_pipe); 1565 ix->ix_pipe = NULL; 1566 } 1567 1568 for (i = 0; i < UVIDEO_NXFERS; i++) { 1569 struct uvideo_isoc *isoc = &ix->ix_i[i]; 1570 if (isoc->i_xfer != NULL) { 1571 usbd_free_buffer(isoc->i_xfer); 1572 usbd_free_xfer(isoc->i_xfer); 1573 isoc->i_xfer = NULL; 1574 } 1575 1576 if (isoc->i_frlengths != NULL) { 1577 kmem_free(isoc->i_frlengths, 1578 sizeof(isoc->i_frlengths[0]) * 1579 ix->ix_nframes); 1580 isoc->i_frlengths = NULL; 1581 } 1582 } 1583 1584 /* Give it some time to settle */ 1585 usbd_delay_ms(vs->vs_parent->sc_udev, 1000); 1586 1587 /* Set to zero bandwidth alternate interface zero */ 1588 err = usbd_set_interface(vs->vs_iface, 0); 1589 if (err != USBD_NORMAL_COMPLETION) { 1590 DPRINTF(("uvideo_stream_stop_transfer: " 1591 "error setting zero bandwidth interface: " 1592 "%s (%d)\n", 1593 usbd_errstr(err), err)); 1594 return EIO; 1595 } 1596 1597 return 0; 1598 default: 1599 /* should never get here */ 1600 DPRINTF(("uvideo_stream_stop_xfer: unknown xfer type 0x%x\n", 1601 vs->vs_xfer_type)); 1602 return EINVAL; 1603 } 1604 } 1605 1606 static usbd_status 1607 uvideo_stream_recv_isoc_start(struct uvideo_stream *vs) 1608 { 1609 int i; 1610 1611 for (i = 0; i < UVIDEO_NXFERS; i++) 1612 uvideo_stream_recv_isoc_start1(&vs->vs_xfer.isoc.ix_i[i]); 1613 1614 return USBD_NORMAL_COMPLETION; 1615 } 1616 1617 /* Initiate a usb transfer. */ 1618 static usbd_status 1619 uvideo_stream_recv_isoc_start1(struct uvideo_isoc *isoc) 1620 { 1621 struct uvideo_isoc_xfer *ix; 1622 usbd_status err; 1623 int i; 1624 1625 ix = isoc->i_ix; 1626 1627 for (i = 0; i < ix->ix_nframes; ++i) 1628 isoc->i_frlengths[i] = ix->ix_uframe_len; 1629 1630 usbd_setup_isoc_xfer(isoc->i_xfer, 1631 ix->ix_pipe, 1632 isoc, 1633 isoc->i_frlengths, 1634 ix->ix_nframes, 1635 USBD_NO_COPY | USBD_SHORT_XFER_OK, 1636 uvideo_stream_recv_isoc_complete); 1637 1638 err = usbd_transfer(isoc->i_xfer); 1639 if (err != USBD_IN_PROGRESS) { 1640 DPRINTF(("uvideo_stream_recv_start: " 1641 "usbd_transfer status=%s (%d)\n", 1642 usbd_errstr(err), err)); 1643 } 1644 return err; 1645 } 1646 1647 /* Callback on completion of usb isoc transfer */ 1648 static void 1649 uvideo_stream_recv_isoc_complete(usbd_xfer_handle xfer, 1650 usbd_private_handle priv, 1651 usbd_status status) 1652 { 1653 struct uvideo_stream *vs; 1654 struct uvideo_isoc_xfer *ix; 1655 struct uvideo_isoc *isoc; 1656 int i; 1657 uint32_t count; 1658 const uvideo_payload_header_t *hdr; 1659 uint8_t *buf; 1660 struct video_payload payload; 1661 1662 isoc = priv; 1663 vs = isoc->i_vs; 1664 ix = isoc->i_ix; 1665 1666 if (status != USBD_NORMAL_COMPLETION) { 1667 DPRINTF(("uvideo_stream_recv_isoc_complete: status=%s (%d)\n", 1668 usbd_errstr(status), status)); 1669 1670 if (status == USBD_STALLED) 1671 usbd_clear_endpoint_stall_async(ix->ix_pipe); 1672 else 1673 return; 1674 } else { 1675 usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL); 1676 1677 if (count == 0) { 1678 /* DPRINTF(("uvideo: zero length transfer\n")); */ 1679 goto next; 1680 } 1681 1682 hdr = (const uvideo_payload_header_t *)isoc->i_buf; 1683 1684 for (i = 0, buf = isoc->i_buf; 1685 i < ix->ix_nframes; 1686 ++i, buf += ix->ix_uframe_len) 1687 { 1688 if (isoc->i_frlengths[i] < 1689 sizeof(uvideo_payload_header_t)) 1690 continue; 1691 1692 hdr = (uvideo_payload_header_t *)buf; 1693 if (hdr->bHeaderLength != UVIDEO_PAYLOAD_HEADER_SIZE) 1694 continue; 1695 if (hdr->bHeaderLength == isoc->i_frlengths[i] && 1696 !(hdr->bmHeaderInfo & UV_END_OF_FRAME)) 1697 continue; 1698 if (hdr->bmHeaderInfo & UV_ERROR) { 1699 DPRINTF(("uvideo: stream error\n")); 1700 break; 1701 } 1702 1703 payload.data = buf + hdr->bHeaderLength; 1704 payload.size = isoc->i_frlengths[i] - 1705 hdr->bHeaderLength; 1706 payload.frameno = hdr->bmHeaderInfo & UV_FRAME_ID; 1707 payload.end_of_frame = 1708 hdr->bmHeaderInfo & UV_END_OF_FRAME; 1709 1710 video_submit_payload(vs->vs_parent->sc_videodev, 1711 &payload); 1712 } 1713 } 1714 1715 next: 1716 uvideo_stream_recv_isoc_start1(isoc); 1717 } 1718 1719 1720 /* 1721 * uvideo_open - probe and commit video format and start receiving 1722 * video data 1723 */ 1724 static int 1725 uvideo_open(void *addr, int flags) 1726 { 1727 struct uvideo_softc *sc; 1728 struct uvideo_stream *vs; 1729 struct video_format fmt; 1730 1731 sc = addr; 1732 vs = sc->sc_stream_in; 1733 1734 DPRINTF(("uvideo_open: sc=%p\n", sc)); 1735 if (sc->sc_dying) 1736 return EIO; 1737 1738 /* XXX select default format */ 1739 fmt = *vs->vs_default_format; 1740 return uvideo_set_format(addr, &fmt); 1741 } 1742 1743 1744 static void 1745 uvideo_close(void *addr) 1746 { 1747 struct uvideo_softc *sc; 1748 1749 sc = addr; 1750 1751 if (sc->sc_state != UVIDEO_STATE_CLOSED) { 1752 sc->sc_state = UVIDEO_STATE_CLOSED; 1753 } 1754 } 1755 1756 static const char * 1757 uvideo_get_devname(void *addr) 1758 { 1759 struct uvideo_softc *sc = addr; 1760 return sc->sc_devname; 1761 } 1762 1763 static int 1764 uvideo_enum_format(void *addr, uint32_t index, struct video_format *format) 1765 { 1766 struct uvideo_softc *sc = addr; 1767 struct uvideo_stream *vs = sc->sc_stream_in; 1768 struct uvideo_pixel_format *pixel_format; 1769 int off; 1770 1771 if (sc->sc_dying) 1772 return EIO; 1773 1774 off = 0; 1775 SIMPLEQ_FOREACH(pixel_format, &vs->vs_pixel_formats, entries) { 1776 if (off++ != index) 1777 continue; 1778 format->pixel_format = pixel_format->pixel_format; 1779 return 0; 1780 } 1781 1782 return EINVAL; 1783 } 1784 1785 /* 1786 * uvideo_get_format 1787 */ 1788 static int 1789 uvideo_get_format(void *addr, struct video_format *format) 1790 { 1791 struct uvideo_softc *sc = addr; 1792 struct uvideo_stream *vs = sc->sc_stream_in; 1793 1794 if (sc->sc_dying) 1795 return EIO; 1796 1797 *format = vs->vs_current_format; 1798 1799 return 0; 1800 } 1801 1802 /* 1803 * uvideo_set_format - TODO: this is boken and does nothing 1804 */ 1805 static int 1806 uvideo_set_format(void *addr, struct video_format *format) 1807 { 1808 struct uvideo_softc *sc; 1809 struct uvideo_stream *vs; 1810 struct uvideo_format *uvfmt; 1811 uvideo_probe_and_commit_data_t probe, maxprobe; 1812 uint8_t ifaceno; 1813 usbd_status err; 1814 1815 sc = addr; 1816 1817 DPRINTF(("uvideo_set_format: sc=%p\n", sc)); 1818 if (sc->sc_dying) 1819 return EIO; 1820 1821 vs = sc->sc_stream_in; 1822 ifaceno = vs->vs_ifaceno; 1823 1824 uvfmt = uvideo_stream_guess_format(vs, format->pixel_format, 1825 format->width, format->height); 1826 if (uvfmt == NULL) { 1827 DPRINTF(("uvideo: uvideo_stream_guess_format couldn't find " 1828 "%dx%d format %d\n", format->width, format->height, 1829 format->pixel_format)); 1830 return EINVAL; 1831 } 1832 1833 uvideo_init_probe_data(&probe); 1834 probe.bFormatIndex = UVIDEO_FORMAT_GET_FORMAT_INDEX(uvfmt); 1835 probe.bFrameIndex = UVIDEO_FORMAT_GET_FRAME_INDEX(uvfmt); 1836 USETDW(probe.dwFrameInterval, vs->vs_frame_interval); /* XXX */ 1837 1838 maxprobe = probe; 1839 err = uvideo_stream_probe(vs, UR_GET_MAX, &maxprobe); 1840 if (err) { 1841 DPRINTF(("uvideo: error probe/GET_MAX: %s (%d)\n", 1842 usbd_errstr(err), err)); 1843 } else { 1844 USETW(probe.wCompQuality, UGETW(maxprobe.wCompQuality)); 1845 } 1846 1847 err = uvideo_stream_probe(vs, UR_SET_CUR, &probe); 1848 if (err) { 1849 DPRINTF(("uvideo: error commit/SET_CUR: %s (%d)\n", 1850 usbd_errstr(err), err)); 1851 return EIO; 1852 } 1853 1854 uvideo_init_probe_data(&probe); 1855 err = uvideo_stream_probe(vs, UR_GET_CUR, &probe); 1856 if (err) { 1857 DPRINTF(("uvideo: error commit/SET_CUR: %s (%d)\n", 1858 usbd_errstr(err), err)); 1859 return EIO; 1860 } 1861 1862 if (probe.bFormatIndex != UVIDEO_FORMAT_GET_FORMAT_INDEX(uvfmt)) { 1863 DPRINTF(("uvideo: probe/GET_CUR returned format index %d " 1864 "(expected %d)\n", probe.bFormatIndex, 1865 UVIDEO_FORMAT_GET_FORMAT_INDEX(uvfmt))); 1866 probe.bFormatIndex = UVIDEO_FORMAT_GET_FORMAT_INDEX(uvfmt); 1867 } 1868 if (probe.bFrameIndex != UVIDEO_FORMAT_GET_FRAME_INDEX(uvfmt)) { 1869 DPRINTF(("uvideo: probe/GET_CUR returned frame index %d " 1870 "(expected %d)\n", probe.bFrameIndex, 1871 UVIDEO_FORMAT_GET_FRAME_INDEX(uvfmt))); 1872 probe.bFrameIndex = UVIDEO_FORMAT_GET_FRAME_INDEX(uvfmt); 1873 } 1874 USETDW(probe.dwFrameInterval, vs->vs_frame_interval); /* XXX */ 1875 1876 /* commit/SET_CUR. Fourth step is to set the alternate 1877 * interface. Currently the fourth step is in 1878 * uvideo_start_transfer. Maybe move it here? */ 1879 err = uvideo_stream_commit(vs, UR_SET_CUR, &probe); 1880 if (err) { 1881 DPRINTF(("uvideo: error commit/SET_CUR: %s (%d)\n", 1882 usbd_errstr(err), err)); 1883 return EIO; 1884 } 1885 1886 DPRINTFN(15, ("uvideo_set_format: committing to format: " 1887 "bmHint=0x%04x bFormatIndex=%d bFrameIndex=%d " 1888 "dwFrameInterval=%u wKeyFrameRate=%d wPFrameRate=%d " 1889 "wCompQuality=%d wCompWindowSize=%d wDelay=%d " 1890 "dwMaxVideoFrameSize=%u dwMaxPayloadTransferSize=%u", 1891 UGETW(probe.bmHint), 1892 probe.bFormatIndex, 1893 probe.bFrameIndex, 1894 UGETDW(probe.dwFrameInterval), 1895 UGETW(probe.wKeyFrameRate), 1896 UGETW(probe.wPFrameRate), 1897 UGETW(probe.wCompQuality), 1898 UGETW(probe.wCompWindowSize), 1899 UGETW(probe.wDelay), 1900 UGETDW(probe.dwMaxVideoFrameSize), 1901 UGETDW(probe.dwMaxPayloadTransferSize))); 1902 if (vs->vs_probelen == 34) { 1903 DPRINTFN(15, (" dwClockFrequency=%u bmFramingInfo=0x%02x " 1904 "bPreferedVersion=%d bMinVersion=%d " 1905 "bMaxVersion=%d", 1906 UGETDW(probe.dwClockFrequency), 1907 probe.bmFramingInfo, 1908 probe.bPreferedVersion, 1909 probe.bMinVersion, 1910 probe.bMaxVersion)); 1911 } 1912 DPRINTFN(15, ("\n")); 1913 1914 vs->vs_frame_interval = UGETDW(probe.dwFrameInterval); 1915 vs->vs_max_payload_size = UGETDW(probe.dwMaxPayloadTransferSize); 1916 1917 *format = uvfmt->format; 1918 vs->vs_current_format = *format; 1919 DPRINTF(("uvideo_set_format: pixeltype is %d\n", format->pixel_format)); 1920 1921 return 0; 1922 } 1923 1924 static int 1925 uvideo_try_format(void *addr, struct video_format *format) 1926 { 1927 struct uvideo_softc *sc = addr; 1928 struct uvideo_stream *vs = sc->sc_stream_in; 1929 struct uvideo_format *uvfmt; 1930 1931 uvfmt = uvideo_stream_guess_format(vs, format->pixel_format, 1932 format->width, format->height); 1933 if (uvfmt == NULL) 1934 return EINVAL; 1935 1936 *format = uvfmt->format; 1937 return 0; 1938 } 1939 1940 static int 1941 uvideo_start_transfer(void *addr) 1942 { 1943 struct uvideo_softc *sc = addr; 1944 struct uvideo_stream *vs; 1945 int s, err; 1946 1947 /* FIXME: this functions should be stream specific */ 1948 vs = SLIST_FIRST(&sc->sc_stream_list); 1949 s = splusb(); 1950 err = uvideo_stream_start_xfer(vs); 1951 splx(s); 1952 1953 return err; 1954 } 1955 1956 static int 1957 uvideo_stop_transfer(void *addr) 1958 { 1959 struct uvideo_softc *sc; 1960 int err, s; 1961 1962 sc = addr; 1963 1964 s = splusb(); 1965 err = uvideo_stream_stop_xfer(sc->sc_stream_in); 1966 splx(s); 1967 1968 return err; 1969 } 1970 1971 1972 static int 1973 uvideo_get_control_group(void *addr, struct video_control_group *group) 1974 { 1975 struct uvideo_softc *sc; 1976 usb_device_request_t req; 1977 usbd_status err; 1978 uint8_t control_id, ent_id, data[16]; 1979 uint16_t len; 1980 int s; 1981 1982 sc = addr; 1983 1984 /* request setup */ 1985 switch (group->group_id) { 1986 case VIDEO_CONTROL_PANTILT_RELATIVE: 1987 if (group->length != 4) 1988 return EINVAL; 1989 1990 return EINVAL; 1991 case VIDEO_CONTROL_SHARPNESS: 1992 if (group->length != 1) 1993 return EINVAL; 1994 1995 control_id = UVIDEO_PU_SHARPNESS_CONTROL; 1996 ent_id = 2; /* TODO: hardcoded logitech processing unit */ 1997 len = 2; 1998 break; 1999 default: 2000 return EINVAL; 2001 } 2002 2003 /* do request */ 2004 req.bmRequestType = UVIDEO_REQUEST_TYPE_INTERFACE | 2005 UVIDEO_REQUEST_TYPE_CLASS_SPECIFIC | 2006 UVIDEO_REQUEST_TYPE_GET; 2007 req.bRequest = UR_GET_CUR; 2008 USETW(req.wValue, control_id << 8); 2009 USETW(req.wIndex, (ent_id << 8) | sc->sc_ifaceno); 2010 USETW(req.wLength, len); 2011 2012 s = splusb(); 2013 err = usbd_do_request(sc->sc_udev, &req, data); 2014 splx(s); 2015 if (err != USBD_NORMAL_COMPLETION) { 2016 DPRINTF(("uvideo_set_control: error %s (%d)\n", 2017 usbd_errstr(err), err)); 2018 return EIO; /* TODO: more detail here? */ 2019 } 2020 2021 /* extract request data */ 2022 switch (group->group_id) { 2023 case VIDEO_CONTROL_SHARPNESS: 2024 group->control[0].value = UGETW(data); 2025 break; 2026 default: 2027 return EINVAL; 2028 } 2029 2030 return 0; 2031 } 2032 2033 2034 static int 2035 uvideo_set_control_group(void *addr, const struct video_control_group *group) 2036 { 2037 struct uvideo_softc *sc; 2038 usb_device_request_t req; 2039 usbd_status err; 2040 uint8_t control_id, ent_id, data[16]; /* long enough for all controls */ 2041 uint16_t len; 2042 int s; 2043 2044 sc = addr; 2045 2046 switch (group->group_id) { 2047 case VIDEO_CONTROL_PANTILT_RELATIVE: 2048 if (group->length != 4) 2049 return EINVAL; 2050 2051 if (group->control[0].value != 0 || 2052 group->control[0].value != 1 || 2053 group->control[0].value != 0xff) 2054 return ERANGE; 2055 2056 if (group->control[2].value != 0 || 2057 group->control[2].value != 1 || 2058 group->control[2].value != 0xff) 2059 return ERANGE; 2060 2061 control_id = UVIDEO_CT_PANTILT_RELATIVE_CONTROL; 2062 ent_id = 1; /* TODO: hardcoded logitech camera terminal */ 2063 len = 4; 2064 data[0] = group->control[0].value; 2065 data[1] = group->control[1].value; 2066 data[2] = group->control[2].value; 2067 data[3] = group->control[3].value; 2068 break; 2069 case VIDEO_CONTROL_BRIGHTNESS: 2070 if (group->length != 1) 2071 return EINVAL; 2072 control_id = UVIDEO_PU_BRIGHTNESS_CONTROL; 2073 ent_id = 2; 2074 len = 2; 2075 USETW(data, group->control[0].value); 2076 break; 2077 case VIDEO_CONTROL_GAIN: 2078 if (group->length != 1) 2079 return EINVAL; 2080 control_id = UVIDEO_PU_GAIN_CONTROL; 2081 ent_id = 2; 2082 len = 2; 2083 USETW(data, group->control[0].value); 2084 break; 2085 case VIDEO_CONTROL_SHARPNESS: 2086 if (group->length != 1) 2087 return EINVAL; 2088 control_id = UVIDEO_PU_SHARPNESS_CONTROL; 2089 ent_id = 2; /* TODO: hardcoded logitech processing unit */ 2090 len = 2; 2091 USETW(data, group->control[0].value); 2092 break; 2093 default: 2094 return EINVAL; 2095 } 2096 2097 req.bmRequestType = UVIDEO_REQUEST_TYPE_INTERFACE | 2098 UVIDEO_REQUEST_TYPE_CLASS_SPECIFIC | 2099 UVIDEO_REQUEST_TYPE_SET; 2100 req.bRequest = UR_SET_CUR; 2101 USETW(req.wValue, control_id << 8); 2102 USETW(req.wIndex, (ent_id << 8) | sc->sc_ifaceno); 2103 USETW(req.wLength, len); 2104 2105 s = splusb(); 2106 err = usbd_do_request(sc->sc_udev, &req, data); 2107 splx(s); 2108 if (err != USBD_NORMAL_COMPLETION) { 2109 DPRINTF(("uvideo_set_control: error %s (%d)\n", 2110 usbd_errstr(err), err)); 2111 return EIO; /* TODO: more detail here? */ 2112 } 2113 2114 return 0; 2115 } 2116 2117 static usbd_status 2118 uvideo_stream_probe_and_commit(struct uvideo_stream *vs, 2119 uint8_t action, uint8_t control, 2120 void *data) 2121 { 2122 usb_device_request_t req; 2123 2124 switch (action) { 2125 case UR_SET_CUR: 2126 req.bmRequestType = UT_WRITE_CLASS_INTERFACE; 2127 USETW(req.wLength, vs->vs_probelen); 2128 break; 2129 case UR_GET_CUR: 2130 case UR_GET_MIN: 2131 case UR_GET_MAX: 2132 case UR_GET_DEF: 2133 req.bmRequestType = UT_READ_CLASS_INTERFACE; 2134 USETW(req.wLength, vs->vs_probelen); 2135 break; 2136 case UR_GET_INFO: 2137 req.bmRequestType = UT_READ_CLASS_INTERFACE; 2138 USETW(req.wLength, sizeof(uByte)); 2139 break; 2140 case UR_GET_LEN: 2141 req.bmRequestType = UT_READ_CLASS_INTERFACE; 2142 USETW(req.wLength, sizeof(uWord)); /* is this right? */ 2143 break; 2144 default: 2145 DPRINTF(("uvideo_probe_and_commit: " 2146 "unknown request action %d\n", action)); 2147 return USBD_NOT_STARTED; 2148 } 2149 2150 req.bRequest = action; 2151 USETW2(req.wValue, control, 0); 2152 USETW2(req.wIndex, 0, vs->vs_ifaceno); 2153 2154 return (usbd_do_request_flags(vs->vs_parent->sc_udev, &req, data, 2155 0, 0, 2156 USBD_DEFAULT_TIMEOUT)); 2157 } 2158 2159 static void 2160 uvideo_init_probe_data(uvideo_probe_and_commit_data_t *probe) 2161 { 2162 /* all zeroes tells camera to choose what it wants */ 2163 memset(probe, 0, sizeof(*probe)); 2164 } 2165 2166 2167 #ifdef _MODULE 2168 2169 MODULE(MODULE_CLASS_DRIVER, uvideo, NULL); 2170 static const struct cfiattrdata videobuscf_iattrdata = { 2171 "videobus", 0, { 2172 { NULL, NULL, 0 }, 2173 } 2174 }; 2175 static const struct cfiattrdata * const uvideo_attrs[] = { 2176 &videobuscf_iattrdata, NULL 2177 }; 2178 CFDRIVER_DECL(uvideo, DV_DULL, uvideo_attrs); 2179 extern struct cfattach uvideo_ca; 2180 extern struct cfattach uvideo_ca; 2181 static int uvideoloc[6] = { -1, -1, -1, -1, -1, -1 }; 2182 static struct cfparent uhubparent = { 2183 "usbifif", NULL, DVUNIT_ANY 2184 }; 2185 static struct cfdata uvideo_cfdata[] = { 2186 { 2187 .cf_name = "uvideo", 2188 .cf_atname = "uvideo", 2189 .cf_unit = 0, 2190 .cf_fstate = FSTATE_STAR, 2191 .cf_loc = uvideoloc, 2192 .cf_flags = 0, 2193 .cf_pspec = &uhubparent, 2194 }, 2195 { NULL } 2196 }; 2197 2198 static int 2199 uvideo_modcmd(modcmd_t cmd, void *arg) 2200 { 2201 int err; 2202 2203 2204 switch (cmd) { 2205 case MODULE_CMD_INIT: 2206 DPRINTF(("uvideo: attempting to load\n")); 2207 2208 err = config_cfdriver_attach(&uvideo_cd); 2209 if (err) 2210 return err; 2211 err = config_cfattach_attach("uvideo", &uvideo_ca); 2212 if (err) { 2213 config_cfdriver_detach(&uvideo_cd); 2214 return err; 2215 } 2216 err = config_cfdata_attach(uvideo_cfdata, 1); 2217 if (err) { 2218 config_cfattach_detach("uvideo", &uvideo_ca); 2219 config_cfdriver_detach(&uvideo_cd); 2220 return err; 2221 } 2222 DPRINTF(("uvideo: loaded module\n")); 2223 return 0; 2224 case MODULE_CMD_FINI: 2225 DPRINTF(("uvideo: attempting to unload module\n")); 2226 err = config_cfdata_detach(uvideo_cfdata); 2227 if (err) 2228 return err; 2229 config_cfattach_detach("uvideo", &uvideo_ca); 2230 config_cfdriver_detach(&uvideo_cd); 2231 DPRINTF(("uvideo: module unload\n")); 2232 return 0; 2233 default: 2234 return ENOTTY; 2235 } 2236 } 2237 2238 #endif /* _MODULE */ 2239 2240 2241 #ifdef UVIDEO_DEBUG 2242 /* Some functions to print out descriptors. Mostly useless other than 2243 * debugging/exploration purposes. */ 2244 2245 2246 static void 2247 print_bitmap(const uByte *start, uByte nbytes) 2248 { 2249 int byte, bit; 2250 2251 /* most significant first */ 2252 for (byte = nbytes-1; byte >= 0; --byte) { 2253 if (byte < nbytes-1) printf("-"); 2254 for (bit = 7; bit >= 0; --bit) 2255 printf("%01d", (start[byte] >> bit) &1); 2256 } 2257 } 2258 2259 static void 2260 print_descriptor(const usb_descriptor_t *desc) 2261 { 2262 static int current_class = -1; 2263 static int current_subclass = -1; 2264 2265 if (desc->bDescriptorType == UDESC_INTERFACE) { 2266 const usb_interface_descriptor_t *id; 2267 id = (const usb_interface_descriptor_t *)desc; 2268 current_class = id->bInterfaceClass; 2269 current_subclass = id->bInterfaceSubClass; 2270 print_interface_descriptor(id); 2271 printf("\n"); 2272 return; 2273 } 2274 2275 printf(" "); /* indent */ 2276 2277 if (current_class == UICLASS_VIDEO) { 2278 switch (current_subclass) { 2279 case UISUBCLASS_VIDEOCONTROL: 2280 print_vc_descriptor(desc); 2281 break; 2282 case UISUBCLASS_VIDEOSTREAMING: 2283 print_vs_descriptor(desc); 2284 break; 2285 case UISUBCLASS_VIDEOCOLLECTION: 2286 printf("uvc collection: len=%d type=0x%02x", 2287 desc->bLength, desc->bDescriptorType); 2288 break; 2289 } 2290 } else { 2291 printf("non uvc descriptor len=%d type=0x%02x", 2292 desc->bLength, desc->bDescriptorType); 2293 } 2294 2295 printf("\n"); 2296 } 2297 2298 static void 2299 print_vc_descriptor(const usb_descriptor_t *desc) 2300 { 2301 const uvideo_descriptor_t *vcdesc; 2302 2303 printf("VC "); 2304 2305 switch (desc->bDescriptorType) { 2306 case UDESC_ENDPOINT: 2307 print_endpoint_descriptor( 2308 (const usb_endpoint_descriptor_t *)desc); 2309 break; 2310 case UDESC_CS_INTERFACE: 2311 vcdesc = (const uvideo_descriptor_t *)desc; 2312 switch (vcdesc->bDescriptorSubtype) { 2313 case UDESC_VC_HEADER: 2314 print_vc_header_descriptor( 2315 (const uvideo_vc_header_descriptor_t *) 2316 vcdesc); 2317 break; 2318 case UDESC_INPUT_TERMINAL: 2319 switch (UGETW( 2320 ((const uvideo_input_terminal_descriptor_t *) 2321 vcdesc)->wTerminalType)) { 2322 case UVIDEO_ITT_CAMERA: 2323 print_camera_terminal_descriptor( 2324 (const uvideo_camera_terminal_descriptor_t *)vcdesc); 2325 break; 2326 default: 2327 print_input_terminal_descriptor( 2328 (const uvideo_input_terminal_descriptor_t *)vcdesc); 2329 break; 2330 } 2331 break; 2332 case UDESC_OUTPUT_TERMINAL: 2333 print_output_terminal_descriptor( 2334 (const uvideo_output_terminal_descriptor_t *) 2335 vcdesc); 2336 break; 2337 case UDESC_SELECTOR_UNIT: 2338 print_selector_unit_descriptor( 2339 (const uvideo_selector_unit_descriptor_t *) 2340 vcdesc); 2341 break; 2342 case UDESC_PROCESSING_UNIT: 2343 print_processing_unit_descriptor( 2344 (const uvideo_processing_unit_descriptor_t *) 2345 vcdesc); 2346 break; 2347 case UDESC_EXTENSION_UNIT: 2348 print_extension_unit_descriptor( 2349 (const uvideo_extension_unit_descriptor_t *) 2350 vcdesc); 2351 break; 2352 default: 2353 printf("class specific interface " 2354 "len=%d type=0x%02x subtype=0x%02x", 2355 vcdesc->bLength, 2356 vcdesc->bDescriptorType, 2357 vcdesc->bDescriptorSubtype); 2358 break; 2359 } 2360 break; 2361 case UDESC_CS_ENDPOINT: 2362 vcdesc = (const uvideo_descriptor_t *)desc; 2363 switch (vcdesc->bDescriptorSubtype) { 2364 case UDESC_VC_INTERRUPT_ENDPOINT: 2365 print_interrupt_endpoint_descriptor( 2366 (const uvideo_vc_interrupt_endpoint_descriptor_t *) 2367 vcdesc); 2368 break; 2369 default: 2370 printf("class specific endpoint " 2371 "len=%d type=0x%02x subtype=0x%02x", 2372 vcdesc->bLength, 2373 vcdesc->bDescriptorType, 2374 vcdesc->bDescriptorSubtype); 2375 break; 2376 } 2377 break; 2378 default: 2379 printf("unknown: len=%d type=0x%02x", 2380 desc->bLength, desc->bDescriptorType); 2381 break; 2382 } 2383 } 2384 2385 static void 2386 print_vs_descriptor(const usb_descriptor_t *desc) 2387 { 2388 const uvideo_descriptor_t * vsdesc; 2389 printf("VS "); 2390 2391 switch (desc->bDescriptorType) { 2392 case UDESC_ENDPOINT: 2393 print_endpoint_descriptor( 2394 (const usb_endpoint_descriptor_t *)desc); 2395 break; 2396 case UDESC_CS_INTERFACE: 2397 vsdesc = (const uvideo_descriptor_t *)desc; 2398 switch (vsdesc->bDescriptorSubtype) { 2399 case UDESC_VS_INPUT_HEADER: 2400 print_vs_input_header_descriptor( 2401 (const uvideo_vs_input_header_descriptor_t *) 2402 vsdesc); 2403 break; 2404 case UDESC_VS_OUTPUT_HEADER: 2405 print_vs_output_header_descriptor( 2406 (const uvideo_vs_output_header_descriptor_t *) 2407 vsdesc); 2408 break; 2409 case UDESC_VS_FORMAT_UNCOMPRESSED: 2410 print_vs_format_uncompressed_descriptor( 2411 (const uvideo_vs_format_uncompressed_descriptor_t *) 2412 vsdesc); 2413 break; 2414 case UDESC_VS_FRAME_UNCOMPRESSED: 2415 print_vs_frame_uncompressed_descriptor( 2416 (const uvideo_vs_frame_uncompressed_descriptor_t *) 2417 vsdesc); 2418 break; 2419 case UDESC_VS_FORMAT_MJPEG: 2420 print_vs_format_mjpeg_descriptor( 2421 (const uvideo_vs_format_mjpeg_descriptor_t *) 2422 vsdesc); 2423 break; 2424 case UDESC_VS_FRAME_MJPEG: 2425 print_vs_frame_mjpeg_descriptor( 2426 (const uvideo_vs_frame_mjpeg_descriptor_t *) 2427 vsdesc); 2428 break; 2429 case UDESC_VS_FORMAT_DV: 2430 print_vs_format_dv_descriptor( 2431 (const uvideo_vs_format_dv_descriptor_t *) 2432 vsdesc); 2433 break; 2434 default: 2435 printf("unknown cs interface: len=%d type=0x%02x " 2436 "subtype=0x%02x", 2437 vsdesc->bLength, vsdesc->bDescriptorType, 2438 vsdesc->bDescriptorSubtype); 2439 } 2440 break; 2441 default: 2442 printf("unknown: len=%d type=0x%02x", 2443 desc->bLength, desc->bDescriptorType); 2444 break; 2445 } 2446 } 2447 2448 static void 2449 print_interface_descriptor(const usb_interface_descriptor_t *id) 2450 { 2451 printf("Interface: Len=%d Type=0x%02x " 2452 "bInterfaceNumber=0x%02x " 2453 "bAlternateSetting=0x%02x bNumEndpoints=0x%02x " 2454 "bInterfaceClass=0x%02x bInterfaceSubClass=0x%02x " 2455 "bInterfaceProtocol=0x%02x iInterface=0x%02x", 2456 id->bLength, 2457 id->bDescriptorType, 2458 id->bInterfaceNumber, 2459 id->bAlternateSetting, 2460 id->bNumEndpoints, 2461 id->bInterfaceClass, 2462 id->bInterfaceSubClass, 2463 id->bInterfaceProtocol, 2464 id->iInterface); 2465 } 2466 2467 static void 2468 print_endpoint_descriptor(const usb_endpoint_descriptor_t *desc) 2469 { 2470 printf("Endpoint: Len=%d Type=0x%02x " 2471 "bEndpointAddress=0x%02x ", 2472 desc->bLength, 2473 desc->bDescriptorType, 2474 desc->bEndpointAddress); 2475 printf("bmAttributes="); 2476 print_bitmap(&desc->bmAttributes, 1); 2477 printf(" wMaxPacketSize=%d bInterval=%d", 2478 UGETW(desc->wMaxPacketSize), 2479 desc->bInterval); 2480 } 2481 2482 static void 2483 print_vc_header_descriptor( 2484 const uvideo_vc_header_descriptor_t *desc) 2485 { 2486 printf("Interface Header: " 2487 "Len=%d Type=0x%02x Subtype=0x%02x " 2488 "bcdUVC=%d wTotalLength=%d " 2489 "dwClockFrequency=%u bInCollection=%d", 2490 desc->bLength, 2491 desc->bDescriptorType, 2492 desc->bDescriptorSubtype, 2493 UGETW(desc->bcdUVC), 2494 UGETW(desc->wTotalLength), 2495 UGETDW(desc->dwClockFrequency), 2496 desc->bInCollection); 2497 } 2498 2499 static void 2500 print_input_terminal_descriptor( 2501 const uvideo_input_terminal_descriptor_t *desc) 2502 { 2503 printf("Input Terminal: " 2504 "Len=%d Type=0x%02x Subtype=0x%02x " 2505 "bTerminalID=%d wTerminalType=%x bAssocTerminal=%d " 2506 "iTerminal=%d", 2507 desc->bLength, 2508 desc->bDescriptorType, 2509 desc->bDescriptorSubtype, 2510 desc->bTerminalID, 2511 UGETW(desc->wTerminalType), 2512 desc->bAssocTerminal, 2513 desc->iTerminal); 2514 } 2515 2516 static void 2517 print_output_terminal_descriptor( 2518 const uvideo_output_terminal_descriptor_t *desc) 2519 { 2520 printf("Output Terminal: " 2521 "Len=%d Type=0x%02x Subtype=0x%02x " 2522 "bTerminalID=%d wTerminalType=%x bAssocTerminal=%d " 2523 "bSourceID=%d iTerminal=%d", 2524 desc->bLength, 2525 desc->bDescriptorType, 2526 desc->bDescriptorSubtype, 2527 desc->bTerminalID, 2528 UGETW(desc->wTerminalType), 2529 desc->bAssocTerminal, 2530 desc->bSourceID, 2531 desc->iTerminal); 2532 } 2533 2534 static void 2535 print_camera_terminal_descriptor( 2536 const uvideo_camera_terminal_descriptor_t *desc) 2537 { 2538 printf("Camera Terminal: " 2539 "Len=%d Type=0x%02x Subtype=0x%02x " 2540 "bTerminalID=%d wTerminalType=%x bAssocTerminal=%d " 2541 "iTerminal=%d " 2542 "wObjectiveFocalLengthMin/Max=%d/%d " 2543 "wOcularFocalLength=%d " 2544 "bControlSize=%d ", 2545 desc->bLength, 2546 desc->bDescriptorType, 2547 desc->bDescriptorSubtype, 2548 desc->bTerminalID, 2549 UGETW(desc->wTerminalType), 2550 desc->bAssocTerminal, 2551 desc->iTerminal, 2552 UGETW(desc->wObjectiveFocalLengthMin), 2553 UGETW(desc->wObjectiveFocalLengthMax), 2554 UGETW(desc->wOcularFocalLength), 2555 desc->bControlSize); 2556 printf("bmControls="); 2557 print_bitmap(desc->bmControls, desc->bControlSize); 2558 } 2559 2560 static void 2561 print_selector_unit_descriptor( 2562 const uvideo_selector_unit_descriptor_t *desc) 2563 { 2564 int i; 2565 const uByte *b; 2566 printf("Selector Unit: " 2567 "Len=%d Type=0x%02x Subtype=0x%02x " 2568 "bUnitID=%d bNrInPins=%d ", 2569 desc->bLength, 2570 desc->bDescriptorType, 2571 desc->bDescriptorSubtype, 2572 desc->bUnitID, 2573 desc->bNrInPins); 2574 printf("baSourceIDs="); 2575 b = &desc->baSourceID[0]; 2576 for (i = 0; i < desc->bNrInPins; ++i) 2577 printf("%d ", *b++); 2578 printf("iSelector=%d", *b); 2579 } 2580 2581 static void 2582 print_processing_unit_descriptor( 2583 const uvideo_processing_unit_descriptor_t *desc) 2584 { 2585 const uByte *b; 2586 2587 printf("Processing Unit: " 2588 "Len=%d Type=0x%02x Subtype=0x%02x " 2589 "bUnitID=%d bSourceID=%d wMaxMultiplier=%d bControlSize=%d ", 2590 desc->bLength, 2591 desc->bDescriptorType, 2592 desc->bDescriptorSubtype, 2593 desc->bUnitID, 2594 desc->bSourceID, 2595 UGETW(desc->wMaxMultiplier), 2596 desc->bControlSize); 2597 printf("bmControls="); 2598 print_bitmap(desc->bmControls, desc->bControlSize); 2599 b = &desc->bControlSize + desc->bControlSize + 1; 2600 printf(" iProcessing=%d bmVideoStandards=", *b); 2601 b += 1; 2602 print_bitmap(b, 1); 2603 } 2604 2605 static void 2606 print_extension_unit_descriptor( 2607 const uvideo_extension_unit_descriptor_t *desc) 2608 { 2609 const uByte * byte; 2610 uByte controlbytes; 2611 int i; 2612 2613 printf("Extension Unit: " 2614 "Len=%d Type=0x%02x Subtype=0x%02x " 2615 "bUnitID=%d ", 2616 desc->bLength, 2617 desc->bDescriptorType, 2618 desc->bDescriptorSubtype, 2619 desc->bUnitID); 2620 2621 printf("guidExtensionCode="); 2622 usb_guid_print(&desc->guidExtensionCode); 2623 printf(" "); 2624 2625 printf("bNumControls=%d bNrInPins=%d ", 2626 desc->bNumControls, 2627 desc->bNrInPins); 2628 2629 printf("baSourceIDs="); 2630 byte = &desc->baSourceID[0]; 2631 for (i = 0; i < desc->bNrInPins; ++i) 2632 printf("%d ", *byte++); 2633 2634 controlbytes = *byte++; 2635 printf("bControlSize=%d ", controlbytes); 2636 printf("bmControls="); 2637 print_bitmap(byte, controlbytes); 2638 2639 byte += controlbytes; 2640 printf(" iExtension=%d", *byte); 2641 } 2642 2643 static void 2644 print_interrupt_endpoint_descriptor( 2645 const uvideo_vc_interrupt_endpoint_descriptor_t *desc) 2646 { 2647 printf("Interrupt Endpoint: " 2648 "Len=%d Type=0x%02x Subtype=0x%02x " 2649 "wMaxTransferSize=%d ", 2650 desc->bLength, 2651 desc->bDescriptorType, 2652 desc->bDescriptorSubtype, 2653 UGETW(desc->wMaxTransferSize)); 2654 } 2655 2656 2657 static void 2658 print_vs_output_header_descriptor( 2659 const uvideo_vs_output_header_descriptor_t *desc) 2660 { 2661 printf("Interface Output Header: " 2662 "Len=%d Type=0x%02x Subtype=0x%02x " 2663 "bNumFormats=%d wTotalLength=%d bEndpointAddress=%d " 2664 "bTerminalLink=%d bControlSize=%d", 2665 desc->bLength, 2666 desc->bDescriptorType, 2667 desc->bDescriptorSubtype, 2668 desc->bNumFormats, 2669 UGETW(desc->wTotalLength), 2670 desc->bEndpointAddress, 2671 desc->bTerminalLink, 2672 desc->bControlSize); 2673 } 2674 2675 static void 2676 print_vs_input_header_descriptor( 2677 const uvideo_vs_input_header_descriptor_t *desc) 2678 { 2679 printf("Interface Input Header: " 2680 "Len=%d Type=0x%02x Subtype=0x%02x " 2681 "bNumFormats=%d wTotalLength=%d bEndpointAddress=%d " 2682 "bmInfo=%x bTerminalLink=%d bStillCaptureMethod=%d " 2683 "bTriggerSupport=%d bTriggerUsage=%d bControlSize=%d ", 2684 desc->bLength, 2685 desc->bDescriptorType, 2686 desc->bDescriptorSubtype, 2687 desc->bNumFormats, 2688 UGETW(desc->wTotalLength), 2689 desc->bEndpointAddress, 2690 desc->bmInfo, 2691 desc->bTerminalLink, 2692 desc->bStillCaptureMethod, 2693 desc->bTriggerSupport, 2694 desc->bTriggerUsage, 2695 desc->bControlSize); 2696 print_bitmap(desc->bmaControls, desc->bControlSize); 2697 } 2698 2699 static void 2700 print_vs_format_uncompressed_descriptor( 2701 const uvideo_vs_format_uncompressed_descriptor_t *desc) 2702 { 2703 printf("Format Uncompressed: " 2704 "Len=%d Type=0x%02x Subtype=0x%02x " 2705 "bFormatIndex=%d bNumFrameDescriptors=%d ", 2706 desc->bLength, 2707 desc->bDescriptorType, 2708 desc->bDescriptorSubtype, 2709 desc->bFormatIndex, 2710 desc->bNumFrameDescriptors); 2711 usb_guid_print(&desc->guidFormat); 2712 printf(" bBitsPerPixel=%d bDefaultFrameIndex=%d " 2713 "bAspectRatioX=%d bAspectRatioY=%d " 2714 "bmInterlaceFlags=0x%02x bCopyProtect=%d", 2715 desc->bBitsPerPixel, 2716 desc->bDefaultFrameIndex, 2717 desc->bAspectRatioX, 2718 desc->bAspectRatioY, 2719 desc->bmInterlaceFlags, 2720 desc->bCopyProtect); 2721 } 2722 2723 static void 2724 print_vs_frame_uncompressed_descriptor( 2725 const uvideo_vs_frame_uncompressed_descriptor_t *desc) 2726 { 2727 printf("Frame Uncompressed: " 2728 "Len=%d Type=0x%02x Subtype=0x%02x " 2729 "bFrameIndex=%d bmCapabilities=0x%02x " 2730 "wWidth=%d wHeight=%d dwMinBitRate=%u dwMaxBitRate=%u " 2731 "dwMaxVideoFrameBufferSize=%u dwDefaultFrameInterval=%u " 2732 "bFrameIntervalType=%d", 2733 desc->bLength, 2734 desc->bDescriptorType, 2735 desc->bDescriptorSubtype, 2736 desc->bFrameIndex, 2737 desc->bmCapabilities, 2738 UGETW(desc->wWidth), 2739 UGETW(desc->wHeight), 2740 UGETDW(desc->dwMinBitRate), 2741 UGETDW(desc->dwMaxBitRate), 2742 UGETDW(desc->dwMaxVideoFrameBufferSize), 2743 UGETDW(desc->dwDefaultFrameInterval), 2744 desc->bFrameIntervalType); 2745 } 2746 2747 static void 2748 print_vs_format_mjpeg_descriptor( 2749 const uvideo_vs_format_mjpeg_descriptor_t *desc) 2750 { 2751 printf("MJPEG format: " 2752 "Len=%d Type=0x%02x Subtype=0x%02x " 2753 "bFormatIndex=%d bNumFrameDescriptors=%d bmFlags=0x%02x " 2754 "bDefaultFrameIndex=%d bAspectRatioX=%d bAspectRatioY=%d " 2755 "bmInterlaceFlags=0x%02x bCopyProtect=%d", 2756 desc->bLength, 2757 desc->bDescriptorType, 2758 desc->bDescriptorSubtype, 2759 desc->bFormatIndex, 2760 desc->bNumFrameDescriptors, 2761 desc->bmFlags, 2762 desc->bDefaultFrameIndex, 2763 desc->bAspectRatioX, 2764 desc->bAspectRatioY, 2765 desc->bmInterlaceFlags, 2766 desc->bCopyProtect); 2767 } 2768 2769 static void 2770 print_vs_frame_mjpeg_descriptor( 2771 const uvideo_vs_frame_mjpeg_descriptor_t *desc) 2772 { 2773 printf("MJPEG frame: " 2774 "Len=%d Type=0x%02x Subtype=0x%02x " 2775 "bFrameIndex=%d bmCapabilities=0x%02x " 2776 "wWidth=%d wHeight=%d dwMinBitRate=%u dwMaxBitRate=%u " 2777 "dwMaxVideoFrameBufferSize=%u dwDefaultFrameInterval=%u " 2778 "bFrameIntervalType=%d", 2779 desc->bLength, 2780 desc->bDescriptorType, 2781 desc->bDescriptorSubtype, 2782 desc->bFrameIndex, 2783 desc->bmCapabilities, 2784 UGETW(desc->wWidth), 2785 UGETW(desc->wHeight), 2786 UGETDW(desc->dwMinBitRate), 2787 UGETDW(desc->dwMaxBitRate), 2788 UGETDW(desc->dwMaxVideoFrameBufferSize), 2789 UGETDW(desc->dwDefaultFrameInterval), 2790 desc->bFrameIntervalType); 2791 } 2792 2793 static void 2794 print_vs_format_dv_descriptor( 2795 const uvideo_vs_format_dv_descriptor_t *desc) 2796 { 2797 printf("MJPEG format: " 2798 "Len=%d Type=0x%02x Subtype=0x%02x " 2799 "bFormatIndex=%d dwMaxVideoFrameBufferSize=%u " 2800 "bFormatType/Rate=%d bFormatType/Format=%d", 2801 desc->bLength, 2802 desc->bDescriptorType, 2803 desc->bDescriptorSubtype, 2804 desc->bFormatIndex, 2805 UGETDW(desc->dwMaxVideoFrameBufferSize), 2806 UVIDEO_GET_DV_FREQ(desc->bFormatType), 2807 UVIDEO_GET_DV_FORMAT(desc->bFormatType)); 2808 } 2809 2810 #endif /* !UVIDEO_DEBUG */ 2811 2812 static const usb_descriptor_t * 2813 usb_desc_iter_peek_next(usbd_desc_iter_t *iter) 2814 { 2815 const usb_descriptor_t *desc; 2816 2817 if (iter->cur + sizeof(usb_descriptor_t) >= iter->end) { 2818 if (iter->cur != iter->end) 2819 printf("usb_desc_iter_peek_next: bad descriptor\n"); 2820 return NULL; 2821 } 2822 desc = (const usb_descriptor_t *)iter->cur; 2823 if (desc->bLength == 0) { 2824 printf("usb_desc_iter_peek_next: descriptor length = 0\n"); 2825 return NULL; 2826 } 2827 if (iter->cur + desc->bLength > iter->end) { 2828 printf("usb_desc_iter_peek_next: descriptor length too large\n"); 2829 return NULL; 2830 } 2831 return desc; 2832 } 2833 2834 /* Return the next interface descriptor, skipping over any other 2835 * descriptors. Returns NULL at the end or on error. */ 2836 static const usb_interface_descriptor_t * 2837 usb_desc_iter_next_interface(usbd_desc_iter_t *iter) 2838 { 2839 const usb_descriptor_t *desc; 2840 2841 while ((desc = usb_desc_iter_peek_next(iter)) != NULL && 2842 desc->bDescriptorType != UDESC_INTERFACE) 2843 { 2844 usb_desc_iter_next(iter); 2845 } 2846 2847 return (const usb_interface_descriptor_t *)usb_desc_iter_next(iter); 2848 } 2849 2850 /* Returns the next non-interface descriptor, returning NULL when the 2851 * next descriptor would be an interface descriptor. */ 2852 static const usb_descriptor_t * 2853 usb_desc_iter_next_non_interface(usbd_desc_iter_t *iter) 2854 { 2855 const usb_descriptor_t *desc; 2856 2857 if ((desc = usb_desc_iter_peek_next(iter)) != NULL && 2858 desc->bDescriptorType != UDESC_INTERFACE) 2859 { 2860 return (usb_desc_iter_next(iter)); 2861 } else { 2862 return NULL; 2863 } 2864 } 2865 2866 #ifdef UVIDEO_DEBUG 2867 static void 2868 usb_guid_print(const usb_guid_t *guid) 2869 { 2870 printf("%04X-%02X-%02X-", 2871 UGETDW(guid->data1), 2872 UGETW(guid->data2), 2873 UGETW(guid->data3)); 2874 printf("%02X%02X-", 2875 guid->data4[0], 2876 guid->data4[1]); 2877 printf("%02X%02X%02X%02X%02X%02X", 2878 guid->data4[2], 2879 guid->data4[3], 2880 guid->data4[4], 2881 guid->data4[5], 2882 guid->data4[6], 2883 guid->data4[7]); 2884 } 2885 #endif /* !UVIDEO_DEBUG */ 2886 2887 /* Returns less than zero, zero, or greater than zero if uguid is less 2888 * than, equal to, or greater than guid. */ 2889 static int 2890 usb_guid_cmp(const usb_guid_t *uguid, const guid_t *guid) 2891 { 2892 if (guid->data1 > UGETDW(uguid->data1)) 2893 return 1; 2894 else if (guid->data1 < UGETDW(uguid->data1)) 2895 return -1; 2896 2897 if (guid->data2 > UGETW(uguid->data2)) 2898 return 1; 2899 else if (guid->data2 < UGETW(uguid->data2)) 2900 return -1; 2901 2902 if (guid->data3 > UGETW(uguid->data3)) 2903 return 1; 2904 else if (guid->data3 < UGETW(uguid->data3)) 2905 return -1; 2906 2907 return (memcmp(guid->data4, uguid->data4, 8)); 2908 } 2909
Indexes created Thu Sep 25 16:09:42 GMT 2025