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