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