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 2005 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #ifndef _CS_PRIV_H 28 #define _CS_PRIV_H 29 30 #pragma ident "%Z%%M% %I% %E% SMI" 31 32 #ifdef __cplusplus 33 extern "C" { 34 #endif 35 36 /* 37 * PCMCIA Card Services private header file 38 */ 39 40 /* 41 * typedef for function pointers to quiet lint and cc -v 42 */ 43 typedef int32_t (f_t)(int32_t, ...); /* for lint - cc -v quieting */ 44 45 /* 46 * Magic number we use when talking with Socket Services 47 */ 48 #define CS_MAGIC PCCS_MAGIC 49 50 /* 51 * Make the calls to SocketServices and the CIS Parser look like 52 * function calls. 53 */ 54 #define SocketServices (*cs_socket_services) 55 #define CIS_PARSER (*cis_parser) 56 57 /* 58 * CIS_DEFAULT_SPEED is the default speed to use to read the CIS 59 * in AM space. It is expressed in nS. 60 */ 61 #define CIS_DEFAULT_SPEED 250 62 63 /* 64 * This is the IO window speed. 65 */ 66 #define IO_WIN_SPEED 250 67 68 /* 69 * Flags to support various internal first/next functions. All of 70 * these must be within CIS_GET_LTUPLE_OPMASK which is defined 71 * in the cis.h file. Values outside this mask range are used 72 * internally by the CIS parser. 73 */ 74 #define CS_GET_FIRST_FLAG 0x0001 75 #define CS_GET_NEXT_FLAG 0x0002 76 77 /* 78 * Macros to manipulate bits - only does up to uint32_t size 79 */ 80 #define CS_BIT_WORDSIZE (sizeof (uint32_t)) 81 82 #define CS_BIT_GET(val, bit) \ 83 ((uint32_t)(val) & (uint32_t)(1<<(uint32_t)(bit))) 84 85 #define CS_BIT_CLEAR(val, bit) ((val) &= (uint32_t)~(1<<(uint32_t)(bit))) 86 87 #define CS_BIT_SET(val, bit) \ 88 ((uint32_t)(val) |= (uint32_t)(1<<(uint32_t)(bit))) 89 90 /* 91 * Minimum time to wait after socket reset before we are allowed to 92 * access the card. The PCMCIA specification says at least 20mS 93 * must elapse from the time that the card is reset until the 94 * first access of any kind can be made to the card. This time 95 * value is expressed in mS. 96 */ 97 #define RESET_TIMEOUT_TIME 180 98 99 /* 100 * Maximum time to wait for card ready after resetting the socket. 101 * We wait for card ready a maximum of 20 seconds after card 102 * reset before considering that we have an error condition. 103 * XXX - what does PCMCIA specify as the max time here?? 104 */ 105 #define READY_TIMEOUT_TIME (drv_usectohz(20000000)) 106 107 /* 108 * Time between periodically kicking the soft interrupt handler. 109 */ 110 #define SOFTINT_TIMEOUT_TIME (drv_usectohz(2000000)) 111 112 /* 113 * Various delays are necessary when switching the card and socket 114 * between IO and memory modes. All delays are in mS. 115 * 116 * cs_request_configuration parameters: 117 * CS_RC1_DELAY - delay between writing COR and switching socket 118 * to IO mode 119 * CS_RC2_DELAY - delay after switching socket to IO mode 120 * 121 * cs_release_configuration parameters: 122 * CS_RQ_DELAY - amount of time that the RESET bit in the COR is 123 * held asserted 124 */ 125 #define CS_RC1_DELAY 20 /* COR->IO delay in mS */ 126 #define CS_RC2_DELAY 300 /* post-COR delay in mS */ 127 #define CS_RQ_DELAY 100 /* COR(RESET) delay in mS */ 128 129 /* 130 * Handy macro to do untimeout. 131 */ 132 #define UNTIMEOUT(id) \ 133 if ((id)) { \ 134 (void) untimeout((id)); \ 135 (id) = 0; \ 136 } 137 138 /* 139 * Macros to enter/exit event thread mutex 140 */ 141 #define EVENT_THREAD_MUTEX_ENTER(acq, sp) \ 142 acq = !MUTEX_HELD(&sp->client_lock); \ 143 if (acq) \ 144 mutex_enter(&sp->client_lock); 145 #define EVENT_THREAD_MUTEX_EXIT(acq, sp) \ 146 if (acq) \ 147 mutex_exit(&sp->client_lock); 148 149 /* 150 * cisregister_t structure is used to support the CISRegister 151 * and the CISUnregister function calls 152 */ 153 typedef struct cisregister_t { 154 uint32_t cis_magic; 155 uint32_t cis_version; 156 void * (*cis_parser)(int32_t function, ...); 157 cistpl_callout_t *cistpl_std_callout; /* standard callout list */ 158 } cisregister_t; 159 160 /* 161 * These two defines are to support CISRegister and CISUnregister 162 */ 163 #define CIS_MAGIC 0x20434953 164 #define CIS_VERSION _VERSION(0, 1) 165 166 /* 167 * CS_MAX_CIS defines the number of CIS chains that we hang off the per-socket 168 * structure. 169 * 170 * CS_GLOBAL_CIS defines the index where the CIS parser puts the first CIS list 171 * for a single-function card or the global CIS list for a multi-function 172 * card. 173 * 174 * CS_MAX_CIS is one greater than CIS_MAX_FUNCTIONS since the CIS parser 175 * puts the global CIS chain on the CS_GLOBAL_CIS function index as 176 * follows: 177 * 178 * For single-function cards: 179 * sp->cis[0] - CIS chain 180 * sp->cis[1..(CIS_MAX_FUNCTIONS - 1)] - not used 181 * sp->cis[CS_GLOBAL_CIS] - not used 182 * 183 * For multi-function cards: 184 * sp->cis[0..(CIS_MAX_FUNCTIONS - 1)] - global CIS chain followed 185 * by per-function CIS chain 186 * sp->cis[CS_GLOBAL_CIS] - global CIS chain 187 */ 188 #define CS_MAX_CIS (CIS_MAX_FUNCTIONS + 1) 189 #define CS_GLOBAL_CIS CIS_MAX_FUNCTIONS 190 191 /* 192 * CS_SS_CLIENT_HANDLE is a special client handle that Socket Services gets 193 * when it registers with RegisterClient. 194 */ 195 #define CS_SS_CLIENT_HANDLE 0x00000000 196 197 /* 198 * Client handle, socket number, function number and socket pointer 199 * macros. The client handle encoding is private to Card Services, 200 * and external modules should not use these macros to manipulate 201 * client handles. 202 * 203 * The encoding of the client handle is: 204 * 205 * xxxxxfff | xsssssss | cccccccc | cccccccc 206 * 207 * f - function number bit 208 * s - socket number bit 209 * c - client number bit 210 * x - don't care bits 211 */ 212 #define CLIENT_HANDLE_IS_SS(ch) (!GET_CLIENT_MINOR((ch))) 213 #define CS_MAX_SOCKETS_MASK (PCMCIA_MAX_SOCKETS - 1) 214 #define CS_MAX_FUNCTIONS_MASK (CIS_MAX_FUNCTIONS - 1) 215 #define CS_MAX_CLIENTS_MASK 0x0ffff 216 #define CS_MAX_CLIENTS (CS_MAX_CLIENTS_MASK - 2) 217 #define MAKE_CLIENT_HANDLE(s, f, c) ((((f)&CS_MAX_FUNCTIONS_MASK)<<24) | \ 218 (((s)&CS_MAX_SOCKETS_MASK)<<16) | \ 219 ((c)&CS_MAX_CLIENTS_MASK)) 220 #define GET_CLIENT_SOCKET(ch) (((ch)>>16)&CS_MAX_SOCKETS_MASK) 221 #define GET_CLIENT_FUNCTION(ch) (((ch)>>24)&CS_MAX_FUNCTIONS_MASK) 222 #define GET_CLIENT_MINOR(ch) ((ch)&CS_MAX_CLIENTS_MASK) 223 224 /* 225 * Socket number macros. These are used by Socket Services, CSI 226 * drivers and the "super-client" driver to specify which 227 * socket and function number on that socket they wish to 228 * manipulate. This socket number encoding is typically passed 229 * to various Card Services functions by these drivers. 230 * 231 * The encoding of the socket number is: 232 * 233 * xxxxxxxx | xxxxgfff | xxxxxxxx | xsssssss 234 * 235 * g - global CIS bit 236 * f - function number bit 237 * s - socket number bit 238 * x - don't care bits 239 */ 240 #define CS_GET_SOCKET_NUMBER(s) ((s)&CS_MAX_SOCKETS_MASK) 241 #define CS_GET_FUNCTION_NUMBER(s) (((s)>>16)&(CS_MAX_FUNCTIONS_MASK | \ 242 CIS_MAX_FUNCTIONS)) 243 #define CS_SET_SOCKET_NUMBER(s) ((s)&CS_MAX_SOCKETS_MASK) 244 #define CS_SET_FUNCTION_NUMBER(f) (((f)&(CS_MAX_FUNCTIONS_MASK | \ 245 CIS_MAX_FUNCTIONS))<<16) 246 #define CS_MAKE_SOCKET_NUMBER(s, f) (CS_SET_SOCKET_NUMBER(s) | \ 247 CS_SET_FUNCTION_NUMBER(f)) 248 249 /* 250 * DIP2SOCKET_NUM(dip) - this macro gets the PCM_DEV_SOCKET property from 251 * the passed dip. If the property can't be found, then the default 252 * value of cs_globals.max_socket_num is returned. 253 */ 254 #define DIP2SOCKET_NUM(dip) ddi_getprop(DDI_DEV_T_NONE, dip,\ 255 (DDI_PROP_CANSLEEP | \ 256 DDI_PROP_NOTPROM), \ 257 PCM_DEV_SOCKET, \ 258 cs_globals.max_socket_num) 259 260 /* 261 * Range checking macros 262 * 263 * CHECK_SOCKET_NUM(socket_number, max_sockets) returns 1 if 264 * socket_number is in range 265 */ 266 #define CHECK_SOCKET_NUM(sn, ms) (((sn) >= (ms))?0:1) 267 268 /* 269 * window macros 270 * 271 * These all expect that the window has been validated as a valid 272 * window (i.e. CW_WINDOW_VALID is set in window state) 273 * 274 * Note that WINDOW_FOR_SOCKET expects a socket mask for the wsm 275 * parameter (this is a socket_enum_t type, and NOT just a 276 * plain old uint32_t) 277 */ 278 #define WINDOW_FOR_SOCKET(wsm, sn) ((wsm)[sn/PR_WORDSIZE] & \ 279 (1 << ((sn) & PR_MASK))) 280 #define WINDOW_AVAILABLE_FOR_MEM(cwp) (!(cwp->state & CW_WIN_IN_USE)) 281 #define WINDOW_AVAILABLE_FOR_IO(cwp) \ 282 (!(cwp->state & (CW_CIS | CW_MEM | CW_ALLOCATED))) 283 284 /* 285 * IO Base and NumPorts address frobnitz macros 286 */ 287 #define IOADDR_FROBNITZ(Base, IOAddrLines) (Base&((1<<IOAddrLines)-1)) 288 #define IONUMPORTS_FROBNITZ(np) (((np)&1)?((np)+1):(np)) 289 290 /* 291 * Structure that contains offsets to the card's configuration registers 292 * as well as copies of the data written to them in RequestConfiguration. 293 * We use an offset per register approach since not all cards have 294 * all registers implemented, and by specifying a NULL register offset, 295 * we know not to try to access that register. 296 */ 297 typedef struct config_regs_t { 298 cfg_regs_t cor; /* Configuration Option Register */ 299 uint32_t cor_p; 300 cfg_regs_t ccsr; /* Configuration and Status Register */ 301 uint32_t ccsr_p; 302 cfg_regs_t prr; /* Pin Replacement Register */ 303 uint32_t prr_p; 304 cfg_regs_t scr; /* Socket and Copy Register */ 305 uint32_t scr_p; 306 cfg_regs_t exstat; /* Extended Status Register */ 307 uint32_t exstat_p; 308 cfg_regs_t iobase0; /* IO Base 0 Register */ 309 uint32_t iobase0_p; 310 cfg_regs_t iobase1; /* IO Base 1 Register */ 311 uint32_t iobase1_p; 312 cfg_regs_t iobase2; /* IO Base 2 Register */ 313 uint32_t iobase2_p; 314 cfg_regs_t iobase3; /* IO Base 3 Register */ 315 uint32_t iobase3_p; 316 cfg_regs_t iolimit; /* IO Limit Register */ 317 uint32_t iolimit_p; 318 } config_regs_t; 319 320 /* 321 * Macro to make calling the client's event handler look like a function. 322 */ 323 #define CLIENT_EVENT_CALLBACK(cp, event, pri) \ 324 (cp)->event_callback_handler(event, pri, \ 325 &(cp)->event_callback_args) 326 327 /* 328 * Macro to return event in PRR - this also clears the changed bit if 329 * the event occured. 330 */ 331 #define PRR_EVENT(prrx, pe, ps, ce, re) \ 332 if (prrx & pe) { \ 333 if (prrx & ps) \ 334 (re) |= ce; \ 335 prrx &= ~pe; \ 336 prrx |= ps; \ 337 } 338 339 /* 340 * io_alloc_t struct used to keep track of a client's IO window allocation 341 */ 342 typedef struct io_alloc_t { 343 uint32_t Window1; /* allocated IO window no. for set #1 */ 344 baseaddru_t BasePort1; /* 1st IO range base address or port */ 345 uint32_t NumPorts1; /* 1st IO range no. contiguous ports */ 346 uint32_t Attributes1; /* 1st IO range attributes */ 347 uint32_t Window2; /* allocated IO window no. for set #2 */ 348 baseaddru_t BasePort2; /* s2nd IO range base address or port */ 349 uint32_t NumPorts2; /* 2nd IO range no. contiguous ports */ 350 uint32_t Attributes2; /* second IO range attributes */ 351 uint32_t IOAddrLines; /* number of IO address lines decoded */ 352 } io_alloc_t; 353 354 /* 355 * irq_alloc_t structure used to keep track of a client's IRQ allocation 356 */ 357 typedef struct irq_alloc_t { 358 uint32_t Attributes; /* IRQ attribute flags */ 359 uint32_t irq; /* assigned IRQ number */ 360 uint32_t handler_id; /* IRQ handler ID for this IRQ */ 361 f_t *irq_handler; 362 void *irq_handler_arg1; 363 void *irq_handler_arg2; 364 } irq_alloc_t; 365 366 /* 367 * The client data structure 368 */ 369 typedef struct client_t { 370 client_handle_t client_handle; /* this client's client handle */ 371 unsigned flags; /* client flags */ 372 /* resource control */ 373 uint32_t memwin_count; /* number of mem windows allocated */ 374 io_alloc_t io_alloc; /* IO resource allocations */ 375 irq_alloc_t irq_alloc; /* IRQ resource allocations */ 376 /* event support */ 377 uint32_t event_mask; /* client event mask */ 378 uint32_t global_mask; /* client global event mask */ 379 uint32_t events; /* current events pending */ 380 uint32_t pending_events; /* events pending in RegisterClient */ 381 csfunction_t *event_callback_handler; 382 event_callback_args_t event_callback_args; 383 /* config registers support */ 384 config_regs_t config_regs; /* pointers to config registers */ 385 uint32_t config_regs_offset; /* offset from start of AM */ 386 unsigned pin; /* valid bits in PRR */ 387 uint32_t present; /* which config registers present */ 388 /* DDI support */ 389 dev_info_t *dip; /* this client's dip */ 390 char *driver_name; /* client's driver name */ 391 int32_t instance; /* client's driver instance */ 392 /* list control */ 393 struct client_t *next; /* next client pointer */ 394 struct client_t *prev; /* previous client pointer */ 395 } client_t; 396 397 /* 398 * Flags for client structure - note that we share the client_t->flags 399 * member with the definitions in cs.h that are used by the 400 * RegisterClient function. 401 * 402 * We can start our flags from 0x00001000 and on up. 403 */ 404 #define REQ_CONFIGURATION_DONE 0x00001000 /* RequestConfiguration done */ 405 #define REQ_SOCKET_MASK_DONE 0x00002000 /* RequestSocketMask done */ 406 #define REQ_IO_DONE 0x00004000 /* RequestIO done */ 407 #define REQ_IRQ_DONE 0x00008000 /* RequestIRQ done */ 408 #define CLIENT_SUPER_CLIENT 0x00010000 /* "super-client" client */ 409 #define CLIENT_CSI_CLIENT 0x00020000 /* CSI client */ 410 #define CLIENT_CARD_INSERTED 0x00100000 /* current card for client */ 411 #define CLIENT_SENT_INSERTION 0x00200000 /* send CARD_INSERTION */ 412 #define CLIENT_MTD_IN_PROGRESS 0x01000000 /* MTD op in progress */ 413 #define CLIENT_IO_ALLOCATED 0x02000000 /* IO resources allocated */ 414 #define CLIENT_IRQ_ALLOCATED 0x04000000 /* IRQ resources allocated */ 415 #define CLIENT_WIN_ALLOCATED 0x08000000 /* window resources allocated */ 416 417 #ifdef USE_IOMMAP_WINDOW 418 /* 419 * io_mmap_window_t structure that describes the memory-mapped IO 420 * window on this socket 421 */ 422 typedef struct io_mmap_window_t { 423 uint32_t flags; /* window flags */ 424 uint32_t number; /* IO window number */ 425 uint32_t size; /* size of mapped IO window */ 426 ddi_acc_handle_t handle; /* window mapped base address */ 427 uint32_t count; /* referance count */ 428 } io_mmap_window_t; 429 #endif /* USE_IOMMAP_WINDOW */ 430 431 /* 432 * cis_info_t structure used to hold per-socket CIS information 433 */ 434 typedef struct cis_info_t { 435 uint32_t flags; /* CIS-specific flags */ 436 cistpl_t *cis; /* CIS linked lists */ 437 uint32_t nchains; /* number of tuple chains in CIS */ 438 uint32_t ntuples; /* number of tuples in CIS */ 439 } cis_info_t; 440 441 /* 442 * cs_adapter_t structure used to hold per-socket 443 * adapter-specific info 444 */ 445 typedef struct cs_adapter_t { 446 uint32_t flags; /* adapter flags */ 447 char name[MODMAXNAMELEN]; /* adapter module name */ 448 uint32_t major; /* adapter major number */ 449 uint32_t minor; /* adapter minor number */ 450 uint32_t instance; /* instance number of this adapter */ 451 uint32_t number; /* canonical adapter number */ 452 uint32_t num_sockets; /* # sockets on this adapter */ 453 uint32_t first_socket; /* first socket # on this adapter */ 454 } cs_adapter_t; 455 456 /* 457 * The per-socket structure. 458 */ 459 typedef struct cs_socket_t { 460 unsigned socket_num; /* socket number */ 461 uint32_t flags; /* socket flags */ 462 uint32_t init_state; /* cs_init state */ 463 cs_adapter_t adapter; /* adapter info */ 464 /* socket thread control and status */ 465 kthread_t *event_thread; /* per-socket work thread */ 466 uint32_t thread_state; /* socket thread state flags */ 467 kmutex_t lock; /* protects events and clients */ 468 kcondvar_t thread_cv; /* event handling synchronization */ 469 kcondvar_t caller_cv; /* event handling synchronization */ 470 kcondvar_t reset_cv; /* for use after card RESET */ 471 uint32_t events; /* socket events */ 472 uint32_t event_mask; /* socket event mask */ 473 ddi_softintr_t softint_id; /* soft interrupt handler ID */ 474 timeout_id_t rdybsy_tmo_id; /* timer ID for READY/BUSY timer */ 475 ddi_iblock_cookie_t *iblk; /* event iblk cookie */ 476 ddi_idevice_cookie_t *idev; /* event idev cookie */ 477 callb_cpr_t cprinfo_cs; /* CPR cookie for cs_event_thread */ 478 callb_cpr_t cprinfo_ss; /* CPR cookie for cs_ss_thread */ 479 /* client management */ 480 client_t *client_list; /* clients on this socket */ 481 unsigned next_cl_minor; /* next available client minor num */ 482 kmutex_t client_lock; /* protects client list */ 483 uint32_t num_clients; /* number of clients on this socket */ 484 /* CIS support */ 485 uint32_t cis_win_num; /* CIS window number */ 486 unsigned cis_win_size; /* CIS window size */ 487 uint32_t cis_flags; 488 uint32_t nfuncs; /* number of functions */ 489 cis_info_t cis[CS_MAX_CIS]; /* CIS information */ 490 kmutex_t cis_lock; /* protects CIS */ 491 #ifdef USE_IOMMAP_WINDOW 492 /* memory mapped IO window support */ 493 io_mmap_window_t *io_mmap_window; 494 #endif /* USE_IOMMAP_WINDOW */ 495 /* Socket Services work thread control and status */ 496 kthread_t *ss_thread; /* SS work thread */ 497 uint32_t ss_thread_state; /* SS work thread state */ 498 kcondvar_t ss_thread_cv; /* SS work thread synchronization */ 499 kcondvar_t ss_caller_cv; /* SS work thread synchronization */ 500 kmutex_t ss_thread_lock; /* protects SS work thread state */ 501 struct cs_socket_t *next; /* next socket in list */ 502 } cs_socket_t; 503 504 /* 505 * cs_socket_t->flags flags 506 */ 507 #define SOCKET_CARD_INSERTED 0x00000001 /* card is inserted */ 508 #define SOCKET_IS_IO 0x00000002 /* socket in IO mode */ 509 #define SOCKET_UNLOAD_MODULE 0x00000004 /* want to unload CS */ 510 #define SOCKET_NEEDS_THREAD 0x00000008 /* wake event thread */ 511 #define SOCKET_IS_VALID 0x00000020 /* socket OK to use */ 512 513 /* 514 * cs_socket_t->thread_state and cs_socket_t->ss_thread_state flags 515 */ 516 517 /* generic for all threads */ 518 #define SOCKET_THREAD_EXIT 0x00000001 /* exit event thread */ 519 520 /* only used for per-socket event thread */ 521 #define SOCKET_WAIT_FOR_READY 0x00001000 /* waiting for READY */ 522 #define SOCKET_RESET_TIMER 0x00002000 /* RESET timer */ 523 #define SOCKET_WAIT_SYNC 0x00004000 /* SYNC */ 524 525 /* only used for Socket Services work thread */ 526 #define SOCKET_THREAD_CSCISInit 0x00100000 /* call CSCISInit */ 527 528 /* 529 * cs_socket_t->cis_flags and cs_socket_t->cis_info_t->flags flags 530 */ 531 #define CW_VALID_CIS 0x00000001 /* valid CIS */ 532 #define CW_MULTI_FUNCTION_CIS 0x00000002 /* multifunction card */ 533 #define CW_LONGLINK_A_FOUND 0x00000004 /* CISTPL_LONGLINK_A */ 534 #define CW_LONGLINK_C_FOUND 0x00000008 /* CISTP_LONGLINK_C */ 535 #define CW_LONGLINK_MFC_FOUND 0x00000010 /* LONGLINK_MFC */ 536 #define CW_CHECK_LINKTARGET 0x00000020 /* check linktarget */ 537 #define CW_RET_ON_LINKTARGET_ERROR 0x00000040 /* linktarget invalid */ 538 #define CW_CHECK_PRIMARY_CHAIN 0x00000080 /* check for primary */ 539 /* chain tuples */ 540 541 /* 542 * CW_LONGLINK_FOUND - a combination of the various CW_LONGLINK_XXX_FOUND 543 * flags used to make the code less dense. 544 */ 545 #define CW_LONGLINK_FOUND (CW_LONGLINK_A_FOUND | \ 546 CW_LONGLINK_C_FOUND | \ 547 CW_LONGLINK_MFC_FOUND) 548 549 /* 550 * macro to test for a valid CIS window on a socket 551 */ 552 #define SOCKET_HAS_CIS_WINDOW(sp) (sp->cis_win_num != PCMCIA_MAX_WINDOWS) 553 554 /* 555 * cs_socket_t->init_state flags - these flags are used to keep track of what 556 * was allocated in cs_init so that things can be deallocated properly 557 * in cs_deinit. 558 */ 559 #define SOCKET_INIT_STATE_MUTEX 0x00000001 /* mutexii are OK */ 560 #define SOCKET_INIT_STATE_CV 0x00000002 /* cvii are OK */ 561 #define SOCKET_INIT_STATE_THREAD 0x00000004 /* thread OK */ 562 #define SOCKET_INIT_STATE_READY 0x00000008 /* socket OK */ 563 #define SOCKET_INIT_STATE_SS_THREAD 0x00000010 /* SS thread OK */ 564 /* 565 * While this next flag doesn't really describe a per-socket resource, 566 * we still set it for each socket. When the soft interrupt handler 567 * finally gets removed in cs_deinit, this flag will get cleared. 568 * The value of this flag should follow the previous SOCKET_INIT 569 * flag values. 570 */ 571 #define SOCKET_INIT_STATE_SOFTINTR 0x00000020 /* softintr handler */ 572 573 /* 574 * Macro to create a socket event thread. 575 */ 576 #define CS_THREAD_PRIORITY (v.v_maxsyspri - 4) 577 #define CREATE_SOCKET_EVENT_THREAD(eh, csp) \ 578 thread_create(NULL, 0, eh, (void *)csp, \ 579 0, &p0, TS_RUN, CS_THREAD_PRIORITY) 580 581 /* 582 * The per-window structure. 583 */ 584 typedef struct cs_window_t { 585 uint32_t window_num; /* window number */ 586 window_handle_t window_handle; /* unique window handle */ 587 client_handle_t client_handle; /* owner of this window */ 588 unsigned socket_num; /* socket number */ 589 unsigned state; /* window state flags */ 590 struct cs_window_t *next; /* next window in list */ 591 } cs_window_t; 592 593 /* 594 * Window structure state flags - if none of the bits in the 595 * CW_WIN_IN_USE mask are set AND if CW_WINDOW_VALID is set, 596 * it means that this window is available and not being used 597 * by anyone. 598 * Setting the CW_ALLOCATED will prevent the window from being found 599 * as an available window for memory or IO; since memory windows 600 * are not shared between clients, RequestWindow will always set 601 * the CW_ALLOCATED flag when it has assigned a memory window to 602 * a client. Since we can sometimes share IO windows, RequestIO 603 * will only set the CW_ALLOCATED flag if it doesn't want the IO 604 * window to be used by other calls to RequestIO. 605 * When CW_WINDOW_VALID is set, it means that this is a valid window 606 * that has been added by the framework and can be used. If this 607 * bit is not set, this window can not be used at all. 608 */ 609 #define CW_ALLOCATED 0x00000001 /* window is allocated */ 610 #define CW_CIS 0x00000002 /* window being used as CIS window */ 611 #define CW_MEM 0x00000004 /* window being used as mem window */ 612 #define CW_IO 0x00000008 /* window being used as IO window */ 613 #define CW_WIN_IN_USE 0x0000ffff /* window in use mask */ 614 #define CW_WINDOW_VALID 0x00010000 /* window is valid */ 615 616 /* 617 * window handle defines - the WINDOW_HANDLE_MASK implies the maximum number 618 * of windows allowed 619 */ 620 #define WINDOW_HANDLE_MAGIC 0x574d0000 621 #define WINDOW_HANDLE_MASK 0x0000ffff 622 #define GET_WINDOW_NUMBER(wh) ((wh) & WINDOW_HANDLE_MASK) 623 #define GET_WINDOW_MAGIC(wh) ((wh) & ~WINDOW_HANDLE_MASK) 624 625 /* 626 * The client type structures, used to sequence events to clients on a 627 * socket. The "type" flags are the same as are used for the 628 * RegisterClient function. 629 */ 630 typedef struct client_types_t { 631 uint32_t type; 632 uint32_t order; 633 struct client_types_t *next; 634 } client_types_t; 635 636 /* 637 * Flags that specify the order of client event notifications for the 638 * client_types_t structure. 639 */ 640 #define CLIENT_EVENTS_LIFO 0x00000001 641 #define CLIENT_EVENTS_FIFO 0x00000002 642 643 /* 644 * This is a structure that CS uses to keep track of items that are global 645 * to all functions in the module. 646 */ 647 typedef struct cs_globals_t { 648 cs_socket_t *sp; /* head of socket list */ 649 cs_window_t *cw; /* head of window list */ 650 kmutex_t global_lock; /* protects this struct */ 651 kmutex_t window_lock; /* protects cs_windows */ 652 ddi_softintr_t softint_id; /* soft interrupt handler id */ 653 timeout_id_t sotfint_tmo; /* soft interrupt handler timeout id */ 654 uint32_t init_state; /* flags set in cs_init */ 655 uint32_t flags; /* general global flags */ 656 uint32_t max_socket_num; /* highest socket number plus one */ 657 uint32_t num_sockets; /* total number of sockets */ 658 uint32_t num_windows; /* total number of windows */ 659 struct sclient_list_t *sclient_list; 660 } cs_globals_t; 661 662 /* 663 * Flags for cs_globals_t->init_state 664 */ 665 #define GLOBAL_INIT_STATE_SOFTINTR 0x00010000 /* softintr handler */ 666 #define GLOBAL_INIT_STATE_MUTEX 0x00020000 /* global mutex init */ 667 #define GLOBAL_INIT_STATE_NO_CLIENTS 0x00040000 /* no new clients */ 668 #define GLOBAL_INIT_STATE_UNLOADING 0x00080000 /* cs_deinit running */ 669 #define GLOBAL_INIT_STATE_SS_READY 0x00100000 /* SS ready for */ 670 /* callbacks */ 671 /* 672 * Flags for cs_globals_t->flags 673 */ 674 #define GLOBAL_SUPER_CLIENT_REGISTERED 0x00000001 /* "super-client" reg */ 675 #define GLOBAL_IN_SOFTINTR 0x00000002 /* in soft int code */ 676 677 /* 678 * sclient_reg_t struct for RegisterClient when a "super-client" is 679 * registering. 680 * This structure is actually hung off of the client_reg_t.private 681 * structure member. Since we don't make public how to write 682 * a "super-client", the actual structure that the client uses 683 * is defined in this private header file. 684 */ 685 typedef struct sclient_reg_t { 686 uint32_t max_socket_num; 687 uint32_t num_sockets; 688 uint32_t num_windows; 689 uint32_t num_clients; 690 struct sclient_list_t { 691 client_handle_t client_handle; 692 uint32_t error; 693 } **sclient_list; 694 } sclient_reg_t; 695 696 /* 697 * structure for event text used for cs_ss_event_text 698 */ 699 typedef struct cs_ss_event_text_t { 700 event_t ss_event; /* SS event code */ 701 event_t cs_event; /* CS event code */ 702 char *text; 703 } cs_ss_event_text_t; 704 705 /* 706 * Flags for cs_read_event_status 707 */ 708 #define CS_RES_IGNORE_NO_CARD 0x0001 /* don't check for card */ 709 710 /* 711 * cs_csfunc2text_strings_t structure used internally in Error2Text 712 */ 713 typedef struct cs_csfunc2text_strings_t { 714 uint32_t item; 715 char *text; 716 } cs_csfunc2text_strings_t; 717 718 /* 719 * Flags for Error2Text - not used by clients; the struct is defined 720 * in the cs.h header file. 721 */ 722 #define CSFUN2TEXT_FUNCTION 0x0001 /* return text of CS function code */ 723 #define CSFUN2TEXT_RETURN 0x0002 /* return text of CS return code */ 724 725 /* 726 * Macros to walk the local linked CIS list. 727 * 728 * These macros can take any valid local list tuple pointer. They return 729 * another tuple pointer or NULL if they fail. 730 */ 731 #define GET_NEXT_TUPLE(tp, f) CIS_PARSER(CISP_CIS_GET_LTUPLE, tp, \ 732 NULL, GET_NEXT_LTUPLEF | \ 733 (f & ~CIS_GET_LTUPLE_OPMASK)) 734 #define GET_PREV_TUPLE(tp, f) CIS_PARSER(CISP_CIS_GET_LTUPLE, tp, \ 735 NULL, GET_PREV_LTUPLEF | \ 736 (f & ~CIS_GET_LTUPLE_OPMASK)) 737 #define GET_FIRST_LTUPLE(tp, f) CIS_PARSER(CISP_CIS_GET_LTUPLE, tp, \ 738 NULL, GET_FIRST_LTUPLEF | \ 739 (f & ~CIS_GET_LTUPLE_OPMASK)) 740 #define GET_LAST_LTUPLE(tp, f) CIS_PARSER(CISP_CIS_GET_LTUPLE, tp, \ 741 NULL, GET_LAST_LTUPLEF | \ 742 (f & ~CIS_GET_LTUPLE_OPMASK)) 743 #define FIND_LTUPLE_FWD(tp, tu, f) CIS_PARSER(CISP_CIS_GET_LTUPLE, tp, \ 744 tu, FIND_LTUPLE_FWDF | \ 745 (f & ~CIS_GET_LTUPLE_OPMASK)) 746 #define FIND_LTUPLE_BACK(tp, tu, f) CIS_PARSER(CISP_CIS_GET_LTUPLE, tp, \ 747 tu, FIND_LTUPLE_BACKF | \ 748 (f & ~CIS_GET_LTUPLE_OPMASK)) 749 #define FIND_NEXT_LTUPLE(tp, tu, f) CIS_PARSER(CISP_CIS_GET_LTUPLE, tp, \ 750 tu, FIND_NEXT_LTUPLEF | \ 751 (f & ~CIS_GET_LTUPLE_OPMASK)) 752 #define FIND_PREV_LTUPLE(tp, tu, f) CIS_PARSER(CISP_CIS_GET_LTUPLE, tp, \ 753 tu, FIND_PREV_LTUPLEF | \ 754 (f & ~CIS_GET_LTUPLE_OPMASK)) 755 #define FIND_FIRST_LTUPLE(tp, tu, f) FIND_LTUPLE_FWD(GET_FIRST_LTUPLE(tp, \ 756 f), tu, f) 757 758 759 /* 760 * Card Services hooks and general nexus prototypes 761 */ 762 int cs_init(void); 763 uint32_t cs_event(event_t, uint32_t, uint32_t); 764 int pcmcia_set_em_handler(int (*handler)(), caddr_t events, 765 int elen, uint32_t id, void **cs, void **ss); 766 767 extern csfunction_t *cs_socket_services; 768 769 770 #ifdef __cplusplus 771 } 772 #endif 773 774 #endif /* _CS_PRIV_H */ 775