Lines Matching refs:sp
314 cs_socket_t *sp;
344 if ((sp = cs_get_sp(sn)) != NULL) {
346 if (sp->client_list) {
400 if ((sp = cs_get_sp(sn)) != NULL) {
405 UNTIMEOUT(sp->rdybsy_tmo_id);
407 if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
408 mutex_enter(&sp->lock);
409 sp->flags = SOCKET_UNLOAD_MODULE;
410 if (sp->init_state & SOCKET_INIT_STATE_SOFTINTR)
411 sp->init_state &= ~SOCKET_INIT_STATE_SOFTINTR;
412 if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
413 mutex_exit(&sp->lock);
415 if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
416 mutex_enter(&sp->cis_lock);
417 (void) cs_destroy_cis(sp);
418 if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
419 mutex_exit(&sp->cis_lock);
425 if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
426 mutex_enter(&sp->client_lock);
427 if (sp->init_state & SOCKET_INIT_STATE_THREAD) {
428 sp->thread_state = SOCKET_THREAD_EXIT;
429 cv_broadcast(&sp->thread_cv);
430 cv_wait(&sp->caller_cv, &sp->client_lock);
432 if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
433 mutex_exit(&sp->client_lock);
439 if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
440 mutex_enter(&sp->ss_thread_lock);
441 if (sp->init_state & SOCKET_INIT_STATE_SS_THREAD) {
442 sp->ss_thread_state = SOCKET_THREAD_EXIT;
443 cv_broadcast(&sp->ss_thread_cv);
444 cv_wait(&sp->ss_caller_cv, &sp->ss_thread_lock);
447 if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
448 mutex_exit(&sp->ss_thread_lock);
453 if (sp->init_state & SOCKET_INIT_STATE_MUTEX) {
454 mutex_destroy(&sp->lock);
455 mutex_destroy(&sp->client_lock);
456 mutex_destroy(&sp->cis_lock);
457 mutex_destroy(&sp->ss_thread_lock);
460 if (sp->init_state & SOCKET_INIT_STATE_CV) {
461 cv_destroy(&sp->thread_cv);
462 cv_destroy(&sp->caller_cv);
463 cv_destroy(&sp->reset_cv);
464 cv_destroy(&sp->ss_thread_cv);
465 cv_destroy(&sp->ss_caller_cv);
472 if (sp->io_mmap_window)
473 kmem_free(sp->io_mmap_window, sizeof (io_mmap_window_t));
480 sp->event_mask = 0;
481 set_socket.socket = sp->socket_num;
488 (void) cs_convert_powerlevel(sp->socket_num, 0, VCC,
490 (void) cs_convert_powerlevel(sp->socket_num, 0, VPP1,
492 (void) cs_convert_powerlevel(sp->socket_num, 0, VPP2,
503 sp->socket_num, ret);
925 cs_socket_t *sp;
931 &fn, &sp, &client)) != CS_SUCCESS)
948 mutex_enter(&sp->cis_lock);
960 if ((sp->cis_flags & CW_VALID_CIS) &&
961 (sp->cis[fn].flags & CW_VALID_CIS)) {
969 mutex_exit(&sp->cis_lock);
976 mutex_exit(&sp->cis_lock);
1065 cs_socket_t *sp;
1071 &sp, &client)) != CS_SUCCESS)
1081 mutex_enter(&sp->cis_lock);
1087 if ((!(sp->cis_flags & CW_VALID_CIS)) ||
1088 (!(sp->cis[fn].flags & CW_VALID_CIS))) {
1089 mutex_exit(&sp->cis_lock);
1124 if (sp->cis_flags & CW_MULTI_FUNCTION_CIS) {
1126 GET_FIRST_LTUPLE(sp->cis[CS_GLOBAL_CIS].cis,
1128 mutex_exit(&sp->cis_lock);
1132 tuple->CISOffset = sp->cis[0].cis;
1144 mutex_exit(&sp->cis_lock);
1158 if (sp->cis_flags & CW_MULTI_FUNCTION_CIS) {
1161 tp = GET_FIRST_LTUPLE(sp->cis[fn].cis, flags);
1170 mutex_exit(&sp->cis_lock);
1188 if (sp->cis_flags & CW_MULTI_FUNCTION_CIS) {
1191 tp = FIND_FIRST_LTUPLE(sp->cis[fn].cis,
1201 mutex_exit(&sp->cis_lock);
1217 mutex_exit(&sp->cis_lock);
1239 cs_socket_t *sp;
1248 &sp, &client)) != CS_SUCCESS)
1258 mutex_enter(&sp->cis_lock);
1260 if ((sp->cis_flags & CW_VALID_CIS) &&
1261 (sp->cis[fn].flags & CW_VALID_CIS)) {
1268 mutex_exit(&sp->cis_lock);
1287 mutex_exit(&sp->cis_lock);
1297 mutex_exit(&sp->cis_lock);
1341 if (cs_init_cis_window(sp, &newoffset, &cis_handle,
1343 mutex_exit(&sp->cis_lock);
1346 sp->socket_num);
1356 mutex_exit(&sp->cis_lock);
1365 mutex_exit(&sp->cis_lock);
1425 cs_socket_t *sp;
1431 &sp, &client)) != CS_SUCCESS)
1441 mutex_enter(&sp->cis_lock);
1442 if ((sp->cis_flags & CW_VALID_CIS) &&
1443 (sp->cis[fn].flags & CW_VALID_CIS)) {
1444 cisinfo->Chains = sp->cis[fn].nchains;
1445 cisinfo->Tuples = sp->cis[fn].ntuples;
1448 (sp->cis[CS_GLOBAL_CIS].flags & CW_VALID_CIS)) {
1449 cisinfo->Chains += sp->cis[CS_GLOBAL_CIS].nchains;
1450 cisinfo->Tuples += sp->cis[CS_GLOBAL_CIS].ntuples;
1459 mutex_exit(&sp->cis_lock);
1467 * calling: *sp - pointer to the per-socket structure
1492 cs_init_cis_window(cs_socket_t *sp, uint32_t *offset,
1504 if (!SOCKET_HAS_CIS_WINDOW(sp)) {
1507 sp->socket_num);
1514 if ((cw = cs_get_wp(sp->cis_win_num)) == NULL)
1520 sp->socket_num, cw->state);
1529 iw.window = sp->cis_win_num;
1541 sw.WindowSize = sp->cis_win_size;
1542 set_page.offset = ((*offset / sp->cis_win_size) *
1543 sp->cis_win_size);
1573 sw.window = sp->cis_win_num;
1574 sw.socket = sp->socket_num;
1594 sp->cis_win_num = PCMCIA_MAX_WINDOWS;
1598 set_page.window = sp->cis_win_num;
1605 sp->cis_win_num = PCMCIA_MAX_WINDOWS;
1614 gw.window = sp->cis_win_num;
1615 gw.socket = sp->socket_num; /* XXX - SS_GetWindow should set this */
1834 cs_socket_t *sp;
1842 if ((sp = cs_get_sp(sn)) == NULL)
1845 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
1858 mutex_enter(&sp->lock);
1859 client = sp->client_list;
1863 mutex_exit(&sp->lock);
1864 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
1876 mutex_exit(&sp->lock);
1884 * We do it here so that we can grab the sp->lock mutex for the
1892 mutex_enter(&sp->lock);
1894 mutex_exit(&sp->lock);
1895 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
1912 mutex_exit(&sp->lock);
1913 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
1957 cr->iblk_cookie = sp->iblk;
1958 cr->idev_cookie = sp->idev;
2026 get_ss_status.socket = sp->socket_num;
2029 mutex_exit(&sp->lock);
2030 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
2045 sp->num_clients++;
2046 mutex_exit(&sp->lock);
2047 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
2058 cs_socket_t *sp;
2073 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
2076 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
2082 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
2098 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
2103 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
2124 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
2185 cs_socket_t *sp;
2208 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL) {
2214 clp = sp->client_list;
2241 cs_socket_t *sp;
2252 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
2262 mutex_enter(&sp->lock);
2263 sp->next_cl_minor = GET_CLIENT_MINOR(client_handle);
2280 sp->client_list = clp->next;
2291 sp->num_clients--;
2292 mutex_exit(&sp->lock);
2313 cs_socket_t *sp;
2317 if ((sp = cs_get_sp(socket_num)) == NULL)
2331 cs_create_next_client_minor(socket_num, sp->next_cl_minor)))
2358 if (!sp->client_list) {
2359 sp->client_list = cclp;
2360 clp = sp->client_list;
2366 clp = sp->client_list;
2374 } /* if (!sp->client_list) */
2385 sp->next_cl_minor =
2386 cs_create_next_client_minor(socket_num, sp->next_cl_minor);
2453 cs_socket_t *sp;
2485 if ((sp = cs_get_sp(sn)) == NULL)
2492 if (sp->flags & SOCKET_UNLOAD_MODULE) {
2499 mutex_enter(&sp->lock);
2515 sp->events |= ss_to_cs_events(sp, event);
2532 client = sp->client_list;
2545 client->events |= ((sp->events & ~CS_EVENT_CARD_INSERTION) &
2605 if (sp->events)
2606 sp->flags |= SOCKET_NEEDS_THREAD;
2613 if ((sp->init_state & SOCKET_INIT_STATE_SOFTINTR) &&
2615 ddi_trigger_softintr(sp->softint_id);
2617 mutex_exit(&sp->lock);
2633 * sp->thread_state was set or if we get a CARD_READY event right
2636 * calling: sp - pointer to socket structure
2643 cs_card_insertion(cs_socket_t *sp, event_t event)
2653 UNTIMEOUT(sp->rdybsy_tmo_id);
2658 (int)event, sp->socket_num);
2672 if (!SOCKET_HAS_CIS_WINDOW(sp)) {
2676 sp->socket_num);
2684 mutex_enter(&sp->lock);
2685 sp->event_mask = (CS_EVENT_CARD_REMOVAL |
2687 mutex_exit(&sp->lock);
2688 set_socket.socket = sp->socket_num;
2695 (void) cs_convert_powerlevel(sp->socket_num, 50, VCC,
2697 (void) cs_convert_powerlevel(sp->socket_num, 50, VPP1,
2699 (void) cs_convert_powerlevel(sp->socket_num, 50, VPP2,
2705 sp->socket_num, ret);
2714 mutex_enter(&sp->lock);
2716 sp->events &= ~(CS_EVENT_CARD_READY | CS_EVENT_READY_TIMEOUT);
2717 mutex_exit(&sp->lock);
2719 SocketServices(SS_ResetSocket, sp->socket_num,
2728 mutex_enter(&sp->lock);
2729 sp->thread_state |= SOCKET_RESET_TIMER;
2730 (void) timeout(cs_ready_timeout, sp,
2732 cv_wait(&sp->reset_cv, &sp->lock);
2733 sp->thread_state &= ~SOCKET_RESET_TIMER;
2734 mutex_exit(&sp->lock);
2739 "for %d mS sp->events 0x%x\n",
2740 sp->socket_num, cs_reset_timeout_time, (int)sp->events);
2749 if (sp->events & CS_EVENT_CARD_REMOVAL) {
2756 sp->socket_num);
2769 gs.socket = sp->socket_num;
2774 sp->socket_num, ret);
2778 mutex_enter(&sp->lock);
2779 if ((sp->events & CS_EVENT_CARD_READY) ||
2785 "READY\n", sp->socket_num);
2793 "READY timer\n", sp->socket_num);
2797 sp->rdybsy_tmo_id = timeout(cs_ready_timeout, sp,
2799 sp->thread_state |= SOCKET_WAIT_FOR_READY;
2803 mutex_exit(&sp->lock);
2819 mutex_enter(&sp->lock);
2820 sp->event_mask = CS_EVENT_CARD_REMOVAL;
2821 mutex_exit(&sp->lock);
2822 get_socket.socket = sp->socket_num;
2826 sp->socket_num);
2830 set_socket.socket = sp->socket_num;
2844 sp->socket_num);
2854 mutex_enter(&sp->cis_lock);
2856 if ((ret = cs_create_cis(sp)) != CS_SUCCESS) {
2857 mutex_exit(&sp->cis_lock);
2861 mutex_exit(&sp->cis_lock);
2870 if (sp->events & CS_EVENT_CARD_REMOVAL) {
2871 mutex_enter(&sp->cis_lock);
2872 (void) cs_destroy_cis(sp);
2873 mutex_exit(&sp->cis_lock);
2878 mutex_enter(&sp->ss_thread_lock);
2879 sp->ss_thread_state |= SOCKET_THREAD_CSCISInit;
2880 cv_broadcast(&sp->ss_thread_cv);
2881 mutex_exit(&sp->ss_thread_lock);
2903 mutex_enter(&sp->lock);
2904 client = sp->client_list;
2911 mutex_exit(&sp->lock);
2923 * calling: sp - pointer to socket structure
2927 cs_card_removal(cs_socket_t *sp)
2934 cmn_err(CE_CONT, "cs_card_removal: socket %d\n", sp->socket_num);
2941 UNTIMEOUT(sp->rdybsy_tmo_id);
2949 mutex_enter(&sp->lock);
2950 sp->thread_state &= ~(SOCKET_WAIT_FOR_READY | SOCKET_RESET_TIMER);
2956 sp->event_mask = CS_EVENT_CARD_INSERTION;
2957 mutex_exit(&sp->lock);
2958 set_socket.socket = sp->socket_num;
2965 (void) cs_convert_powerlevel(sp->socket_num, 0, VCC,
2967 (void) cs_convert_powerlevel(sp->socket_num, 0, VPP1,
2969 (void) cs_convert_powerlevel(sp->socket_num, 0, VPP2,
2975 sp->socket_num, ret);
2983 sp->socket_num);
2991 mutex_enter(&sp->cis_lock);
2992 (void) cs_destroy_cis(sp);
2993 mutex_exit(&sp->cis_lock);
3001 SocketServices(CSCardRemoved, sp->socket_num);
3018 ss_to_cs_events(cs_socket_t *sp, event_t event)
3027 if (sp->flags & SOCKET_CARD_INSERTED) {
3028 sp->flags &= ~(SOCKET_CARD_INSERTED | SOCKET_IS_IO);
3036 sp->events &= ~(CS_EVENT_CARD_INSERTION |
3050 sp->thread_state &= ~SOCKET_WAIT_FOR_READY;
3055 if (!(sp->flags & SOCKET_CARD_INSERTED)) {
3056 sp->flags |= SOCKET_CARD_INSERTED;
3061 if (sp->flags & SOCKET_CARD_INSERTED)
3065 if (sp->flags & SOCKET_CARD_INSERTED)
3069 if (sp->flags & SOCKET_CARD_INSERTED)
3073 if (sp->flags & SOCKET_CARD_INSERTED)
3099 * we hold our high-priority mutex (sp->lock) over a cv_broadcast, and
3104 * This callback routine can not grab the sp->client_lock mutex or deadlock
3110 cs_socket_t *sp = arg;
3113 mutex_enter(&sp->lock);
3115 if (sp->thread_state & SOCKET_RESET_TIMER) {
3119 sp->socket_num);
3123 cvp = &sp->reset_cv;
3126 if (sp->thread_state & SOCKET_WAIT_FOR_READY) {
3127 sp->events |= CS_EVENT_READY_TIMEOUT;
3128 cvp = &sp->thread_cv;
3133 "socket %d\n", sp->socket_num);
3139 mutex_exit(&sp->lock);
3181 cs_socket_t *sp;
3213 if ((sp = cs_get_sp(sn)) != NULL) {
3214 if (sp->init_state & SOCKET_INIT_STATE_READY) {
3219 if (!(sp->flags & SOCKET_UNLOAD_MODULE) &&
3220 (sp->flags & SOCKET_NEEDS_THREAD)) {
3222 mutex_enter(&sp->client_lock);
3223 cv_broadcast(&sp->thread_cv);
3224 mutex_exit(&sp->client_lock);
3243 cs_socket_t *sp;
3247 if ((sp = cs_get_sp(sn)) == NULL)
3253 sp->socket_num);
3257 CALLB_CPR_INIT(&sp->cprinfo_cs, &sp->client_lock,
3260 mutex_enter(&sp->client_lock);
3264 CALLB_CPR_SAFE_BEGIN(&sp->cprinfo_cs);
3265 cv_wait(&sp->thread_cv, &sp->client_lock);
3266 CALLB_CPR_SAFE_END(&sp->cprinfo_cs, &sp->client_lock);
3268 mutex_enter(&sp->lock);
3269 sp->flags &= ~SOCKET_NEEDS_THREAD;
3270 mutex_exit(&sp->lock);
3276 if (sp->thread_state & SOCKET_THREAD_EXIT) {
3281 sp->socket_num);
3284 CALLB_CPR_EXIT(&sp->cprinfo_cs);
3285 cv_broadcast(&sp->caller_cv); /* wakes up cs_deinit */
3286 mutex_exit(&sp->client_lock);
3292 cmn_err(CE_CONT, "cs_event_thread: socket %d sp->events 0x%x\n",
3293 sp->socket_num,
3294 (int)sp->events);
3301 if (sp->events & CS_EVENT_CARD_INSERTION) {
3302 mutex_enter(&sp->lock);
3303 sp->events &= ~CS_EVENT_CARD_INSERTION;
3304 mutex_exit(&sp->lock);
3311 if ((sp->events & CS_EVENT_CARD_REMOVAL) == 0) {
3312 (void) cs_card_insertion(sp, CS_EVENT_CARD_INSERTION);
3320 "processing\n", sp->socket_num);
3328 if (sp->events & (CS_EVENT_CARD_READY | CS_EVENT_READY_TIMEOUT)) {
3329 mutex_enter(&sp->lock);
3330 sp->events &= ~(CS_EVENT_CARD_READY | CS_EVENT_READY_TIMEOUT);
3331 mutex_exit(&sp->lock);
3332 if (sp->thread_state & SOCKET_WAIT_FOR_READY) {
3333 mutex_enter(&sp->lock);
3334 sp->thread_state &= ~SOCKET_WAIT_FOR_READY;
3335 mutex_exit(&sp->lock);
3336 (void) cs_card_insertion(sp, CS_EVENT_CARD_READY);
3343 if (sp->events & CS_EVENT_SS_UPDATED) {
3344 mutex_enter(&sp->lock);
3345 sp->events &= ~CS_EVENT_SS_UPDATED;
3346 mutex_exit(&sp->lock);
3347 (void) cs_card_insertion(sp, CS_EVENT_SS_UPDATED);
3353 if (sp->events & CS_EVENT_STATUS_CHANGE) {
3356 mutex_enter(&sp->cis_lock);
3357 mutex_enter(&sp->lock);
3358 sp->events &= ~CS_EVENT_STATUS_CHANGE;
3372 client = sp->client_list;
3385 (void) cs_read_event_status(sp, client,
3395 mutex_exit(&sp->lock);
3396 mutex_exit(&sp->cis_lock);
3414 client = sp->client_list;
3457 mutex_enter(&sp->lock);
3462 mutex_exit(&sp->lock);
3475 mutex_enter(&sp->lock);
3477 mutex_exit(&sp->lock);
3491 mutex_enter(&sp->lock);
3495 mutex_exit(&sp->lock);
3510 mutex_enter(&sp->cis_lock);
3511 mutex_enter(&sp->lock);
3512 (void) cs_read_event_status(sp, client,
3524 mutex_exit(&sp->lock);
3525 mutex_exit(&sp->cis_lock);
3543 mutex_enter(&sp->lock);
3545 mutex_exit(&sp->lock);
3562 if (sp->events & CS_EVENT_CARD_REMOVAL) {
3563 mutex_enter(&sp->lock);
3564 sp->events &= ~CS_EVENT_CARD_REMOVAL;
3565 mutex_exit(&sp->lock);
3566 (void) cs_card_removal(sp);
3572 if (sp->thread_state & SOCKET_WAIT_SYNC) {
3573 mutex_enter(&sp->lock);
3574 sp->thread_state &= ~SOCKET_WAIT_SYNC;
3575 mutex_exit(&sp->lock);
3576 cv_broadcast(&sp->caller_cv);
3643 cs_socket_t *sp;
3645 if ((sp = cs_get_sp(sn)) == NULL)
3651 CALLB_CPR_INIT(&sp->cprinfo_ss, &sp->ss_thread_lock,
3654 mutex_enter(&sp->ss_thread_lock);
3658 CALLB_CPR_SAFE_BEGIN(&sp->cprinfo_ss);
3659 cv_wait(&sp->ss_thread_cv, &sp->ss_thread_lock);
3660 CALLB_CPR_SAFE_END(&sp->cprinfo_ss, &sp->ss_thread_lock);
3666 if (sp->ss_thread_state & SOCKET_THREAD_EXIT) {
3671 sp->socket_num);
3674 CALLB_CPR_EXIT(&sp->cprinfo_ss);
3675 cv_broadcast(&sp->ss_caller_cv); /* wake up cs_deinit */
3676 mutex_exit(&sp->ss_thread_lock);
3684 (int)sp->socket_num,
3685 (int)sp->ss_thread_state);
3693 if (sp->ss_thread_state & SOCKET_THREAD_CSCISInit) {
3695 sp->ss_thread_state &= ~SOCKET_THREAD_CSCISInit;
3697 if (!(sp->flags & SOCKET_CARD_INSERTED)) {
3700 sp->socket_num);
3706 "CSCISInit\n", sp->socket_num);
3717 SocketServices(CSCISInit, sp->socket_num);
3724 mutex_enter(&sp->lock);
3725 sp->events |= CS_EVENT_SS_UPDATED;
3726 mutex_exit(&sp->lock);
3733 cv_broadcast(&sp->thread_cv);
3748 cs_socket_t *sp;
3763 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
3766 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
3772 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
3776 mutex_enter(&sp->lock);
3783 mutex_exit(&sp->lock);
3784 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
3820 (void) cs_set_socket_event_mask(sp, cs_merge_event_masks(sp, client));
3822 mutex_exit(&sp->lock);
3828 cv_broadcast(&sp->thread_cv);
3841 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
3857 cs_socket_t *sp;
3872 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
3875 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
3881 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
3885 mutex_enter(&sp->lock);
3892 mutex_exit(&sp->lock);
3893 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
3912 (void) cs_set_socket_event_mask(sp, cs_merge_event_masks(sp, client));
3914 mutex_exit(&sp->lock);
3915 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
3926 cs_socket_t *sp;
3941 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
3944 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
3950 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
3954 mutex_enter(&sp->lock);
3964 mutex_exit(&sp->lock);
3965 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
3983 mutex_exit(&sp->lock);
3984 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
3992 mutex_exit(&sp->lock);
3993 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4004 cs_socket_t *sp;
4019 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
4022 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
4028 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4032 mutex_enter(&sp->lock);
4040 mutex_exit(&sp->lock);
4041 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4059 mutex_exit(&sp->lock);
4060 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4072 (void) cs_set_socket_event_mask(sp, cs_merge_event_masks(sp, client));
4074 mutex_exit(&sp->lock);
4075 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4083 * calling: *sp - socket struct point
4114 cs_read_event_status(cs_socket_t *sp, client_t *client, event_t *revent,
4126 if ((sp->flags & SOCKET_CARD_INSERTED) ||
4128 if (sp->flags & SOCKET_IS_IO) {
4136 if (cs_init_cis_window(sp, &newoffset, &cis_handle,
4140 sp->socket_num);
4237 get_socket.socket = sp->socket_num;
4239 set_socket.socket = sp->socket_num;
4262 gs->socket = sp->socket_num;
4266 if (sp->flags & SOCKET_IS_IO) {
4328 cs_socket_t *sp;
4346 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
4349 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
4355 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4367 mutex_enter(&sp->cis_lock);
4368 if ((error = cs_read_event_status(sp, client, NULL, &get_ss_status,
4370 mutex_exit(&sp->cis_lock);
4371 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4375 mutex_exit(&sp->cis_lock);
4389 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4391 get_socket.socket = sp->socket_num;
4397 set_socket.socket = sp->socket_num;
4494 cs_merge_event_masks(cs_socket_t *sp, client_t *client)
4505 sp->event_mask;
4507 if (!(sp->flags & SOCKET_IS_IO)) {
4550 cs_set_socket_event_mask(cs_socket_t *sp, unsigned event_mask)
4555 get_socket.socket = sp->socket_num;
4559 set_socket.socket = sp->socket_num;
4618 cs_socket_t *sp;
4658 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
4661 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
4667 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4672 mutex_enter(&sp->lock);
4679 mutex_exit(&sp->lock);
4680 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4685 mutex_exit(&sp->lock);
4696 if ((error = cs_find_mem_window(sp->socket_num, rw, &aw)) !=
4698 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4713 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4720 cw->socket_num = sp->socket_num;
4732 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4757 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4775 cs_socket_t *sp;
4800 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(cw->client_handle))) == NULL)
4803 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
4809 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4826 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4838 cs_socket_t *sp;
4859 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(cw->client_handle))) == NULL)
4862 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
4865 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4870 mutex_enter(&sp->lock);
4877 mutex_exit(&sp->lock);
4878 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4883 mutex_exit(&sp->lock);
4895 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
4900 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5025 cs_socket_t *sp;
5058 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(cw->client_handle))) == NULL)
5061 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
5064 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5069 mutex_enter(&sp->lock);
5076 mutex_exit(&sp->lock);
5077 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5082 mutex_exit(&sp->lock);
5096 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5110 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5115 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5401 cs_socket_t *sp;
5449 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
5452 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
5458 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5468 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5477 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5482 mutex_enter(&sp->lock);
5489 mutex_exit(&sp->lock);
5490 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5495 mutex_exit(&sp->lock);
5546 if (sp->io_mmap_window) {
5548 io_mmap_window_t *imw = sp->io_mmap_window;
5565 if ((error = cs_find_io_win(sp->socket_num, &iowin_char,
5567 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5588 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5602 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5608 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5655 if ((error = cs_allocate_io_win(sp->socket_num, ior->Attributes1,
5658 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5680 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5700 if ((error = cs_allocate_io_win(sp->socket_num,
5710 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5737 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5748 } /* if (sp->io_mmap_window) */
5771 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5793 cs_socket_t *sp;
5815 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
5818 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
5824 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5834 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5843 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5863 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5876 if (sp->io_mmap_window) {
5877 io_mmap_window_t *imw = sp->io_mmap_window;
5885 sp->socket_num);
5886 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
5923 } /* if (sp->io_mmap_window) */
5931 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6144 cs_socket_t *sp;
6169 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
6172 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
6178 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6187 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6195 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6204 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6226 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6247 sp->socket_num,
6257 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6278 cs_socket_t *sp;
6298 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
6301 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
6307 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6316 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6324 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6345 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6354 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6387 cs_socket_t *sp;
6416 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
6427 inquire_socket.socket = sp->socket_num;
6437 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
6443 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6452 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6461 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6470 mutex_enter(&sp->cis_lock);
6476 get_socket.socket = sp->socket_num;
6479 mutex_exit(&sp->cis_lock);
6480 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6489 sp->socket_num,
6495 set_socket.socket = sp->socket_num;
6501 if (cs_convert_powerlevel(sp->socket_num, cr->Vcc, VCC,
6503 mutex_exit(&sp->cis_lock);
6504 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6508 if (cs_convert_powerlevel(sp->socket_num, cr->Vpp1, VPP1,
6510 mutex_exit(&sp->cis_lock);
6511 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6515 if (cs_convert_powerlevel(sp->socket_num, cr->Vpp2, VPP2,
6517 mutex_exit(&sp->cis_lock);
6518 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6537 sp->flags &= ~SOCKET_IS_IO;
6538 mutex_exit(&sp->cis_lock);
6539 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6551 mutex_enter(&sp->lock);
6554 mutex_exit(&sp->lock);
6555 if (cs_init_cis_window(sp, &newoffset, &cis_handle,
6557 mutex_exit(&sp->cis_lock);
6558 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6560 "CIS window\n", sp->socket_num);
6570 mutex_enter(&sp->lock);
6723 sp->flags |= SOCKET_IS_IO;
6725 mutex_exit(&sp->lock);
6738 set_socket.SCIntMask = cs_merge_event_masks(sp, client);
6753 if (sp->cis_flags & CW_MULTI_FUNCTION_CIS) {
6765 crt->cor, cr->ConfigIndex, cr->Attributes, sp->cis_flags,
6783 sp->flags &= ~SOCKET_IS_IO;
6784 mutex_exit(&sp->cis_lock);
6785 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6798 mutex_exit(&sp->cis_lock);
6799 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6817 cs_socket_t *sp;
6837 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
6840 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
6846 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6855 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6863 sp->cis_flags, CW_MULTI_FUNCTION_CIS);
6866 mutex_enter(&sp->cis_lock);
6878 if (cs_init_cis_window(sp, &newoffset, &cis_handle,
6880 mutex_exit(&sp->cis_lock);
6881 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6883 "CIS window\n", sp->socket_num);
6887 if (sp->cis_flags & CW_MULTI_FUNCTION_CIS) {
6898 mutex_exit(&sp->cis_lock);
6899 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6907 get_socket.socket = sp->socket_num;
6910 mutex_exit(&sp->cis_lock);
6911 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6915 mutex_enter(&sp->lock);
6916 sp->flags &= ~SOCKET_IS_IO;
6917 set_socket.SCIntMask = cs_merge_event_masks(sp, client);
6918 mutex_exit(&sp->lock);
6920 set_socket.socket = sp->socket_num;
6933 mutex_exit(&sp->cis_lock);
6934 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6943 mutex_exit(&sp->cis_lock);
6944 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
6967 cs_socket_t *sp;
6984 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
6987 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
6993 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7002 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7011 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7018 get_socket.socket = sp->socket_num;
7021 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7030 sp->socket_num, (int)client->irq_alloc.irq,
7034 set_socket.socket = sp->socket_num;
7048 if ((sp->cis_flags & CW_MULTI_FUNCTION_CIS) &&
7058 if (cs_init_cis_window(sp, &newoffset, &cis_handle,
7060 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7063 "CIS window\n", sp->socket_num);
7093 if (cs_convert_powerlevel(sp->socket_num, mc->Vpp1, VPP1,
7095 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7103 if (cs_convert_powerlevel(sp->socket_num, mc->Vpp2, VPP2,
7105 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7116 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7120 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7140 cs_socket_t *sp;
7163 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
7166 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
7172 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7181 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7190 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7194 mutex_enter(&sp->cis_lock);
7200 if (cs_init_cis_window(sp, &newoffset, &cis_handle,
7202 mutex_exit(&sp->cis_lock);
7203 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7205 sp->socket_num);
7213 mutex_enter(&sp->lock);
7243 mutex_exit(&sp->lock);
7244 mutex_exit(&sp->cis_lock);
7245 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7278 cs_socket_t *sp;
7286 if ((sp = cs_get_sp(CS_GET_SOCKET_NUMBER(gci->Socket))) == NULL)
7289 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
7290 mutex_enter(&sp->lock);
7294 client = sp->client_list;
7305 mutex_exit(&sp->lock);
7306 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7310 mutex_exit(&sp->lock);
7311 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7319 mutex_exit(&sp->lock);
7320 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7368 cs_socket_t *sp;
7379 if ((sp = cs_get_sp(CS_GET_SOCKET_NUMBER(gpai->PhySocket))) == NULL)
7382 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
7389 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7394 gpai->flags = sp->adapter.flags;
7395 (void) strcpy(gpai->name, sp->adapter.name);
7396 gpai->major = sp->adapter.major;
7397 gpai->minor = sp->adapter.minor;
7398 gpai->instance = sp->adapter.instance;
7399 gpai->number = sp->adapter.number;
7400 gpai->num_sockets = sp->adapter.num_sockets;
7401 gpai->first_socket = sp->adapter.first_socket;
7403 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7437 cs_socket_t *sp;
7448 if ((sp = cs_get_sp(CS_GET_SOCKET_NUMBER(mls->PhySocket))) == NULL)
7451 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
7458 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7463 mls->PhyAdapter = sp->adapter.number;
7465 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7621 cs_socket_t *sp;
7637 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
7640 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
7646 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7656 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7686 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7724 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7729 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7757 cs_socket_t *sp;
7795 if ((sp = cs_get_sp(cdi->Socket)) == NULL)
7798 EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
7800 client = sp->client_list;
7827 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7834 EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
7844 cs_socket_t *sp;
7854 if ((sp = cs_get_sp(sn)) == NULL)
7856 mutex_enter(&sp->client_lock);
7857 mutex_enter(&sp->lock);
7860 sp->events |= csc->Events;
7864 mutex_exit(&sp->lock);
7865 mutex_exit(&sp->client_lock);
7876 sp->thread_state |= SOCKET_WAIT_SYNC;
7877 mutex_exit(&sp->lock);
7878 cv_broadcast(&sp->thread_cv);
7879 cv_wait(&sp->caller_cv, &sp->client_lock);
7881 mutex_exit(&sp->lock);
7882 cv_broadcast(&sp->thread_cv);
7884 mutex_exit(&sp->client_lock);
7904 cs_socket_t *sp = cs_globals.sp;
7909 if ((sp = cs_find_sp(sn)) == NULL)
7912 if (sp->flags & SOCKET_IS_VALID)
7913 return (sp);
7928 cs_socket_t *sp = cs_globals.sp;
7930 while (sp) {
7931 if (sp->socket_num == CS_GET_SOCKET_NUMBER(sn))
7932 return (sp);
7933 sp = sp->next;
7958 cs_socket_t *sp;
7985 if ((sp = cs_find_sp(sn)) == NULL) {
7986 cs_socket_t *spp = cs_globals.sp;
7988 sp = (cs_socket_t *)kmem_zalloc(sizeof (cs_socket_t), KM_SLEEP);
7990 if (cs_globals.sp == NULL)
7991 cs_globals.sp = sp;
7995 spp->next = sp;
8002 if (sp->flags & SOCKET_IS_VALID)
8009 sp->socket_num = sn;
8042 sp->cis_win_num = PCMCIA_MAX_WINDOWS;
8054 if ((ret = cs_find_mem_window(sp->socket_num, &win_req,
8055 &sp->cis_win_num)) != CS_SUCCESS) {
8057 sp->cis_win_num = PCMCIA_MAX_WINDOWS;
8060 sp->socket_num, ret);
8064 if ((cw = cs_get_wp(sp->cis_win_num)) == NULL) {
8069 inquire_window.window = sp->cis_win_num;
8081 sp->cis_win_size = win_req.Size;
8083 sp->cis_win_size = PAGESIZE;
8087 cw->socket_num = sp->socket_num;
8094 "size 0x%x\n", (int)sp->socket_num,
8095 (int)sp->cis_win_num,
8096 (int)sp->cis_win_size);
8106 gcad->socket = sp->socket_num;
8109 "failure\n", sp->socket_num);
8116 sp->iblk = gcad->iblock;
8117 sp->idev = gcad->idevice;
8122 sp->adapter.flags = 0;
8123 (void) strcpy(sp->adapter.name, gcad->adapter_info.name);
8124 sp->adapter.major = gcad->adapter_info.major;
8125 sp->adapter.minor = gcad->adapter_info.minor;
8126 sp->adapter.instance = ddi_get_instance(gcad->dip);
8127 sp->adapter.number = gcad->adapter_info.number;
8128 sp->adapter.num_sockets = gcad->adapter_info.num_sockets;
8129 sp->adapter.first_socket = gcad->adapter_info.first_socket;
8132 mutex_init(&sp->lock, NULL, MUTEX_DRIVER, *(gcad->iblock));
8133 mutex_init(&sp->client_lock, NULL, MUTEX_DRIVER, NULL);
8134 mutex_init(&sp->cis_lock, NULL, MUTEX_DRIVER, NULL);
8137 mutex_init(&sp->ss_thread_lock, NULL, MUTEX_DRIVER, NULL);
8139 sp->init_state |= SOCKET_INIT_STATE_MUTEX;
8142 cv_init(&sp->thread_cv, NULL, CV_DRIVER, NULL);
8143 cv_init(&sp->caller_cv, NULL, CV_DRIVER, NULL);
8144 cv_init(&sp->reset_cv, NULL, CV_DRIVER, NULL);
8147 cv_init(&sp->ss_thread_cv, NULL, CV_DRIVER, NULL);
8148 cv_init(&sp->ss_caller_cv, NULL, CV_DRIVER, NULL);
8150 sp->init_state |= SOCKET_INIT_STATE_CV;
8158 &sp->softint_id,
8163 "softintr\n", sp->socket_num);
8168 cs_globals.softint_id = sp->softint_id;
8179 sp->softint_id = cs_globals.softint_id;
8188 sp->init_state |= SOCKET_INIT_STATE_SOFTINTR;
8197 sp->event_mask = CS_EVENT_CARD_INSERTION;
8198 set_socket.socket = sp->socket_num;
8205 (void) cs_convert_powerlevel(sp->socket_num, 0, VCC,
8207 (void) cs_convert_powerlevel(sp->socket_num, 0, VPP1,
8209 (void) cs_convert_powerlevel(sp->socket_num, 0, VPP2,
8214 "failure %d\n", sp->socket_num, ret);
8228 max(cs_globals.max_socket_num, sp->socket_num + 1);
8230 sp->flags = SOCKET_IS_VALID;
8235 sp->event_thread = CREATE_SOCKET_EVENT_THREAD(cs_event_thread,
8238 mutex_enter(&sp->lock);
8239 sp->init_state |= SOCKET_INIT_STATE_THREAD;
8240 mutex_exit(&sp->lock);
8245 sp->ss_thread = CREATE_SOCKET_EVENT_THREAD(cs_ss_thread,
8248 mutex_enter(&sp->lock);
8249 sp->init_state |= (SOCKET_INIT_STATE_SS_THREAD |
8251 sp->event_mask = CS_EVENT_CARD_INSERTION;
8252 mutex_exit(&sp->lock);
8270 cs_socket_t *sp;
8276 mutex_enter(&sp->client_lock);
8277 sp->thread_state |= SOCKET_THREAD_EXIT;
8278 cv_broadcast(&sp->thread_cv);
8279 cv_wait(&sp->caller_cv, &sp->client_lock);
8280 mutex_exit(&sp->client_lock);
8290 sp->flags &= ~SOCKET_IS_VALID;
8312 * cs_socket_t **sp - pointer to a pointer where a pointer
8330 cs_socket_t *sp;
8357 if ((sp = cs_get_sp(sn)) == NULL)
8365 *csp = sp;
8370 mutex_enter(&sp->lock);
8372 mutex_exit(&sp->lock);
8383 mutex_exit(&sp->lock);
8576 cs_create_cis(cs_socket_t *sp)
8581 cis_cistpl_std_callout, sp);
8587 sp->socket_num);
8591 sp->socket_num, ret);
8604 if (!(sp->cis_flags & CW_VALID_CIS))
8612 if (!(sp->cis_flags & CW_MULTI_FUNCTION_CIS)) {
8613 bcopy((caddr_t)&sp->cis[CS_GLOBAL_CIS],
8614 (caddr_t)&sp->cis[0], sizeof (cis_info_t));
8615 bzero((caddr_t)&sp->cis[CS_GLOBAL_CIS], sizeof (cis_info_t));
8625 cs_destroy_cis(cs_socket_t *sp)
8627 CIS_PARSER(CISP_CIS_LIST_DESTROY, sp);
8650 cs_socket_t *sp;
8661 if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
8664 mutex_enter(&sp->client_lock);
8665 mutex_enter(&sp->lock);
8668 mutex_exit(&sp->lock);
8669 mutex_exit(&sp->client_lock);
8679 mutex_exit(&sp->lock);
8680 mutex_exit(&sp->client_lock);
8691 sp->thread_state |= SOCKET_WAIT_SYNC;
8692 mutex_exit(&sp->lock);
8693 cv_broadcast(&sp->thread_cv);
8694 cv_wait(&sp->caller_cv, &sp->client_lock);
8712 mutex_exit(&sp->client_lock);
8739 cs_socket_t *sp;
8748 if ((sp = cs_get_sp(sn)) != NULL) {
8749 mutex_enter(&sp->client_lock);
8750 if ((client = sp->client_list) != NULL)
8752 mutex_exit(&sp->client_lock);
8761 if ((sp = cs_get_sp(CS_GET_SOCKET_NUMBER(fnc->Socket))) ==
8764 mutex_enter(&sp->client_lock);
8765 if ((client = sp->client_list) == NULL) {
8766 mutex_exit(&sp->client_lock);
8774 fnc->num_clients = sp->num_clients;
8775 mutex_exit(&sp->client_lock);
8781 if ((sp = cs_get_sp(sn)) == NULL)
8784 mutex_enter(&sp->client_lock);
8787 mutex_exit(&sp->client_lock);
8791 mutex_exit(&sp->client_lock);
8794 if ((sp = cs_get_sp(sn)) != NULL) {
8795 mutex_enter(&sp->client_lock);
8796 if ((client = sp->client_list) != NULL)
8798 mutex_exit(&sp->client_lock);
8809 sp = cs_get_sp(GET_CLIENT_SOCKET(fnc->client_handle));
8810 if (sp == NULL)
8812 mutex_enter(&sp->client_lock);
8815 mutex_exit(&sp->client_lock);
8819 mutex_exit(&sp->client_lock);
8827 fnc->num_clients = sp->num_clients;
8828 mutex_exit(&sp->client_lock);