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
42static struct modlmisc modlmisc	= {
43	&mod_miscops,	/* Type	of module */
44	"USBA10: USB V0.8 Drvr Supp"
45};
46
47static struct modlinkage modlinkage = {
48	MODREV_1, (void	*)&modlmisc, NULL
49};
50
51
52int
53_init(void)
54{
55	return (mod_install(&modlinkage));
56}
57
58int
59_fini()
60{
61	return (mod_remove(&modlinkage));
62}
63
64int
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
76int
77usb_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
89void
90usb_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
98void
99usb_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
107size_t
108usb_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
120usb_ep_data_t *
121usb_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
134int
135usb_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
146int
147usb_get_addr(dev_info_t *dip)
148{
149	return (usba10_usb_get_addr(dip));
150}
151
152
153int
154usb_get_if_number(dev_info_t *dip)
155{
156	return (usba10_usb_get_if_number(dip));
157}
158
159
160boolean_t
161usb_owns_device(dev_info_t *dip)
162{
163	return (usba10_usb_owns_device(dip));
164}
165
166
167int
168usb_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
177int
178usb_ep_num(usb_pipe_handle_t ph)
179{
180	return (usba10_usb_ep_num(ph));
181}
182
183
184int
185usb_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
196void
197usb_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
212int
213usb_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
230int
231usb_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
239usb_opaque_t
240usb_pipe_get_private(usb_pipe_handle_t pipe_handle)
241{
242	return (usba10_usb_pipe_get_private(pipe_handle));
243}
244
245
246void
247usb_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
262usb_ctrl_req_t *
263usb_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
272void
273usb_free_ctrl_req(usb_ctrl_req_t *reqp)
274{
275	usba10_usb_free_ctrl_req(reqp);
276}
277
278
279int
280usb_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
289int
290usb_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
302int
303usb_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
315int
316usb_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
329int
330usb_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
345int
346usb_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
355int
356usb_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
373int
374usb_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
384usb_bulk_req_t *
385usb_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
394void
395usb_free_bulk_req(usb_bulk_req_t *reqp)
396{
397	usba10_usb_free_bulk_req(reqp);
398}
399
400
401int
402usb_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
411int
412usb_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
420usb_intr_req_t *
421usb_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
430void
431usb_free_intr_req(usb_intr_req_t *reqp)
432{
433	usba10_usb_free_intr_req(reqp);
434}
435
436
437int
438usb_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
447void
448usb_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
456usb_isoc_req_t *
457usb_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
467void
468usb_free_isoc_req(usb_isoc_req_t *usb_isoc_req)
469{
470	usba10_usb_free_isoc_req(usb_isoc_req);
471}
472
473
474usb_frame_number_t
475usb_get_current_frame_number(dev_info_t	*dip)
476{
477	return (usba10_usb_get_current_frame_number(dip));
478}
479
480
481uint_t
482usb_get_max_isoc_pkts(dev_info_t *dip)
483{
484	return (usba10_usb_get_max_isoc_pkts(dip));
485}
486
487
488int
489usb_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
498void
499usb_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
507int
508usb_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
520int
521usb_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
533int
534usb_is_pm_enabled(dev_info_t *dip)
535{
536	return (usba10_usb_is_pm_enabled(dip));
537}
538
539int
540usb_handle_remote_wakeup(
541	dev_info_t	*dip,
542	int		cmd)
543{
544	return (usba10_usb_handle_remote_wakeup(dip, cmd));
545}
546
547
548int
549usb_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
557int
558usb_set_device_pwrlvl0(dev_info_t *dip)
559{
560	return (usba10_usb_set_device_pwrlvl0(dip));
561}
562
563
564int
565usb_set_device_pwrlvl1(dev_info_t *dip)
566{
567	return (usba10_usb_set_device_pwrlvl1(dip));
568}
569
570
571int
572usb_set_device_pwrlvl2(dev_info_t *dip)
573{
574	return (usba10_usb_set_device_pwrlvl2(dip));
575}
576
577
578int
579usb_set_device_pwrlvl3(dev_info_t *dip)
580{
581	return (usba10_usb_set_device_pwrlvl3(dip));
582}
583
584
585int
586usb_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
596int
597usb_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
606void
607usb_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
615void
616usb_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
625void 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
638void 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
651void 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
665void 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
679void 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
691usb_log_handle_t
692usb_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
706void
707usb_free_log_handle(usb_log_handle_t handle)
708{
709	usba10_usb_free_log_handle(handle);
710}
711
712
713int
714usb_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
732int
733usb_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
743int
744usb_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
752int
753usb_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
766const char *
767usb_str_cr(usb_cr_t cr)
768{
769	return (usba10_usb_str_cr(cr));
770}
771
772
773char *
774usb_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
783const char *
784usb_str_pipe_state(usb_pipe_state_t state)
785{
786	return (usba10_usb_str_pipe_state(state));
787}
788
789
790const char *
791usb_str_dev_state(int state)
792{
793	return (usba10_usb_str_dev_state(state));
794}
795
796
797const char *
798usb_str_rval(int rval)
799{
800	return (usba10_usb_str_rval(rval));
801}
802
803
804int
805usb_rval2errno(int rval)
806{
807	return (usba10_usb_rval2errno(rval));
808}
809
810
811usb_serialization_t
812usb_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
820void
821usb_fini_serialization(usb_serialization_t usb_serp)
822{
823	usba10_usb_fini_serialization(usb_serp);
824}
825
826
827int
828usb_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
838int
839usb_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
847void
848usb_release_access(usb_serialization_t usb_serp)
849{
850	usba10_usb_release_access(usb_serp);
851}
852
853#endif
854