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