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