xref: /titanic_41/usr/src/uts/common/pcmcia/cs/cs_stubs.c (revision 7c478bd95313f5f23a4c958a745db2134aa03244)
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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 /*
30  * This is the PCMCIA Card Services kernel stubs module. It provides
31  *	the various PCMCIA kernel framework entry points.
32  */
33 
34 #if defined(DEBUG)
35 #define	CS_STUBS_DEBUG
36 #endif
37 
38 #include <sys/types.h>
39 #include <sys/systm.h>
40 #include <sys/user.h>
41 #include <sys/buf.h>
42 #include <sys/file.h>
43 #include <sys/uio.h>
44 #include <sys/conf.h>
45 #include <sys/stat.h>
46 #include <sys/autoconf.h>
47 #include <sys/vtoc.h>
48 #include <sys/dkio.h>
49 #include <sys/ddi.h>
50 #include <sys/sunddi.h>
51 #include <sys/debug.h>
52 #include <sys/varargs.h>
53 #include <sys/var.h>
54 #include <sys/proc.h>
55 #include <sys/thread.h>
56 #include <sys/utsname.h>
57 #include <sys/vtrace.h>
58 #include <sys/kstat.h>
59 #include <sys/kmem.h>
60 #include <sys/modctl.h>
61 #include <sys/kobj.h>
62 #include <sys/callb.h>
63 
64 #include <sys/pctypes.h>
65 #include <pcmcia/sys/cs_types.h>
66 #include <sys/pcmcia.h>
67 #include <sys/sservice.h>
68 #include <pcmcia/sys/cis.h>
69 #include <pcmcia/sys/cis_handlers.h>
70 #include <pcmcia/sys/cs.h>
71 #include <pcmcia/sys/cs_priv.h>
72 #include <pcmcia/sys/cs_stubs.h>
73 
74 #ifdef	CS_STUBS_DEBUG
75 int cs_stubs_debug = 0;
76 #endif
77 
78 static csfunction_t *cardservices = NULL;
79 static int do_cs_call = 0;
80 static int cs_no_carservices(void);
81 
82 #define	CardServices	(do_cs_call ? (*cardservices) :		\
83 			((csfunction_t *)cs_no_carservices))
84 
85 #ifdef	USE_CS_STUBS_MODULE
86 
87 /*
88  * Module linkage information for the kernel.
89  */
90 static struct modlmisc modlmisc = {
91 	&mod_miscops,
92 	"PCMCIA Card Services stub module"
93 };
94 
95 static struct modlinkage modlinkage = {
96 	MODREV_1,
97 	(void *)&modlmisc,
98 	NULL
99 };
100 
101 int
_init(void)102 _init(void)
103 {
104 	return (mod_install(&modlinkage));
105 }
106 
107 int
_fini(void)108 _fini(void)
109 {
110 	if (!do_cs_call)
111 	    return (mod_remove(&modlinkage));
112 	else
113 	    return (EBUSY);
114 }
115 
116 int
_info(struct modinfo * modinfop)117 _info(struct modinfo *modinfop)
118 {
119 	return (mod_info(&modlinkage, modinfop));
120 }
121 #endif	/* USE_CS_STUBS_MODULE */
122 
123 /*
124  * csx_register_cardservices - The Card Services loadable module
125  *	calls this runction to register it's entry point.
126  *
127  * Returns:	CS_SUCCESS - if operation sucessful
128  *		CS_UNSUPPORTED_FUNCTION - if invalid function code
129  *		CS_BAD_HANDLE - if Card Services is not registered
130  */
131 int32_t
csx_register_cardservices(cs_register_cardservices_t * rcs)132 csx_register_cardservices(cs_register_cardservices_t *rcs)
133 {
134 #ifdef	CS_STUBS_DEBUG
135 	if (cs_stubs_debug > 2)
136 	    cmn_err(CE_CONT, "csx_register_cardservices: "
137 		"magic: 0x%x function: 0x%x cardservices: 0x%p\n",
138 		rcs->magic, rcs->function, (void *)rcs->cardservices);
139 #endif
140 
141 	if (rcs->magic != CS_STUBS_MAGIC)
142 	    return (CS_BAD_ARGS);
143 
144 	switch (rcs->function) {
145 	    case CS_ENTRY_REGISTER:
146 		cardservices = rcs->cardservices;
147 		do_cs_call = 1;
148 #ifdef	CS_STUBS_DEBUG
149 	if (cs_stubs_debug > 2)
150 	    cmn_err(CE_CONT, "csx_register_cardservices: CS_ENTRY_REGISTER\n");
151 #endif
152 
153 		return (CS_SUCCESS);
154 
155 	    case CS_ENTRY_DEREGISTER:
156 		do_cs_call = 0;
157 		cardservices = (csfunction_t *)cs_no_carservices;
158 #ifdef	CS_STUBS_DEBUG
159 	if (cs_stubs_debug > 2)
160 	    cmn_err(CE_CONT,
161 		"csx_register_cardservices: CS_ENTRY_DEREGISTER\n");
162 #endif
163 		return (CS_UNSUPPORTED_FUNCTION);
164 
165 	    case CS_ENTRY_INQUIRE:
166 		rcs->cardservices = cardservices;
167 #ifdef	CS_STUBS_DEBUG
168 	if (cs_stubs_debug > 2)
169 	    cmn_err(CE_CONT, "csx_register_cardservices: CS_ENTRY_INQUIRE\n");
170 #endif
171 
172 		if (do_cs_call)
173 		    return (CS_SUCCESS);
174 		else
175 		    return (CS_BAD_HANDLE);
176 
177 	    default:
178 #ifdef	CS_STUBS_DEBUG
179 	if (cs_stubs_debug > 2)
180 	    cmn_err(CE_CONT, "csx_register_cardservices: (unknown function)\n");
181 #endif
182 		return (CS_UNSUPPORTED_FUNCTION);
183 	}
184 
185 }
186 
187 int32_t
csx_RegisterClient(client_handle_t * ch,client_reg_t * cr)188 csx_RegisterClient(client_handle_t *ch, client_reg_t *cr)
189 {
190 #ifdef	CS_STUBS_DEBUG
191 	if (cs_stubs_debug > 3)
192 	    cmn_err(CE_CONT, "csx_RegisterClient: (no handle yet)\n");
193 #endif
194 	return (CardServices(RegisterClient, ch, cr));
195 }
196 
197 int32_t
csx_DeregisterClient(client_handle_t ch)198 csx_DeregisterClient(client_handle_t ch)
199 {
200 #ifdef	CS_STUBS_DEBUG
201 	if (cs_stubs_debug > 3)
202 	    cmn_err(CE_CONT, "csx_DeregisterClient: handle: 0x%x\n", ch);
203 #endif
204 	return (CardServices(DeregisterClient, ch));
205 }
206 
207 int32_t
csx_GetStatus(client_handle_t ch,get_status_t * gs)208 csx_GetStatus(client_handle_t ch, get_status_t *gs)
209 {
210 #ifdef	CS_STUBS_DEBUG
211 	if (cs_stubs_debug > 3)
212 	    cmn_err(CE_CONT, "csx_GetStatus: handle: 0x%x\n", ch);
213 #endif
214 	return (CardServices(GetStatus, ch, gs));
215 }
216 
217 int32_t
csx_SetEventMask(client_handle_t ch,sockevent_t * se)218 csx_SetEventMask(client_handle_t ch, sockevent_t *se)
219 {
220 #ifdef	CS_STUBS_DEBUG
221 	if (cs_stubs_debug > 3)
222 	    cmn_err(CE_CONT, "csx_SetEventMask: handle: 0x%x\n", ch);
223 #endif
224 	return (CardServices(SetEventMask, ch, se));
225 }
226 
227 int32_t
csx_GetEventMask(client_handle_t ch,sockevent_t * se)228 csx_GetEventMask(client_handle_t ch, sockevent_t *se)
229 {
230 #ifdef	CS_STUBS_DEBUG
231 	if (cs_stubs_debug > 3)
232 	    cmn_err(CE_CONT, "csx_GetEventMask: handle: 0x%x\n", ch);
233 #endif
234 	return (CardServices(GetEventMask, ch, se));
235 }
236 
237 int32_t
csx_RequestIO(client_handle_t ch,io_req_t * ior)238 csx_RequestIO(client_handle_t ch, io_req_t *ior)
239 {
240 #ifdef	CS_STUBS_DEBUG
241 	if (cs_stubs_debug > 3)
242 	    cmn_err(CE_CONT, "csx_RequestIO: handle: 0x%x\n", ch);
243 #endif
244 	return (CardServices(RequestIO, ch, ior));
245 }
246 
247 int32_t
csx_ReleaseIO(client_handle_t ch,io_req_t * ior)248 csx_ReleaseIO(client_handle_t ch, io_req_t *ior)
249 {
250 #ifdef	CS_STUBS_DEBUG
251 	if (cs_stubs_debug > 3)
252 	    cmn_err(CE_CONT, "csx_ReleaseIO: handle: 0x%x\n", ch);
253 #endif
254 	return (CardServices(ReleaseIO, ch, ior));
255 }
256 
257 int32_t
csx_RequestIRQ(client_handle_t ch,irq_req_t * irqr)258 csx_RequestIRQ(client_handle_t ch, irq_req_t *irqr)
259 {
260 #ifdef	CS_STUBS_DEBUG
261 	if (cs_stubs_debug > 3)
262 	    cmn_err(CE_CONT, "csx_RequestIRQ: handle: 0x%x\n", ch);
263 #endif
264 	return (CardServices(RequestIRQ, ch, irqr));
265 }
266 
267 int32_t
csx_ReleaseIRQ(client_handle_t ch,irq_req_t * irqr)268 csx_ReleaseIRQ(client_handle_t ch, irq_req_t *irqr)
269 {
270 #ifdef	CS_STUBS_DEBUG
271 	if (cs_stubs_debug > 3)
272 	    cmn_err(CE_CONT, "csx_ReleaseIRQ: handle: 0x%x\n", ch);
273 #endif
274 	return (CardServices(ReleaseIRQ, ch, irqr));
275 }
276 
277 int32_t
csx_RequestWindow(client_handle_t ch,window_handle_t * wh,win_req_t * wr)278 csx_RequestWindow(client_handle_t ch, window_handle_t *wh, win_req_t *wr)
279 {
280 #ifdef	CS_STUBS_DEBUG
281 	if (cs_stubs_debug > 3)
282 	    cmn_err(CE_CONT, "csx_RequestWindow: handle: 0x%x\n", ch);
283 #endif
284 	return (CardServices(RequestWindow, ch, wh, wr));
285 }
286 
287 int32_t
csx_ReleaseWindow(window_handle_t wh)288 csx_ReleaseWindow(window_handle_t wh)
289 {
290 #ifdef	CS_STUBS_DEBUG
291 	if (cs_stubs_debug > 3)
292 	    cmn_err(CE_CONT, "csx_ReleaseWindow: handle: 0x%x\n", wh);
293 #endif
294 	return (CardServices(ReleaseWindow, wh));
295 }
296 
297 int32_t
csx_ModifyWindow(window_handle_t wh,modify_win_t * mw)298 csx_ModifyWindow(window_handle_t wh, modify_win_t *mw)
299 {
300 #ifdef	CS_STUBS_DEBUG
301 	if (cs_stubs_debug > 3)
302 	    cmn_err(CE_CONT, "csx_ModifyWindow: handle: 0x%x\n", wh);
303 #endif
304 	return (CardServices(ModifyWindow, wh, mw));
305 }
306 
307 int32_t
csx_MapMemPage(window_handle_t wh,map_mem_page_t * mmp)308 csx_MapMemPage(window_handle_t wh, map_mem_page_t *mmp)
309 {
310 #ifdef	CS_STUBS_DEBUG
311 	if (cs_stubs_debug > 3)
312 	    cmn_err(CE_CONT, "csx_MapMemPage: handle: 0x%x\n", wh);
313 #endif
314 	return (CardServices(MapMemPage, wh, mmp));
315 }
316 
317 int32_t
csx_RequestSocketMask(client_handle_t ch,request_socket_mask_t * sm)318 csx_RequestSocketMask(client_handle_t ch, request_socket_mask_t *sm)
319 {
320 #ifdef	CS_STUBS_DEBUG
321 	if (cs_stubs_debug > 3)
322 	    cmn_err(CE_CONT, "csx_RequestSocketMask: handle: 0x%x\n", ch);
323 #endif
324 	return (CardServices(RequestSocketMask, ch, sm));
325 }
326 
327 int32_t
csx_ReleaseSocketMask(client_handle_t ch,release_socket_mask_t * rsm)328 csx_ReleaseSocketMask(client_handle_t ch, release_socket_mask_t *rsm)
329 {
330 #ifdef	CS_STUBS_DEBUG
331 	if (cs_stubs_debug > 3)
332 	    cmn_err(CE_CONT, "csx_ReleaseSocketMask: handle: 0x%x\n", ch);
333 #endif
334 	return (CardServices(ReleaseSocketMask, ch, rsm));
335 }
336 
337 int32_t
csx_RequestConfiguration(client_handle_t ch,config_req_t * cr)338 csx_RequestConfiguration(client_handle_t ch, config_req_t *cr)
339 {
340 #ifdef	CS_STUBS_DEBUG
341 	if (cs_stubs_debug > 3)
342 	    cmn_err(CE_CONT, "csx_RequestConfiguration: handle: 0x%x\n", ch);
343 #endif
344 	return (CardServices(RequestConfiguration, ch, cr));
345 }
346 
347 int32_t
csx_ModifyConfiguration(client_handle_t ch,modify_config_t * mc)348 csx_ModifyConfiguration(client_handle_t ch, modify_config_t *mc)
349 {
350 #ifdef	CS_STUBS_DEBUG
351 	if (cs_stubs_debug > 3)
352 	    cmn_err(CE_CONT, "csx_ModifyConfiguration: handle: 0x%x\n", ch);
353 #endif
354 	return (CardServices(ModifyConfiguration, ch, mc));
355 }
356 
357 int32_t
csx_ReleaseConfiguration(client_handle_t ch,release_config_t * rc)358 csx_ReleaseConfiguration(client_handle_t ch, release_config_t *rc)
359 {
360 #ifdef	CS_STUBS_DEBUG
361 	if (cs_stubs_debug > 3)
362 	    cmn_err(CE_CONT, "csx_ReleaseConfiguration: handle: 0x%x\n", ch);
363 #endif
364 	return (CardServices(ReleaseConfiguration, ch, rc));
365 }
366 
367 int32_t
csx_AccessConfigurationRegister(client_handle_t ch,access_config_reg_t * acr)368 csx_AccessConfigurationRegister(client_handle_t ch, access_config_reg_t *acr)
369 {
370 #ifdef	CS_STUBS_DEBUG
371 	if (cs_stubs_debug > 3)
372 	    cmn_err(CE_CONT,
373 		"csx_AccessConfigurationRegister: handle: 0x%x\n", ch);
374 #endif
375 	return (CardServices(AccessConfigurationRegister, ch, acr));
376 }
377 
378 int32_t
csx_GetFirstTuple(client_handle_t ch,tuple_t * tp)379 csx_GetFirstTuple(client_handle_t ch, tuple_t *tp)
380 {
381 #ifdef	CS_STUBS_DEBUG
382 	if (cs_stubs_debug > 3)
383 	    cmn_err(CE_CONT, "csx_GetFirstTuple: handle: 0x%x\n", ch);
384 #endif
385 	return (CardServices(GetFirstTuple, ch, tp));
386 }
387 
388 int32_t
csx_GetNextTuple(client_handle_t ch,tuple_t * tp)389 csx_GetNextTuple(client_handle_t ch, tuple_t *tp)
390 {
391 #ifdef	CS_STUBS_DEBUG
392 	if (cs_stubs_debug > 3)
393 	    cmn_err(CE_CONT, "csx_GetNextTuple: handle: 0x%x\n", ch);
394 #endif
395 	return (CardServices(GetNextTuple, ch, tp));
396 }
397 
398 int32_t
csx_GetTupleData(client_handle_t ch,tuple_t * tp)399 csx_GetTupleData(client_handle_t ch, tuple_t *tp)
400 {
401 #ifdef	CS_STUBS_DEBUG
402 	if (cs_stubs_debug > 3)
403 	    cmn_err(CE_CONT, "csx_GetTupleData: handle: 0x%x\n", ch);
404 #endif
405 	return (CardServices(GetTupleData, ch, tp));
406 }
407 
408 int32_t
csx_MapLogSocket(client_handle_t ch,map_log_socket_t * mls)409 csx_MapLogSocket(client_handle_t ch, map_log_socket_t *mls)
410 {
411 #ifdef	CS_STUBS_DEBUG
412 	if (cs_stubs_debug > 3)
413 	    cmn_err(CE_CONT, "csx_MapLogSocket: handle: 0x%x\n", ch);
414 #endif
415 	return (CardServices(MapLogSocket, ch, mls));
416 }
417 
418 int32_t
csx_ValidateCIS(client_handle_t ch,cisinfo_t * ci)419 csx_ValidateCIS(client_handle_t ch, cisinfo_t *ci)
420 {
421 #ifdef	CS_STUBS_DEBUG
422 	if (cs_stubs_debug > 3)
423 	    cmn_err(CE_CONT, "csx_ValidateCIS: handle: 0x%x\n", ch);
424 #endif
425 	return (CardServices(ValidateCIS, ch, ci));
426 }
427 
428 int32_t
csx_MakeDeviceNode(client_handle_t ch,make_device_node_t * mdn)429 csx_MakeDeviceNode(client_handle_t ch, make_device_node_t *mdn)
430 {
431 #ifdef	CS_STUBS_DEBUG
432 	if (cs_stubs_debug > 3)
433 	    cmn_err(CE_CONT, "csx_MakeDeviceNode: handle: 0x%x\n", ch);
434 #endif
435 	return (CardServices(MakeDeviceNode, ch, mdn));
436 }
437 
438 int32_t
csx_RemoveDeviceNode(client_handle_t ch,remove_device_node_t * rdn)439 csx_RemoveDeviceNode(client_handle_t ch, remove_device_node_t *rdn)
440 {
441 #ifdef	CS_STUBS_DEBUG
442 	if (cs_stubs_debug > 3)
443 	    cmn_err(CE_CONT, "csx_RemoveDeviceNode: handle: 0x%x\n", ch);
444 #endif
445 	return (CardServices(RemoveDeviceNode, ch, rdn));
446 }
447 
448 int32_t
csx_ConvertSpeed(convert_speed_t * cp)449 csx_ConvertSpeed(convert_speed_t *cp)
450 {
451 #ifdef	CS_STUBS_DEBUG
452 	if (cs_stubs_debug > 3)
453 	    cmn_err(CE_CONT, "csx_ConvertSpeed\n");
454 #endif
455 	return (CardServices(ConvertSpeed, cp));
456 }
457 
458 int32_t
csx_ConvertSize(convert_size_t * cp)459 csx_ConvertSize(convert_size_t *cp)
460 {
461 #ifdef	CS_STUBS_DEBUG
462 	if (cs_stubs_debug > 3)
463 	    cmn_err(CE_CONT, "csx_ConvertSize\n");
464 #endif
465 	return (CardServices(ConvertSize, cp));
466 }
467 
468 int32_t
csx_Event2Text(event2text_t * e2t)469 csx_Event2Text(event2text_t *e2t)
470 {
471 #ifdef	CS_STUBS_DEBUG
472 	if (cs_stubs_debug > 3)
473 	    cmn_err(CE_CONT, "csx_Event2Text\n");
474 #endif
475 	return (CardServices(Event2Text, e2t));
476 }
477 
478 int32_t
csx_Error2Text(error2text_t * e2t)479 csx_Error2Text(error2text_t *e2t)
480 {
481 #ifdef	CS_STUBS_DEBUG
482 	if (cs_stubs_debug > 3)
483 	    cmn_err(CE_CONT, "csx_Error2Text\n");
484 #endif
485 	return (CardServices(Error2Text, e2t));
486 }
487 
488 int32_t
csx_CS_DDI_Info(cs_ddi_info_t * cp)489 csx_CS_DDI_Info(cs_ddi_info_t *cp)
490 {
491 #ifdef	CS_STUBS_DEBUG
492 	if (cs_stubs_debug > 3)
493 	    cmn_err(CE_CONT, "csx_CS_DDI_Info\n");
494 #endif
495 	return (CardServices(CS_DDI_Info, cp));
496 }
497 
498 int32_t
csx_CS_Sys_Ctl(cs_sys_ctl_t * csc)499 csx_CS_Sys_Ctl(cs_sys_ctl_t *csc)
500 {
501 #ifdef	CS_STUBS_DEBUG
502 	if (cs_stubs_debug > 3)
503 	    cmn_err(CE_CONT, "csx_CS_Sys_Ctl\n");
504 #endif
505 	return (CardServices(CS_Sys_Ctl, csc));
506 }
507 
508 int32_t
csx_GetClientInfo(client_handle_t ch,client_info_t * ci)509 csx_GetClientInfo(client_handle_t ch, client_info_t *ci)
510 {
511 #ifdef	CS_STUBS_DEBUG
512 	if (cs_stubs_debug > 3)
513 	    cmn_err(CE_CONT, "csx_GetClientInfo: handle: 0x%x\n", ch);
514 #endif
515 
516 	return (CardServices(GetClientInfo, ch, ci));
517 }
518 
519 int32_t
csx_GetFirstClient(get_firstnext_client_t * fnc)520 csx_GetFirstClient(get_firstnext_client_t *fnc)
521 {
522 #ifdef	CS_STUBS_DEBUG
523 	if (cs_stubs_debug > 3)
524 	    cmn_err(CE_CONT, "csx_GetFirstClient\n");
525 #endif
526 
527 	return (CardServices(GetFirstClient, fnc));
528 }
529 
530 int32_t
csx_GetNextClient(get_firstnext_client_t * fnc)531 csx_GetNextClient(get_firstnext_client_t *fnc)
532 {
533 #ifdef	CS_STUBS_DEBUG
534 	if (cs_stubs_debug > 3)
535 	    cmn_err(CE_CONT, "csx_GetNextClient\n");
536 #endif
537 
538 	return (CardServices(GetNextClient, fnc));
539 }
540 
541 int32_t
csx_ResetFunction(client_handle_t ch,reset_function_t * rf)542 csx_ResetFunction(client_handle_t ch, reset_function_t *rf)
543 {
544 #ifdef	CS_STUBS_DEBUG
545 	if (cs_stubs_debug > 3)
546 	    cmn_err(CE_CONT, "csx_ResetFunction: handle: 0x%x\n", ch);
547 #endif
548 
549 	return (CardServices(ResetFunction, ch, rf));
550 }
551 
552 int32_t
csx_GetCardServicesInfo(client_handle_t ch,get_cardservices_info_t * gcsi)553 csx_GetCardServicesInfo(client_handle_t ch, get_cardservices_info_t *gcsi)
554 {
555 #ifdef	CS_STUBS_DEBUG
556 	if (cs_stubs_debug > 3)
557 	    cmn_err(CE_CONT, "csx_GetCardServicesInfo: handle: 0x%x\n", ch);
558 #endif
559 
560 	return (CardServices(GetCardServicesInfo, ch, gcsi));
561 }
562 
563 int32_t
csx_GetConfigurationInfo(client_handle_t * ch,get_configuration_info_t * gci)564 csx_GetConfigurationInfo(client_handle_t *ch, get_configuration_info_t *gci)
565 {
566 #ifdef	CS_STUBS_DEBUG
567 	if (cs_stubs_debug > 3)
568 	    cmn_err(CE_CONT, "csx_GetConfigurationInfo: "
569 		"handle: (no handle yet)\n");
570 #endif
571 
572 	return (CardServices(GetConfigurationInfo, ch, gci));
573 }
574 
575 int32_t
csx_GetPhysicalAdapterInfo(client_handle_t ch,get_physical_adapter_info_t * gp)576 csx_GetPhysicalAdapterInfo(client_handle_t ch, get_physical_adapter_info_t *gp)
577 {
578 #ifdef	CS_STUBS_DEBUG
579 	if (cs_stubs_debug > 3)
580 	    cmn_err(CE_CONT, "csx_GetPhysicalAdapterInfo: handle: 0x%x\n", ch);
581 #endif
582 
583 	return (CardServices(GetPhysicalAdapterInfo, ch, gp));
584 }
585 
586 /*
587  * CIS tuple parsing functions - one entrypoint per tuple that we know
588  *	how to parse
589  */
590 int32_t
csx_Parse_CISTPL_CONFIG(client_handle_t ch,tuple_t * tp,cistpl_config_t * pt)591 csx_Parse_CISTPL_CONFIG(client_handle_t ch, tuple_t *tp, cistpl_config_t *pt)
592 {
593 #ifdef	CS_STUBS_DEBUG
594 	if (cs_stubs_debug > 3)
595 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_CONFIG: handle: 0x%x\n", ch);
596 #endif
597 	tp->DesiredTuple = CISTPL_CONFIG;
598 	return (CardServices(ParseTuple, ch, tp, pt));
599 }
600 
601 int32_t
csx_Parse_CISTPL_DEVICE(client_handle_t ch,tuple_t * tp,cistpl_device_t * pt)602 csx_Parse_CISTPL_DEVICE(client_handle_t ch, tuple_t *tp, cistpl_device_t *pt)
603 {
604 #ifdef	CS_STUBS_DEBUG
605 	if (cs_stubs_debug > 3)
606 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_DEVICE: handle: 0x%x\n", ch);
607 #endif
608 	tp->DesiredTuple = CISTPL_DEVICE;
609 	return (CardServices(ParseTuple, ch, tp, pt));
610 }
611 
612 int32_t
csx_Parse_CISTPL_DEVICE_A(client_handle_t ch,tuple_t * tp,cistpl_device_t * pt)613 csx_Parse_CISTPL_DEVICE_A(client_handle_t ch, tuple_t *tp, cistpl_device_t *pt)
614 {
615 #ifdef	CS_STUBS_DEBUG
616 	if (cs_stubs_debug > 3)
617 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_DEVICE_A: handle: 0x%x\n", ch);
618 #endif
619 	tp->DesiredTuple = CISTPL_DEVICE_A;
620 	return (CardServices(ParseTuple, ch, tp, pt));
621 }
622 
623 int32_t
csx_Parse_CISTPL_DEVICE_OA(client_handle_t ch,tuple_t * tp,cistpl_device_t * pt)624 csx_Parse_CISTPL_DEVICE_OA(client_handle_t ch, tuple_t *tp, cistpl_device_t *pt)
625 {
626 #ifdef	CS_STUBS_DEBUG
627 	if (cs_stubs_debug > 3)
628 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_DEVICE_OA: handle: 0x%x\n", ch);
629 #endif
630 	tp->DesiredTuple = CISTPL_DEVICE_OA;
631 	return (CardServices(ParseTuple, ch, tp, pt));
632 }
633 
634 int32_t
csx_Parse_CISTPL_DEVICE_OC(client_handle_t ch,tuple_t * tp,cistpl_device_t * pt)635 csx_Parse_CISTPL_DEVICE_OC(client_handle_t ch, tuple_t *tp, cistpl_device_t *pt)
636 {
637 #ifdef	CS_STUBS_DEBUG
638 	if (cs_stubs_debug > 3)
639 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_DEVICE_OC: handle: 0x%x\n", ch);
640 #endif
641 	tp->DesiredTuple = CISTPL_DEVICE_OC;
642 	return (CardServices(ParseTuple, ch, tp, pt));
643 }
644 
645 int32_t
csx_Parse_CISTPL_VERS_1(client_handle_t ch,tuple_t * tp,cistpl_vers_1_t * pt)646 csx_Parse_CISTPL_VERS_1(client_handle_t ch, tuple_t *tp, cistpl_vers_1_t *pt)
647 {
648 #ifdef	CS_STUBS_DEBUG
649 	if (cs_stubs_debug > 3)
650 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_VERS_1: handle: 0x%x\n", ch);
651 #endif
652 	tp->DesiredTuple = CISTPL_VERS_1;
653 	return (CardServices(ParseTuple, ch, tp, pt));
654 }
655 
656 int32_t
csx_Parse_CISTPL_VERS_2(client_handle_t ch,tuple_t * tp,cistpl_vers_2_t * pt)657 csx_Parse_CISTPL_VERS_2(client_handle_t ch, tuple_t *tp, cistpl_vers_2_t *pt)
658 {
659 #ifdef	CS_STUBS_DEBUG
660 	if (cs_stubs_debug > 3)
661 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_VERS_2: handle: 0x%x\n", ch);
662 #endif
663 	tp->DesiredTuple = CISTPL_VERS_2;
664 	return (CardServices(ParseTuple, ch, tp, pt));
665 }
666 
667 int32_t
csx_Parse_CISTPL_JEDEC_A(client_handle_t ch,tuple_t * tp,cistpl_jedec_t * pt)668 csx_Parse_CISTPL_JEDEC_A(client_handle_t ch, tuple_t *tp, cistpl_jedec_t *pt)
669 {
670 #ifdef	CS_STUBS_DEBUG
671 	if (cs_stubs_debug > 3)
672 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_JEDEC_A: handle: 0x%x\n", ch);
673 #endif
674 	tp->DesiredTuple = CISTPL_JEDEC_A;
675 	return (CardServices(ParseTuple, ch, tp, pt));
676 }
677 
678 int32_t
csx_Parse_CISTPL_JEDEC_C(client_handle_t ch,tuple_t * tp,cistpl_jedec_t * pt)679 csx_Parse_CISTPL_JEDEC_C(client_handle_t ch, tuple_t *tp, cistpl_jedec_t *pt)
680 {
681 #ifdef	CS_STUBS_DEBUG
682 	if (cs_stubs_debug > 3)
683 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_JEDEC_C: handle: 0x%x\n", ch);
684 #endif
685 	tp->DesiredTuple = CISTPL_JEDEC_C;
686 	return (CardServices(ParseTuple, ch, tp, pt));
687 }
688 
689 int32_t
csx_Parse_CISTPL_FORMAT(client_handle_t ch,tuple_t * tp,cistpl_format_t * pt)690 csx_Parse_CISTPL_FORMAT(client_handle_t ch, tuple_t *tp, cistpl_format_t *pt)
691 {
692 #ifdef	CS_STUBS_DEBUG
693 	if (cs_stubs_debug > 3)
694 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_FORMAT: handle: 0x%x\n", ch);
695 #endif
696 	tp->DesiredTuple = CISTPL_FORMAT;
697 	return (CardServices(ParseTuple, ch, tp, pt));
698 }
699 
700 int32_t
csx_Parse_CISTPL_FORMAT_A(client_handle_t ch,tuple_t * tp,cistpl_format_t * pt)701 csx_Parse_CISTPL_FORMAT_A(client_handle_t ch, tuple_t *tp, cistpl_format_t *pt)
702 {
703 #ifdef	CS_STUBS_DEBUG
704 	if (cs_stubs_debug > 3)
705 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_FORMAT_A: handle: 0x%x\n", ch);
706 #endif
707 	tp->DesiredTuple = CISTPL_FORMAT_A;
708 	return (CardServices(ParseTuple, ch, tp, pt));
709 }
710 
711 int32_t
csx_Parse_CISTPL_GEOMETRY(client_handle_t ch,tuple_t * tp,cistpl_geometry_t * pt)712 csx_Parse_CISTPL_GEOMETRY(client_handle_t ch, tuple_t *tp,
713     cistpl_geometry_t *pt)
714 {
715 #ifdef	CS_STUBS_DEBUG
716 	if (cs_stubs_debug > 3)
717 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_GEOMETRY: handle: 0x%x\n", ch);
718 #endif
719 	tp->DesiredTuple = CISTPL_GEOMETRY;
720 	return (CardServices(ParseTuple, ch, tp, pt));
721 }
722 
723 int32_t
csx_Parse_CISTPL_BYTEORDER(client_handle_t ch,tuple_t * tp,cistpl_byteorder_t * pt)724 csx_Parse_CISTPL_BYTEORDER(client_handle_t ch, tuple_t *tp,
725     cistpl_byteorder_t *pt)
726 {
727 #ifdef	CS_STUBS_DEBUG
728 	if (cs_stubs_debug > 3)
729 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_BYTEORDER: handle: 0x%x\n", ch);
730 #endif
731 	tp->DesiredTuple = CISTPL_BYTEORDER;
732 	return (CardServices(ParseTuple, ch, tp, pt));
733 }
734 
735 int32_t
csx_Parse_CISTPL_DATE(client_handle_t ch,tuple_t * tp,cistpl_date_t * pt)736 csx_Parse_CISTPL_DATE(client_handle_t ch, tuple_t *tp, cistpl_date_t *pt)
737 {
738 #ifdef	CS_STUBS_DEBUG
739 	if (cs_stubs_debug > 3)
740 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_DATE: handle: 0x%x\n", ch);
741 #endif
742 	tp->DesiredTuple = CISTPL_DATE;
743 	return (CardServices(ParseTuple, ch, tp, pt));
744 }
745 
746 int32_t
csx_Parse_CISTPL_BATTERY(client_handle_t ch,tuple_t * tp,cistpl_battery_t * pt)747 csx_Parse_CISTPL_BATTERY(client_handle_t ch, tuple_t *tp, cistpl_battery_t *pt)
748 {
749 #ifdef	CS_STUBS_DEBUG
750 	if (cs_stubs_debug > 3)
751 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_BATTERY: handle: 0x%x\n", ch);
752 #endif
753 	tp->DesiredTuple = CISTPL_BATTERY;
754 	return (CardServices(ParseTuple, ch, tp, pt));
755 }
756 
757 int32_t
csx_Parse_CISTPL_ORG(client_handle_t ch,tuple_t * tp,cistpl_org_t * pt)758 csx_Parse_CISTPL_ORG(client_handle_t ch, tuple_t *tp, cistpl_org_t *pt)
759 {
760 #ifdef	CS_STUBS_DEBUG
761 	if (cs_stubs_debug > 3)
762 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_ORG: handle: 0x%x\n", ch);
763 #endif
764 	tp->DesiredTuple = CISTPL_ORG;
765 	return (CardServices(ParseTuple, ch, tp, pt));
766 }
767 
768 int32_t
csx_Parse_CISTPL_MANFID(client_handle_t ch,tuple_t * tp,cistpl_manfid_t * pt)769 csx_Parse_CISTPL_MANFID(client_handle_t ch, tuple_t *tp, cistpl_manfid_t *pt)
770 {
771 #ifdef	CS_STUBS_DEBUG
772 	if (cs_stubs_debug > 3)
773 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_MANFID: handle: 0x%x\n", ch);
774 #endif
775 	tp->DesiredTuple = CISTPL_MANFID;
776 	return (CardServices(ParseTuple, ch, tp, pt));
777 }
778 
779 int32_t
csx_Parse_CISTPL_FUNCID(client_handle_t ch,tuple_t * tp,cistpl_funcid_t * pt)780 csx_Parse_CISTPL_FUNCID(client_handle_t ch, tuple_t *tp, cistpl_funcid_t *pt)
781 {
782 #ifdef	CS_STUBS_DEBUG
783 	if (cs_stubs_debug > 3)
784 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_FUNCID: handle: 0x%x\n", ch);
785 #endif
786 	tp->DesiredTuple = CISTPL_FUNCID;
787 	return (CardServices(ParseTuple, ch, tp, pt));
788 }
789 
790 int32_t
csx_Parse_CISTPL_FUNCE(client_handle_t ch,tuple_t * tp,cistpl_funce_t * pt,uint32_t function)791 csx_Parse_CISTPL_FUNCE(client_handle_t ch, tuple_t *tp,
792     cistpl_funce_t *pt, uint32_t function)
793 {
794 #ifdef	CS_STUBS_DEBUG
795 	if (cs_stubs_debug > 3)
796 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_FUNCE: handle: 0x%x\n", ch);
797 #endif
798 	tp->DesiredTuple = CISTPL_FUNCE;
799 	return (CardServices(ParseTuple, ch, tp, pt, function));
800 }
801 
802 int32_t
csx_Parse_CISTPL_CFTABLE_ENTRY(client_handle_t ch,tuple_t * tp,cistpl_cftable_entry_t * pt)803 csx_Parse_CISTPL_CFTABLE_ENTRY(client_handle_t ch, tuple_t *tp,
804     cistpl_cftable_entry_t *pt)
805 {
806 #ifdef	CS_STUBS_DEBUG
807 	if (cs_stubs_debug > 3)
808 	    cmn_err(CE_CONT,
809 		"csx_Parse_CISTPL_CFTABLE_ENTRY: handle: 0x%x\n", ch);
810 #endif
811 	tp->DesiredTuple = CISTPL_CFTABLE_ENTRY;
812 	return (CardServices(ParseTuple, ch, tp, pt));
813 }
814 
815 int32_t
csx_Parse_CISTPL_LINKTARGET(client_handle_t ch,tuple_t * tp,cistpl_linktarget_t * pt)816 csx_Parse_CISTPL_LINKTARGET(client_handle_t ch, tuple_t *tp,
817     cistpl_linktarget_t *pt)
818 {
819 #ifdef	CS_STUBS_DEBUG
820 	if (cs_stubs_debug > 3)
821 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_LINKTARGET: handle: 0x%x\n", ch);
822 #endif
823 	tp->DesiredTuple = CISTPL_LINKTARGET;
824 	return (CardServices(ParseTuple, ch, tp, pt));
825 }
826 
827 int32_t
csx_Parse_CISTPL_LONGLINK_A(client_handle_t ch,tuple_t * tp,cistpl_longlink_ac_t * pt)828 csx_Parse_CISTPL_LONGLINK_A(client_handle_t ch, tuple_t *tp,
829     cistpl_longlink_ac_t *pt)
830 {
831 #ifdef	CS_STUBS_DEBUG
832 	if (cs_stubs_debug > 3)
833 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_LONGLINK_A: handle: 0x%x\n", ch);
834 #endif
835 	tp->DesiredTuple = CISTPL_LONGLINK_A;
836 	return (CardServices(ParseTuple, ch, tp, pt));
837 }
838 
839 int32_t
csx_Parse_CISTPL_LONGLINK_C(client_handle_t ch,tuple_t * tp,cistpl_longlink_ac_t * pt)840 csx_Parse_CISTPL_LONGLINK_C(client_handle_t ch, tuple_t *tp,
841     cistpl_longlink_ac_t *pt)
842 {
843 #ifdef	CS_STUBS_DEBUG
844 	if (cs_stubs_debug > 3)
845 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_LONGLINK_C: handle: 0x%x\n", ch);
846 #endif
847 	tp->DesiredTuple = CISTPL_LONGLINK_C;
848 	return (CardServices(ParseTuple, ch, tp, pt));
849 }
850 
851 int32_t
csx_Parse_CISTPL_LONGLINK_MFC(client_handle_t ch,tuple_t * tp,cistpl_longlink_mfc_t * pt)852 csx_Parse_CISTPL_LONGLINK_MFC(client_handle_t ch, tuple_t *tp,
853     cistpl_longlink_mfc_t *pt)
854 {
855 #ifdef	CS_STUBS_DEBUG
856 	if (cs_stubs_debug > 3)
857 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_LONGLINK_MFC: "
858 						"handle: 0x%x\n", ch);
859 #endif
860 	tp->DesiredTuple = CISTPL_LONGLINK_MFC;
861 	return (CardServices(ParseTuple, ch, tp, pt));
862 }
863 
csx_Parse_CISTPL_LONGLINK_CB(client_handle_t ch,tuple_t * tp,cistpl_longlink_cb_t * pt)864 int32_t csx_Parse_CISTPL_LONGLINK_CB(client_handle_t ch, tuple_t *tp,
865     cistpl_longlink_cb_t *pt)
866 {
867 #ifdef	CS_STUBS_DEBUG
868 	if (cs_stubs_debug > 3)
869 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_LONGLINK_CB: "
870 						"handle: 0x%x\n", ch);
871 #endif
872 	tp->DesiredTuple = CISTPL_LONGLINK_CB;
873 	return (CardServices(ParseTuple, ch, tp, pt));
874 }
875 
876 int32_t
csx_Parse_CISTPL_SPCL(client_handle_t ch,tuple_t * tp,cistpl_spcl_t * pt)877 csx_Parse_CISTPL_SPCL(client_handle_t ch, tuple_t *tp,
878     cistpl_spcl_t *pt)
879 {
880 #ifdef	CS_STUBS_DEBUG
881 	if (cs_stubs_debug > 3)
882 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_SPCL: handle: 0x%x\n", ch);
883 #endif
884 	tp->DesiredTuple = CISTPL_SPCL;
885 	return (CardServices(ParseTuple, ch, tp, pt));
886 }
887 
888 int32_t
csx_Parse_CISTPL_SWIL(client_handle_t ch,tuple_t * tp,cistpl_swil_t * pt)889 csx_Parse_CISTPL_SWIL(client_handle_t ch, tuple_t *tp,
890     cistpl_swil_t *pt)
891 {
892 #ifdef	CS_STUBS_DEBUG
893 	if (cs_stubs_debug > 3)
894 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_SWIL: handle: 0x%x\n", ch);
895 #endif
896 	tp->DesiredTuple = CISTPL_SWIL;
897 	return (CardServices(ParseTuple, ch, tp, pt));
898 }
899 
csx_Parse_CISTPL_BAR(client_handle_t ch,tuple_t * tp,cistpl_bar_t * pt)900 int32_t csx_Parse_CISTPL_BAR(client_handle_t ch, tuple_t *tp,
901     cistpl_bar_t *pt)
902 {
903 #ifdef	CS_STUBS_DEBUG
904 	if (cs_stubs_debug > 3)
905 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_BAR: handle: 0x%x\n", ch);
906 #endif
907 	tp->DesiredTuple = CISTPL_BAR;
908 	return (CardServices(ParseTuple, ch, tp, pt));
909 }
910 
911 int32_t
csx_Parse_CISTPL_DEVICEGEO(client_handle_t ch,tuple_t * tp,cistpl_devicegeo_t * pt)912 csx_Parse_CISTPL_DEVICEGEO(client_handle_t ch, tuple_t *tp,
913     cistpl_devicegeo_t *pt)
914 {
915 #ifdef	CS_STUBS_DEBUG
916 	if (cs_stubs_debug > 3)
917 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_DEVICEGEO: handle: 0x%x\n", ch);
918 #endif
919 	tp->DesiredTuple = CISTPL_DEVICEGEO;
920 	return (CardServices(ParseTuple, ch, tp, pt));
921 }
922 
923 int32_t
csx_Parse_CISTPL_DEVICEGEO_A(client_handle_t ch,tuple_t * tp,cistpl_devicegeo_t * pt)924 csx_Parse_CISTPL_DEVICEGEO_A(client_handle_t ch, tuple_t *tp,
925     cistpl_devicegeo_t *pt)
926 {
927 #ifdef	CS_STUBS_DEBUG
928 	if (cs_stubs_debug > 3)
929 	    cmn_err(CE_CONT, "csx_Parse_CISTPL_DEVICEGEO_A: "
930 						"handle: 0x%x\n", ch);
931 #endif
932 	tp->DesiredTuple = CISTPL_DEVICEGEO_A;
933 	return (CardServices(ParseTuple, ch, tp, pt));
934 }
935 
936 int32_t
csx_ParseTuple(client_handle_t ch,tuple_t * tp,cisparse_t * cp,uint32_t ef)937 csx_ParseTuple(client_handle_t ch, tuple_t *tp, cisparse_t *cp, uint32_t ef)
938 {
939 #ifdef	CS_STUBS_DEBUG
940 	if (cs_stubs_debug > 3)
941 	    cmn_err(CE_CONT, "csx_ParseTuple: handle: 0x%x\n", ch);
942 #endif
943 	return (CardServices(ParseTuple, ch, tp, cp, ef));
944 }
945 
946 /*
947  * The following functions are used to access various datatypes.
948  *	These functions are not specific to PCMCIA client drivers
949  *	and they don't depend on Card Services being present to
950  *	operate.
951  */
952 void
csx_Put8(acc_handle_t handle,uint32_t offset,uint8_t value)953 csx_Put8(acc_handle_t handle, uint32_t offset, uint8_t value)
954 {
955 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
956 
957 	ddi_put8(handle, (uint8_t *)(hp->ah_addr + offset), value);
958 }
959 
960 void
csx_Put16(acc_handle_t handle,uint32_t offset,uint16_t value)961 csx_Put16(acc_handle_t handle, uint32_t offset, uint16_t value)
962 {
963 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
964 
965 	ddi_put16(handle, (uint16_t *)(hp->ah_addr + offset), value);
966 }
967 
968 void
csx_Put32(acc_handle_t handle,uint32_t offset,uint32_t value)969 csx_Put32(acc_handle_t handle, uint32_t offset, uint32_t value)
970 {
971 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
972 
973 	ddi_put32(handle, (uint32_t *)(hp->ah_addr + offset), value);
974 }
975 
976 void
csx_Put64(acc_handle_t handle,uint32_t offset,uint64_t value)977 csx_Put64(acc_handle_t handle, uint32_t offset, uint64_t value)
978 {
979 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
980 
981 	ddi_put64(handle, (uint64_t *)(hp->ah_addr + offset), value);
982 }
983 
984 uint8_t
csx_Get8(acc_handle_t handle,uint32_t offset)985 csx_Get8(acc_handle_t handle, uint32_t offset)
986 {
987 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
988 
989 	return (ddi_get8(handle, (uint8_t *)(hp->ah_addr + offset)));
990 }
991 
992 uint16_t
csx_Get16(acc_handle_t handle,uint32_t offset)993 csx_Get16(acc_handle_t handle, uint32_t offset)
994 {
995 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
996 
997 	return (ddi_get16(handle, (uint16_t *)(hp->ah_addr + offset)));
998 }
999 
1000 uint32_t
csx_Get32(acc_handle_t handle,uint32_t offset)1001 csx_Get32(acc_handle_t handle, uint32_t offset)
1002 {
1003 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
1004 
1005 	return (ddi_get32(handle, (uint32_t *)(hp->ah_addr + offset)));
1006 }
1007 
1008 uint64_t
csx_Get64(acc_handle_t handle,uint32_t offset)1009 csx_Get64(acc_handle_t handle, uint32_t offset)
1010 {
1011 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
1012 
1013 	return (ddi_get64(handle, (uint64_t *)(hp->ah_addr + offset)));
1014 }
1015 
1016 void
csx_RepPut8(acc_handle_t handle,uint8_t * hostaddr,uint32_t offset,uint32_t rc,uint32_t flags)1017 csx_RepPut8(acc_handle_t handle, uint8_t *hostaddr, uint32_t offset,
1018 						uint32_t rc, uint32_t flags)
1019 {
1020 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
1021 
1022 	ddi_rep_put8(handle, hostaddr, (uint8_t *)(hp->ah_addr + offset),
1023 		rc, (uint32_t)flags);
1024 }
1025 
1026 void
csx_RepPut16(acc_handle_t handle,uint16_t * hostaddr,uint32_t offset,uint32_t rc,uint32_t flags)1027 csx_RepPut16(acc_handle_t handle, uint16_t *hostaddr, uint32_t offset,
1028 						uint32_t rc, uint32_t flags)
1029 {
1030 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
1031 
1032 	ddi_rep_put16(handle, hostaddr, (uint16_t *)(hp->ah_addr + offset),
1033 		rc, (uint32_t)flags);
1034 }
1035 
1036 void
csx_RepPut32(acc_handle_t handle,uint32_t * hostaddr,uint32_t offset,uint32_t rc,uint32_t flags)1037 csx_RepPut32(acc_handle_t handle, uint32_t *hostaddr, uint32_t offset,
1038 						uint32_t rc, uint32_t flags)
1039 {
1040 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
1041 
1042 	ddi_rep_put32(handle, hostaddr, (uint32_t *)(hp->ah_addr + offset),
1043 		rc, (uint32_t)flags);
1044 }
1045 
1046 void
csx_RepPut64(acc_handle_t handle,uint64_t * hostaddr,uint32_t offset,uint32_t rc,uint32_t flags)1047 csx_RepPut64(acc_handle_t handle, uint64_t *hostaddr, uint32_t offset,
1048 						uint32_t rc, uint32_t flags)
1049 {
1050 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
1051 
1052 	ddi_rep_put64(handle, hostaddr, (uint64_t *)(hp->ah_addr + offset),
1053 		rc, (uint32_t)flags);
1054 }
1055 
1056 void
csx_RepGet8(acc_handle_t handle,uint8_t * hostaddr,uint32_t offset,uint32_t rc,uint32_t flags)1057 csx_RepGet8(acc_handle_t handle, uint8_t *hostaddr, uint32_t offset,
1058 						uint32_t rc, uint32_t flags)
1059 {
1060 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
1061 
1062 	ddi_rep_get8(handle, hostaddr, (uint8_t *)(hp->ah_addr + offset),
1063 		rc, (uint32_t)flags);
1064 }
1065 
1066 void
csx_RepGet16(acc_handle_t handle,uint16_t * hostaddr,uint32_t offset,uint32_t rc,uint32_t flags)1067 csx_RepGet16(acc_handle_t handle, uint16_t *hostaddr, uint32_t offset,
1068 						uint32_t rc, uint32_t flags)
1069 {
1070 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
1071 
1072 	ddi_rep_get16(handle, hostaddr, (uint16_t *)(hp->ah_addr + offset),
1073 		rc, (uint32_t)flags);
1074 }
1075 
1076 void
csx_RepGet32(acc_handle_t handle,uint32_t * hostaddr,uint32_t offset,uint32_t rc,uint32_t flags)1077 csx_RepGet32(acc_handle_t handle, uint32_t *hostaddr, uint32_t offset,
1078 						uint32_t rc, uint32_t flags)
1079 {
1080 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
1081 
1082 	ddi_rep_get32(handle, hostaddr, (uint32_t *)(hp->ah_addr + offset),
1083 		rc, (uint32_t)flags);
1084 }
1085 
1086 void
csx_RepGet64(acc_handle_t handle,uint64_t * hostaddr,uint32_t offset,uint32_t rc,uint32_t flags)1087 csx_RepGet64(acc_handle_t handle, uint64_t *hostaddr, uint32_t offset,
1088 						uint32_t rc, uint32_t flags)
1089 {
1090 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
1091 
1092 	ddi_rep_get64(handle, hostaddr, (uint64_t *)(hp->ah_addr + offset),
1093 		rc, (uint32_t)flags);
1094 }
1095 
1096 /*
1097  * The following two functions return the mapped (virtual) or physical
1098  *	base address associated with the passed handle if the address
1099  *	can be directly accessed by the caller. If the object represented
1100  *	by the handle needs to be accessed through a common access
1101  *	function, CS_BAD_BASE is returned.
1102  *
1103  * XXX - Need to figure out how to determine when to return CS_BAD_BASE
1104  *	and also we need more generic return codes not tied to CS.
1105  */
1106 int32_t
csx_GetMappedAddr(acc_handle_t handle,void ** addr)1107 csx_GetMappedAddr(acc_handle_t handle, void **addr)
1108 {
1109 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
1110 
1111 #ifdef	CS_STUBS_DEBUG
1112 	if (cs_stubs_debug > 3)
1113 	    cmn_err(CE_CONT, "csx_GetMappedAddr: handle: 0x%p\n", handle);
1114 #endif
1115 
1116 	*addr = hp->ah_addr;
1117 
1118 	return (CS_SUCCESS);	/* XXX should be generic return code */
1119 }
1120 
1121 int32_t
csx_GetPhysAddr(acc_handle_t handle,void ** addr)1122 csx_GetPhysAddr(acc_handle_t handle, void **addr)
1123 {
1124 #ifndef	lint
1125 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
1126 #endif	/* lint */
1127 
1128 #ifdef	CS_STUBS_DEBUG
1129 	if (cs_stubs_debug > 3)
1130 	    cmn_err(CE_CONT, "csx_GetPhysAddr: handle: 0x%p\n", handle);
1131 #endif
1132 
1133 	*addr = NULL;
1134 
1135 	return (CS_BAD_BASE);
1136 }
1137 
1138 /*ARGSUSED*/
1139 int32_t
csx_DupHandle(acc_handle_t handle,acc_handle_t * dup,uint32_t flags)1140 csx_DupHandle(acc_handle_t handle, acc_handle_t *dup, uint32_t flags)
1141 {
1142 #ifndef	lint
1143 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
1144 #endif	/* lint */
1145 
1146 #ifdef	CS_STUBS_DEBUG
1147 	if (cs_stubs_debug > 3)
1148 	    cmn_err(CE_CONT, "csx_DupHandle: handle: 0x%p\n", handle);
1149 #endif
1150 
1151 	return (CS_BAD_HANDLE);
1152 
1153 #ifdef	XXX
1154 	*dup = (acc_handle_t)kmem_alloc(sizeof (acc_hdl_t), KM_SLEEP);
1155 	((acc_hdl_t *)*dup)->ddi_handle =
1156 		(ddi_acc_handle_t *)kmem_alloc(sizeof (ddi_acc_impl_t),
1157 		    KM_SLEEP);
1158 
1159 	bcopy((caddr_t)hp, (caddr_t)((acc_hdl_t *)*dup)->ddi_handle,
1160 	    sizeof (ddi_acc_impl_t));
1161 
1162 	return (CS_SUCCESS);
1163 #endif
1164 }
1165 
1166 int32_t
csx_FreeHandle(acc_handle_t * handle)1167 csx_FreeHandle(acc_handle_t *handle)
1168 {
1169 #ifdef	CS_STUBS_DEBUG
1170 	if (cs_stubs_debug > 3)
1171 	    cmn_err(CE_CONT, "csx_FreeHandle: handle: 0x%p\n", *handle);
1172 #endif
1173 	return (CS_BAD_HANDLE);
1174 
1175 #ifdef	XXX
1176 
1177 	kmem_free((void *)((acc_hdl_t *)*handle)->ddi_handle,
1178 		sizeof (ddi_acc_impl_t));
1179 	kmem_free((void *)(acc_hdl_t *)*handle, sizeof (acc_hdl_t));
1180 
1181 	return (CS_SUCCESS);
1182 #endif
1183 }
1184 
1185 /*
1186  * XXX - Probably want to remove these fucntions soon
1187  */
1188 int32_t
csx_GetHandleOffset(acc_handle_t handle,uint32_t * offset)1189 csx_GetHandleOffset(acc_handle_t handle, uint32_t *offset)
1190 {
1191 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
1192 
1193 #ifdef	CS_STUBS_DEBUG
1194 	if (cs_stubs_debug > 3)
1195 	    cmn_err(CE_CONT, "csx_GetHandleOffset: handle: 0x%p\n", handle);
1196 #endif
1197 
1198 	*offset = hp->ah_offset;
1199 
1200 	return (CS_SUCCESS);
1201 }
1202 
1203 int32_t
csx_SetHandleOffset(acc_handle_t handle,uint32_t offset)1204 csx_SetHandleOffset(acc_handle_t handle, uint32_t offset)
1205 {
1206 	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
1207 
1208 #ifdef	CS_STUBS_DEBUG
1209 	if (cs_stubs_debug > 3)
1210 	    cmn_err(CE_CONT, "csx_SetHandleOffset: handle: 0x%p\n", handle);
1211 #endif
1212 
1213 	hp->ah_offset = offset;
1214 
1215 	return (CS_SUCCESS);
1216 }
1217 
1218 static int
cs_no_carservices()1219 cs_no_carservices()
1220 {
1221 #ifdef	CS_STUBS_DEBUG
1222 	if (cs_stubs_debug > 3)
1223 	    cmn_err(CE_CONT, "cs_no_carservices\n");
1224 #endif
1225 	return (CS_UNSUPPORTED_FUNCTION);
1226 }
1227