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