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 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 * Copyright 2019, Joyent, Inc. 25 */ 26 27 28 /* 29 * Dummy module to load usba module on behalf of legacy drivers. 30 * 31 * Please see the on81-patch gate usr/src/uts/common/sys/usba10/usba10_usbai.h 32 * header file for descriptions and comments for these functions. 33 */ 34 35 #include <sys/usb/usba.h> 36 #include <sys/usb/usba/usbai_private.h> 37 #include <sys/usb/usba/usba10.h> 38 39 /* 40 * modload support 41 */ 42 43 static struct modlmisc modlmisc = { 44 &mod_miscops, /* Type of module */ 45 "USBA10: USB V0.8 Drvr Supp" 46 }; 47 48 static struct modlinkage modlinkage = { 49 MODREV_1, (void *)&modlmisc, NULL 50 }; 51 52 53 int 54 _init(void) 55 { 56 return (mod_install(&modlinkage)); 57 } 58 59 int 60 _fini() 61 { 62 return (mod_remove(&modlinkage)); 63 } 64 65 int 66 _info(struct modinfo *modinfop) 67 { 68 return (mod_info(&modlinkage, modinfop)); 69 } 70 71 /* 72 * Turn off lint checking of this module because it will find duplicate names 73 * defined here and in the usbai.c source for the usba module. 74 */ 75 #ifndef __lint 76 77 int 78 usb_register_client( 79 dev_info_t *dip, 80 uint_t version, 81 usb_client_dev_data_t **dev_data, 82 usb_reg_parse_lvl_t parse_level, 83 usb_flags_t flags) 84 { 85 return (usba10_usb_register_client( 86 dip, version, dev_data, parse_level, flags)); 87 } 88 89 90 void 91 usb_unregister_client( 92 dev_info_t *dip, 93 usb_client_dev_data_t *dev_data) 94 { 95 usba10_usb_unregister_client(dip, dev_data); 96 } 97 98 99 void 100 usb_free_descr_tree( 101 dev_info_t *dip, 102 usb_client_dev_data_t *dev_data) 103 { 104 usba10_usb_free_descr_tree(dip, dev_data); 105 } 106 107 108 size_t 109 usb_parse_data( 110 char *format, 111 const uchar_t *data, 112 size_t datalen, 113 void *structure, 114 size_t structlen) 115 { 116 return (usba10_usb_parse_data( 117 format, data, datalen, structure, structlen)); 118 } 119 120 121 usb_ep_data_t * 122 usb_get_ep_data( 123 dev_info_t *dip, 124 usb_client_dev_data_t *dev_datap, 125 uint_t interface, 126 uint_t alternate, 127 uint_t type, 128 uint_t direction) 129 { 130 return (usba10_usb_get_ep_data( 131 dip, dev_datap, interface, alternate, type, direction)); 132 } 133 134 135 int 136 usb_get_string_descr( 137 dev_info_t *dip, 138 uint16_t langid, 139 uint8_t index, 140 char *buf, 141 size_t buflen) 142 { 143 return (usba10_usb_get_string_descr(dip, langid, index, buf, buflen)); 144 } 145 146 147 int 148 usb_get_addr(dev_info_t *dip) 149 { 150 return (usba10_usb_get_addr(dip)); 151 } 152 153 154 int 155 usb_get_if_number(dev_info_t *dip) 156 { 157 return (usba10_usb_get_if_number(dip)); 158 } 159 160 161 boolean_t 162 usb_owns_device(dev_info_t *dip) 163 { 164 return (usba10_usb_owns_device(dip)); 165 } 166 167 168 int 169 usb_pipe_get_state( 170 usb_pipe_handle_t pipe_handle, 171 usb_pipe_state_t *pipe_state, 172 usb_flags_t flags) 173 { 174 return (usba10_usb_pipe_get_state(pipe_handle, pipe_state, flags)); 175 } 176 177 178 int 179 usb_ep_num(usb_pipe_handle_t ph) 180 { 181 return (usba10_usb_ep_num(ph)); 182 } 183 184 185 int 186 usb_pipe_open( 187 dev_info_t *dip, 188 usb_ep_descr_t *ep, 189 usb_pipe_policy_t *pipe_policy, 190 usb_flags_t flags, 191 usb_pipe_handle_t *pipe_handle) 192 { 193 return (usba10_usb_pipe_open(dip, ep, pipe_policy, flags, pipe_handle)); 194 } 195 196 197 void 198 usb_pipe_close( 199 dev_info_t *dip, 200 usb_pipe_handle_t pipe_handle, 201 usb_flags_t flags, 202 void (*cb)( 203 usb_pipe_handle_t ph, 204 usb_opaque_t arg, /* cb arg */ 205 int rval, 206 usb_cb_flags_t flags), 207 usb_opaque_t cb_arg) 208 { 209 usba10_usb_pipe_close(dip, pipe_handle, flags, cb, cb_arg); 210 } 211 212 213 int 214 usb_pipe_drain_reqs( 215 dev_info_t *dip, 216 usb_pipe_handle_t pipe_handle, 217 uint_t time, 218 usb_flags_t flags, 219 void (*cb)( 220 usb_pipe_handle_t ph, 221 usb_opaque_t arg, /* cb arg */ 222 int rval, 223 usb_cb_flags_t flags), 224 usb_opaque_t cb_arg) 225 { 226 return (usba10_usb_pipe_drain_reqs( 227 dip, pipe_handle, time, flags, cb, cb_arg)); 228 } 229 230 231 int 232 usb_pipe_set_private( 233 usb_pipe_handle_t pipe_handle, 234 usb_opaque_t data) 235 { 236 return (usba10_usb_pipe_set_private(pipe_handle, data)); 237 } 238 239 240 usb_opaque_t 241 usb_pipe_get_private(usb_pipe_handle_t pipe_handle) 242 { 243 return (usba10_usb_pipe_get_private(pipe_handle)); 244 } 245 246 247 void 248 usb_pipe_reset( 249 dev_info_t *dip, 250 usb_pipe_handle_t pipe_handle, 251 usb_flags_t usb_flags, 252 void (*cb)( 253 usb_pipe_handle_t ph, 254 usb_opaque_t arg, 255 int rval, 256 usb_cb_flags_t flags), 257 usb_opaque_t cb_arg) 258 { 259 usba10_usb_pipe_reset(dip, pipe_handle, usb_flags, cb, cb_arg); 260 } 261 262 263 usb_ctrl_req_t * 264 usb_alloc_ctrl_req( 265 dev_info_t *dip, 266 size_t len, 267 usb_flags_t flags) 268 { 269 return (usba10_usb_alloc_ctrl_req(dip, len, flags)); 270 } 271 272 273 void 274 usb_free_ctrl_req(usb_ctrl_req_t *reqp) 275 { 276 usba10_usb_free_ctrl_req(reqp); 277 } 278 279 280 int 281 usb_pipe_ctrl_xfer( 282 usb_pipe_handle_t pipe_handle, 283 usb_ctrl_req_t *reqp, 284 usb_flags_t flags) 285 { 286 return (usba10_usb_pipe_ctrl_xfer(pipe_handle, reqp, flags)); 287 } 288 289 290 int 291 usb_get_status( 292 dev_info_t *dip, 293 usb_pipe_handle_t ph, 294 uint_t type, /* bmRequestType */ 295 uint_t what, /* 0, interface, endpoint number */ 296 uint16_t *status, 297 usb_flags_t flags) 298 { 299 return (usba10_usb_get_status(dip, ph, type, what, status, flags)); 300 } 301 302 303 int 304 usb_clear_feature( 305 dev_info_t *dip, 306 usb_pipe_handle_t ph, 307 uint_t type, /* bmRequestType */ 308 uint_t feature, 309 uint_t what, /* 0, interface, endpoint number */ 310 usb_flags_t flags) 311 { 312 return (usba10_usb_clear_feature(dip, ph, type, feature, what, flags)); 313 } 314 315 316 int 317 usb_pipe_ctrl_xfer_wait( 318 usb_pipe_handle_t pipe_handle, 319 usb_ctrl_setup_t *setup, 320 mblk_t **data, 321 usb_cr_t *completion_reason, 322 usb_cb_flags_t *cb_flags, 323 usb_flags_t flags) 324 { 325 return (usba10_usb_pipe_ctrl_xfer_wait( 326 pipe_handle, setup, data, completion_reason, cb_flags, flags)); 327 } 328 329 330 int 331 usb_set_cfg( 332 dev_info_t *dip, 333 uint_t cfg_index, 334 usb_flags_t usb_flags, 335 void (*cb)( 336 usb_pipe_handle_t ph, 337 usb_opaque_t arg, 338 int rval, 339 usb_cb_flags_t flags), 340 usb_opaque_t cb_arg) 341 { 342 return (usba10_usb_set_cfg(dip, cfg_index, usb_flags, cb, cb_arg)); 343 } 344 345 346 int 347 usb_get_cfg( 348 dev_info_t *dip, 349 uint_t *cfgval, 350 usb_flags_t usb_flags) 351 { 352 return (usba10_usb_get_cfg(dip, cfgval, usb_flags)); 353 } 354 355 356 int 357 usb_set_alt_if( 358 dev_info_t *dip, 359 uint_t interface, 360 uint_t alt_number, 361 usb_flags_t usb_flags, 362 void (*cb)( 363 usb_pipe_handle_t ph, 364 usb_opaque_t arg, 365 int rval, 366 usb_cb_flags_t flags), 367 usb_opaque_t cb_arg) 368 { 369 return (usba10_usb_set_alt_if( 370 dip, interface, alt_number, usb_flags, cb, cb_arg)); 371 } 372 373 374 int 375 usb_get_alt_if( 376 dev_info_t *dip, 377 uint_t if_number, 378 uint_t *alt_number, 379 usb_flags_t flags) 380 { 381 return (usba10_usb_get_alt_if(dip, if_number, alt_number, flags)); 382 } 383 384 385 usb_bulk_req_t * 386 usb_alloc_bulk_req( 387 dev_info_t *dip, 388 size_t len, 389 usb_flags_t flags) 390 { 391 return (usba10_usb_alloc_bulk_req(dip, len, flags)); 392 } 393 394 395 void 396 usb_free_bulk_req(usb_bulk_req_t *reqp) 397 { 398 usba10_usb_free_bulk_req(reqp); 399 } 400 401 402 int 403 usb_pipe_bulk_xfer( 404 usb_pipe_handle_t pipe_handle, 405 usb_bulk_req_t *reqp, 406 usb_flags_t flags) 407 { 408 return (usba10_usb_pipe_bulk_xfer(pipe_handle, reqp, flags)); 409 } 410 411 412 int 413 usb_pipe_bulk_transfer_size( 414 dev_info_t *dip, 415 size_t *size) 416 { 417 return (usba10_usb_pipe_bulk_transfer_size(dip, size)); 418 } 419 420 421 usb_intr_req_t * 422 usb_alloc_intr_req( 423 dev_info_t *dip, 424 size_t len, 425 usb_flags_t flags) 426 { 427 return (usba10_usb_alloc_intr_req(dip, len, flags)); 428 } 429 430 431 void 432 usb_free_intr_req(usb_intr_req_t *reqp) 433 { 434 usba10_usb_free_intr_req(reqp); 435 } 436 437 438 int 439 usb_pipe_intr_xfer( 440 usb_pipe_handle_t pipe_handle, 441 usb_intr_req_t *req, 442 usb_flags_t flags) 443 { 444 return (usba10_usb_pipe_intr_xfer(pipe_handle, req, flags)); 445 } 446 447 448 void 449 usb_pipe_stop_intr_polling( 450 usb_pipe_handle_t pipe_handle, 451 usb_flags_t flags) 452 { 453 usba10_usb_pipe_stop_intr_polling(pipe_handle, flags); 454 } 455 456 457 usb_isoc_req_t * 458 usb_alloc_isoc_req( 459 dev_info_t *dip, 460 uint_t isoc_pkts_count, 461 size_t len, 462 usb_flags_t flags) 463 { 464 return (usba10_usb_alloc_isoc_req(dip, isoc_pkts_count, len, flags)); 465 } 466 467 468 void 469 usb_free_isoc_req(usb_isoc_req_t *usb_isoc_req) 470 { 471 usba10_usb_free_isoc_req(usb_isoc_req); 472 } 473 474 475 usb_frame_number_t 476 usb_get_current_frame_number(dev_info_t *dip) 477 { 478 return (usba10_usb_get_current_frame_number(dip)); 479 } 480 481 482 uint_t 483 usb_get_max_isoc_pkts(dev_info_t *dip) 484 { 485 return (usba10_usb_get_max_isoc_pkts(dip)); 486 } 487 488 489 int 490 usb_pipe_isoc_xfer( 491 usb_pipe_handle_t pipe_handle, 492 usb_isoc_req_t *reqp, 493 usb_flags_t flags) 494 { 495 return (usba10_usb_pipe_isoc_xfer(pipe_handle, reqp, flags)); 496 } 497 498 499 void 500 usb_pipe_stop_isoc_polling( 501 usb_pipe_handle_t pipe_handle, 502 usb_flags_t flags) 503 { 504 usba10_usb_pipe_stop_isoc_polling(pipe_handle, flags); 505 } 506 507 508 int 509 usb_req_raise_power( 510 dev_info_t *dip, 511 int comp, 512 int level, 513 void (*cb)(void *arg, int rval), 514 void *arg, 515 usb_flags_t flags) 516 { 517 return (usba10_usb_req_raise_power(dip, comp, level, cb, arg, flags)); 518 } 519 520 521 int 522 usb_req_lower_power( 523 dev_info_t *dip, 524 int comp, 525 int level, 526 void (*cb)(void *arg, int rval), 527 void *arg, 528 usb_flags_t flags) 529 { 530 return (usba10_usb_req_raise_power(dip, comp, level, cb, arg, flags)); 531 } 532 533 534 int 535 usb_is_pm_enabled(dev_info_t *dip) 536 { 537 return (usba10_usb_is_pm_enabled(dip)); 538 } 539 540 int 541 usb_handle_remote_wakeup( 542 dev_info_t *dip, 543 int cmd) 544 { 545 return (usba10_usb_handle_remote_wakeup(dip, cmd)); 546 } 547 548 549 int 550 usb_create_pm_components( 551 dev_info_t *dip, 552 uint_t *pwrstates) 553 { 554 return (usba10_usb_create_pm_components(dip, pwrstates)); 555 } 556 557 558 int 559 usb_set_device_pwrlvl0(dev_info_t *dip) 560 { 561 return (usba10_usb_set_device_pwrlvl0(dip)); 562 } 563 564 565 int 566 usb_set_device_pwrlvl1(dev_info_t *dip) 567 { 568 return (usba10_usb_set_device_pwrlvl1(dip)); 569 } 570 571 572 int 573 usb_set_device_pwrlvl2(dev_info_t *dip) 574 { 575 return (usba10_usb_set_device_pwrlvl2(dip)); 576 } 577 578 579 int 580 usb_set_device_pwrlvl3(dev_info_t *dip) 581 { 582 return (usba10_usb_set_device_pwrlvl3(dip)); 583 } 584 585 586 int 587 usb_async_req( 588 dev_info_t *dip, 589 void (*func)(void *), 590 void *arg, 591 usb_flags_t flag) 592 { 593 return (usba10_usb_async_req(dip, func, arg, flag)); 594 } 595 596 597 int 598 usb_register_event_cbs( 599 dev_info_t *dip, 600 usb_event_t *usb_evt_data, 601 usb_flags_t flags) 602 { 603 return (usba10_usb_register_event_cbs(dip, usb_evt_data, flags)); 604 } 605 606 607 void 608 usb_unregister_event_cbs( 609 dev_info_t *dip, 610 usb_event_t *usb_evt_data) 611 { 612 usba10_usb_unregister_event_cbs(dip, usb_evt_data); 613 } 614 615 616 void 617 usb_fail_checkpoint( 618 dev_info_t *dip, 619 usb_flags_t flags) 620 { 621 usba10_usb_fail_checkpoint(dip, flags); 622 } 623 624 #ifdef DEBUG 625 626 void usb_dprintf4( 627 uint_t mask, 628 usb_log_handle_t handle, 629 char *fmt, ...) 630 { 631 va_list ap; 632 633 va_start(ap, fmt); 634 (void) usba10_usba_vlog(handle, USB_LOG_L4, mask, fmt, ap); 635 va_end(ap); 636 } 637 638 639 void usb_dprintf3( 640 uint_t mask, 641 usb_log_handle_t handle, 642 char *fmt, ...) 643 { 644 va_list ap; 645 646 va_start(ap, fmt); 647 (void) usba10_usba_vlog(handle, USB_LOG_L3, mask, fmt, ap); 648 va_end(ap); 649 } 650 651 652 void usb_dprintf2( 653 uint_t mask, 654 usb_log_handle_t handle, 655 char *fmt, ...) 656 { 657 va_list ap; 658 659 va_start(ap, fmt); 660 (void) usba10_usba_vlog(handle, USB_LOG_L2, mask, fmt, ap); 661 va_end(ap); 662 } 663 664 #endif 665 666 void usb_dprintf1( 667 uint_t mask, 668 usb_log_handle_t handle, 669 char *fmt, ...) 670 { 671 va_list ap; 672 673 va_start(ap, fmt); 674 (void) usba10_usba_vlog(handle, USB_LOG_L1, mask, fmt, ap); 675 va_end(ap); 676 } 677 678 679 680 void usb_dprintf0( 681 uint_t mask, 682 usb_log_handle_t handle, 683 char *fmt, ...) 684 { 685 va_list ap; 686 687 va_start(ap, fmt); 688 (void) usba10_usba_vlog(handle, USB_LOG_L4, mask, fmt, ap); 689 va_end(ap); 690 } 691 692 usb_log_handle_t 693 usb_alloc_log_handle( 694 dev_info_t *dip, 695 char *name, 696 uint_t *errlevel, 697 uint_t *mask, 698 uint_t *instance_filter, 699 uint_t show_label, 700 usb_flags_t flags) 701 { 702 return (usba10_usb_alloc_log_handle( 703 dip, name, errlevel, mask, instance_filter, show_label, flags)); 704 } 705 706 707 void 708 usb_free_log_handle(usb_log_handle_t handle) 709 { 710 usba10_usb_free_log_handle(handle); 711 } 712 713 714 int 715 usb_log( 716 usb_log_handle_t handle, 717 uint_t level, 718 uint_t mask, 719 char *fmt, ...) 720 { 721 va_list ap; 722 int rval; 723 724 va_start(ap, fmt); 725 rval = usba10_usba_vlog(handle, level, mask, fmt, ap); 726 va_end(ap); 727 728 return (rval); 729 } 730 731 732 733 int 734 usb_log_descr_tree( 735 usb_client_dev_data_t *dev_data, 736 usb_log_handle_t log_handle, 737 uint_t level, 738 uint_t mask) 739 { 740 return (usba10_usb_log_descr_tree(dev_data, log_handle, level, mask)); 741 } 742 743 744 int 745 usb_print_descr_tree( 746 dev_info_t *dip, 747 usb_client_dev_data_t *dev_data) 748 { 749 return (usba10_usb_print_descr_tree(dip, dev_data)); 750 } 751 752 753 int 754 usb_check_same_device( 755 dev_info_t *dip, 756 usb_log_handle_t log_handle, 757 int log_level, 758 int log_mask, 759 uint_t check_mask, 760 char *device_string) 761 { 762 return (usba10_usb_check_same_device( 763 dip, log_handle, log_level, log_mask, check_mask, device_string)); 764 } 765 766 767 const char * 768 usb_str_cr(usb_cr_t cr) 769 { 770 return (usba10_usb_str_cr(cr)); 771 } 772 773 774 char * 775 usb_str_cb_flags( 776 usb_cb_flags_t cb_flags, 777 char *buffer, 778 size_t length) 779 { 780 return (usba10_usb_str_cb_flags(cb_flags, buffer, length)); 781 } 782 783 784 const char * 785 usb_str_pipe_state(usb_pipe_state_t state) 786 { 787 return (usba10_usb_str_pipe_state(state)); 788 } 789 790 791 const char * 792 usb_str_dev_state(int state) 793 { 794 return (usba10_usb_str_dev_state(state)); 795 } 796 797 798 const char * 799 usb_str_rval(int rval) 800 { 801 return (usba10_usb_str_rval(rval)); 802 } 803 804 805 int 806 usb_rval2errno(int rval) 807 { 808 return (usba10_usb_rval2errno(rval)); 809 } 810 811 812 usb_serialization_t 813 usb_init_serialization( 814 dev_info_t *s_dip, 815 uint_t flag) 816 { 817 return (usba10_usb_init_serialization(s_dip, flag)); 818 } 819 820 821 void 822 usb_fini_serialization(usb_serialization_t usb_serp) 823 { 824 usba10_usb_fini_serialization(usb_serp); 825 } 826 827 828 int 829 usb_serialize_access( 830 usb_serialization_t usb_serp, 831 uint_t how_to_wait, 832 uint_t delta_timeout) 833 { 834 return (usba10_usb_serialize_access( 835 usb_serp, how_to_wait, delta_timeout)); 836 } 837 838 839 int 840 usb_try_serialize_access( 841 usb_serialization_t usb_serp, 842 uint_t flag) 843 { 844 return (usba10_usb_try_serialize_access(usb_serp, flag)); 845 } 846 847 848 void 849 usb_release_access(usb_serialization_t usb_serp) 850 { 851 usba10_usb_release_access(usb_serp); 852 } 853 854 #endif 855