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
102 _init(void)
103 {
104 return (mod_install(&modlinkage));
105 }
106
107 int
108 _fini(void)
109 {
110 if (!do_cs_call)
111 return (mod_remove(&modlinkage));
112 else
113 return (EBUSY);
114 }
115
116 int
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 }