1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 26 /* 27 * USB video class driver (usbvc(7D)) 28 * 29 * 1. Overview 30 * ------------ 31 * 32 * This driver supports USB video class devices that used to capture video, 33 * e.g., some webcams. It is developed according to "USB Device Class 34 * Definition for Video Devices" spec. This spec defines detail info needed by 35 * designing a USB video device. It is available at: 36 * http://www.usb.org/developers/devclass_docs 37 * 38 * This driver implements: 39 * 40 * - V4L2 interfaces for applications to communicate with video devices. 41 * V4L2 is an API that is widely used by video applications, like Ekiga, 42 * luvcview, etc. The API spec is at: 43 * http://www.thedirks.org/v4l2/ 44 * This driver is according to V4L2 spec version 0.20 45 * 46 * - Video capture function. (Video output is not supported by now.) 47 * 48 * - Isochronous transfer for video data. (Bulk transfer is not supported.) 49 * 50 * - read & mmap I/O methods for userland video applications to get video 51 * data. Userland video applications can use read() system call directly, 52 * it is the simplest way but not the most efficient way. Applications can 53 * also use mmap() system call to map several bufs (they are linked as a 54 * buf list), and then use some specific ioctls to start/stop isoc polling, 55 * to queue/dequeue bufs. 56 * 57 * 2. Source and header files 58 * --------------------------- 59 * 60 * There are two source files and three header files for this driver: 61 * 62 * - usbvc.c Main source file, implements usb video class spec. 63 * 64 * - usbvc_v4l2.c V4L2 interface specific code. 65 * 66 * - usbvc_var.h Main header file, includes soft state structure. 67 * 68 * - usbvc.h The descriptors in usb video class spec. 69 * 70 * - videodev2.h This header file is included in V4L2 spec. It defines 71 * ioctls and data structures that used as an interface between video 72 * applications and video drivers. This is the only header file that 73 * usbvc driver should export to userland application. 74 * 75 * 3. USB video class devices overview 76 * ----------------------------------- 77 * According to UVC spec, there must be one control interface in a UVC device. 78 * Control interface is used to receive control commands from user, all the 79 * commands are sent through default ctrl pipe. usbvc driver implements V4L2 80 * API, so ioctls are implemented to relay user commands to UVC device. 81 * 82 * There can be no or multiple stream interfaces in a UVC device. Stream 83 * interfaces are used to do video data I/O. In practice, if no stream 84 * interface, the video device can do nothing since it has no data I/O. 85 * 86 * usbvc driver parses descriptors of control interface and stream interfaces. 87 * The descriptors tell the function layout and the capability of the device. 88 * During attach, usbvc driver set up some key data structures according to 89 * the descriptors. 90 * 91 * 4. I/O methods 92 * --------------- 93 * 94 * Userland applications use ioctls to set/get video formats of the device, 95 * and control brightness, contrast, image size, etc. 96 * 97 * Besides implementing standard read I/O method to get video data from 98 * the device, usbvc driver also implements some specific ioctls to implement 99 * mmap I/O method. 100 * 101 * A view from userland application: ioctl and mmap flow chart: 102 * 103 * REQBUFS -> QUERYBUF -> mmap() -> 104 * 105 * -> QBUF -> STREAMON -> DQBUF -> process image -> QBUF 106 * ^ | 107 * | | 108 * | v 109 * |---<-------------------- 110 * 111 * The above queue and dequeue buf operations can be stopped by issuing a 112 * STREAMOFF ioctl. 113 * 114 * 5. Device states 115 * ---------------- 116 * 117 * The device has four states (refer to usbai.h): 118 * 119 * - USB_DEV_ONLINE: In action or ready for action. 120 * 121 * - USB_DEV_DISCONNECTED: Hotplug removed, or device not present/correct 122 * on resume (CPR). 123 * 124 * - USB_DEV_SUSPENDED: Device has been suspended along with the system. 125 * 126 * - USB_DEV_PWRED_DOWN: Device has been powered down. (Note that this 127 * driver supports only two power states, powered down and 128 * full power.) 129 * 130 * 6. Serialize 131 * ------------- 132 * In order to avoid race conditions between driver entry points, access to 133 * the device is serialized. All the ioctls, and read, open/close are 134 * serialized. The functions usbvc_serialize/release_access are implemented 135 * for this purpose. 136 * 137 * 7. PM & CPR 138 * ------------ 139 * PM & CPR are supported. pm_busy_component and pm_idle_component mark 140 * the device as busy or idle to the system. 141 */ 142 143 #if defined(lint) && !defined(DEBUG) 144 #define DEBUG 145 #endif 146 147 #define USBDRV_MAJOR_VER 2 148 #define USBDRV_MINOR_VER 0 149 150 #include <sys/usb/usba.h> 151 #include <sys/fcntl.h> 152 #include <sys/cmn_err.h> 153 #include <sys/usb/clients/video/usbvc/usbvc_var.h> 154 #include <sys/videodev2.h> /* V4L2 API header file */ 155 156 /* Descriptors according to USB video class spec */ 157 #include <sys/usb/clients/video/usbvc/usbvc.h> 158 159 static uint_t usbvc_errmask = (uint_t)PRINT_MASK_ALL; 160 static uint_t usbvc_errlevel = 4; 161 static uint_t usbvc_instance_debug = (uint_t)-1; 162 163 static char *name = "usbvc"; /* Driver name, used all over. */ 164 165 /* 166 * Function Prototypes 167 */ 168 169 /* Entries */ 170 static int usbvc_info(dev_info_t *, ddi_info_cmd_t, void *, void **); 171 static int usbvc_attach(dev_info_t *, ddi_attach_cmd_t); 172 static int usbvc_detach(dev_info_t *, ddi_detach_cmd_t); 173 static void usbvc_cleanup(dev_info_t *, usbvc_state_t *); 174 static int usbvc_open(dev_t *, int, int, cred_t *); 175 static int usbvc_close(dev_t, int, int, cred_t *); 176 static int usbvc_read(dev_t, struct uio *uip_p, cred_t *); 177 static int usbvc_strategy(struct buf *); 178 static void usbvc_minphys(struct buf *); 179 static int usbvc_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 180 static int usbvc_devmap(dev_t, devmap_cookie_t, offset_t, 181 size_t, size_t *, uint_t); 182 183 /* pm and cpr */ 184 static int usbvc_power(dev_info_t *, int, int); 185 static void usbvc_init_power_mgmt(usbvc_state_t *); 186 static void usbvc_destroy_power_mgmt(usbvc_state_t *); 187 static void usbvc_pm_busy_component(usbvc_state_t *); 188 static void usbvc_pm_idle_component(usbvc_state_t *); 189 static int usbvc_pwrlvl0(usbvc_state_t *); 190 static int usbvc_pwrlvl1(usbvc_state_t *); 191 static int usbvc_pwrlvl2(usbvc_state_t *); 192 static int usbvc_pwrlvl3(usbvc_state_t *); 193 static void usbvc_cpr_suspend(dev_info_t *); 194 static void usbvc_cpr_resume(dev_info_t *); 195 static void usbvc_restore_device_state(dev_info_t *, usbvc_state_t *); 196 197 /* Events */ 198 static int usbvc_disconnect_event_cb(dev_info_t *); 199 static int usbvc_reconnect_event_cb(dev_info_t *); 200 201 /* Sync objs and lists */ 202 static void usbvc_init_sync_objs(usbvc_state_t *); 203 static void usbvc_fini_sync_objs(usbvc_state_t *); 204 static void usbvc_init_lists(usbvc_state_t *); 205 static void usbvc_fini_lists(usbvc_state_t *); 206 static void usbvc_free_ctrl_descr(usbvc_state_t *); 207 static void usbvc_free_stream_descr(usbvc_state_t *); 208 209 /* Parse descriptors */ 210 static int usbvc_chk_descr_len(uint8_t, uint8_t, uint8_t, 211 usb_cvs_data_t *); 212 static usbvc_stream_if_t *usbvc_parse_stream_if(usbvc_state_t *, int); 213 static int usbvc_parse_ctrl_if(usbvc_state_t *); 214 static int usbvc_parse_stream_ifs(usbvc_state_t *); 215 static void usbvc_parse_color_still(usbvc_state_t *, 216 usbvc_format_group_t *, usb_cvs_data_t *, uint_t, uint_t); 217 static void usbvc_parse_frames(usbvc_state_t *, usbvc_format_group_t *, 218 usb_cvs_data_t *, uint_t, uint_t); 219 static int usbvc_parse_format_group(usbvc_state_t *, 220 usbvc_format_group_t *, usb_cvs_data_t *, uint_t, uint_t); 221 static int usbvc_parse_format_groups(usbvc_state_t *, usbvc_stream_if_t *); 222 static int usbvc_parse_stream_header(usbvc_state_t *, usbvc_stream_if_t *); 223 224 /* read I/O functions */ 225 static int usbvc_alloc_read_bufs(usbvc_state_t *, usbvc_stream_if_t *); 226 static int usbvc_read_buf(usbvc_state_t *, struct buf *); 227 static void usbvc_free_read_buf(usbvc_buf_t *); 228 static void usbvc_free_read_bufs(usbvc_state_t *, usbvc_stream_if_t *); 229 static void usbvc_close_isoc_pipe(usbvc_state_t *, usbvc_stream_if_t *); 230 231 /* callbacks */ 232 static void usbvc_isoc_cb(usb_pipe_handle_t, usb_isoc_req_t *); 233 static void usbvc_isoc_exc_cb(usb_pipe_handle_t, usb_isoc_req_t *); 234 235 /* Others */ 236 static int usbvc_set_alt(usbvc_state_t *, usbvc_stream_if_t *); 237 static int usbvc_decode_stream_header(usbvc_state_t *, usbvc_buf_grp_t *, 238 mblk_t *, int); 239 static int usbvc_serialize_access(usbvc_state_t *, boolean_t); 240 static void usbvc_release_access(usbvc_state_t *); 241 static int usbvc_set_default_stream_fmt(usbvc_state_t *); 242 243 static usb_event_t usbvc_events = { 244 usbvc_disconnect_event_cb, 245 usbvc_reconnect_event_cb, 246 NULL, NULL 247 }; 248 249 /* module loading stuff */ 250 struct cb_ops usbvc_cb_ops = { 251 usbvc_open, /* open */ 252 usbvc_close, /* close */ 253 usbvc_strategy, /* strategy */ 254 nulldev, /* print */ 255 nulldev, /* dump */ 256 usbvc_read, /* read */ 257 nodev, /* write */ 258 usbvc_ioctl, /* ioctl */ 259 usbvc_devmap, /* devmap */ 260 nodev, /* mmap */ 261 ddi_devmap_segmap, /* segmap */ 262 nochpoll, /* poll */ 263 ddi_prop_op, /* cb_prop_op */ 264 NULL, /* streamtab */ 265 D_MP | D_DEVMAP 266 }; 267 268 static struct dev_ops usbvc_ops = { 269 DEVO_REV, /* devo_rev, */ 270 0, /* refcnt */ 271 usbvc_info, /* info */ 272 nulldev, /* identify */ 273 nulldev, /* probe */ 274 usbvc_attach, /* attach */ 275 usbvc_detach, /* detach */ 276 nodev, /* reset */ 277 &usbvc_cb_ops, /* driver operations */ 278 NULL, /* bus operations */ 279 usbvc_power, /* power */ 280 ddi_quiesce_not_needed, /* quiesce */ 281 }; 282 283 static struct modldrv usbvc_modldrv = { 284 &mod_driverops, 285 "USB video class driver", 286 &usbvc_ops 287 }; 288 289 static struct modlinkage modlinkage = { 290 MODREV_1, 291 &usbvc_modldrv, 292 NULL 293 }; 294 295 /* Soft state structures */ 296 #define USBVC_INITIAL_SOFT_SPACE 1 297 static void *usbvc_statep; 298 299 300 /* 301 * Module-wide initialization routine. 302 */ 303 int 304 _init(void) 305 { 306 int rval; 307 308 if ((rval = ddi_soft_state_init(&usbvc_statep, 309 sizeof (usbvc_state_t), USBVC_INITIAL_SOFT_SPACE)) != 0) { 310 311 return (rval); 312 } 313 314 if ((rval = mod_install(&modlinkage)) != 0) { 315 ddi_soft_state_fini(&usbvc_statep); 316 } 317 318 return (rval); 319 } 320 321 322 /* 323 * Module-wide tear-down routine. 324 */ 325 int 326 _fini(void) 327 { 328 int rval; 329 330 if ((rval = mod_remove(&modlinkage)) != 0) { 331 332 return (rval); 333 } 334 335 ddi_soft_state_fini(&usbvc_statep); 336 337 return (rval); 338 } 339 340 341 int 342 _info(struct modinfo *modinfop) 343 { 344 return (mod_info(&modlinkage, modinfop)); 345 } 346 347 348 /* 349 * usbvc_info: 350 * Get minor number, soft state structure, etc. 351 */ 352 /*ARGSUSED*/ 353 static int 354 usbvc_info(dev_info_t *dip, ddi_info_cmd_t infocmd, 355 void *arg, void **result) 356 { 357 usbvc_state_t *usbvcp; 358 int error = DDI_FAILURE; 359 360 switch (infocmd) { 361 case DDI_INFO_DEVT2DEVINFO: 362 if ((usbvcp = ddi_get_soft_state(usbvc_statep, 363 getminor((dev_t)arg))) != NULL) { 364 *result = usbvcp->usbvc_dip; 365 if (*result != NULL) { 366 error = DDI_SUCCESS; 367 } 368 } else { 369 *result = NULL; 370 } 371 break; 372 case DDI_INFO_DEVT2INSTANCE: 373 *result = (void *)(uintptr_t)getminor((dev_t)arg); 374 error = DDI_SUCCESS; 375 break; 376 default: 377 break; 378 } 379 380 return (error); 381 } 382 383 384 /* 385 * Entry functions. 386 */ 387 388 /* 389 * usbvc_attach: 390 * Attach or resume. 391 * 392 * For attach, initialize state and device, including: 393 * state variables, locks, device node 394 * device registration with system 395 * power management, hotplugging 396 * For resume, restore device and state 397 */ 398 static int 399 usbvc_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 400 { 401 int instance = ddi_get_instance(dip); 402 usbvc_state_t *usbvcp = NULL; 403 int status; 404 405 switch (cmd) { 406 case DDI_ATTACH: 407 408 break; 409 case DDI_RESUME: 410 usbvc_cpr_resume(dip); 411 412 return (DDI_SUCCESS); 413 default: 414 415 return (DDI_FAILURE); 416 } 417 418 if (ddi_soft_state_zalloc(usbvc_statep, instance) == DDI_SUCCESS) { 419 usbvcp = ddi_get_soft_state(usbvc_statep, instance); 420 } 421 if (usbvcp == NULL) { 422 423 return (DDI_FAILURE); 424 } 425 426 usbvcp->usbvc_dip = dip; 427 428 usbvcp->usbvc_log_handle = usb_alloc_log_hdl(dip, 429 "usbvc", &usbvc_errlevel, 430 &usbvc_errmask, &usbvc_instance_debug, 0); 431 432 USB_DPRINTF_L3(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 433 "usbvc_attach: enter"); 434 435 if ((status = usb_client_attach(dip, USBDRV_VERSION, 0)) != 436 USB_SUCCESS) { 437 USB_DPRINTF_L2(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 438 "usbvc_attach: usb_client_attach failed, error code:%d", 439 status); 440 441 goto fail; 442 } 443 444 if ((status = usb_get_dev_data(dip, &usbvcp->usbvc_reg, 445 USB_PARSE_LVL_ALL, 0)) != USB_SUCCESS) { 446 USB_DPRINTF_L2(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 447 "usbvc_attach: usb_get_dev_data failed, error code:%d", 448 status); 449 450 goto fail; 451 } 452 usbvc_init_sync_objs(usbvcp); 453 454 /* create minor node */ 455 if ((status = ddi_create_minor_node(dip, name, S_IFCHR, instance, 456 "usb_video", 0)) != DDI_SUCCESS) { 457 USB_DPRINTF_L2(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 458 "usbvc_attach: Error creating minor node, error code:%d", 459 status); 460 461 goto fail; 462 } 463 464 mutex_enter(&usbvcp->usbvc_mutex); 465 usbvc_init_lists(usbvcp); 466 467 usbvcp->usbvc_default_ph = usbvcp->usbvc_reg->dev_default_ph; 468 469 /* Put online before PM init as can get power managed afterward. */ 470 usbvcp->usbvc_dev_state = USB_DEV_ONLINE; 471 mutex_exit(&usbvcp->usbvc_mutex); 472 473 /* initialize power management */ 474 usbvc_init_power_mgmt(usbvcp); 475 476 if ((status = usbvc_parse_ctrl_if(usbvcp)) != USB_SUCCESS) { 477 USB_DPRINTF_L2(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 478 "usbvc_attach: parse ctrl interface fail, error code:%d", 479 status); 480 481 goto fail; 482 } 483 if ((status = usbvc_parse_stream_ifs(usbvcp)) != USB_SUCCESS) { 484 USB_DPRINTF_L2(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 485 "usbvc_attach: parse stream interfaces fail, error code:%d", 486 status); 487 488 goto fail; 489 } 490 (void) usbvc_set_default_stream_fmt(usbvcp); 491 492 /* Register for events */ 493 if ((status = usb_register_event_cbs(dip, &usbvc_events, 0)) != 494 USB_SUCCESS) { 495 USB_DPRINTF_L2(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 496 "usbvc_attach: register_event_cbs failed, error code:%d", 497 status); 498 499 goto fail; 500 } 501 502 /* Report device */ 503 ddi_report_dev(dip); 504 505 return (DDI_SUCCESS); 506 507 fail: 508 if (usbvcp) { 509 usbvc_cleanup(dip, usbvcp); 510 } 511 512 return (DDI_FAILURE); 513 } 514 515 516 /* 517 * usbvc_detach: 518 * detach or suspend driver instance 519 * 520 * Note: in detach, only contention threads is from pm and disconnnect. 521 */ 522 static int 523 usbvc_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 524 { 525 int instance = ddi_get_instance(dip); 526 usbvc_state_t *usbvcp = ddi_get_soft_state(usbvc_statep, instance); 527 int rval = USB_FAILURE; 528 529 switch (cmd) { 530 case DDI_DETACH: 531 mutex_enter(&usbvcp->usbvc_mutex); 532 ASSERT((usbvcp->usbvc_drv_state & USBVC_OPEN) == 0); 533 mutex_exit(&usbvcp->usbvc_mutex); 534 535 USB_DPRINTF_L3(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 536 "usbvc_detach: enter for detach"); 537 538 usbvc_cleanup(dip, usbvcp); 539 rval = USB_SUCCESS; 540 541 break; 542 case DDI_SUSPEND: 543 USB_DPRINTF_L3(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 544 "usbvc_detach: enter for suspend"); 545 546 usbvc_cpr_suspend(dip); 547 rval = USB_SUCCESS; 548 549 break; 550 default: 551 552 break; 553 } 554 555 return ((rval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE); 556 } 557 558 559 /* 560 * usbvc_cleanup: 561 * clean up the driver state for detach 562 */ 563 static void 564 usbvc_cleanup(dev_info_t *dip, usbvc_state_t *usbvcp) 565 { 566 USB_DPRINTF_L4(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 567 "Cleanup: enter"); 568 569 if (usbvcp->usbvc_locks_initialized) { 570 571 /* This must be done 1st to prevent more events from coming. */ 572 usb_unregister_event_cbs(dip, &usbvc_events); 573 574 /* 575 * At this point, no new activity can be initiated. The driver 576 * has disabled hotplug callbacks. The Solaris framework has 577 * disabled new opens on a device being detached, and does not 578 * allow detaching an open device. 579 * 580 * The following ensures that all driver activity has drained. 581 */ 582 mutex_enter(&usbvcp->usbvc_mutex); 583 (void) usbvc_serialize_access(usbvcp, USBVC_SER_NOSIG); 584 usbvc_release_access(usbvcp); 585 mutex_exit(&usbvcp->usbvc_mutex); 586 587 /* All device activity has died down. */ 588 usbvc_destroy_power_mgmt(usbvcp); 589 mutex_enter(&usbvcp->usbvc_mutex); 590 usbvc_fini_lists(usbvcp); 591 mutex_exit(&usbvcp->usbvc_mutex); 592 593 ddi_remove_minor_node(dip, NULL); 594 usbvc_fini_sync_objs(usbvcp); 595 } 596 597 usb_client_detach(dip, usbvcp->usbvc_reg); 598 usb_free_log_hdl(usbvcp->usbvc_log_handle); 599 ddi_soft_state_free(usbvc_statep, ddi_get_instance(dip)); 600 ddi_prop_remove_all(dip); 601 } 602 603 604 /*ARGSUSED*/ 605 static int 606 usbvc_open(dev_t *devp, int flag, int otyp, cred_t *cred_p) 607 { 608 usbvc_state_t *usbvcp = 609 ddi_get_soft_state(usbvc_statep, getminor(*devp)); 610 611 if (usbvcp == NULL) { 612 613 return (ENXIO); 614 } 615 616 /* 617 * Keep it simple: one client at a time. 618 * Exclusive open only 619 */ 620 mutex_enter(&usbvcp->usbvc_mutex); 621 USB_DPRINTF_L4(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 622 "usbvc_open: enter, dev_stat=%d", usbvcp->usbvc_dev_state); 623 624 if (usbvcp->usbvc_dev_state == USB_DEV_DISCONNECTED) { 625 mutex_exit(&usbvcp->usbvc_mutex); 626 627 return (ENODEV); 628 } 629 if (usbvcp->usbvc_dev_state == USB_DEV_SUSPENDED) { 630 mutex_exit(&usbvcp->usbvc_mutex); 631 632 return (EIO); 633 } 634 if ((usbvcp->usbvc_drv_state & USBVC_OPEN) != 0) { 635 mutex_exit(&usbvcp->usbvc_mutex); 636 637 return (EBUSY); 638 } 639 usbvcp->usbvc_drv_state |= USBVC_OPEN; 640 641 if (usbvc_serialize_access(usbvcp, USBVC_SER_SIG) == 0) { 642 usbvcp->usbvc_drv_state &= ~USBVC_OPEN; 643 usbvcp->usbvc_serial_inuse = B_FALSE; 644 mutex_exit(&usbvcp->usbvc_mutex); 645 646 return (EINTR); 647 } 648 649 /* raise power */ 650 usbvc_pm_busy_component(usbvcp); 651 if (usbvcp->usbvc_pm->usbvc_current_power != USB_DEV_OS_FULL_PWR) { 652 usbvcp->usbvc_pm->usbvc_raise_power = B_TRUE; 653 mutex_exit(&usbvcp->usbvc_mutex); 654 (void) pm_raise_power(usbvcp->usbvc_dip, 655 0, USB_DEV_OS_FULL_PWR); 656 mutex_enter(&usbvcp->usbvc_mutex); 657 usbvcp->usbvc_pm->usbvc_raise_power = B_FALSE; 658 } 659 660 /* Device is idle until it is used. */ 661 usbvc_release_access(usbvcp); 662 mutex_exit(&usbvcp->usbvc_mutex); 663 664 USB_DPRINTF_L4(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 665 "usbvc_open: end."); 666 667 return (0); 668 } 669 670 671 /*ARGSUSED*/ 672 static int 673 usbvc_close(dev_t dev, int flag, int otyp, cred_t *cred_p) 674 { 675 usbvc_stream_if_t *strm_if; 676 int if_num; 677 usbvc_state_t *usbvcp = 678 ddi_get_soft_state(usbvc_statep, getminor(dev)); 679 680 USB_DPRINTF_L4(PRINT_MASK_CLOSE, usbvcp->usbvc_log_handle, 681 "close: enter"); 682 683 mutex_enter(&usbvcp->usbvc_mutex); 684 (void) usbvc_serialize_access(usbvcp, USBVC_SER_NOSIG); 685 mutex_exit(&usbvcp->usbvc_mutex); 686 687 /* Perform device session cleanup here. */ 688 689 USB_DPRINTF_L3(PRINT_MASK_CLOSE, usbvcp->usbvc_log_handle, 690 "close: cleaning up..."); 691 692 /* 693 * USBA automatically flushes/resets active non-default pipes 694 * when they are closed. We can't reset default pipe, but we 695 * can wait for all requests on it from this dip to drain. 696 */ 697 (void) usb_pipe_drain_reqs(usbvcp->usbvc_dip, 698 usbvcp->usbvc_reg->dev_default_ph, 0, 699 USB_FLAGS_SLEEP, NULL, 0); 700 701 mutex_enter(&usbvcp->usbvc_mutex); 702 strm_if = usbvcp->usbvc_curr_strm; 703 if (strm_if->start_polling == 1) { 704 mutex_exit(&usbvcp->usbvc_mutex); 705 usb_pipe_stop_isoc_polling(strm_if->datain_ph, USB_FLAGS_SLEEP); 706 mutex_enter(&usbvcp->usbvc_mutex); 707 strm_if->start_polling = 0; 708 } 709 strm_if->stream_on = 0; 710 711 usbvc_close_isoc_pipe(usbvcp, strm_if); 712 if_num = strm_if->if_descr->if_alt->altif_descr.bInterfaceNumber; 713 mutex_exit(&usbvcp->usbvc_mutex); 714 715 /* reset alternate to the default one. */ 716 (void) usb_set_alt_if(usbvcp->usbvc_dip, if_num, 0, 717 USB_FLAGS_SLEEP, NULL, NULL); 718 mutex_enter(&usbvcp->usbvc_mutex); 719 720 usbvc_free_read_bufs(usbvcp, strm_if); 721 722 /* reset the desired read buf number to the default value on close */ 723 strm_if->buf_read_num = USBVC_DEFAULT_READ_BUF_NUM; 724 725 usbvc_free_map_bufs(usbvcp, strm_if); 726 usbvcp->usbvc_drv_state &= ~USBVC_OPEN; 727 728 usbvc_release_access(usbvcp); 729 usbvc_pm_idle_component(usbvcp); 730 mutex_exit(&usbvcp->usbvc_mutex); 731 732 return (0); 733 } 734 735 736 /*ARGSUSED*/ 737 /* Read isoc data from usb video devices */ 738 static int 739 usbvc_read(dev_t dev, struct uio *uio_p, cred_t *cred_p) 740 { 741 int rval; 742 usbvc_stream_if_t *strm_if; 743 usbvc_state_t *usbvcp = 744 ddi_get_soft_state(usbvc_statep, getminor(dev)); 745 746 USB_DPRINTF_L4(PRINT_MASK_READ, usbvcp->usbvc_log_handle, 747 "usbvc_read: enter"); 748 mutex_enter(&usbvcp->usbvc_mutex); 749 if (usbvcp->usbvc_dev_state != USB_DEV_ONLINE) { 750 USB_DPRINTF_L2(PRINT_MASK_READ, usbvcp->usbvc_log_handle, 751 "usbvc_read: Device is not available," 752 " dev_stat=%d", usbvcp->usbvc_dev_state); 753 mutex_exit(&usbvcp->usbvc_mutex); 754 755 return (EFAULT); 756 } 757 if ((uio_p->uio_fmode & (FNDELAY|FNONBLOCK)) && 758 (usbvcp->usbvc_serial_inuse != B_FALSE)) { 759 USB_DPRINTF_L2(PRINT_MASK_READ, usbvcp->usbvc_log_handle, 760 "usbvc_read: non-blocking read, return fail."); 761 mutex_exit(&usbvcp->usbvc_mutex); 762 763 return (EAGAIN); 764 } 765 if (usbvc_serialize_access(usbvcp, USBVC_SER_SIG) <= 0) { 766 USB_DPRINTF_L2(PRINT_MASK_READ, usbvcp->usbvc_log_handle, 767 "usbvc_read: serialize_access failed."); 768 rval = EFAULT; 769 770 goto fail; 771 } 772 773 /* Get the first stream interface */ 774 strm_if = usbvcp->usbvc_curr_strm; 775 if (!strm_if) { 776 USB_DPRINTF_L2(PRINT_MASK_READ, usbvcp->usbvc_log_handle, 777 "usbvc_read: no stream interfaces"); 778 rval = EFAULT; 779 780 goto fail; 781 } 782 783 /* 784 * If it is the first read, open isoc pipe and allocate bufs for 785 * read I/O method. 786 */ 787 if (strm_if->datain_ph == NULL) { 788 if (usbvc_open_isoc_pipe(usbvcp, strm_if) != USB_SUCCESS) { 789 USB_DPRINTF_L2(PRINT_MASK_READ, 790 usbvcp->usbvc_log_handle, 791 "usbvc_read: first read, open pipe fail"); 792 rval = EFAULT; 793 794 goto fail; 795 } 796 if (usbvc_alloc_read_bufs(usbvcp, strm_if) != USB_SUCCESS) { 797 USB_DPRINTF_L2(PRINT_MASK_READ, 798 usbvcp->usbvc_log_handle, 799 "usbvc_read: allocate rw bufs fail"); 800 rval = EFAULT; 801 802 goto fail; 803 } 804 } 805 806 /* start polling if it is not started yet */ 807 if (strm_if->start_polling != 1) { 808 if (usbvc_start_isoc_polling(usbvcp, strm_if, NULL) != 809 USB_SUCCESS) { 810 USB_DPRINTF_L2(PRINT_MASK_READ, 811 usbvcp->usbvc_log_handle, 812 "usbvc_read: usbvc_start_isoc_polling fail"); 813 rval = EFAULT; 814 815 goto fail; 816 } 817 strm_if->start_polling = 1; 818 } 819 820 if (list_is_empty(&strm_if->buf_read.uv_buf_done)) { 821 USB_DPRINTF_L3(PRINT_MASK_READ, usbvcp->usbvc_log_handle, 822 "usbvc_read: full buf list is empty."); 823 824 if (uio_p->uio_fmode & (FNDELAY | FNONBLOCK)) { 825 USB_DPRINTF_L2(PRINT_MASK_READ, 826 usbvcp->usbvc_log_handle, "usbvc_read: fail, " 827 "non-blocking read, done buf is empty."); 828 rval = EAGAIN; 829 830 goto fail; 831 } 832 833 /* no available buffers, block here */ 834 while (list_is_empty(&strm_if->buf_read.uv_buf_done)) { 835 USB_DPRINTF_L3(PRINT_MASK_READ, 836 usbvcp->usbvc_log_handle, 837 "usbvc_read: wait for done buf"); 838 if (cv_wait_sig(&usbvcp->usbvc_read_cv, 839 &usbvcp->usbvc_mutex) <= 0) { 840 /* no done buf and cv is signaled */ 841 rval = EINTR; 842 843 goto fail; 844 } 845 if (usbvcp->usbvc_dev_state != USB_DEV_ONLINE) { 846 847 /* Device is disconnected. */ 848 rval = EINTR; 849 850 goto fail; 851 } 852 } 853 854 } 855 856 mutex_exit(&usbvcp->usbvc_mutex); 857 rval = physio(usbvc_strategy, NULL, dev, B_READ, 858 usbvc_minphys, uio_p); 859 860 mutex_enter(&usbvcp->usbvc_mutex); 861 usbvc_release_access(usbvcp); 862 mutex_exit(&usbvcp->usbvc_mutex); 863 864 return (rval); 865 866 fail: 867 usbvc_release_access(usbvcp); 868 mutex_exit(&usbvcp->usbvc_mutex); 869 870 return (rval); 871 } 872 873 874 /* 875 * strategy: 876 * Called through physio to setup and start the transfer. 877 */ 878 static int 879 usbvc_strategy(struct buf *bp) 880 { 881 usbvc_state_t *usbvcp = ddi_get_soft_state(usbvc_statep, 882 getminor(bp->b_edev)); 883 884 USB_DPRINTF_L4(PRINT_MASK_READ, usbvcp->usbvc_log_handle, 885 "usbvc_strategy: enter"); 886 887 /* 888 * Initialize residual count here in case transfer doesn't even get 889 * started. 890 */ 891 bp->b_resid = bp->b_bcount; 892 893 /* Needed as this is a character driver. */ 894 if (bp->b_flags & (B_PHYS | B_PAGEIO)) { 895 bp_mapin(bp); 896 } 897 898 mutex_enter(&usbvcp->usbvc_mutex); 899 900 /* Make sure device has not been disconnected. */ 901 if (usbvcp->usbvc_dev_state != USB_DEV_ONLINE) { 902 USB_DPRINTF_L2(PRINT_MASK_READ, usbvcp->usbvc_log_handle, 903 "usbvc_strategy: device can't be accessed"); 904 mutex_exit(&usbvcp->usbvc_mutex); 905 906 goto fail; 907 } 908 909 /* read data from uv_buf_done list */ 910 if (usbvc_read_buf(usbvcp, bp) != USB_SUCCESS) { 911 USB_DPRINTF_L2(PRINT_MASK_READ, usbvcp->usbvc_log_handle, 912 "usbvc_strategy: read full buf list fail"); 913 mutex_exit(&usbvcp->usbvc_mutex); 914 915 goto fail; 916 } 917 918 mutex_exit(&usbvcp->usbvc_mutex); 919 920 biodone(bp); 921 922 return (0); 923 924 fail: 925 USB_DPRINTF_L2(PRINT_MASK_READ, usbvcp->usbvc_log_handle, 926 "usbvc_strategy: strategy fail"); 927 bp->b_private = NULL; 928 929 bioerror(bp, EIO); 930 biodone(bp); 931 932 return (0); 933 } 934 935 936 static void 937 usbvc_minphys(struct buf *bp) 938 { 939 dev_t dev = bp->b_edev; 940 usbvc_stream_if_t *strm_if; 941 uint32_t maxsize; 942 usbvc_state_t *usbvcp = 943 ddi_get_soft_state(usbvc_statep, getminor(dev)); 944 945 mutex_enter(&usbvcp->usbvc_mutex); 946 strm_if = usbvcp->usbvc_curr_strm; 947 LE_TO_UINT32(strm_if->ctrl_pc.dwMaxVideoFrameSize, 0, maxsize); 948 USB_DPRINTF_L3(PRINT_MASK_READ, usbvcp->usbvc_log_handle, 949 "usbvc_minphys: max read size=%d", maxsize); 950 951 if (bp->b_bcount > maxsize) { 952 bp->b_bcount = maxsize; 953 } 954 mutex_exit(&usbvcp->usbvc_mutex); 955 } 956 957 958 /* 959 * ioctl entry. 960 */ 961 /*ARGSUSED*/ 962 static int 963 usbvc_ioctl(dev_t dev, int cmd, intptr_t arg, 964 int mode, cred_t *cred_p, int *rval_p) 965 { 966 int rv = 0; 967 usbvc_state_t *usbvcp = 968 ddi_get_soft_state(usbvc_statep, getminor(dev)); 969 970 if (usbvcp == NULL) { 971 972 return (ENXIO); 973 } 974 USB_DPRINTF_L4(PRINT_MASK_IOCTL, usbvcp->usbvc_log_handle, 975 "ioctl enter, cmd=%x", cmd); 976 mutex_enter(&usbvcp->usbvc_mutex); 977 if (usbvcp->usbvc_dev_state != USB_DEV_ONLINE) { 978 USB_DPRINTF_L2(PRINT_MASK_IOCTL, usbvcp->usbvc_log_handle, 979 "ioctl: Device is not online," 980 " dev_stat=%d", usbvcp->usbvc_dev_state); 981 mutex_exit(&usbvcp->usbvc_mutex); 982 983 return (EFAULT); 984 } 985 if (usbvc_serialize_access(usbvcp, USBVC_SER_SIG) <= 0) { 986 usbvcp->usbvc_serial_inuse = B_FALSE; 987 mutex_exit(&usbvcp->usbvc_mutex); 988 USB_DPRINTF_L2(PRINT_MASK_IOCTL, usbvcp->usbvc_log_handle, 989 "serialize_access failed."); 990 991 return (EFAULT); 992 } 993 mutex_exit(&usbvcp->usbvc_mutex); 994 995 rv = usbvc_v4l2_ioctl(usbvcp, cmd, arg, mode); 996 997 mutex_enter(&usbvcp->usbvc_mutex); 998 usbvc_release_access(usbvcp); 999 mutex_exit(&usbvcp->usbvc_mutex); 1000 1001 USB_DPRINTF_L4(PRINT_MASK_IOCTL, usbvcp->usbvc_log_handle, 1002 "usbvc_ioctl exit"); 1003 1004 return (rv); 1005 } 1006 1007 1008 /* Entry for mmap system call */ 1009 static int 1010 usbvc_devmap(dev_t dev, devmap_cookie_t handle, offset_t off, 1011 size_t len, size_t *maplen, uint_t model) 1012 { 1013 usbvc_state_t *usbvcp; 1014 int error, i; 1015 usbvc_buf_t *buf = NULL; 1016 usbvc_stream_if_t *strm_if; 1017 usbvc_buf_grp_t *bufgrp; 1018 1019 usbvcp = ddi_get_soft_state(usbvc_statep, getminor(dev)); 1020 if (usbvcp == NULL) { 1021 USB_DPRINTF_L2(PRINT_MASK_DEVMAP, usbvcp->usbvc_log_handle, 1022 "usbvc_devmap: usbvcp == NULL"); 1023 1024 return (ENXIO); 1025 } 1026 1027 USB_DPRINTF_L3(PRINT_MASK_DEVMAP, usbvcp->usbvc_log_handle, 1028 "devmap: memory map for instance(%d), off=%llx," 1029 "len=%ld, maplen=%ld, model=%d", getminor(dev), off, 1030 len, *maplen, model); 1031 1032 mutex_enter(&usbvcp->usbvc_mutex); 1033 (void) usbvc_serialize_access(usbvcp, USBVC_SER_NOSIG); 1034 strm_if = usbvcp->usbvc_curr_strm; 1035 if (!strm_if) { 1036 USB_DPRINTF_L2(PRINT_MASK_DEVMAP, usbvcp->usbvc_log_handle, 1037 "usbvc_devmap: No current strm if"); 1038 mutex_exit(&usbvcp->usbvc_mutex); 1039 1040 return (ENXIO); 1041 } 1042 bufgrp = &strm_if->buf_map; 1043 for (i = 0; i < bufgrp->buf_cnt; i++) { 1044 if (bufgrp->buf_head[i].v4l2_buf.m.offset == off) { 1045 buf = &bufgrp->buf_head[i]; 1046 1047 break; 1048 } 1049 } 1050 USB_DPRINTF_L3(PRINT_MASK_DEVMAP, usbvcp->usbvc_log_handle, 1051 "usbvc_devmap: idx=%d", i); 1052 if (buf == NULL) { 1053 mutex_exit(&usbvcp->usbvc_mutex); 1054 1055 return (ENXIO); 1056 } 1057 /* 1058 * round up len to a multiple of a page size, according to chapter 1059 * 10 of "writing device drivers" 1060 */ 1061 len = ptob(btopr(len)); 1062 if (len > ptob(btopr(buf->len))) { 1063 USB_DPRINTF_L2(PRINT_MASK_DEVMAP, usbvcp->usbvc_log_handle, 1064 "usbvc_devmap: len=0x%lx", len); 1065 mutex_exit(&usbvcp->usbvc_mutex); 1066 1067 return (ENXIO); 1068 } 1069 mutex_exit(&usbvcp->usbvc_mutex); 1070 1071 error = devmap_umem_setup(handle, usbvcp->usbvc_dip, NULL, 1072 buf->umem_cookie, off, len, PROT_ALL, DEVMAP_DEFAULTS, NULL); 1073 mutex_enter(&usbvcp->usbvc_mutex); 1074 *maplen = len; 1075 if (error == 0 && buf->status == USBVC_BUF_INIT) { 1076 buf->status = USBVC_BUF_MAPPED; 1077 } else { 1078 USB_DPRINTF_L3(PRINT_MASK_DEVMAP, usbvcp->usbvc_log_handle, 1079 "usbvc_devmap: devmap_umem_setup, err=%d", error); 1080 } 1081 1082 (void) usbvc_release_access(usbvcp); 1083 mutex_exit(&usbvcp->usbvc_mutex); 1084 1085 return (error); 1086 } 1087 1088 /* 1089 * pm and cpr 1090 */ 1091 1092 /* 1093 * usbvc_power : 1094 * Power entry point, the workhorse behind pm_raise_power, pm_lower_power, 1095 * usb_req_raise_power and usb_req_lower_power. 1096 */ 1097 /* ARGSUSED */ 1098 static int 1099 usbvc_power(dev_info_t *dip, int comp, int level) 1100 { 1101 usbvc_state_t *usbvcp; 1102 usbvc_power_t *pm; 1103 int rval = USB_FAILURE; 1104 1105 usbvcp = ddi_get_soft_state(usbvc_statep, ddi_get_instance(dip)); 1106 mutex_enter(&usbvcp->usbvc_mutex); 1107 USB_DPRINTF_L4(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1108 "usbvc_power: enter: level = %d, dev_state: %x", 1109 level, usbvcp->usbvc_dev_state); 1110 1111 if (usbvcp->usbvc_pm == NULL) { 1112 1113 goto done; 1114 } 1115 1116 pm = usbvcp->usbvc_pm; 1117 1118 /* Check if we are transitioning to a legal power level */ 1119 if (USB_DEV_PWRSTATE_OK(pm->usbvc_pwr_states, level)) { 1120 USB_DPRINTF_L2(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 1121 "usbvc_power: illegal power level = %d " 1122 "pwr_states: %x", level, pm->usbvc_pwr_states); 1123 1124 goto done; 1125 } 1126 /* 1127 * if we are about to raise power and asked to lower power, fail 1128 */ 1129 if (pm->usbvc_raise_power && (level < (int)pm->usbvc_current_power)) { 1130 1131 goto done; 1132 } 1133 switch (level) { 1134 case USB_DEV_OS_PWR_OFF : 1135 rval = usbvc_pwrlvl0(usbvcp); 1136 1137 break; 1138 case USB_DEV_OS_PWR_1 : 1139 rval = usbvc_pwrlvl1(usbvcp); 1140 1141 break; 1142 case USB_DEV_OS_PWR_2 : 1143 rval = usbvc_pwrlvl2(usbvcp); 1144 1145 break; 1146 case USB_DEV_OS_FULL_PWR : 1147 rval = usbvc_pwrlvl3(usbvcp); 1148 1149 break; 1150 } 1151 1152 done: 1153 mutex_exit(&usbvcp->usbvc_mutex); 1154 1155 return ((rval == USB_SUCCESS) ? DDI_SUCCESS : DDI_FAILURE); 1156 } 1157 1158 1159 /* 1160 * usbvc_init_power_mgmt: 1161 * Initialize power management and remote wakeup functionality. 1162 * No mutex is necessary in this function as it's called only by attach. 1163 */ 1164 static void 1165 usbvc_init_power_mgmt(usbvc_state_t *usbvcp) 1166 { 1167 usbvc_power_t *usbvcpm; 1168 uint_t pwr_states; 1169 1170 USB_DPRINTF_L4(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1171 "init_power_mgmt enter"); 1172 1173 /* Allocate the state structure */ 1174 usbvcpm = kmem_zalloc(sizeof (usbvc_power_t), KM_SLEEP); 1175 mutex_enter(&usbvcp->usbvc_mutex); 1176 usbvcp->usbvc_pm = usbvcpm; 1177 usbvcpm->usbvc_state = usbvcp; 1178 usbvcpm->usbvc_pm_capabilities = 0; 1179 usbvcpm->usbvc_current_power = USB_DEV_OS_FULL_PWR; 1180 mutex_exit(&usbvcp->usbvc_mutex); 1181 1182 if (usb_create_pm_components(usbvcp->usbvc_dip, &pwr_states) == 1183 USB_SUCCESS) { 1184 USB_DPRINTF_L2(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1185 "usbvc_init_power_mgmt: created PM components"); 1186 1187 if (usb_handle_remote_wakeup(usbvcp->usbvc_dip, 1188 USB_REMOTE_WAKEUP_ENABLE) == USB_SUCCESS) { 1189 usbvcpm->usbvc_wakeup_enabled = 1; 1190 } else { 1191 USB_DPRINTF_L2(PRINT_MASK_ATTA, 1192 usbvcp->usbvc_log_handle, "usbvc_init_power_mgmt:" 1193 " remote wakeup not supported"); 1194 } 1195 1196 mutex_enter(&usbvcp->usbvc_mutex); 1197 usbvcpm->usbvc_pwr_states = (uint8_t)pwr_states; 1198 usbvc_pm_busy_component(usbvcp); 1199 usbvcpm->usbvc_raise_power = B_TRUE; 1200 mutex_exit(&usbvcp->usbvc_mutex); 1201 1202 (void) pm_raise_power( 1203 usbvcp->usbvc_dip, 0, USB_DEV_OS_FULL_PWR); 1204 1205 mutex_enter(&usbvcp->usbvc_mutex); 1206 usbvcpm->usbvc_raise_power = B_FALSE; 1207 usbvc_pm_idle_component(usbvcp); 1208 mutex_exit(&usbvcp->usbvc_mutex); 1209 1210 } 1211 USB_DPRINTF_L4(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1212 "usbvc_init_power_mgmt: end"); 1213 } 1214 1215 1216 /* 1217 * usbvc_destroy_power_mgmt: 1218 * Shut down and destroy power management and remote wakeup functionality. 1219 */ 1220 static void 1221 usbvc_destroy_power_mgmt(usbvc_state_t *usbvcp) 1222 { 1223 usbvc_power_t *pm; 1224 int rval; 1225 1226 USB_DPRINTF_L4(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1227 "destroy_power_mgmt enter"); 1228 mutex_enter(&usbvcp->usbvc_mutex); 1229 pm = usbvcp->usbvc_pm; 1230 if (pm && (usbvcp->usbvc_dev_state != USB_DEV_DISCONNECTED)) { 1231 1232 usbvc_pm_busy_component(usbvcp); 1233 if (pm->usbvc_wakeup_enabled) { 1234 pm->usbvc_raise_power = B_TRUE; 1235 mutex_exit(&usbvcp->usbvc_mutex); 1236 1237 /* First bring the device to full power */ 1238 (void) pm_raise_power(usbvcp->usbvc_dip, 0, 1239 USB_DEV_OS_FULL_PWR); 1240 if ((rval = usb_handle_remote_wakeup( 1241 usbvcp->usbvc_dip, 1242 USB_REMOTE_WAKEUP_DISABLE)) != 1243 USB_SUCCESS) { 1244 USB_DPRINTF_L2(PRINT_MASK_ATTA, 1245 usbvcp->usbvc_log_handle, 1246 "usbvc_destroy_power_mgmt: " 1247 "Error disabling rmt wakeup: rval = %d", 1248 rval); 1249 } 1250 mutex_enter(&usbvcp->usbvc_mutex); 1251 pm->usbvc_raise_power = B_FALSE; 1252 1253 } 1254 mutex_exit(&usbvcp->usbvc_mutex); 1255 1256 /* 1257 * Since remote wakeup is disabled now, 1258 * no one can raise power 1259 * and get to device once power is lowered here. 1260 */ 1261 (void) pm_lower_power(usbvcp->usbvc_dip, 0, USB_DEV_OS_PWR_OFF); 1262 mutex_enter(&usbvcp->usbvc_mutex); 1263 usbvc_pm_idle_component(usbvcp); 1264 } 1265 1266 if (pm) { 1267 kmem_free(pm, sizeof (usbvc_power_t)); 1268 usbvcp->usbvc_pm = NULL; 1269 } 1270 mutex_exit(&usbvcp->usbvc_mutex); 1271 } 1272 1273 1274 static void 1275 usbvc_pm_busy_component(usbvc_state_t *usbvcp) 1276 { 1277 ASSERT(mutex_owned(&usbvcp->usbvc_mutex)); 1278 USB_DPRINTF_L4(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1279 "usbvc_pm_busy_component: enter"); 1280 1281 usbvcp->usbvc_pm->usbvc_pm_busy++; 1282 mutex_exit(&usbvcp->usbvc_mutex); 1283 1284 if (pm_busy_component(usbvcp->usbvc_dip, 0) != 1285 DDI_SUCCESS) { 1286 mutex_enter(&usbvcp->usbvc_mutex); 1287 USB_DPRINTF_L2(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1288 "usbvc_pm_busy_component: pm busy fail, usbvc_pm_busy=%d", 1289 usbvcp->usbvc_pm->usbvc_pm_busy); 1290 1291 usbvcp->usbvc_pm->usbvc_pm_busy--; 1292 mutex_exit(&usbvcp->usbvc_mutex); 1293 } 1294 mutex_enter(&usbvcp->usbvc_mutex); 1295 USB_DPRINTF_L4(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1296 "usbvc_pm_busy_component: exit"); 1297 } 1298 1299 1300 static void 1301 usbvc_pm_idle_component(usbvc_state_t *usbvcp) 1302 { 1303 ASSERT(mutex_owned(&usbvcp->usbvc_mutex)); 1304 USB_DPRINTF_L4(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1305 "usbvc_pm_idle_component: enter"); 1306 1307 if (usbvcp->usbvc_pm != NULL) { 1308 mutex_exit(&usbvcp->usbvc_mutex); 1309 if (pm_idle_component(usbvcp->usbvc_dip, 0) == 1310 DDI_SUCCESS) { 1311 mutex_enter(&usbvcp->usbvc_mutex); 1312 ASSERT(usbvcp->usbvc_pm->usbvc_pm_busy > 0); 1313 usbvcp->usbvc_pm->usbvc_pm_busy--; 1314 mutex_exit(&usbvcp->usbvc_mutex); 1315 } 1316 mutex_enter(&usbvcp->usbvc_mutex); 1317 USB_DPRINTF_L2(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1318 "usbvc_pm_idle_component: %d", 1319 usbvcp->usbvc_pm->usbvc_pm_busy); 1320 } 1321 } 1322 1323 1324 /* 1325 * usbvc_pwrlvl0: 1326 * Functions to handle power transition for OS levels 0 -> 3 1327 */ 1328 static int 1329 usbvc_pwrlvl0(usbvc_state_t *usbvcp) 1330 { 1331 int rval; 1332 1333 USB_DPRINTF_L4(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1334 "usbvc_pwrlvl0, dev_state: %x", usbvcp->usbvc_dev_state); 1335 1336 switch (usbvcp->usbvc_dev_state) { 1337 case USB_DEV_ONLINE: 1338 /* Deny the powerdown request if the device is busy */ 1339 if (usbvcp->usbvc_pm->usbvc_pm_busy != 0) { 1340 USB_DPRINTF_L2(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1341 "usbvc_pwrlvl0: usbvc_pm_busy"); 1342 1343 return (USB_FAILURE); 1344 } 1345 1346 /* Issue USB D3 command to the device here */ 1347 rval = usb_set_device_pwrlvl3(usbvcp->usbvc_dip); 1348 ASSERT(rval == USB_SUCCESS); 1349 1350 usbvcp->usbvc_dev_state = USB_DEV_PWRED_DOWN; 1351 usbvcp->usbvc_pm->usbvc_current_power = USB_DEV_OS_PWR_OFF; 1352 1353 /* FALLTHRU */ 1354 case USB_DEV_DISCONNECTED: 1355 case USB_DEV_SUSPENDED: 1356 /* allow a disconnect/cpr'ed device to go to lower power */ 1357 1358 return (USB_SUCCESS); 1359 case USB_DEV_PWRED_DOWN: 1360 default: 1361 USB_DPRINTF_L2(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1362 "usbvc_pwrlvl0: illegal dev state"); 1363 1364 return (USB_FAILURE); 1365 } 1366 } 1367 1368 1369 /* 1370 * usbvc_pwrlvl1: 1371 * Functions to handle power transition to OS levels -> 2 1372 */ 1373 static int 1374 usbvc_pwrlvl1(usbvc_state_t *usbvcp) 1375 { 1376 int rval; 1377 1378 USB_DPRINTF_L4(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1379 "usbvc_pwrlvl1"); 1380 1381 /* Issue USB D2 command to the device here */ 1382 rval = usb_set_device_pwrlvl2(usbvcp->usbvc_dip); 1383 ASSERT(rval == USB_SUCCESS); 1384 1385 return (USB_FAILURE); 1386 } 1387 1388 1389 /* 1390 * usbvc_pwrlvl2: 1391 * Functions to handle power transition to OS levels -> 1 1392 */ 1393 static int 1394 usbvc_pwrlvl2(usbvc_state_t *usbvcp) 1395 { 1396 int rval; 1397 1398 USB_DPRINTF_L4(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1399 "usbvc_pwrlvl2"); 1400 1401 /* Issue USB D1 command to the device here */ 1402 rval = usb_set_device_pwrlvl1(usbvcp->usbvc_dip); 1403 ASSERT(rval == USB_SUCCESS); 1404 1405 return (USB_FAILURE); 1406 } 1407 1408 1409 /* 1410 * usbvc_pwrlvl3: 1411 * Functions to handle power transition to OS level -> 0 1412 */ 1413 static int 1414 usbvc_pwrlvl3(usbvc_state_t *usbvcp) 1415 { 1416 USB_DPRINTF_L4(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1417 "usbvc_pwrlvl3, dev_stat=%d", usbvcp->usbvc_dev_state); 1418 1419 switch (usbvcp->usbvc_dev_state) { 1420 case USB_DEV_PWRED_DOWN: 1421 /* Issue USB D0 command to the device here */ 1422 (void) usb_set_device_pwrlvl0(usbvcp->usbvc_dip); 1423 1424 usbvcp->usbvc_dev_state = USB_DEV_ONLINE; 1425 usbvcp->usbvc_pm->usbvc_current_power = 1426 USB_DEV_OS_FULL_PWR; 1427 1428 /* FALLTHRU */ 1429 case USB_DEV_ONLINE: 1430 /* we are already in full power */ 1431 /* FALLTHRU */ 1432 case USB_DEV_DISCONNECTED: 1433 case USB_DEV_SUSPENDED: 1434 /* 1435 * PM framework tries to put us in full power 1436 * during system shutdown. If we are disconnected/cpr'ed 1437 * return success anyways 1438 */ 1439 1440 return (USB_SUCCESS); 1441 default: 1442 USB_DPRINTF_L2(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1443 "usbvc_pwrlvl3: illegal dev state"); 1444 1445 return (USB_FAILURE); 1446 } 1447 } 1448 1449 1450 /* 1451 * usbvc_cpr_suspend: 1452 * Clean up device. 1453 * Wait for any IO to finish, then close pipes. 1454 * Quiesce device. 1455 */ 1456 static void 1457 usbvc_cpr_suspend(dev_info_t *dip) 1458 { 1459 int instance = ddi_get_instance(dip); 1460 usbvc_state_t *usbvcp = ddi_get_soft_state(usbvc_statep, instance); 1461 1462 USB_DPRINTF_L4(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1463 "usbvc_cpr_suspend enter"); 1464 1465 mutex_enter(&usbvcp->usbvc_mutex); 1466 1467 /* 1468 * Set dev_state to suspended so other driver threads don't start any 1469 * new I/O. 1470 */ 1471 usbvcp->usbvc_dev_state = USB_DEV_SUSPENDED; 1472 1473 mutex_exit(&usbvcp->usbvc_mutex); 1474 1475 USB_DPRINTF_L4(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 1476 "usbvc_cpr_suspend: return"); 1477 } 1478 1479 1480 /* 1481 * If the polling has been stopped due to some exceptional errors, 1482 * we reconfigure the device and start polling again. Only for S/R 1483 * resume or hotplug reconnect operations. 1484 */ 1485 static int 1486 usbvc_resume_operation(usbvc_state_t *usbvcp) 1487 { 1488 usbvc_stream_if_t *strm_if; 1489 int rv = USB_SUCCESS; 1490 1491 USB_DPRINTF_L4(PRINT_MASK_IOCTL, usbvcp->usbvc_log_handle, 1492 "usbvc_resume_operation: enter"); 1493 1494 mutex_enter(&usbvcp->usbvc_mutex); 1495 strm_if = usbvcp->usbvc_curr_strm; 1496 if (!strm_if) { 1497 mutex_exit(&usbvcp->usbvc_mutex); 1498 rv = USB_FAILURE; 1499 1500 return (rv); 1501 } 1502 1503 /* 1504 * 1) if application has not started STREAMON ioctl yet, 1505 * just return 1506 * 2) if application use READ mode, return immediately 1507 */ 1508 if (strm_if->stream_on == 0) { 1509 mutex_exit(&usbvcp->usbvc_mutex); 1510 1511 return (rv); 1512 } 1513 1514 /* isoc pipe is expected to be opened already if (stream_on==1) */ 1515 if (!strm_if->datain_ph) { 1516 mutex_exit(&usbvcp->usbvc_mutex); 1517 rv = USB_FAILURE; 1518 1519 return (rv); 1520 } 1521 1522 mutex_exit(&usbvcp->usbvc_mutex); 1523 1524 /* first commit the parameters negotiated and saved during S_FMT */ 1525 if ((rv = usbvc_vs_set_probe_commit(usbvcp, strm_if, 1526 &strm_if->ctrl_pc, VS_COMMIT_CONTROL)) != USB_SUCCESS) { 1527 USB_DPRINTF_L2(PRINT_MASK_IOCTL, 1528 usbvcp->usbvc_log_handle, 1529 "usbvc_resume_operation: set probe failed, rv=%d", rv); 1530 1531 return (rv); 1532 } 1533 1534 mutex_enter(&usbvcp->usbvc_mutex); 1535 1536 /* Set alt interfaces, must be after probe_commit according to spec */ 1537 if ((rv = usbvc_set_alt(usbvcp, strm_if)) != USB_SUCCESS) { 1538 USB_DPRINTF_L2(PRINT_MASK_IOCTL, 1539 usbvcp->usbvc_log_handle, 1540 "usbvc_resume_operation: set alt failed"); 1541 mutex_exit(&usbvcp->usbvc_mutex); 1542 1543 return (rv); 1544 } 1545 1546 /* 1547 * The isoc polling could be stopped by isoc_exc_cb 1548 * during suspend or hotplug. Restart it. 1549 */ 1550 if (usbvc_start_isoc_polling(usbvcp, strm_if, V4L2_MEMORY_MMAP) 1551 != USB_SUCCESS) { 1552 rv = USB_FAILURE; 1553 mutex_exit(&usbvcp->usbvc_mutex); 1554 1555 return (rv); 1556 } 1557 1558 strm_if->start_polling = 1; 1559 1560 mutex_exit(&usbvcp->usbvc_mutex); 1561 1562 return (rv); 1563 } 1564 1565 /* 1566 * usbvc_cpr_resume: 1567 * 1568 * usbvc_restore_device_state marks success by putting device back online 1569 */ 1570 static void 1571 usbvc_cpr_resume(dev_info_t *dip) 1572 { 1573 int instance = ddi_get_instance(dip); 1574 usbvc_state_t *usbvcp = ddi_get_soft_state(usbvc_statep, instance); 1575 1576 USB_DPRINTF_L4(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 1577 "resume: enter"); 1578 1579 /* 1580 * NOTE: A pm_raise_power in usbvc_restore_device_state will bring 1581 * the power-up state of device into synch with the system. 1582 */ 1583 mutex_enter(&usbvcp->usbvc_mutex); 1584 usbvc_restore_device_state(dip, usbvcp); 1585 mutex_exit(&usbvcp->usbvc_mutex); 1586 } 1587 1588 1589 /* 1590 * usbvc_restore_device_state: 1591 * Called during hotplug-reconnect and resume. 1592 * reenable power management 1593 * Verify the device is the same as before the disconnect/suspend. 1594 * Restore device state 1595 * Thaw any IO which was frozen. 1596 * Quiesce device. (Other routines will activate if thawed IO.) 1597 * Set device online. 1598 * Leave device disconnected if there are problems. 1599 */ 1600 static void 1601 usbvc_restore_device_state(dev_info_t *dip, usbvc_state_t *usbvcp) 1602 { 1603 USB_DPRINTF_L4(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1604 "usbvc_restore_device_state: enter"); 1605 1606 ASSERT(mutex_owned(&usbvcp->usbvc_mutex)); 1607 1608 ASSERT((usbvcp->usbvc_dev_state == USB_DEV_DISCONNECTED) || 1609 (usbvcp->usbvc_dev_state == USB_DEV_SUSPENDED)); 1610 1611 usbvc_pm_busy_component(usbvcp); 1612 usbvcp->usbvc_pm->usbvc_raise_power = B_TRUE; 1613 mutex_exit(&usbvcp->usbvc_mutex); 1614 (void) pm_raise_power(dip, 0, USB_DEV_OS_FULL_PWR); 1615 1616 /* Check if we are talking to the same device */ 1617 if (usb_check_same_device(dip, usbvcp->usbvc_log_handle, 1618 USB_LOG_L0, PRINT_MASK_ALL, 1619 USB_CHK_BASIC|USB_CHK_CFG, NULL) != USB_SUCCESS) { 1620 1621 goto fail; 1622 } 1623 1624 mutex_enter(&usbvcp->usbvc_mutex); 1625 usbvcp->usbvc_pm->usbvc_raise_power = B_FALSE; 1626 usbvcp->usbvc_dev_state = USB_DEV_ONLINE; 1627 mutex_exit(&usbvcp->usbvc_mutex); 1628 1629 if (usbvcp->usbvc_pm->usbvc_wakeup_enabled) { 1630 1631 /* Failure here means device disappeared again. */ 1632 if (usb_handle_remote_wakeup(dip, USB_REMOTE_WAKEUP_ENABLE) != 1633 USB_SUCCESS) { 1634 USB_DPRINTF_L2(PRINT_MASK_ATTA, 1635 usbvcp->usbvc_log_handle, 1636 "device may or may not be accessible. " 1637 "Please verify reconnection"); 1638 } 1639 } 1640 1641 if (usbvc_resume_operation(usbvcp) != USB_SUCCESS) { 1642 USB_DPRINTF_L2(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1643 "usbvc_restore_device_state: can't resume operation"); 1644 1645 goto fail; 1646 } 1647 1648 mutex_enter(&usbvcp->usbvc_mutex); 1649 1650 usbvc_pm_idle_component(usbvcp); 1651 1652 USB_DPRINTF_L4(PRINT_MASK_PM, usbvcp->usbvc_log_handle, 1653 "usbvc_restore_device_state: end"); 1654 1655 return; 1656 1657 fail: 1658 /* change the device state from suspended to disconnected */ 1659 mutex_enter(&usbvcp->usbvc_mutex); 1660 usbvcp->usbvc_dev_state = USB_DEV_DISCONNECTED; 1661 usbvc_pm_idle_component(usbvcp); 1662 } 1663 1664 1665 /* Events */ 1666 1667 /* 1668 * usbvc_disconnect_event_cb: 1669 * Called when device hotplug-removed. 1670 * Close pipes. (This does not attempt to contact device.) 1671 * Set state to DISCONNECTED 1672 */ 1673 static int 1674 usbvc_disconnect_event_cb(dev_info_t *dip) 1675 { 1676 int instance = ddi_get_instance(dip); 1677 usbvc_state_t *usbvcp = ddi_get_soft_state(usbvc_statep, instance); 1678 1679 USB_DPRINTF_L4(PRINT_MASK_HOTPLUG, usbvcp->usbvc_log_handle, 1680 "disconnect: enter"); 1681 1682 mutex_enter(&usbvcp->usbvc_mutex); 1683 /* 1684 * Save any state of device or IO in progress required by 1685 * usbvc_restore_device_state for proper device "thawing" later. 1686 */ 1687 usbvcp->usbvc_dev_state = USB_DEV_DISCONNECTED; 1688 1689 /* 1690 * wake up the read threads in case there are any threads are blocking, 1691 * after being waked up, those threads will quit fail immediately since 1692 * we have changed the dev_stat. 1693 */ 1694 if (usbvcp->usbvc_io_type == V4L2_MEMORY_MMAP) { 1695 cv_broadcast(&usbvcp->usbvc_mapio_cv); 1696 } else { 1697 cv_broadcast(&usbvcp->usbvc_read_cv); 1698 } 1699 /* Wait for the other threads to quit */ 1700 (void) usbvc_serialize_access(usbvcp, USBVC_SER_SIG); 1701 usbvc_release_access(usbvcp); 1702 mutex_exit(&usbvcp->usbvc_mutex); 1703 1704 return (USB_SUCCESS); 1705 } 1706 1707 1708 /* 1709 * usbvc_reconnect_event_cb: 1710 * Called with device hotplug-inserted 1711 * Restore state 1712 */ 1713 static int 1714 usbvc_reconnect_event_cb(dev_info_t *dip) 1715 { 1716 int instance = ddi_get_instance(dip); 1717 usbvc_state_t *usbvcp = ddi_get_soft_state(usbvc_statep, instance); 1718 1719 USB_DPRINTF_L4(PRINT_MASK_HOTPLUG, usbvcp->usbvc_log_handle, 1720 "reconnect: enter"); 1721 1722 mutex_enter(&usbvcp->usbvc_mutex); 1723 (void) usbvc_serialize_access(usbvcp, USBVC_SER_SIG); 1724 usbvc_restore_device_state(dip, usbvcp); 1725 usbvc_release_access(usbvcp); 1726 mutex_exit(&usbvcp->usbvc_mutex); 1727 1728 return (USB_SUCCESS); 1729 } 1730 1731 /* Sync objs and lists */ 1732 1733 /* 1734 * init/fini sync objects during attach 1735 */ 1736 static void 1737 usbvc_init_sync_objs(usbvc_state_t *usbvcp) 1738 { 1739 mutex_init(&usbvcp->usbvc_mutex, NULL, MUTEX_DRIVER, 1740 usbvcp->usbvc_reg->dev_iblock_cookie); 1741 1742 cv_init(&usbvcp->usbvc_serial_cv, NULL, CV_DRIVER, NULL); 1743 cv_init(&usbvcp->usbvc_read_cv, NULL, CV_DRIVER, NULL); 1744 cv_init(&usbvcp->usbvc_mapio_cv, NULL, CV_DRIVER, NULL); 1745 1746 usbvcp->usbvc_serial_inuse = B_FALSE; 1747 1748 usbvcp->usbvc_locks_initialized = B_TRUE; 1749 } 1750 1751 1752 static void 1753 usbvc_fini_sync_objs(usbvc_state_t *usbvcp) 1754 { 1755 cv_destroy(&usbvcp->usbvc_serial_cv); 1756 cv_destroy(&usbvcp->usbvc_read_cv); 1757 cv_destroy(&usbvcp->usbvc_mapio_cv); 1758 1759 mutex_destroy(&usbvcp->usbvc_mutex); 1760 } 1761 1762 1763 static void 1764 usbvc_init_lists(usbvc_state_t *usbvcp) 1765 { 1766 /* video terminals */ 1767 list_create(&(usbvcp->usbvc_term_list), sizeof (usbvc_terms_t), 1768 offsetof(usbvc_terms_t, term_node)); 1769 1770 /* video units */ 1771 list_create(&(usbvcp->usbvc_unit_list), sizeof (usbvc_units_t), 1772 offsetof(usbvc_units_t, unit_node)); 1773 1774 /* stream interfaces */ 1775 list_create(&(usbvcp->usbvc_stream_list), sizeof (usbvc_stream_if_t), 1776 offsetof(usbvc_stream_if_t, stream_if_node)); 1777 } 1778 1779 1780 /* 1781 * Free all the data structures allocated when parsing descriptors of ctrl 1782 * and stream interfaces. It is safe to call this function because it always 1783 * checks the pointer before free mem. 1784 */ 1785 static void 1786 usbvc_fini_lists(usbvc_state_t *usbvcp) 1787 { 1788 USB_DPRINTF_L4(PRINT_MASK_CLOSE, usbvcp->usbvc_log_handle, 1789 "usbvc_fini_lists: enter"); 1790 1791 usbvc_free_ctrl_descr(usbvcp); 1792 1793 /* Free all video stream structure and the sub-structures */ 1794 usbvc_free_stream_descr(usbvcp); 1795 1796 USB_DPRINTF_L4(PRINT_MASK_CLOSE, usbvcp->usbvc_log_handle, 1797 "usbvc_fini_lists: end"); 1798 } 1799 1800 1801 /* 1802 * Free all the data structures allocated when parsing descriptors of ctrl 1803 * interface. 1804 */ 1805 static void 1806 usbvc_free_ctrl_descr(usbvc_state_t *usbvcp) 1807 { 1808 usbvc_terms_t *term; 1809 usbvc_units_t *unit; 1810 1811 USB_DPRINTF_L4(PRINT_MASK_CLOSE, usbvcp->usbvc_log_handle, 1812 "usbvc_free_ctrl_descr: enter"); 1813 1814 if (usbvcp->usbvc_vc_header) { 1815 kmem_free(usbvcp->usbvc_vc_header, sizeof (usbvc_vc_header_t)); 1816 } 1817 1818 /* Free all video terminal structure */ 1819 while (!list_is_empty(&usbvcp->usbvc_term_list)) { 1820 term = list_head(&usbvcp->usbvc_term_list); 1821 if (term != NULL) { 1822 list_remove(&(usbvcp->usbvc_term_list), term); 1823 kmem_free(term, sizeof (usbvc_terms_t)); 1824 } 1825 } 1826 1827 /* Free all video unit structure */ 1828 while (!list_is_empty(&usbvcp->usbvc_unit_list)) { 1829 unit = list_head(&usbvcp->usbvc_unit_list); 1830 if (unit != NULL) { 1831 list_remove(&(usbvcp->usbvc_unit_list), unit); 1832 kmem_free(unit, sizeof (usbvc_units_t)); 1833 } 1834 } 1835 } 1836 1837 1838 /* 1839 * Free all the data structures allocated when parsing descriptors of stream 1840 * interfaces. 1841 */ 1842 static void 1843 usbvc_free_stream_descr(usbvc_state_t *usbvcp) 1844 { 1845 usbvc_stream_if_t *strm; 1846 usbvc_input_header_t *in_hdr; 1847 usbvc_output_header_t *out_hdr; 1848 uint8_t fmt_cnt, frm_cnt; 1849 1850 while (!list_is_empty(&usbvcp->usbvc_stream_list)) { 1851 USB_DPRINTF_L3(PRINT_MASK_CLOSE, usbvcp->usbvc_log_handle, 1852 "usbvc_fini_lists: stream list not empty."); 1853 1854 strm = list_head(&usbvcp->usbvc_stream_list); 1855 if (strm != NULL) { 1856 1857 /* unlink this stream's data structure from the list */ 1858 list_remove(&(usbvcp->usbvc_stream_list), strm); 1859 } else { 1860 1861 /* No real stream data structure in the list */ 1862 return; 1863 } 1864 1865 in_hdr = strm->input_header; 1866 out_hdr = strm->output_header; 1867 1868 if (in_hdr) { 1869 fmt_cnt = in_hdr->descr->bNumFormats; 1870 } else if (out_hdr) { 1871 fmt_cnt = out_hdr->descr->bNumFormats; 1872 } 1873 1874 USB_DPRINTF_L3(PRINT_MASK_CLOSE, 1875 usbvcp->usbvc_log_handle, "usbvc_fini_lists:" 1876 " fmtgrp cnt=%d", fmt_cnt); 1877 1878 /* Free headers */ 1879 if (in_hdr) { 1880 kmem_free(in_hdr, sizeof (usbvc_input_header_t)); 1881 } 1882 if (out_hdr) { 1883 kmem_free(out_hdr, sizeof (usbvc_output_header_t)); 1884 } 1885 1886 /* Free format descriptors */ 1887 if (strm->format_group) { 1888 int i; 1889 usbvc_format_group_t *fmtgrp; 1890 1891 for (i = 0; i < fmt_cnt; i++) { 1892 fmtgrp = &strm->format_group[i]; 1893 if (fmtgrp->format == NULL) { 1894 1895 break; 1896 } 1897 if (fmtgrp->still) { 1898 kmem_free(fmtgrp->still, 1899 sizeof (usbvc_still_image_frame_t)); 1900 } 1901 frm_cnt = fmtgrp->format->bNumFrameDescriptors; 1902 1903 USB_DPRINTF_L3(PRINT_MASK_CLOSE, 1904 usbvcp->usbvc_log_handle, 1905 "usbvc_fini_lists:" 1906 " frame cnt=%d", frm_cnt); 1907 1908 if (fmtgrp->frames) { 1909 kmem_free(fmtgrp->frames, 1910 sizeof (usbvc_frames_t) * frm_cnt); 1911 } 1912 } 1913 kmem_free(strm->format_group, 1914 sizeof (usbvc_format_group_t) * fmt_cnt); 1915 } 1916 USB_DPRINTF_L3(PRINT_MASK_CLOSE, 1917 usbvcp->usbvc_log_handle, "usbvc_fini_lists:" 1918 " free stream_if_t"); 1919 1920 kmem_free(strm, sizeof (usbvc_stream_if_t)); 1921 } 1922 } 1923 1924 /* 1925 * Parse class specific descriptors of the video device 1926 */ 1927 1928 /* 1929 * Check the length of a class specific descriptor. Make sure cvs_buf_len is 1930 * not less than the length expected according to uvc spec. 1931 * 1932 * Args: 1933 * - off_num: the cvs_buf offset of the descriptor element that 1934 * indicates the number of variable descriptor elements; 1935 * - size: the size of each variable descriptor element, if zero, then the 1936 * size value is offered by off_size; 1937 * - off_size: the cvs_buf offset of the descriptor element that indicates 1938 * the size of each variable descriptor element; 1939 */ 1940 static int 1941 usbvc_chk_descr_len(uint8_t off_num, uint8_t size, uint8_t off_size, 1942 usb_cvs_data_t *cvs_data) 1943 { 1944 uchar_t *cvs_buf; 1945 uint_t cvs_buf_len; 1946 1947 cvs_buf = cvs_data->cvs_buf; 1948 cvs_buf_len = cvs_data->cvs_buf_len; 1949 1950 if (size == 0) { 1951 if (cvs_buf_len > off_size) { 1952 size = cvs_buf[off_size]; 1953 } else { 1954 1955 return (USB_FAILURE); 1956 } 1957 } 1958 if (cvs_buf_len < (off_num + 1)) { 1959 1960 return (USB_FAILURE); 1961 } 1962 1963 if (cvs_buf_len < (cvs_buf[off_num] * size + off_num +1)) { 1964 1965 return (USB_FAILURE); 1966 } 1967 1968 return (USB_SUCCESS); 1969 } 1970 1971 1972 /* Parse the descriptors of control interface */ 1973 static int 1974 usbvc_parse_ctrl_if(usbvc_state_t *usbvcp) 1975 { 1976 int if_num; 1977 int cvs_num; 1978 usb_alt_if_data_t *if_alt_data; 1979 usb_cvs_data_t *cvs_data; 1980 uchar_t *cvs_buf; 1981 uint_t cvs_buf_len; 1982 uint16_t version; 1983 1984 if_num = usbvcp->usbvc_reg->dev_curr_if; 1985 if_alt_data = usbvcp->usbvc_reg->dev_curr_cfg->cfg_if[if_num].if_alt; 1986 cvs_data = if_alt_data->altif_cvs; 1987 1988 for (cvs_num = 0; cvs_num < if_alt_data->altif_n_cvs; cvs_num++) { 1989 cvs_buf = cvs_data[cvs_num].cvs_buf; 1990 cvs_buf_len = cvs_data[cvs_num].cvs_buf_len; 1991 USB_DPRINTF_L3(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 1992 "usbvc_parse_ctrl_if: cvs_num= %d, cvs_buf_len=%d", 1993 cvs_num, cvs_buf_len); 1994 1995 /* 1996 * parse interface cvs descriptors here; by checking 1997 * bDescriptorType (cvs_buf[1]) 1998 */ 1999 if (cvs_buf[1] != CS_INTERFACE) { 2000 2001 continue; 2002 } 2003 2004 /* 2005 * Different descriptors in VC interface; according to 2006 * bDescriptorSubType (cvs_buf[2]) 2007 */ 2008 switch (cvs_buf[2]) { 2009 case VC_HEADER: 2010 2011 /* 2012 * According to uvc spec, there must be one and only 2013 * be one header. If more than one, return failure. 2014 */ 2015 if (usbvcp->usbvc_vc_header) { 2016 2017 return (USB_FAILURE); 2018 } 2019 /* 2020 * Check if it is a valid HEADER descriptor in case of 2021 * a device not compliant to uvc spec. This descriptor 2022 * is critical, return failure if not a valid one. 2023 */ 2024 if (usbvc_chk_descr_len(11, 1, 0, cvs_data) != 2025 USB_SUCCESS) { 2026 2027 return (USB_FAILURE); 2028 } 2029 usbvcp->usbvc_vc_header = 2030 (usbvc_vc_header_t *)kmem_zalloc( 2031 sizeof (usbvc_vc_header_t), KM_SLEEP); 2032 usbvcp->usbvc_vc_header->descr = 2033 (usbvc_vc_header_descr_t *)&cvs_buf[0]; 2034 2035 LE_TO_UINT16(usbvcp->usbvc_vc_header->descr->bcdUVC, 2036 0, version); 2037 USB_DPRINTF_L3(PRINT_MASK_ATTA, 2038 usbvcp->usbvc_log_handle, "usbvc_parse_ctrl_if:" 2039 " VC header, bcdUVC=%x", version); 2040 if (usbvcp->usbvc_vc_header->descr->bInCollection == 2041 0) { 2042 USB_DPRINTF_L3(PRINT_MASK_ATTA, 2043 usbvcp->usbvc_log_handle, 2044 "usbvc_parse_ctrl_if: no strm interfaces"); 2045 2046 break; 2047 } 2048 2049 /* stream interface numbers */ 2050 usbvcp->usbvc_vc_header->baInterfaceNr = &cvs_buf[12]; 2051 2052 break; 2053 case VC_INPUT_TERMINAL: 2054 { 2055 usbvc_terms_t *term; 2056 2057 /* 2058 * Check if it is a valid descriptor in case of a 2059 * device not compliant to uvc spec 2060 */ 2061 if (cvs_buf_len < USBVC_I_TERM_LEN_MIN) { 2062 2063 break; 2064 } 2065 term = (usbvc_terms_t *) 2066 kmem_zalloc(sizeof (usbvc_terms_t), KM_SLEEP); 2067 term->descr = (usbvc_term_descr_t *)cvs_buf; 2068 2069 USB_DPRINTF_L3(PRINT_MASK_ATTA, 2070 usbvcp->usbvc_log_handle, "usbvc_parse_ctrl_if: " 2071 "input term type=%x", term->descr->wTerminalType); 2072 if (term->descr->wTerminalType == ITT_CAMERA) { 2073 if (usbvc_chk_descr_len(14, 1, 0, cvs_data) != 2074 USB_SUCCESS) { 2075 kmem_free(term, sizeof (usbvc_terms_t)); 2076 2077 break; 2078 } 2079 term->bmControls = &cvs_buf[15]; 2080 } else if (cvs_buf_len > 8) { /* other input terms */ 2081 term->bSpecific = &cvs_buf[8]; 2082 } 2083 list_insert_tail(&(usbvcp->usbvc_term_list), term); 2084 2085 break; 2086 } 2087 case VC_OUTPUT_TERMINAL: 2088 { 2089 usbvc_terms_t *term; 2090 2091 if (cvs_buf_len < USBVC_O_TERM_LEN_MIN) { 2092 2093 break; 2094 } 2095 term = (usbvc_terms_t *) 2096 kmem_zalloc(sizeof (usbvc_terms_t), KM_SLEEP); 2097 term->descr = (usbvc_term_descr_t *)cvs_buf; 2098 2099 USB_DPRINTF_L3(PRINT_MASK_ATTA, 2100 usbvcp->usbvc_log_handle, "usbvc_parse_ctrl_if:" 2101 " output term id= %x", term->descr->bTerminalID); 2102 if (cvs_buf_len > 9) { 2103 term->bSpecific = &cvs_buf[9]; 2104 } 2105 list_insert_tail(&(usbvcp->usbvc_term_list), term); 2106 2107 break; 2108 } 2109 case VC_PROCESSING_UNIT: 2110 { 2111 uint8_t sz; 2112 usbvc_units_t *unit; 2113 2114 if (usbvc_chk_descr_len(7, 1, 0, cvs_data) != 2115 USB_SUCCESS) { 2116 2117 break; 2118 } 2119 2120 /* bControlSize */ 2121 sz = cvs_buf[7]; 2122 2123 if ((sz + 8) >= cvs_buf_len) { 2124 2125 break; 2126 } 2127 unit = (usbvc_units_t *) 2128 kmem_zalloc(sizeof (usbvc_units_t), KM_SLEEP); 2129 2130 unit->descr = (usbvc_unit_descr_t *)cvs_buf; 2131 2132 USB_DPRINTF_L3(PRINT_MASK_ATTA, 2133 usbvcp->usbvc_log_handle, "usbvc_parse_ctrl_if: " 2134 "unit type=%x", unit->descr->bDescriptorSubType); 2135 2136 if (sz != 0) { 2137 unit->bmControls = &cvs_buf[8]; 2138 } 2139 unit->iProcessing = cvs_buf[8 + sz]; 2140 2141 /* 2142 * video class 1.1 version add one element 2143 * (bmVideoStandards) to processing unit descriptor 2144 */ 2145 if (cvs_buf_len > (9 + sz)) { 2146 unit->bmVideoStandards = cvs_buf[9 + sz]; 2147 } 2148 list_insert_tail(&(usbvcp->usbvc_unit_list), unit); 2149 2150 break; 2151 } 2152 case VC_SELECTOR_UNIT: 2153 { 2154 uint8_t pins; 2155 usbvc_units_t *unit; 2156 2157 if (usbvc_chk_descr_len(4, 1, 0, cvs_data) != 2158 USB_SUCCESS) { 2159 2160 break; 2161 } 2162 pins = cvs_buf[4]; 2163 if ((pins + 5) >= cvs_buf_len) { 2164 2165 break; 2166 } 2167 unit = (usbvc_units_t *) 2168 kmem_zalloc(sizeof (usbvc_units_t), KM_SLEEP); 2169 2170 unit->descr = (usbvc_unit_descr_t *)cvs_buf; 2171 2172 USB_DPRINTF_L3(PRINT_MASK_ATTA, 2173 usbvcp->usbvc_log_handle, "usbvc_parse_ctrl_if: " 2174 "unit type=%x", unit->descr->bDescriptorSubType); 2175 if (pins > 0) { 2176 unit->baSourceID = &cvs_buf[5]; 2177 } 2178 unit->iSelector = cvs_buf[5 + pins]; 2179 2180 list_insert_tail(&(usbvcp->usbvc_unit_list), unit); 2181 2182 break; 2183 } 2184 case VC_EXTENSION_UNIT: 2185 { 2186 uint8_t pins, n; 2187 usbvc_units_t *unit; 2188 2189 if (usbvc_chk_descr_len(21, 1, 0, cvs_data) != 2190 USB_SUCCESS) { 2191 2192 break; 2193 } 2194 pins = cvs_buf[21]; 2195 if ((pins + 22) >= cvs_buf_len) { 2196 2197 break; 2198 } 2199 2200 /* Size of bmControls */ 2201 n = cvs_buf[pins + 22]; 2202 2203 if (usbvc_chk_descr_len(pins + 22, 1, 0, cvs_data) != 2204 USB_SUCCESS) { 2205 2206 break; 2207 } 2208 if ((23 + pins + n) >= cvs_buf_len) { 2209 2210 break; 2211 } 2212 unit = (usbvc_units_t *) 2213 kmem_zalloc(sizeof (usbvc_units_t), KM_SLEEP); 2214 2215 unit->descr = (usbvc_unit_descr_t *)cvs_buf; 2216 2217 USB_DPRINTF_L3(PRINT_MASK_ATTA, 2218 usbvcp->usbvc_log_handle, "usbvc_parse_ctrl_if: " 2219 "unit type=%x", unit->descr->bDescriptorSubType); 2220 if (pins != 0) { 2221 unit->baSourceID = &cvs_buf[22]; 2222 } 2223 unit->bControlSize = cvs_buf[22 + pins]; 2224 2225 if (unit->bControlSize != 0) { 2226 unit->bmControls = &cvs_buf[23 + pins]; 2227 } 2228 unit->iExtension = cvs_buf[23 + pins + n]; 2229 2230 list_insert_tail(&(usbvcp->usbvc_unit_list), unit); 2231 2232 break; 2233 } 2234 default: 2235 2236 break; 2237 } 2238 } 2239 2240 /* 2241 * For webcam which is not compliant to video class specification 2242 * and no header descriptor in VC interface, return USB_FAILURE. 2243 */ 2244 if (!usbvcp->usbvc_vc_header) { 2245 USB_DPRINTF_L2(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2246 "usbvc_parse_ctrl_if: no header descriptor"); 2247 2248 return (USB_FAILURE); 2249 } 2250 2251 return (USB_SUCCESS); 2252 } 2253 2254 2255 /* Parse all the cvs descriptors in one stream interface. */ 2256 usbvc_stream_if_t * 2257 usbvc_parse_stream_if(usbvc_state_t *usbvcp, int if_num) 2258 { 2259 usb_alt_if_data_t *if_alt_data; 2260 uint_t i, j; 2261 usbvc_stream_if_t *strm_if; 2262 uint16_t pktsize; 2263 uint8_t ep_adr; 2264 2265 strm_if = (usbvc_stream_if_t *)kmem_zalloc(sizeof (usbvc_stream_if_t), 2266 KM_SLEEP); 2267 strm_if->if_descr = &usbvcp->usbvc_reg->dev_curr_cfg->cfg_if[if_num]; 2268 if_alt_data = strm_if->if_descr->if_alt; 2269 if (usbvc_parse_stream_header(usbvcp, strm_if) != USB_SUCCESS) { 2270 USB_DPRINTF_L2(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2271 "usbvc_parse_stream_if: parse header fail"); 2272 kmem_free(strm_if, sizeof (usbvc_stream_if_t)); 2273 2274 return (NULL); 2275 } 2276 if (usbvc_parse_format_groups(usbvcp, strm_if) != USB_SUCCESS) { 2277 USB_DPRINTF_L2(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2278 "usbvc_parse_stream_if: parse groups fail"); 2279 kmem_free(strm_if, sizeof (usbvc_stream_if_t)); 2280 2281 return (NULL); 2282 } 2283 2284 /* Parse the alternate settings to find the maximum bandwidth. */ 2285 for (i = 0; i < strm_if->if_descr->if_n_alt; i++) { 2286 if_alt_data = &strm_if->if_descr->if_alt[i]; 2287 for (j = 0; j < if_alt_data->altif_n_ep; j++) { 2288 ep_adr = 2289 if_alt_data->altif_ep[j].ep_descr.bEndpointAddress; 2290 if (strm_if->input_header != NULL && 2291 ep_adr != 2292 strm_if->input_header->descr->bEndpointAddress) { 2293 2294 continue; 2295 } 2296 if (strm_if->output_header != NULL && 2297 ep_adr != 2298 strm_if->output_header->descr->bEndpointAddress) { 2299 2300 continue; 2301 } 2302 pktsize = 2303 if_alt_data->altif_ep[j].ep_descr.wMaxPacketSize; 2304 pktsize = HS_PKT_SIZE(pktsize); 2305 if (pktsize > strm_if->max_isoc_payload) { 2306 strm_if->max_isoc_payload = pktsize; 2307 } 2308 } 2309 } 2310 2311 /* initialize MJPEC FID toggle */ 2312 strm_if->fid = 0xff; 2313 2314 /* 2315 * initialize desired number of buffers used internally in read() mode 2316 */ 2317 strm_if->buf_read_num = USBVC_DEFAULT_READ_BUF_NUM; 2318 2319 USB_DPRINTF_L4(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2320 "usbvc_parse_stream_if: return. max_isoc_payload=%x", 2321 strm_if->max_isoc_payload); 2322 2323 return (strm_if); 2324 } 2325 2326 2327 /* 2328 * Parse all the stream interfaces asociated with the video control interface. 2329 * This driver will attach to a video control interface on the device, 2330 * there might be multiple video stream interfaces associated with one video 2331 * control interface. 2332 */ 2333 static int 2334 usbvc_parse_stream_ifs(usbvc_state_t *usbvcp) 2335 { 2336 int i, if_cnt, if_num; 2337 usbvc_stream_if_t *strm_if; 2338 2339 if_cnt = usbvcp->usbvc_vc_header->descr->bInCollection; 2340 if (if_cnt == 0) { 2341 ASSERT(list_is_empty(&usbvcp->usbvc_stream_list)); 2342 USB_DPRINTF_L2(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2343 "usbvc_parse_stream_ifs: no stream interfaces"); 2344 2345 return (USB_SUCCESS); 2346 } 2347 for (i = 0; i < if_cnt; i++) { 2348 if_num = usbvcp->usbvc_vc_header->baInterfaceNr[i]; 2349 strm_if = usbvc_parse_stream_if(usbvcp, if_num); 2350 if (strm_if == NULL) { 2351 USB_DPRINTF_L2(PRINT_MASK_ATTA, 2352 usbvcp->usbvc_log_handle, "usbvc_parse_stream_ifs:" 2353 " parse stream interface %d failed.", if_num); 2354 2355 return (USB_FAILURE); 2356 } 2357 /* video data buffers */ 2358 list_create(&(strm_if->buf_map.uv_buf_free), 2359 sizeof (usbvc_buf_t), offsetof(usbvc_buf_t, buf_node)); 2360 list_create(&(strm_if->buf_map.uv_buf_done), 2361 sizeof (usbvc_buf_t), offsetof(usbvc_buf_t, buf_node)); 2362 list_create(&(strm_if->buf_read.uv_buf_free), 2363 sizeof (usbvc_buf_t), offsetof(usbvc_buf_t, buf_node)); 2364 list_create(&(strm_if->buf_read.uv_buf_done), 2365 sizeof (usbvc_buf_t), offsetof(usbvc_buf_t, buf_node)); 2366 2367 list_insert_tail(&(usbvcp->usbvc_stream_list), strm_if); 2368 } 2369 2370 /* Make the first stream interface as the default one. */ 2371 usbvcp->usbvc_curr_strm = 2372 (usbvc_stream_if_t *)list_head(&usbvcp->usbvc_stream_list); 2373 2374 return (USB_SUCCESS); 2375 } 2376 2377 2378 /* 2379 * Parse colorspace descriptor and still image descriptor of a format group. 2380 * There is only one colorspace or still image descriptor in one format group. 2381 */ 2382 static void 2383 usbvc_parse_color_still(usbvc_state_t *usbvcp, usbvc_format_group_t *fmtgrp, 2384 usb_cvs_data_t *cvs_data, uint_t cvs_num, uint_t altif_n_cvs) 2385 { 2386 uint8_t frame_cnt; 2387 uint_t last_frame, i; 2388 uchar_t *cvs_buf; 2389 uint_t cvs_buf_len; 2390 2391 frame_cnt = fmtgrp->format->bNumFrameDescriptors; 2392 last_frame = frame_cnt + cvs_num; 2393 2394 /* 2395 * Find the still image descr and color format descr if there are any. 2396 * UVC Spec: only one still image and one color descr is allowed in 2397 * one format group. 2398 */ 2399 for (i = 1; i <= 2; i++) { 2400 if ((last_frame + i) >= altif_n_cvs) { 2401 2402 break; 2403 } 2404 cvs_buf = cvs_data[last_frame + i].cvs_buf; 2405 cvs_buf_len = cvs_data[last_frame + i].cvs_buf_len; 2406 2407 if (cvs_buf[2] == VS_STILL_IMAGE_FRAME) { 2408 uint8_t m, n, off; 2409 usbvc_still_image_frame_t *st; 2410 2411 if (usbvc_chk_descr_len(4, 4, 0, cvs_data) != 2412 USB_SUCCESS) { 2413 2414 continue; 2415 } 2416 2417 /* Number of Image Size patterns of this format */ 2418 n = cvs_buf[4]; 2419 2420 /* offset of bNumCompressionPattern */ 2421 off = 9 + 4 * n -4; 2422 2423 if (off >= cvs_buf_len) { 2424 2425 continue; 2426 } 2427 2428 /* Number of compression pattern of this format */ 2429 m = cvs_buf[off]; 2430 2431 if (usbvc_chk_descr_len(m, 1, 0, cvs_data) != 2432 USB_SUCCESS) { 2433 2434 continue; 2435 } 2436 fmtgrp->still = (usbvc_still_image_frame_t *) 2437 kmem_zalloc(sizeof (usbvc_still_image_frame_t), 2438 KM_SLEEP); 2439 st = fmtgrp->still; 2440 st->descr = (usbvc_still_image_frame_descr_t *)cvs_buf; 2441 n = st->descr->bNumImageSizePatterns; 2442 if (n > 0) { 2443 st->width_height = 2444 (width_height_t *)&cvs_buf[5]; 2445 } 2446 st->bNumCompressionPattern = cvs_buf[off]; 2447 if (cvs_buf[off] > 0) { 2448 st->bCompression = &cvs_buf[off + 1]; 2449 } 2450 } 2451 if (cvs_buf[2] == VS_COLORFORMAT) { 2452 fmtgrp->color = (usbvc_color_matching_descr_t *)cvs_buf; 2453 fmtgrp->v4l2_color = usbvc_v4l2_colorspace( 2454 fmtgrp->color->bColorPrimaries); 2455 } 2456 } 2457 USB_DPRINTF_L4(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2458 "usbvc_parse_color_still: still=%p, color=%p", 2459 (void *)fmtgrp->still, (void *)fmtgrp->color); 2460 } 2461 2462 2463 /* 2464 * Parse frame descriptors of a format group. There might be multi frame 2465 * descriptors in one format group. 2466 */ 2467 static void 2468 usbvc_parse_frames(usbvc_state_t *usbvcp, usbvc_format_group_t *fmtgrp, 2469 usb_cvs_data_t *cvs_data, uint_t cvs_num, uint_t altif_n_cvs) 2470 { 2471 uint_t last_frame; 2472 usbvc_frames_t *frm; 2473 usb_cvs_data_t *cvs; 2474 uchar_t *cvs_buf; 2475 uint_t cvs_buf_len; 2476 uint8_t i; 2477 uint8_t frame_cnt = fmtgrp->format->bNumFrameDescriptors; 2478 2479 USB_DPRINTF_L4(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2480 "usbvc_parse_format_group: frame_cnt=%d", frame_cnt); 2481 2482 if (frame_cnt == 0) { 2483 fmtgrp->frames = NULL; 2484 2485 return; 2486 } 2487 2488 /* All these mem allocated will be freed in cleanup() */ 2489 fmtgrp->frames = (usbvc_frames_t *) 2490 kmem_zalloc(sizeof (usbvc_frames_t) * frame_cnt, KM_SLEEP); 2491 2492 last_frame = frame_cnt + cvs_num; 2493 cvs_num++; 2494 i = 0; 2495 2496 /* 2497 * Traverse from the format decr's first frame decr to the the last 2498 * frame descr. 2499 */ 2500 for (; cvs_num <= last_frame; cvs_num++) { 2501 USB_DPRINTF_L3(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2502 "usbvc_parse_frames: cvs_num=%d, i=%d", cvs_num, i); 2503 if (cvs_num >= altif_n_cvs) { 2504 USB_DPRINTF_L3(PRINT_MASK_ATTA, 2505 usbvcp->usbvc_log_handle, 2506 "usbvc_parse_frames: less frames than " 2507 "expected, cvs_num=%d, i=%d", cvs_num, i); 2508 2509 break; 2510 } 2511 cvs = &cvs_data[cvs_num]; 2512 cvs_buf = cvs->cvs_buf; 2513 cvs_buf_len = cvs->cvs_buf_len; 2514 if (cvs_buf_len < USBVC_FRAME_LEN_MIN) { 2515 i++; 2516 2517 continue; 2518 } 2519 frm = &fmtgrp->frames[i]; 2520 frm->descr = (usbvc_frame_descr_t *)cvs->cvs_buf; 2521 2522 /* Descriptor for discrete frame interval */ 2523 if (frm->descr->bFrameIntervalType > 0) { 2524 if (usbvc_chk_descr_len(25, 4, 0, cvs) != USB_SUCCESS) { 2525 frm->descr = NULL; 2526 i++; 2527 2528 continue; 2529 } 2530 2531 frm->dwFrameInterval = (uint8_t *)&cvs_buf[26]; 2532 } else { /* Continuous interval */ 2533 if (cvs_buf_len < USBVC_FRAME_LEN_CON) { 2534 frm->descr = NULL; 2535 i++; 2536 2537 continue; 2538 } 2539 2540 /* Continuous frame intervals */ 2541 LE_TO_UINT32(cvs_buf, 26, frm->dwMinFrameInterval); 2542 LE_TO_UINT32(cvs_buf, 30, frm->dwMaxFrameInterval); 2543 LE_TO_UINT32(cvs_buf, 34, frm->dwFrameIntervalStep); 2544 } 2545 2546 i++; 2547 } 2548 fmtgrp->frame_cnt = i; 2549 USB_DPRINTF_L4(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2550 "usbvc_parse_frames: %d frames are actually parsed", 2551 fmtgrp->frame_cnt); 2552 } 2553 2554 2555 /* Parse one of the format groups in a stream interface */ 2556 static int 2557 usbvc_parse_format_group(usbvc_state_t *usbvcp, usbvc_format_group_t *fmtgrp, 2558 usb_cvs_data_t *cvs_data, uint_t cvs_num, uint_t altif_n_cvs) 2559 { 2560 usbvc_format_descr_t *fmt; 2561 2562 fmt = fmtgrp->format; 2563 USB_DPRINTF_L4(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2564 "usbvc_parse_format_group: frame_cnt=%d, cvs_num=%d", 2565 fmt->bNumFrameDescriptors, cvs_num); 2566 2567 switch (fmt->bDescriptorSubType) { 2568 case VS_FORMAT_UNCOMPRESSED: 2569 usbvc_parse_color_still(usbvcp, fmtgrp, cvs_data, cvs_num, 2570 altif_n_cvs); 2571 usbvc_parse_frames(usbvcp, fmtgrp, cvs_data, cvs_num, 2572 altif_n_cvs); 2573 fmtgrp->v4l2_bpp = fmt->fmt.uncompressed.bBitsPerPixel / 8; 2574 fmtgrp->v4l2_pixelformat = usbvc_v4l2_guid2fcc( 2575 (uint8_t *)&fmt->fmt.uncompressed.guidFormat); 2576 2577 break; 2578 case VS_FORMAT_MJPEG: 2579 usbvc_parse_color_still(usbvcp, fmtgrp, cvs_data, cvs_num, 2580 altif_n_cvs); 2581 usbvc_parse_frames(usbvcp, fmtgrp, cvs_data, cvs_num, 2582 altif_n_cvs); 2583 fmtgrp->v4l2_bpp = 0; 2584 fmtgrp->v4l2_pixelformat = V4L2_PIX_FMT_MJPEG; 2585 2586 break; 2587 case VS_FORMAT_MPEG2TS: 2588 case VS_FORMAT_DV: 2589 case VS_FORMAT_FRAME_BASED: 2590 case VS_FORMAT_STREAM_BASED: 2591 USB_DPRINTF_L2(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2592 "usbvc_parse_format_group: format not supported yet."); 2593 2594 return (USB_FAILURE); 2595 default: 2596 USB_DPRINTF_L2(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2597 "usbvc_parse_format_group: unknown format."); 2598 2599 return (USB_FAILURE); 2600 } 2601 2602 return (USB_SUCCESS); 2603 } 2604 2605 2606 /* Parse the descriptors belong to one format */ 2607 static int 2608 usbvc_parse_format_groups(usbvc_state_t *usbvcp, usbvc_stream_if_t *strm_if) 2609 { 2610 usb_alt_if_data_t *if_alt_data; 2611 usb_cvs_data_t *cvs_data; 2612 uint8_t fmtgrp_num, fmtgrp_cnt; 2613 uchar_t *cvs_buf; 2614 uint_t cvs_num = 0; 2615 usbvc_format_group_t *fmtgrp; 2616 2617 fmtgrp_cnt = 0; 2618 /* 2619 * bNumFormats indicates the number of formats in this stream 2620 * interface. On some devices, we see this number is larger than 2621 * the truth. 2622 */ 2623 if (strm_if->input_header) { 2624 fmtgrp_cnt = strm_if->input_header->descr->bNumFormats; 2625 } else if (strm_if->output_header) { 2626 fmtgrp_cnt = strm_if->output_header->descr->bNumFormats; 2627 } 2628 if (!fmtgrp_cnt) { 2629 2630 return (USB_FAILURE); 2631 } 2632 USB_DPRINTF_L3(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2633 "usbvc_parse_format_groups: fmtgrp_cnt=%d", fmtgrp_cnt); 2634 2635 fmtgrp = (usbvc_format_group_t *) 2636 kmem_zalloc(sizeof (usbvc_format_group_t) * fmtgrp_cnt, KM_SLEEP); 2637 2638 if_alt_data = strm_if->if_descr->if_alt; 2639 cvs_data = if_alt_data->altif_cvs; 2640 2641 for (fmtgrp_num = 0; fmtgrp_num < fmtgrp_cnt && 2642 cvs_num < if_alt_data->altif_n_cvs; cvs_num++) { 2643 cvs_buf = cvs_data[cvs_num].cvs_buf; 2644 switch (cvs_buf[2]) { 2645 case VS_FORMAT_UNCOMPRESSED: 2646 case VS_FORMAT_MJPEG: 2647 case VS_FORMAT_MPEG2TS: 2648 case VS_FORMAT_DV: 2649 case VS_FORMAT_FRAME_BASED: 2650 case VS_FORMAT_STREAM_BASED: 2651 fmtgrp[fmtgrp_num].format = 2652 (usbvc_format_descr_t *)cvs_buf; 2653 2654 /* 2655 * Now cvs_data[cvs_num].cvs_buf is format descriptor, 2656 * usbvc_parse_format_group will then parse the frame 2657 * descriptors following this format descriptor. 2658 */ 2659 (void) usbvc_parse_format_group(usbvcp, 2660 &fmtgrp[fmtgrp_num], cvs_data, cvs_num, 2661 if_alt_data->altif_n_cvs); 2662 2663 fmtgrp_num++; 2664 2665 break; 2666 default: 2667 break; 2668 } 2669 } 2670 2671 /* Save the number of parsed format groups. */ 2672 strm_if->fmtgrp_cnt = fmtgrp_num; 2673 USB_DPRINTF_L3(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2674 "usbvc_parse_format_groups: acctually %d formats parsed", 2675 fmtgrp_num); 2676 2677 /* 2678 * If can't find any formats, then free all allocated 2679 * usbvc_format_group_t, return failure. 2680 */ 2681 if (!(fmtgrp[0].format)) { 2682 kmem_free(fmtgrp, sizeof (usbvc_format_group_t) * fmtgrp_cnt); 2683 strm_if->format_group = NULL; 2684 2685 USB_DPRINTF_L2(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2686 "usbvc_parse_format_groups: can't find any formats"); 2687 2688 return (USB_FAILURE); 2689 } 2690 strm_if->format_group = fmtgrp; 2691 USB_DPRINTF_L3(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2692 "usbvc_parse_format_groups: %d format groups parsed", fmtgrp_num); 2693 2694 return (USB_SUCCESS); 2695 } 2696 2697 2698 /* 2699 * Parse the input/output header in one stream interface. 2700 * UVC Spec: there must be one and only one header in one stream interface. 2701 */ 2702 int 2703 usbvc_parse_stream_header(usbvc_state_t *usbvcp, usbvc_stream_if_t *strm_if) 2704 { 2705 usb_alt_if_data_t *if_alt_data; 2706 usb_cvs_data_t *cvs_data; 2707 int cvs_num; 2708 uchar_t *cvs_buf; 2709 usbvc_input_header_t *in_hdr; 2710 usbvc_output_header_t *out_hdr; 2711 2712 if_alt_data = strm_if->if_descr->if_alt; 2713 cvs_data = if_alt_data->altif_cvs; 2714 for (cvs_num = 0; cvs_num < if_alt_data->altif_n_cvs; cvs_num++) { 2715 cvs_buf = cvs_data[cvs_num].cvs_buf; 2716 USB_DPRINTF_L3(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2717 "usbvc_parse_stream_header: cvs_num= %d", cvs_num); 2718 2719 /* 2720 * parse interface cvs descriptors here; by checking 2721 * bDescriptorType (cvs_buf[1]) 2722 */ 2723 if (cvs_buf[1] != CS_INTERFACE) { 2724 2725 continue; 2726 } 2727 2728 if (cvs_buf[2] == VS_INPUT_HEADER) { 2729 if (usbvc_chk_descr_len(3, 0, 12, cvs_data) != 2730 USB_SUCCESS) { 2731 2732 continue; 2733 } 2734 2735 strm_if->input_header = 2736 (usbvc_input_header_t *) 2737 kmem_zalloc(sizeof (usbvc_input_header_t), 2738 KM_SLEEP); 2739 in_hdr = strm_if->input_header; 2740 in_hdr->descr = (usbvc_input_header_descr_t *)cvs_buf; 2741 if (in_hdr->descr->bNumFormats > 0) { 2742 in_hdr->bmaControls = &cvs_buf[13]; 2743 } 2744 2745 return (USB_SUCCESS); 2746 } else if (cvs_buf[2] == VS_OUTPUT_HEADER) { 2747 if (usbvc_chk_descr_len(3, 0, 8, cvs_data) != 2748 USB_SUCCESS) { 2749 2750 continue; 2751 } 2752 strm_if->output_header = 2753 (usbvc_output_header_t *) 2754 kmem_zalloc(sizeof (usbvc_output_header_t), 2755 KM_SLEEP); 2756 out_hdr = strm_if->output_header; 2757 out_hdr->descr = 2758 (usbvc_output_header_descr_t *)cvs_buf; 2759 if (out_hdr->descr->bNumFormats > 0) { 2760 out_hdr->bmaControls = &cvs_buf[13]; 2761 } 2762 2763 return (USB_SUCCESS); 2764 } else { 2765 2766 continue; 2767 } 2768 } 2769 /* Didn't find one header descriptor. */ 2770 USB_DPRINTF_L2(PRINT_MASK_ATTA, usbvcp->usbvc_log_handle, 2771 "usbvc_parse_stream_header: FAIL"); 2772 2773 return (USB_FAILURE); 2774 } 2775 2776 /* read I/O functions */ 2777 2778 /* Allocate bufs for read I/O method */ 2779 static int 2780 usbvc_alloc_read_bufs(usbvc_state_t *usbvcp, usbvc_stream_if_t *strm_if) 2781 { 2782 usbvc_buf_t *buf; 2783 uchar_t *data; 2784 int i; 2785 uint32_t len; 2786 2787 ASSERT(mutex_owned(&usbvcp->usbvc_mutex)); 2788 2789 LE_TO_UINT32(strm_if->ctrl_pc.dwMaxVideoFrameSize, 0, len); 2790 if (!len) { 2791 2792 return (USB_FAILURE); 2793 } 2794 for (i = 0; i < strm_if->buf_read_num; i++) { 2795 mutex_exit(&usbvcp->usbvc_mutex); 2796 buf = (usbvc_buf_t *)kmem_zalloc(sizeof (usbvc_buf_t), 2797 KM_SLEEP); 2798 data = (uchar_t *)kmem_zalloc(len, KM_SLEEP); 2799 mutex_enter(&usbvcp->usbvc_mutex); 2800 buf->data = data; 2801 buf->len = len; 2802 list_insert_tail(&(strm_if->buf_read.uv_buf_free), buf); 2803 } 2804 strm_if->buf_read.buf_cnt = strm_if->buf_read_num; 2805 USB_DPRINTF_L4(PRINT_MASK_READ, usbvcp->usbvc_log_handle, 2806 "read_bufs: %d bufs allocated", strm_if->buf_read.buf_cnt); 2807 2808 return (USB_SUCCESS); 2809 } 2810 2811 2812 /* Read a done buf, copy data to bp. This function is for read I/O method */ 2813 static int 2814 usbvc_read_buf(usbvc_state_t *usbvcp, struct buf *bp) 2815 { 2816 usbvc_buf_t *buf; 2817 int buf_residue; 2818 int len_to_copy; 2819 2820 ASSERT(mutex_owned(&usbvcp->usbvc_mutex)); 2821 2822 if (list_is_empty(&usbvcp->usbvc_curr_strm->buf_read.uv_buf_done)) { 2823 USB_DPRINTF_L2(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 2824 "usbvc_read_buf: empty list(uv_buf_done)!"); 2825 2826 return (USB_FAILURE); 2827 } 2828 2829 /* read a buf from full list and then put it to free list */ 2830 buf = list_head(&usbvcp->usbvc_curr_strm->buf_read.uv_buf_done); 2831 2832 USB_DPRINTF_L2(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 2833 "usbvc_read_buf: buf=%p, buf->filled=%d, buf->len=%d," 2834 " buf->len_read=%d bp->b_bcount=%ld, bp->b_resid=%lu", 2835 (void *)buf, buf->filled, buf->len, buf->len_read, 2836 bp->b_bcount, bp->b_resid); 2837 2838 ASSERT(buf->len_read <= buf->filled); 2839 2840 buf_residue = buf->filled - buf->len_read; 2841 len_to_copy = min(bp->b_bcount, buf_residue); 2842 2843 bcopy(buf->data + buf->len_read, bp->b_un.b_addr, len_to_copy); 2844 bp->b_private = NULL; 2845 buf->len_read += len_to_copy; 2846 bp->b_resid = bp->b_bcount - len_to_copy; 2847 2848 if (len_to_copy == buf_residue) { 2849 /* 2850 * the bp can accommodate all the remaining bytes of 2851 * the buf. Then we can reuse this buf. 2852 */ 2853 buf->len_read = 0; 2854 list_remove(&usbvcp->usbvc_curr_strm->buf_read.uv_buf_done, 2855 buf); 2856 list_insert_tail(&usbvcp->usbvc_curr_strm->buf_read.uv_buf_free, 2857 buf); 2858 } 2859 2860 return (USB_SUCCESS); 2861 } 2862 2863 2864 /* Free one buf which is for read/write IO style */ 2865 static void 2866 usbvc_free_read_buf(usbvc_buf_t *buf) 2867 { 2868 if (buf != NULL) { 2869 if (buf->data) { 2870 kmem_free(buf->data, buf->len); 2871 } 2872 kmem_free(buf, sizeof (usbvc_buf_t)); 2873 } 2874 } 2875 2876 2877 /* Free all bufs which are for read/write IO style */ 2878 static void 2879 usbvc_free_read_bufs(usbvc_state_t *usbvcp, usbvc_stream_if_t *strm_if) 2880 { 2881 usbvc_buf_t *buf; 2882 2883 ASSERT(mutex_owned(&usbvcp->usbvc_mutex)); 2884 2885 if (!strm_if) { 2886 2887 return; 2888 } 2889 buf = strm_if->buf_read.buf_filling; 2890 usbvc_free_read_buf(buf); 2891 strm_if->buf_read.buf_filling = NULL; 2892 2893 while (!list_is_empty(&strm_if->buf_read.uv_buf_free)) { 2894 buf = list_head(&strm_if->buf_read.uv_buf_free); 2895 if (buf != NULL) { 2896 list_remove(&(strm_if->buf_read.uv_buf_free), buf); 2897 usbvc_free_read_buf(buf); 2898 } 2899 } 2900 while (!list_is_empty(&strm_if->buf_read.uv_buf_done)) { 2901 buf = list_head(&strm_if->buf_read.uv_buf_done); 2902 if (buf != NULL) { 2903 list_remove(&(strm_if->buf_read.uv_buf_done), buf); 2904 usbvc_free_read_buf(buf); 2905 } 2906 } 2907 strm_if->buf_read.buf_cnt = 0; 2908 USB_DPRINTF_L4(PRINT_MASK_CLOSE, usbvcp->usbvc_log_handle, 2909 "usbvc_free_read_bufs: return"); 2910 } 2911 2912 2913 /* 2914 * Allocate bufs for mapped I/O , return the number of allocated bufs 2915 * if success, return 0 if fail. 2916 */ 2917 int 2918 usbvc_alloc_map_bufs(usbvc_state_t *usbvcp, usbvc_stream_if_t *strm_if, 2919 int buf_cnt, int buf_len) 2920 { 2921 int i = 0; 2922 usbvc_buf_t *bufs; 2923 2924 ASSERT(mutex_owned(&usbvcp->usbvc_mutex)); 2925 USB_DPRINTF_L4(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 2926 "usbvc_alloc_map_bufs: bufcnt=%d, buflen=%d", buf_cnt, buf_len); 2927 if (buf_len <= 0 || buf_cnt <= 0) { 2928 USB_DPRINTF_L2(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 2929 "usbvc_alloc_map_bufs: len<=0, cnt<=0"); 2930 2931 return (0); 2932 } 2933 mutex_exit(&usbvcp->usbvc_mutex); 2934 2935 bufs = (usbvc_buf_t *) kmem_zalloc(sizeof (usbvc_buf_t) * buf_cnt, 2936 KM_SLEEP); 2937 2938 mutex_enter(&usbvcp->usbvc_mutex); 2939 strm_if->buf_map.buf_head = bufs; 2940 buf_len = ptob(btopr(buf_len)); 2941 2942 mutex_exit(&usbvcp->usbvc_mutex); 2943 bufs[0].data = ddi_umem_alloc(buf_len * buf_cnt, DDI_UMEM_SLEEP, 2944 &bufs[0].umem_cookie); 2945 mutex_enter(&usbvcp->usbvc_mutex); 2946 2947 for (i = 0; i < buf_cnt; i++) { 2948 bufs[i].len = buf_len; 2949 bufs[i].data = bufs[0].data + (buf_len * i); 2950 bufs[i].umem_cookie = bufs[0].umem_cookie; 2951 bufs[i].status = USBVC_BUF_INIT; 2952 2953 bufs[i].v4l2_buf.index = i; 2954 bufs[i].v4l2_buf.m.offset = i * bufs[i].len; 2955 bufs[i].v4l2_buf.length = bufs[i].len; 2956 bufs[i].v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2957 bufs[i].v4l2_buf.sequence = 0; 2958 bufs[i].v4l2_buf.field = V4L2_FIELD_NONE; 2959 bufs[i].v4l2_buf.memory = V4L2_MEMORY_MMAP; 2960 bufs[i].v4l2_buf.flags = V4L2_MEMORY_MMAP; 2961 2962 list_insert_tail(&strm_if->buf_map.uv_buf_free, &bufs[i]); 2963 USB_DPRINTF_L4(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 2964 "usbvc_alloc_map_bufs: prepare %d buffers of %d bytes", 2965 buf_cnt, bufs[i].len); 2966 } 2967 strm_if->buf_map.buf_cnt = buf_cnt; 2968 strm_if->buf_map.buf_filling = NULL; 2969 2970 return (buf_cnt); 2971 } 2972 2973 2974 /* Free all bufs which are for memory map IO style */ 2975 void 2976 usbvc_free_map_bufs(usbvc_state_t *usbvcp, usbvc_stream_if_t *strm_if) 2977 { 2978 usbvc_buf_t *buf; 2979 2980 ASSERT(mutex_owned(&usbvcp->usbvc_mutex)); 2981 if (!strm_if) { 2982 2983 return; 2984 } 2985 strm_if->buf_map.buf_filling = NULL; 2986 while (!list_is_empty(&strm_if->buf_map.uv_buf_free)) { 2987 buf = (usbvc_buf_t *)list_head(&strm_if->buf_map.uv_buf_free); 2988 list_remove(&(strm_if->buf_map.uv_buf_free), buf); 2989 } 2990 while (!list_is_empty(&strm_if->buf_map.uv_buf_done)) { 2991 buf = (usbvc_buf_t *)list_head(&strm_if->buf_map.uv_buf_done); 2992 list_remove(&(strm_if->buf_map.uv_buf_done), buf); 2993 } 2994 buf = strm_if->buf_map.buf_head; 2995 if (!buf) { 2996 USB_DPRINTF_L2(PRINT_MASK_CLOSE, usbvcp->usbvc_log_handle, 2997 "usbvc_free_map_bufs: no data buf need be freed, return"); 2998 2999 return; 3000 } 3001 if (buf->umem_cookie) { 3002 ddi_umem_free(buf->umem_cookie); 3003 } 3004 kmem_free(buf, sizeof (usbvc_buf_t) * strm_if->buf_map.buf_cnt); 3005 strm_if->buf_map.buf_cnt = 0; 3006 strm_if->buf_map.buf_head = NULL; 3007 3008 USB_DPRINTF_L4(PRINT_MASK_CLOSE, usbvcp->usbvc_log_handle, 3009 "usbvc_free_map_bufs: return"); 3010 } 3011 3012 3013 /* 3014 * Open the isoc pipe, this pipe is for video data transfer 3015 */ 3016 int 3017 usbvc_open_isoc_pipe(usbvc_state_t *usbvcp, usbvc_stream_if_t *strm_if) 3018 { 3019 usb_pipe_policy_t policy; 3020 int rval = USB_SUCCESS; 3021 3022 ASSERT(mutex_owned(&usbvcp->usbvc_mutex)); 3023 3024 if ((rval = usbvc_set_alt(usbvcp, strm_if)) != USB_SUCCESS) { 3025 3026 return (rval); 3027 } 3028 bzero(&policy, sizeof (usb_pipe_policy_t)); 3029 policy.pp_max_async_reqs = 2; 3030 mutex_exit(&usbvcp->usbvc_mutex); 3031 if ((rval = usb_pipe_open(usbvcp->usbvc_dip, strm_if->curr_ep, &policy, 3032 USB_FLAGS_SLEEP, &strm_if->datain_ph)) != USB_SUCCESS) { 3033 USB_DPRINTF_L2(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 3034 "usbvc_open_isoc_pipe: open pipe fail"); 3035 mutex_enter(&usbvcp->usbvc_mutex); 3036 3037 return (rval); 3038 } 3039 mutex_enter(&usbvcp->usbvc_mutex); 3040 strm_if->start_polling = 0; 3041 3042 strm_if->stream_on = 0; 3043 3044 USB_DPRINTF_L4(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 3045 "usbvc_open_isoc_pipe: success, datain_ph=%p", 3046 (void *)strm_if->datain_ph); 3047 3048 return (rval); 3049 } 3050 3051 3052 /* 3053 * Open the isoc pipe 3054 */ 3055 static void 3056 usbvc_close_isoc_pipe(usbvc_state_t *usbvcp, usbvc_stream_if_t *strm_if) 3057 { 3058 ASSERT(mutex_owned(&usbvcp->usbvc_mutex)); 3059 if (!strm_if) { 3060 USB_DPRINTF_L2(PRINT_MASK_CLOSE, usbvcp->usbvc_log_handle, 3061 "usbvc_close_isoc_pipe: stream interface is NULL"); 3062 3063 return; 3064 } 3065 if (strm_if->datain_ph) { 3066 mutex_exit(&usbvcp->usbvc_mutex); 3067 usb_pipe_close(usbvcp->usbvc_dip, strm_if->datain_ph, 3068 USB_FLAGS_SLEEP, NULL, NULL); 3069 mutex_enter(&usbvcp->usbvc_mutex); 3070 } 3071 strm_if->datain_ph = NULL; 3072 } 3073 3074 3075 /* 3076 * Start to get video data from isoc pipe in the stream interface, 3077 * issue isoc req. 3078 */ 3079 int 3080 usbvc_start_isoc_polling(usbvc_state_t *usbvcp, usbvc_stream_if_t *strm_if, 3081 uchar_t io_type) 3082 { 3083 int rval = USB_SUCCESS; 3084 uint_t if_num; 3085 usb_isoc_req_t *req; 3086 ushort_t pkt_size; 3087 ushort_t n_pkt, pkt; 3088 uint32_t frame_size; 3089 3090 ASSERT(mutex_owned(&usbvcp->usbvc_mutex)); 3091 pkt_size = HS_PKT_SIZE(strm_if->curr_ep->wMaxPacketSize); 3092 if_num = strm_if->if_descr->if_alt->altif_descr.bInterfaceNumber; 3093 LE_TO_UINT32(strm_if->ctrl_pc.dwMaxVideoFrameSize, 0, frame_size); 3094 n_pkt = (frame_size + (pkt_size) - 1) / (pkt_size); 3095 3096 USB_DPRINTF_L3(PRINT_MASK_IOCTL, usbvcp->usbvc_log_handle, 3097 "usbvc_start_isoc_polling: if_num=%d, alt=%d, n_pkt=%d," 3098 " pkt_size=0x%x, MaxPacketSize=0x%x(Tsac#=%d), frame_size=0x%x", 3099 if_num, strm_if->curr_alt, n_pkt, pkt_size, 3100 strm_if->curr_ep->wMaxPacketSize, 3101 (1 + ((strm_if->curr_ep->wMaxPacketSize>> 11) & 3)), 3102 frame_size); 3103 3104 if (n_pkt > USBVC_MAX_PKTS) { 3105 n_pkt = USBVC_MAX_PKTS; 3106 } 3107 USB_DPRINTF_L3(PRINT_MASK_IOCTL, usbvcp->usbvc_log_handle, 3108 "usbvc_start_isoc_polling: n_pkt=%d", n_pkt); 3109 3110 mutex_exit(&usbvcp->usbvc_mutex); 3111 if ((req = usb_alloc_isoc_req(usbvcp->usbvc_dip, n_pkt, 3112 n_pkt * pkt_size, USB_FLAGS_SLEEP)) != NULL) { 3113 mutex_enter(&usbvcp->usbvc_mutex); 3114 3115 /* Initialize the packet descriptor */ 3116 for (pkt = 0; pkt < n_pkt; pkt++) { 3117 req->isoc_pkt_descr[pkt].isoc_pkt_length = pkt_size; 3118 } 3119 3120 req->isoc_pkts_count = n_pkt; 3121 3122 /* 3123 * zero here indicates that HCDs will use 3124 * isoc_pkt_descr->isoc_pkt_length to calculate 3125 * isoc_pkts_length. 3126 */ 3127 req->isoc_pkts_length = 0; 3128 req->isoc_attributes = USB_ATTRS_ISOC_XFER_ASAP | 3129 USB_ATTRS_SHORT_XFER_OK | USB_ATTRS_AUTOCLEARING; 3130 req->isoc_cb = usbvc_isoc_cb; 3131 req->isoc_exc_cb = usbvc_isoc_exc_cb; 3132 usbvcp->usbvc_io_type = io_type; 3133 req->isoc_client_private = (usb_opaque_t)usbvcp; 3134 mutex_exit(&usbvcp->usbvc_mutex); 3135 rval = usb_pipe_isoc_xfer(strm_if->datain_ph, req, 0); 3136 mutex_enter(&usbvcp->usbvc_mutex); 3137 } else { 3138 mutex_enter(&usbvcp->usbvc_mutex); 3139 USB_DPRINTF_L2(PRINT_MASK_IOCTL, usbvcp->usbvc_log_handle, 3140 "usbvc_start_isoc_polling: alloc_isoc_req fail"); 3141 3142 return (USB_FAILURE); 3143 } 3144 3145 if (rval != USB_SUCCESS) { 3146 if (req) { 3147 usb_free_isoc_req(req); 3148 req = NULL; 3149 } 3150 } 3151 USB_DPRINTF_L4(PRINT_MASK_IOCTL, usbvcp->usbvc_log_handle, 3152 "usbvc_start_isoc_polling: return, rval=%d", rval); 3153 3154 return (rval); 3155 } 3156 3157 /* callbacks for receiving video data (isco in transfer) */ 3158 3159 /*ARGSUSED*/ 3160 /* Isoc transfer callback, get video data */ 3161 static void 3162 usbvc_isoc_cb(usb_pipe_handle_t ph, usb_isoc_req_t *isoc_req) 3163 { 3164 usbvc_state_t *usbvcp = 3165 (usbvc_state_t *)isoc_req->isoc_client_private; 3166 int i; 3167 mblk_t *data = isoc_req->isoc_data; 3168 usbvc_buf_grp_t *bufgrp; 3169 3170 mutex_enter(&usbvcp->usbvc_mutex); 3171 3172 USB_DPRINTF_L3(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3173 "usbvc_isoc_cb: rq=0x%p, fno=%" PRId64 ", n_pkts=%u, flag=0x%x," 3174 " data=0x%p, cnt=%d", 3175 (void *)isoc_req, isoc_req->isoc_frame_no, 3176 isoc_req->isoc_pkts_count, isoc_req->isoc_attributes, 3177 (void *)isoc_req->isoc_data, isoc_req->isoc_error_count); 3178 3179 ASSERT((isoc_req->isoc_cb_flags & USB_CB_INTR_CONTEXT) != 0); 3180 for (i = 0; i < isoc_req->isoc_pkts_count; i++) { 3181 3182 USB_DPRINTF_L3(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3183 "\tpkt%d: " 3184 "pktsize=%d status=%d resid=%d", 3185 i, 3186 isoc_req->isoc_pkt_descr[i].isoc_pkt_length, 3187 isoc_req->isoc_pkt_descr[i].isoc_pkt_status, 3188 isoc_req->isoc_pkt_descr[i].isoc_pkt_actual_length); 3189 3190 if (isoc_req->isoc_pkt_descr[i].isoc_pkt_status != 3191 USB_CR_OK) { 3192 USB_DPRINTF_L3(PRINT_MASK_CB, 3193 usbvcp->usbvc_log_handle, 3194 "record: pkt=%d status=%s", i, usb_str_cr( 3195 isoc_req->isoc_pkt_descr[i].isoc_pkt_status)); 3196 } 3197 3198 if (usbvcp->usbvc_io_type == V4L2_MEMORY_MMAP) { 3199 bufgrp = &usbvcp->usbvc_curr_strm->buf_map; 3200 } else { 3201 bufgrp = &usbvcp->usbvc_curr_strm->buf_read; 3202 } 3203 3204 if (isoc_req->isoc_pkt_descr[i].isoc_pkt_actual_length) { 3205 if (usbvc_decode_stream_header(usbvcp, bufgrp, data, 3206 isoc_req->isoc_pkt_descr[i].isoc_pkt_actual_length) 3207 != USB_SUCCESS) { 3208 USB_DPRINTF_L3(PRINT_MASK_CB, 3209 usbvcp->usbvc_log_handle, "decode error"); 3210 } 3211 if (bufgrp->buf_filling && 3212 (bufgrp->buf_filling->status == USBVC_BUF_ERR || 3213 bufgrp->buf_filling->status == USBVC_BUF_DONE)) { 3214 3215 /* Move the buf to the full list */ 3216 list_insert_tail(&bufgrp->uv_buf_done, 3217 bufgrp->buf_filling); 3218 3219 bufgrp->buf_filling = NULL; 3220 3221 if (usbvcp->usbvc_io_type == V4L2_MEMORY_MMAP) { 3222 cv_broadcast(&usbvcp->usbvc_mapio_cv); 3223 } else { 3224 cv_broadcast(&usbvcp->usbvc_read_cv); 3225 } 3226 } 3227 } 3228 3229 data->b_rptr += isoc_req->isoc_pkt_descr[i].isoc_pkt_length; 3230 } 3231 mutex_exit(&usbvcp->usbvc_mutex); 3232 usb_free_isoc_req(isoc_req); 3233 } 3234 3235 3236 /*ARGSUSED*/ 3237 static void 3238 usbvc_isoc_exc_cb(usb_pipe_handle_t ph, usb_isoc_req_t *isoc_req) 3239 { 3240 usbvc_state_t *usbvcp = 3241 (usbvc_state_t *)isoc_req->isoc_client_private; 3242 usb_cr_t completion_reason; 3243 int rval; 3244 usbvc_stream_if_t *strm_if; 3245 3246 ASSERT(!list_is_empty(&usbvcp->usbvc_stream_list)); 3247 3248 mutex_enter(&usbvcp->usbvc_mutex); 3249 3250 /* get the first stream interface */ 3251 strm_if = usbvcp->usbvc_curr_strm; 3252 3253 completion_reason = isoc_req->isoc_completion_reason; 3254 3255 USB_DPRINTF_L3(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3256 "usbvc_isoc_exc_cb: ph=0x%p, isoc_req=0x%p, cr=%d", 3257 (void *)ph, (void *)isoc_req, completion_reason); 3258 3259 ASSERT((isoc_req->isoc_cb_flags & USB_CB_INTR_CONTEXT) == 0); 3260 3261 switch (completion_reason) { 3262 case USB_CR_STOPPED_POLLING: 3263 case USB_CR_PIPE_CLOSING: 3264 case USB_CR_PIPE_RESET: 3265 3266 break; 3267 case USB_CR_NO_RESOURCES: 3268 /* 3269 * keep the show going: Since we have the original 3270 * request, we just resubmit it 3271 */ 3272 rval = usb_pipe_isoc_xfer(strm_if->datain_ph, isoc_req, 3273 USB_FLAGS_NOSLEEP); 3274 USB_DPRINTF_L2(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3275 "usbvc_isoc_exc_cb: restart capture rval=%d", rval); 3276 mutex_exit(&usbvcp->usbvc_mutex); 3277 3278 return; 3279 default: 3280 mutex_exit(&usbvcp->usbvc_mutex); 3281 usb_pipe_stop_isoc_polling(ph, USB_FLAGS_NOSLEEP); 3282 USB_DPRINTF_L2(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3283 "usbvc_isoc_exc_cb: stop polling"); 3284 mutex_enter(&usbvcp->usbvc_mutex); 3285 } 3286 usb_free_isoc_req(isoc_req); 3287 strm_if->start_polling = 0; 3288 USB_DPRINTF_L3(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3289 "usbvc_isoc_exc_cb: start_polling=%d cr=%d", 3290 strm_if->start_polling, completion_reason); 3291 mutex_exit(&usbvcp->usbvc_mutex); 3292 } 3293 3294 /* 3295 * Other utility functions 3296 */ 3297 3298 /* 3299 * Find a proper alternate according to the bandwidth that the current video 3300 * format need; 3301 * Set alternate by calling usb_set_alt_if; 3302 * Called before open pipes in stream interface. 3303 */ 3304 static int 3305 usbvc_set_alt(usbvc_state_t *usbvcp, usbvc_stream_if_t *strm_if) 3306 { 3307 usb_alt_if_data_t *alt; 3308 uint_t i, j, if_num; 3309 uint16_t pktsize, curr_pktsize; 3310 uint32_t bandwidth; 3311 int rval = USB_SUCCESS; 3312 usbvc_input_header_t *ihd; 3313 usbvc_output_header_t *ohd; 3314 3315 ASSERT(mutex_owned(&usbvcp->usbvc_mutex)); 3316 3317 LE_TO_UINT32(strm_if->ctrl_pc.dwMaxPayloadTransferSize, 0, bandwidth); 3318 if (!bandwidth) { 3319 USB_DPRINTF_L2(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 3320 "usbvc_set_alt: bandwidth is not set yet"); 3321 3322 return (USB_FAILURE); 3323 } 3324 USB_DPRINTF_L3(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 3325 "usbvc_set_alt: bandwidth=%x", bandwidth); 3326 3327 strm_if->curr_ep = NULL; 3328 curr_pktsize = 0xffff; 3329 ohd = strm_if->output_header; 3330 ihd = strm_if->input_header; 3331 /* 3332 * Find one alternate setting whose isoc ep's max pktsize is just 3333 * enough for the bandwidth. 3334 */ 3335 for (i = 0; i < strm_if->if_descr->if_n_alt; i++) { 3336 alt = &strm_if->if_descr->if_alt[i]; 3337 3338 for (j = 0; j < alt->altif_n_ep; j++) { 3339 3340 /* if this stream interface is for input */ 3341 if (ihd != NULL && 3342 alt->altif_ep[j].ep_descr.bEndpointAddress != 3343 ihd->descr->bEndpointAddress) { 3344 3345 continue; 3346 } 3347 /* if this stream interface is for output */ 3348 if (ohd != NULL && 3349 alt->altif_ep[j].ep_descr.bEndpointAddress != 3350 ohd->descr->bEndpointAddress) { 3351 3352 continue; 3353 } 3354 pktsize = 3355 alt->altif_ep[j].ep_descr.wMaxPacketSize; 3356 pktsize = HS_PKT_SIZE(pktsize); 3357 if (pktsize >= bandwidth && pktsize < curr_pktsize) { 3358 curr_pktsize = pktsize; 3359 strm_if->curr_alt = i; 3360 strm_if->curr_ep = &alt->altif_ep[j].ep_descr; 3361 } 3362 } 3363 } 3364 if (!strm_if->curr_ep) { 3365 USB_DPRINTF_L2(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 3366 "usbvc_set_alt: can't find a proper ep to satisfy" 3367 " the given bandwidth"); 3368 3369 return (USB_FAILURE); 3370 } 3371 USB_DPRINTF_L3(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 3372 "usbvc_set_alt: strm_if->curr_alt=%d", strm_if->curr_alt); 3373 if_num = strm_if->if_descr->if_alt->altif_descr.bInterfaceNumber; 3374 mutex_exit(&usbvcp->usbvc_mutex); 3375 if ((rval = usb_set_alt_if(usbvcp->usbvc_dip, if_num, strm_if->curr_alt, 3376 USB_FLAGS_SLEEP, NULL, NULL)) != USB_SUCCESS) { 3377 mutex_enter(&usbvcp->usbvc_mutex); 3378 USB_DPRINTF_L2(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 3379 "usbvc_set_alt: usb_set_alt_if fail, if.alt=%d.%d, rval=%d", 3380 if_num, strm_if->curr_alt, rval); 3381 3382 return (rval); 3383 } 3384 mutex_enter(&usbvcp->usbvc_mutex); 3385 3386 USB_DPRINTF_L4(PRINT_MASK_OPEN, usbvcp->usbvc_log_handle, 3387 "usbvc_set_alt: return, if_num=%d, alt=%d", 3388 if_num, strm_if->curr_alt); 3389 3390 return (rval); 3391 } 3392 3393 3394 /* 3395 * Decode stream header for mjpeg and uncompressed format video data. 3396 * mjpeg and uncompressed format have the same stream header. See their 3397 * payload spec, 2.2 and 2.4 3398 */ 3399 static int 3400 usbvc_decode_stream_header(usbvc_state_t *usbvcp, usbvc_buf_grp_t *bufgrp, 3401 mblk_t *data, int actual_len) 3402 { 3403 uint32_t len, buf_left, data_len; 3404 usbvc_stream_if_t *strm_if; 3405 uchar_t head_flag, head_len; 3406 usbvc_buf_t *buf_filling; 3407 3408 ASSERT(mutex_owned(&usbvcp->usbvc_mutex)); 3409 USB_DPRINTF_L4(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3410 "usbvc_decode_stream_header: enter. actual_len=%x", actual_len); 3411 3412 /* header length check. */ 3413 if (actual_len < 2) { 3414 USB_DPRINTF_L2(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3415 "usbvc_decode_stream_header: header is not completed"); 3416 3417 return (USB_FAILURE); 3418 } 3419 head_len = data->b_rptr[0]; 3420 head_flag = data->b_rptr[1]; 3421 3422 USB_DPRINTF_L3(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3423 "usbvc_decode_stream_header: headlen=%x", head_len); 3424 3425 /* header length check. */ 3426 if (actual_len < head_len) { 3427 USB_DPRINTF_L2(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3428 "usbvc_decode_stream_header: actual_len < head_len"); 3429 3430 return (USB_FAILURE); 3431 } 3432 3433 /* 3434 * If there is no stream data in this packet and this packet is not 3435 * used to indicate the end of a frame, then just skip it. 3436 */ 3437 if ((actual_len == head_len) && !(head_flag & USBVC_STREAM_EOF)) { 3438 USB_DPRINTF_L2(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3439 "usbvc_decode_stream_header: only header, no data"); 3440 3441 return (USB_FAILURE); 3442 } 3443 3444 /* Get the first stream interface */ 3445 strm_if = usbvcp->usbvc_curr_strm; 3446 3447 LE_TO_UINT32(strm_if->ctrl_pc.dwMaxVideoFrameSize, 0, len); 3448 USB_DPRINTF_L3(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3449 "usbvc_decode_stream_header: dwMaxVideoFrameSize=%x, head_flag=%x", 3450 len, head_flag); 3451 3452 /* 3453 * if no buf is filling, pick one buf from free list and alloc data 3454 * mem for the buf. 3455 */ 3456 if (!bufgrp->buf_filling) { 3457 if (list_is_empty(&bufgrp->uv_buf_free)) { 3458 strm_if->fid = head_flag & USBVC_STREAM_FID; 3459 USB_DPRINTF_L2(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3460 "usbvc_decode_stream_header: free list are empty"); 3461 3462 return (USB_FAILURE); 3463 3464 } else { 3465 bufgrp->buf_filling = 3466 (usbvc_buf_t *)list_head(&bufgrp->uv_buf_free); 3467 3468 /* unlink from buf free list */ 3469 list_remove(&bufgrp->uv_buf_free, bufgrp->buf_filling); 3470 } 3471 bufgrp->buf_filling->filled = 0; 3472 USB_DPRINTF_L3(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3473 "usbvc_decode_stream_header: status=%d", 3474 bufgrp->buf_filling->status); 3475 bufgrp->buf_filling->status = USBVC_BUF_EMPTY; 3476 } 3477 buf_filling = bufgrp->buf_filling; 3478 ASSERT(buf_filling->len >= buf_filling->filled); 3479 buf_left = buf_filling->len - buf_filling->filled; 3480 3481 /* if no buf room left, then return with a err status */ 3482 if (buf_left == 0) { 3483 /* buffer full, got an EOF packet(head only, no payload) */ 3484 if ((head_flag & USBVC_STREAM_EOF) && 3485 (actual_len == head_len)) { 3486 buf_filling->status = USBVC_BUF_DONE; 3487 USB_DPRINTF_L3(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3488 "usbvc_decode_stream_header: got a EOF packet"); 3489 3490 return (USB_SUCCESS); 3491 } 3492 3493 /* Otherwise, mark the buf error and return failure */ 3494 buf_filling->status = USBVC_BUF_ERR; 3495 USB_DPRINTF_L3(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3496 "usbvc_decode_stream_header: frame buf full"); 3497 3498 return (USB_FAILURE); 3499 } 3500 3501 /* get this sample's data length except header */ 3502 data_len = actual_len - head_len; 3503 USB_DPRINTF_L3(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3504 "usbvc_decode_stream_header: fid=%x, len=%x, filled=%x", 3505 strm_if->fid, buf_filling->len, buf_filling->filled); 3506 3507 /* if the first sample for a frame */ 3508 if (buf_filling->filled == 0) { 3509 /* 3510 * Only if it is the frist packet of a frame, 3511 * we will begin filling a frame. 3512 */ 3513 if (strm_if->fid != 0xff && strm_if->fid == 3514 (head_flag & USBVC_STREAM_FID)) { 3515 USB_DPRINTF_L2(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3516 "usbvc_decode_stream_header: 1st sample of a frame," 3517 " fid is incorrect."); 3518 3519 return (USB_FAILURE); 3520 } 3521 strm_if->fid = head_flag & USBVC_STREAM_FID; 3522 3523 /* If in the middle of a frame, fid should be consistent. */ 3524 } else if (strm_if->fid != (head_flag & USBVC_STREAM_FID)) { 3525 USB_DPRINTF_L2(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3526 "usbvc_decode_stream_header: fid is incorrect."); 3527 strm_if->fid = head_flag & USBVC_STREAM_FID; 3528 buf_filling->status = USBVC_BUF_ERR; 3529 3530 return (USB_FAILURE); 3531 } 3532 if (data_len) { 3533 bcopy((void *)(data->b_rptr + head_len), 3534 (void *)(buf_filling->data + buf_filling->filled), 3535 min(data_len, buf_left)); 3536 3537 buf_filling->filled += min(data_len, buf_left); 3538 } 3539 3540 /* If the last packet for this frame */ 3541 if (head_flag & USBVC_STREAM_EOF) { 3542 buf_filling->status = USBVC_BUF_DONE; 3543 } 3544 if (data_len > buf_left) { 3545 buf_filling->status = USBVC_BUF_ERR; 3546 } 3547 USB_DPRINTF_L4(PRINT_MASK_CB, usbvcp->usbvc_log_handle, 3548 "usbvc_decode_stream_header: buf_status=%d", buf_filling->status); 3549 3550 return (USB_SUCCESS); 3551 } 3552 3553 3554 /* 3555 * usbvc_serialize_access: 3556 * Get the serial synchronization object before returning. 3557 * 3558 * Arguments: 3559 * usbvcp - Pointer to usbvc state structure 3560 * waitsig - Set to: 3561 * USBVC_SER_SIG - to wait such that a signal can interrupt 3562 * USBVC_SER_NOSIG - to wait such that a signal cannot interrupt 3563 */ 3564 static int 3565 usbvc_serialize_access(usbvc_state_t *usbvcp, boolean_t waitsig) 3566 { 3567 int rval = 1; 3568 3569 ASSERT(mutex_owned(&usbvcp->usbvc_mutex)); 3570 3571 while (usbvcp->usbvc_serial_inuse) { 3572 if (waitsig == USBVC_SER_SIG) { 3573 rval = cv_wait_sig(&usbvcp->usbvc_serial_cv, 3574 &usbvcp->usbvc_mutex); 3575 } else { 3576 cv_wait(&usbvcp->usbvc_serial_cv, 3577 &usbvcp->usbvc_mutex); 3578 } 3579 } 3580 usbvcp->usbvc_serial_inuse = B_TRUE; 3581 3582 return (rval); 3583 } 3584 3585 3586 /* 3587 * usbvc_release_access: 3588 * Release the serial synchronization object. 3589 */ 3590 static void 3591 usbvc_release_access(usbvc_state_t *usbvcp) 3592 { 3593 ASSERT(mutex_owned(&usbvcp->usbvc_mutex)); 3594 usbvcp->usbvc_serial_inuse = B_FALSE; 3595 cv_broadcast(&usbvcp->usbvc_serial_cv); 3596 } 3597 3598 3599 /* Send req to video control interface to get ctrl */ 3600 int 3601 usbvc_vc_get_ctrl(usbvc_state_t *usbvcp, uint8_t req_code, uint8_t entity_id, 3602 uint16_t cs, uint16_t wlength, mblk_t *data) 3603 { 3604 usb_cb_flags_t cb_flags; 3605 usb_cr_t cr; 3606 usb_ctrl_setup_t setup; 3607 3608 setup.bmRequestType = USBVC_GET_IF; /* bmRequestType */ 3609 setup.bRequest = req_code; /* bRequest */ 3610 setup.wValue = cs<<8; 3611 setup.wIndex = entity_id<<8; 3612 setup.wLength = wlength; 3613 setup.attrs = 0; 3614 3615 if (usb_pipe_ctrl_xfer_wait(usbvcp->usbvc_default_ph, &setup, &data, 3616 &cr, &cb_flags, 0) != USB_SUCCESS) { 3617 USB_DPRINTF_L2(PRINT_MASK_DEVCTRL, usbvcp->usbvc_log_handle, 3618 "usbvc_vc_get_ctrl: cmd failed, cr=%d, cb_flags=%x", 3619 cr, cb_flags); 3620 3621 return (USB_FAILURE); 3622 } 3623 3624 return (USB_SUCCESS); 3625 } 3626 3627 3628 /* Send req to video control interface to get ctrl */ 3629 int 3630 usbvc_vc_set_ctrl(usbvc_state_t *usbvcp, uint8_t req_code, uint8_t entity_id, 3631 uint16_t cs, uint16_t wlength, mblk_t *data) 3632 { 3633 usb_cb_flags_t cb_flags; 3634 usb_cr_t cr; 3635 usb_ctrl_setup_t setup; 3636 3637 setup.bmRequestType = USBVC_SET_IF; /* bmRequestType */ 3638 setup.bRequest = req_code; /* bRequest */ 3639 setup.wValue = cs<<8; 3640 setup.wIndex = entity_id<<8; 3641 setup.wLength = wlength; 3642 setup.attrs = 0; 3643 3644 if (usb_pipe_ctrl_xfer_wait(usbvcp->usbvc_default_ph, &setup, &data, 3645 &cr, &cb_flags, 0) != USB_SUCCESS) { 3646 USB_DPRINTF_L2(PRINT_MASK_DEVCTRL, usbvcp->usbvc_log_handle, 3647 "usbvc_vc_set_ctrl: cmd failed, cr=%d, cb_flags=%x", 3648 cr, cb_flags); 3649 3650 return (USB_FAILURE); 3651 } 3652 3653 return (USB_SUCCESS); 3654 } 3655 3656 3657 /* Set probe or commit ctrl for video stream interface */ 3658 int 3659 usbvc_vs_set_probe_commit(usbvc_state_t *usbvcp, usbvc_stream_if_t *strm_if, 3660 usbvc_vs_probe_commit_t *ctrl_pc, uchar_t cs) 3661 { 3662 mblk_t *data; 3663 usb_cb_flags_t cb_flags; 3664 usb_cr_t cr; 3665 usb_ctrl_setup_t setup; 3666 int rval; 3667 3668 setup.bmRequestType = USBVC_SET_IF; /* bmRequestType */ 3669 setup.bRequest = SET_CUR; /* bRequest */ 3670 3671 /* wValue, VS_PROBE_CONTROL or VS_COMMIT_CONTROL */ 3672 setup.wValue = cs; 3673 3674 /* UVC Spec: this value must be put to the high byte */ 3675 setup.wValue = setup.wValue << 8; 3676 3677 setup.wIndex = strm_if->if_descr->if_alt->altif_descr.bInterfaceNumber; 3678 setup.wLength = usbvcp->usbvc_vc_header->descr->bcdUVC[0] ? 34 : 26; 3679 setup.attrs = 0; 3680 3681 USB_DPRINTF_L3(PRINT_MASK_DEVCTRL, usbvcp->usbvc_log_handle, 3682 "usbvc_vs_set_probe_commit: wLength=%d", setup.wLength); 3683 3684 /* Data block */ 3685 if ((data = allocb(setup.wLength, BPRI_HI)) == NULL) { 3686 USB_DPRINTF_L2(PRINT_MASK_DEVCTRL, usbvcp->usbvc_log_handle, 3687 "usbvc_vs_set_probe_commit: allocb failed"); 3688 3689 return (USB_FAILURE); 3690 } 3691 3692 bcopy(ctrl_pc, data->b_rptr, setup.wLength); 3693 data->b_wptr += setup.wLength; 3694 3695 if ((rval = usb_pipe_ctrl_xfer_wait(usbvcp->usbvc_default_ph, &setup, 3696 &data, &cr, &cb_flags, 0)) != USB_SUCCESS) { 3697 if (data) { 3698 freemsg(data); 3699 } 3700 USB_DPRINTF_L2(PRINT_MASK_DEVCTRL, usbvcp->usbvc_log_handle, 3701 "usbvc_vs_set_probe_commit: fail, rval=%d, cr=%d, " 3702 "cb_flags=%x", rval, cr, cb_flags); 3703 3704 return (rval); 3705 } 3706 if (data) { 3707 freemsg(data); 3708 } 3709 3710 return (USB_SUCCESS); 3711 } 3712 3713 3714 /* Get probe ctrl for vodeo stream interface */ 3715 int 3716 usbvc_vs_get_probe(usbvc_state_t *usbvcp, usbvc_stream_if_t *strm_if, 3717 usbvc_vs_probe_commit_t *ctrl_pc, uchar_t bRequest) 3718 { 3719 mblk_t *data = NULL; 3720 usb_cb_flags_t cb_flags; 3721 usb_cr_t cr; 3722 usb_ctrl_setup_t setup; 3723 3724 setup.bmRequestType = USBVC_GET_IF; /* bmRequestType */ 3725 setup.bRequest = bRequest; /* bRequest */ 3726 setup.wValue = VS_PROBE_CONTROL; /* wValue, PROBE or COMMIT */ 3727 setup.wValue = setup.wValue << 8; 3728 setup.wIndex = 3729 (uint16_t)strm_if->if_descr->if_alt->altif_descr.bInterfaceNumber; 3730 setup.wLength = usbvcp->usbvc_vc_header->descr->bcdUVC[0] ? 34 : 26; 3731 3732 setup.attrs = 0; 3733 3734 if (usb_pipe_ctrl_xfer_wait(usbvcp->usbvc_default_ph, &setup, &data, 3735 &cr, &cb_flags, 0) != USB_SUCCESS) { 3736 if (data) { 3737 freemsg(data); 3738 } 3739 USB_DPRINTF_L2(PRINT_MASK_DEVCTRL, usbvcp->usbvc_log_handle, 3740 "usbvc_vs_get_probe: cmd failed, cr=%d, cb_flags=%x", 3741 cr, cb_flags); 3742 3743 return (USB_FAILURE); 3744 } 3745 bcopy(data->b_rptr, ctrl_pc, setup.wLength); 3746 if (data) { 3747 freemsg(data); 3748 } 3749 3750 return (USB_SUCCESS); 3751 } 3752 3753 3754 /* Set a default format when open the device */ 3755 static int 3756 usbvc_set_default_stream_fmt(usbvc_state_t *usbvcp) 3757 { 3758 usbvc_vs_probe_commit_t ctrl, ctrl_get; 3759 usbvc_stream_if_t *strm_if; 3760 usbvc_format_group_t *curr_fmtgrp; 3761 uint32_t bandwidth; 3762 uint8_t index, i; 3763 3764 USB_DPRINTF_L4(PRINT_MASK_DEVCTRL, usbvcp->usbvc_log_handle, 3765 "usbvc_set_default_stream_fmt: enter"); 3766 3767 mutex_enter(&usbvcp->usbvc_mutex); 3768 if (list_is_empty(&usbvcp->usbvc_stream_list)) { 3769 USB_DPRINTF_L2(PRINT_MASK_DEVCTRL, usbvcp->usbvc_log_handle, 3770 "usbvc_set_default_stream_fmt: no stream interface, fail"); 3771 mutex_exit(&usbvcp->usbvc_mutex); 3772 3773 return (USB_FAILURE); 3774 } 3775 bzero((void *)&ctrl, sizeof (usbvc_vs_probe_commit_t)); 3776 3777 /* Get the current stream interface */ 3778 strm_if = usbvcp->usbvc_curr_strm; 3779 3780 /* Fill the probe commit req data */ 3781 ctrl.bmHint[0] = 0; 3782 3783 for (i = 0; i < strm_if->fmtgrp_cnt; i++) { 3784 curr_fmtgrp = &strm_if->format_group[i]; 3785 3786 /* 3787 * If v4l2_pixelformat is NULL, then that means there is not 3788 * a parsed format in format_group[i]. 3789 */ 3790 if (!curr_fmtgrp || !curr_fmtgrp->v4l2_pixelformat || 3791 curr_fmtgrp->frame_cnt == 0) { 3792 USB_DPRINTF_L2(PRINT_MASK_DEVCTRL, 3793 usbvcp->usbvc_log_handle, 3794 "usbvc_set_default_stream_fmt: no frame, fail"); 3795 3796 continue; 3797 } else { 3798 3799 break; 3800 } 3801 } 3802 if (!curr_fmtgrp || curr_fmtgrp->frame_cnt == 0) { 3803 USB_DPRINTF_L2(PRINT_MASK_DEVCTRL, usbvcp->usbvc_log_handle, 3804 "usbvc_set_default_stream_fmt: can't find a fmtgrp" 3805 "which has a frame, fail"); 3806 mutex_exit(&usbvcp->usbvc_mutex); 3807 3808 return (USB_FAILURE); 3809 } 3810 3811 ctrl.bFormatIndex = curr_fmtgrp->format->bFormatIndex; 3812 3813 /* use the first frame descr as default */ 3814 ctrl.bFrameIndex = curr_fmtgrp->frames[0].descr->bFrameIndex; 3815 3816 /* use bcopy to keep the byte sequence as 32 bit little endian */ 3817 bcopy(&(curr_fmtgrp->frames[0].descr->dwDefaultFrameInterval[0]), 3818 &(ctrl.dwFrameInterval[0]), 4); 3819 3820 mutex_exit(&usbvcp->usbvc_mutex); 3821 if (usbvc_vs_set_probe_commit(usbvcp, strm_if, &ctrl, VS_PROBE_CONTROL) 3822 != USB_SUCCESS) { 3823 3824 return (USB_FAILURE); 3825 } 3826 if (usbvc_vs_get_probe(usbvcp, strm_if, &ctrl_get, GET_CUR) 3827 != USB_SUCCESS) { 3828 3829 return (USB_FAILURE); 3830 } 3831 3832 mutex_enter(&usbvcp->usbvc_mutex); 3833 LE_TO_UINT32(strm_if->ctrl_pc.dwMaxPayloadTransferSize, 0, bandwidth); 3834 USB_DPRINTF_L3(PRINT_MASK_DEVCTRL, usbvcp->usbvc_log_handle, 3835 "usbvc_set_default_stream_fmt: get bandwidth=%x", bandwidth); 3836 3837 mutex_exit(&usbvcp->usbvc_mutex); 3838 if (usbvc_vs_set_probe_commit(usbvcp, strm_if, &ctrl_get, 3839 VS_COMMIT_CONTROL) != USB_SUCCESS) { 3840 3841 return (USB_FAILURE); 3842 } 3843 3844 mutex_enter(&usbvcp->usbvc_mutex); 3845 3846 /* it's good to check index here before use it */ 3847 index = ctrl_get.bFormatIndex - curr_fmtgrp->format->bFormatIndex; 3848 if (index < strm_if->fmtgrp_cnt) { 3849 strm_if->cur_format_group = &strm_if->format_group[index]; 3850 } else { 3851 USB_DPRINTF_L2(PRINT_MASK_DEVCTRL, usbvcp->usbvc_log_handle, 3852 "usbvc_set_default_stream_fmt: format index out of range"); 3853 mutex_exit(&usbvcp->usbvc_mutex); 3854 3855 return (USB_FAILURE); 3856 } 3857 3858 index = ctrl_get.bFrameIndex - 3859 strm_if->cur_format_group->frames[0].descr->bFrameIndex; 3860 if (index < strm_if->cur_format_group->frame_cnt) { 3861 strm_if->cur_format_group->cur_frame = 3862 &strm_if->cur_format_group->frames[index]; 3863 } else { 3864 USB_DPRINTF_L2(PRINT_MASK_DEVCTRL, usbvcp->usbvc_log_handle, 3865 "usbvc_set_default_stream: frame index out of range"); 3866 mutex_exit(&usbvcp->usbvc_mutex); 3867 3868 return (USB_FAILURE); 3869 } 3870 3871 /* 3872 * by now, the video format is set successfully. record the current 3873 * setting to strm_if->ctrl_pc 3874 */ 3875 bcopy(&ctrl_get, &strm_if->ctrl_pc, sizeof (usbvc_vs_probe_commit_t)); 3876 3877 mutex_exit(&usbvcp->usbvc_mutex); 3878 3879 return (USB_SUCCESS); 3880 } 3881