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