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