xref: /onnv-gate/usr/src/uts/common/pcmcia/cs/cs.c (revision 1278)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * PCMCIA Card Services
 *	The PCMCIA Card Services is a loadable module which
 *	presents the Card Services interface to client device
 *	drivers.
 *
 *	Card Services uses Socket Services-like calls into the
 *	PCMCIA nexus driver to manipulate socket and adapter
 *	resources.
 *
 * Note that a bunch of comments are not indented correctly with the
 *	code that they are commenting on. This is because cstyle is
 *	is inflexible concerning 4-column indenting.
 */

#if defined(DEBUG)
#define	CS_DEBUG
#endif

#include <sys/types.h>
#include <sys/systm.h>
#include <sys/user.h>
#include <sys/buf.h>
#include <sys/file.h>
#include <sys/uio.h>
#include <sys/conf.h>
#include <sys/stat.h>
#include <sys/autoconf.h>
#include <sys/vtoc.h>
#include <sys/dkio.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/debug.h>
#include <sys/varargs.h>
#include <sys/var.h>
#include <sys/proc.h>
#include <sys/thread.h>
#include <sys/utsname.h>
#include <sys/vtrace.h>
#include <sys/kstat.h>
#include <sys/kmem.h>
#include <sys/modctl.h>
#include <sys/kobj.h>
#include <sys/callb.h>
#include <sys/time.h>

#include <sys/pctypes.h>
#include <pcmcia/sys/cs_types.h>
#include <sys/pcmcia.h>
#include <sys/sservice.h>
#include <pcmcia/sys/cis.h>
#include <pcmcia/sys/cis_handlers.h>
#include <pcmcia/sys/cs.h>
#include <pcmcia/sys/cs_priv.h>
#include <pcmcia/sys/cs_stubs.h>

/*
 * The cs_strings header file is where all of the major strings that
 *	Card Services uses are located.
 */
#include <pcmcia/sys/cs_strings.h>


/*
 * Function declarations
 *
 * The main Card Services entry point
 */
int CardServices(int function, ...);

/*
 * functions and globals used by Socket Services
 *
 * WAS: void *(*cis_parser)(int, ...) = NULL;
 */
void *(*cis_parser)(int, ...) = NULL;
csfunction_t *cs_socket_services = NULL;

/*
 * event handling functions
 */
static event_t ss_to_cs_events(cs_socket_t *, event_t);
static event_t cs_cse2sbm(event_t);
static void cs_event_thread(uint32_t);
static int cs_card_insertion(cs_socket_t *, event_t);
static int cs_card_removal(cs_socket_t *);
static void cs_ss_thread(uint32_t);
void cs_ready_timeout(void *);
static int cs_card_for_client(client_t *);
static int cs_request_socket_mask(client_handle_t, request_socket_mask_t *);
static int cs_release_socket_mask(client_handle_t, release_socket_mask_t *);
static int cs_get_event_mask(client_handle_t, sockevent_t *);
static int cs_set_event_mask(client_handle_t, sockevent_t *);
static int cs_event2text(event2text_t *, int);
static int cs_read_event_status(cs_socket_t *, client_t *, event_t *,
						get_ss_status_t *, int);
uint32_t cs_socket_event_softintr(caddr_t);
void cs_event_softintr_timeout(void *);
static int cs_get_status(client_handle_t, get_status_t *);
static uint32_t cs_sbm2cse(uint32_t);
static unsigned cs_merge_event_masks(cs_socket_t *, client_t *);
static int cs_set_socket_event_mask(cs_socket_t *, unsigned);

/*
 * SS<->CS communication and internal socket and window  handling functions
 */
static uint32_t cs_add_socket(uint32_t);
static uint32_t cs_drop_socket(uint32_t);
static cs_socket_t *cs_get_sp(uint32_t);
static cs_socket_t *cs_find_sp(uint32_t);
static cs_window_t *cs_get_wp(uint32_t);
static cs_window_t *cs_find_wp(uint32_t);
static int cs_add_windows(int, uint32_t);
static uint32_t cs_ss_init();
static void cs_set_acc_attributes(set_window_t *, uint32_t);

/*
 * CIS handling functions
 */
cistpl_callout_t *cis_cistpl_std_callout;
static int cs_parse_tuple(client_handle_t,  tuple_t *, cisparse_t *, cisdata_t);
static int cs_get_tuple_data(client_handle_t, tuple_t *);
static int cs_validate_cis(client_handle_t, cisinfo_t *);
static int cs_get_firstnext_tuple(client_handle_t, tuple_t *, uint32_t);
static int cs_create_cis(cs_socket_t *);
static int cs_destroy_cis(cs_socket_t *);

/*
 * client handling functions
 */
unsigned cs_create_next_client_minor(unsigned, unsigned);
static client_t *cs_find_client(client_handle_t, int *);
static client_handle_t cs_create_client_handle(unsigned, client_t *);
static int cs_destroy_client_handle(client_handle_t);
static int cs_register_client(client_handle_t *, client_reg_t *);
static int cs_deregister_client(client_handle_t);
static int cs_deregister_mtd(client_handle_t);
static void cs_clear_superclient_lock(int);
static int cs_add_client_to_socket(unsigned, client_handle_t *,
						client_reg_t *, int);
static int cs_get_client_info(client_handle_t, client_info_t *);
static int cs_get_firstnext_client(get_firstnext_client_t *, uint32_t);

/*
 * window handling functions
 */
static int cs_request_window(client_handle_t, window_handle_t *, win_req_t *);
static int cs_release_window(window_handle_t);
static int cs_modify_window(window_handle_t, modify_win_t *);
static int cs_modify_mem_window(window_handle_t, modify_win_t *, win_req_t *,
									int);
static int cs_map_mem_page(window_handle_t, map_mem_page_t *);
static int cs_find_mem_window(uint32_t, win_req_t *, uint32_t *);
static int cs_memwin_space_and_map_ok(inquire_window_t *, win_req_t *);
static int cs_valid_window_speed(inquire_window_t *, uint32_t);
static window_handle_t cs_create_window_handle(uint32_t);
static cs_window_t *cs_find_window(window_handle_t);
static int cs_find_io_win(uint32_t, iowin_char_t *, uint32_t *, uint32_t *);

/*
 * IO, IRQ and configuration handling functions
 */
static int cs_request_io(client_handle_t, io_req_t *);
static int cs_release_io(client_handle_t, io_req_t *);
static int cs_allocate_io_win(uint32_t, uint32_t, uint32_t *);
static int cs_setup_io_win(uint32_t, uint32_t, baseaddru_t *,
					uint32_t *, uint32_t, uint32_t);
static int cs_request_irq(client_handle_t, irq_req_t *);
static int cs_release_irq(client_handle_t, irq_req_t *);
static int cs_request_configuration(client_handle_t, config_req_t *);
static int cs_release_configuration(client_handle_t, release_config_t *);
static int cs_modify_configuration(client_handle_t, modify_config_t *);
static int cs_access_configuration_register(client_handle_t,
						access_config_reg_t *);

/*
 * RESET and general info functions
 */
static int cs_reset_function(client_handle_t, reset_function_t *);
static int cs_get_configuration_info(client_handle_t *,
						get_configuration_info_t *);
static int cs_get_cardservices_info(client_handle_t,
						get_cardservices_info_t *);
static int cs_get_physical_adapter_info(client_handle_t,
						get_physical_adapter_info_t *);

/*
 * general functions
 */
static uint32_t cs_get_socket(client_handle_t, uint32_t *, uint32_t *,
					cs_socket_t **, client_t **);
static int cs_convert_speed(convert_speed_t *);
static int cs_convert_size(convert_size_t *);
static char *cs_error2text(int, int);
static int cs_map_log_socket(client_handle_t, map_log_socket_t *);
static int cs_convert_powerlevel(uint32_t, uint32_t, uint32_t, unsigned *);
static int cs_make_device_node(client_handle_t, make_device_node_t *);
static int cs_remove_device_node(client_handle_t, remove_device_node_t *);
static int cs_ddi_info(cs_ddi_info_t *);
static int cs_init_cis_window(cs_socket_t *, uint32_t *, acc_handle_t *,
				uint32_t);
static int cs_sys_ctl(cs_sys_ctl_t *);

/*
 * global variables
 */
static int cs_max_client_handles = CS_MAX_CLIENTS;
static client_t cs_socket_services_client;	/* global SS client */
static client_types_t client_types[MAX_CLIENT_TYPES];
static cs_globals_t cs_globals;
int cs_reset_timeout_time = RESET_TIMEOUT_TIME;
int cs_rc1_delay = CS_RC1_DELAY;
int cs_rc2_delay = CS_RC2_DELAY;
int cs_rq_delay = CS_RQ_DELAY;

#ifdef	CS_DEBUG
int	cs_debug = 0;
#endif

/*
 * cs_init - Initialize CS internal structures, databases, and state,
 *		and register with SS
 *
 * XXX - Need to make sure that if we fail at any point that we free
 *		any resources that we allocated, as well as kill any
 *		threads that may have been started.
 */
int
cs_init()
{
	client_types_t *ct;
	client_t *client;

	/*
	 * Initialize the CS global structure
	 */
	bzero((caddr_t)&cs_globals, sizeof (cs_globals_t));

	mutex_init(&cs_globals.global_lock, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&cs_globals.window_lock, NULL, MUTEX_DRIVER, NULL);

	cs_globals.init_state = GLOBAL_INIT_STATE_MUTEX;

	/*
	 * Set up the global Socket Services client, since we're going to
	 *	need it once we register with SS.
	 */
	client = &cs_socket_services_client;
	bzero((caddr_t)client, sizeof (client_t));
	client->client_handle = CS_SS_CLIENT_HANDLE;
	client->flags |= (INFO_SOCKET_SERVICES | CLIENT_CARD_INSERTED);

	/*
	 * Setup the client type structure - this is used in the socket event
	 *	thread to sequence the delivery of events to all clients on
	 *	the socket.
	 */
	ct = &client_types[0];
	ct->type = INFO_IO_CLIENT;
	ct->order = CLIENT_EVENTS_LIFO;
	ct->next = &client_types[1];

	ct = ct->next;
	ct->type = INFO_MTD_CLIENT;
	ct->order = CLIENT_EVENTS_FIFO;
	ct->next = &client_types[2];

	ct = ct->next;
	ct->type = INFO_MEM_CLIENT;
	ct->order = CLIENT_EVENTS_FIFO;
	ct->next = NULL;

	return (CS_SUCCESS);
}

/*
 * cs_deinit - Deinitialize CS
 *
 * This function cleans up any allocated resources, stops any running threads,
 *	destroys any mutexes and condition variables, and finally frees up the
 *	global socket and window structure arrays.
 */
int
cs_deinit()
{
	cs_socket_t *sp;
	int sn, have_clients = 0, have_sockets = 0;
	cs_register_cardservices_t rcs;

#if defined(CS_DEBUG)
	if (cs_debug > 1)
	    cmn_err(CE_CONT, "CS: cs_deinit\n");
#endif

	/*
	 * Deregister with the Card Services kernel stubs module
	 */
	rcs.magic = CS_STUBS_MAGIC;
	rcs.function = CS_ENTRY_DEREGISTER;
	(void) csx_register_cardservices(&rcs);

	/*
	 * Set the GLOBAL_INIT_STATE_NO_CLIENTS flag to prevent new clients
	 *	from registering.
	 */
	mutex_enter(&cs_globals.global_lock);
	cs_globals.init_state |= GLOBAL_INIT_STATE_NO_CLIENTS;
	mutex_exit(&cs_globals.global_lock);

	/*
	 * Go through each socket and make sure that there are no clients
	 *	on any of the sockets.  If there are, we can't deinit until
	 *	all the clients for every socket are gone.
	 */
	for (sn = 0; sn < cs_globals.max_socket_num; sn++) {
	    if ((sp = cs_get_sp(sn)) != NULL) {
		have_sockets++;
		if (sp->client_list) {
		    cmn_err(CE_CONT, "cs_deinit: cannot unload module since "
				"socket %d has registered clients\n", sn);
		    have_clients++;
		}
	    }
	}

	/*
	 * We don't allow unload if there are any clients registered
	 *	or if there are still sockets that are active.
	 */
	if ((have_clients > 0) || (have_sockets > 0))
	    return (BAD_FUNCTION);

#ifdef	XXX
	/*
	 * If one or more sockets have been added, we need to deallocate
	 *	the resources associated with those sockets.
	 */

	/*
	 * First, tell Socket Services that we're leaving, so that we
	 *	don't get any more event callbacks.
	 */
	SocketServices(CSUnregister);

	/*
	 * Wait for the soft int timer to tell us it's done
	 */
	mutex_enter(&cs_globals.global_lock);
	cs_globals.init_state |= GLOBAL_INIT_STATE_UNLOADING;
	mutex_exit(&cs_globals.global_lock);
	UNTIMEOUT(cs_globals.sotfint_tmo);

	/*
	 * Remove the soft interrupt handler.
	 */
	mutex_enter(&cs_globals.global_lock);
	if (cs_globals.init_state & GLOBAL_INIT_STATE_SOFTINTR) {
	    ddi_remove_softintr(cs_globals.softint_id);
	    cs_globals.init_state &= ~GLOBAL_INIT_STATE_SOFTINTR;
	}
	mutex_exit(&cs_globals.global_lock);

	return (CS_SUCCESS);

	/*
	 * Go through each socket and free any resource allocated to that
	 *	socket, as well as any mutexs and condition variables.
	 */
	for (sn = 0; sn < cs_globals.max_socket_num; sn++) {
	    set_socket_t set_socket;

	    if ((sp = cs_get_sp(sn)) != NULL) {

		/*
		 * untimeout possible pending ready/busy timer
		 */
		UNTIMEOUT(sp->rdybsy_tmo_id);

		if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
		    mutex_enter(&sp->lock);
		sp->flags = SOCKET_UNLOAD_MODULE;
		if (sp->init_state & SOCKET_INIT_STATE_SOFTINTR)
		    sp->init_state &= ~SOCKET_INIT_STATE_SOFTINTR;
		if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
		    mutex_exit(&sp->lock);

		if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
		    mutex_enter(&sp->cis_lock);
		(void) cs_destroy_cis(sp);
		if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
		    mutex_exit(&sp->cis_lock);

		/*
		 * Tell the event handler thread that we want it to exit, then
		 *	wait around until it tells us that it has exited.
		 */
		if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
		    mutex_enter(&sp->client_lock);
		if (sp->init_state & SOCKET_INIT_STATE_THREAD) {
		    sp->thread_state = SOCKET_THREAD_EXIT;
		    cv_broadcast(&sp->thread_cv);
		    cv_wait(&sp->caller_cv, &sp->client_lock);
		}
		if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
		    mutex_exit(&sp->client_lock);

		/*
		 * Tell the SS work thread that we want it to exit, then
		 *	wait around until it tells us that it has exited.
		 */
		if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
		    mutex_enter(&sp->ss_thread_lock);
		if (sp->init_state & SOCKET_INIT_STATE_SS_THREAD) {
		    sp->ss_thread_state = SOCKET_THREAD_EXIT;
		    cv_broadcast(&sp->ss_thread_cv);
		    cv_wait(&sp->ss_caller_cv, &sp->ss_thread_lock);
		}

		if (sp->init_state & SOCKET_INIT_STATE_MUTEX)
		    mutex_exit(&sp->ss_thread_lock);

		/*
		 * Free the mutexii and condition variables that we used.
		 */
		if (sp->init_state & SOCKET_INIT_STATE_MUTEX) {
		    mutex_destroy(&sp->lock);
		    mutex_destroy(&sp->client_lock);
		    mutex_destroy(&sp->cis_lock);
		    mutex_destroy(&sp->ss_thread_lock);
		}

		if (sp->init_state & SOCKET_INIT_STATE_CV) {
		    cv_destroy(&sp->thread_cv);
		    cv_destroy(&sp->caller_cv);
		    cv_destroy(&sp->reset_cv);
		    cv_destroy(&sp->ss_thread_cv);
		    cv_destroy(&sp->ss_caller_cv);
		}

#ifdef	USE_IOMMAP_WINDOW
		/*
		 * Free the memory-mapped IO structure if we allocated one.
		 */
		if (sp->io_mmap_window)
		    kmem_free(sp->io_mmap_window, sizeof (io_mmap_window_t));
#endif	/* USE_IOMMAP_WINDOW */

		/*
		 * Return the socket to memory-only mode and turn off the
		 *	socket power.
		 */
		sp->event_mask = 0;
		set_socket.socket = sp->socket_num;
		set_socket.SCIntMask = 0;
		set_socket.IREQRouting = 0;
		set_socket.IFType = IF_MEMORY;
		set_socket.CtlInd = 0; /* turn off controls and indicators */
		set_socket.State = (unsigned)~0; /* clear latched state bits */

		(void) cs_convert_powerlevel(sp->socket_num, 0, VCC,
						&set_socket.VccLevel);
		(void) cs_convert_powerlevel(sp->socket_num, 0, VPP1,
						&set_socket.Vpp1Level);
		(void) cs_convert_powerlevel(sp->socket_num, 0, VPP2,
						&set_socket.Vpp2Level);

		/*
		 * If we fail this call, there's not much we can do, so
		 *	just continue with the resource deallocation.
		 */
		if ((ret =
			SocketServices(SS_SetSocket, &set_socket)) != SUCCESS) {
		    cmn_err(CE_CONT,
			"cs_deinit: socket %d SS_SetSocket failure %d\n",
							sp->socket_num, ret);
		}
	    } /* cs_get_sp */
	} /* for (sn) */
#endif	/* XXX */

	/*
	 * Destroy the global mutexii.
	 */
	mutex_destroy(&cs_globals.global_lock);
	mutex_destroy(&cs_globals.window_lock);

#ifdef	XXX
	/*
	 * Free the global "super-client" structure
	 */
	if (cs_globals.sclient_list)
	    kmem_free(cs_globals.sclient_list,
		(cs_globals.num_sockets * sizeof (struct sclient_list_t)));
	cs_globals.sclient_list = NULL;
#endif	/* XXX */

	return (CS_SUCCESS);
}

/*
 * ==== drip, drip, drip - the Card Services waterfall :-) ====
 */

/*
 * CardServices - general Card Services entry point for CS clients
 *			and Socket Services; the address of this
 *			function is handed to SS via the CSRegister
 *			SS call
 */
int
CardServices(int function, ...)
{
	va_list arglist;
	int retcode = CS_UNSUPPORTED_FUNCTION;

	cs_socket_t	*socp;
	uint32_t	*offp;
	acc_handle_t	*hp;
	client_handle_t	ch;
	client_handle_t	*chp;
	window_handle_t	wh;
	window_handle_t	*whp;
	tuple_t		*tuple;
	cisparse_t	*cisparse;

#ifdef	CS_DEBUG
	if (cs_debug > 127) {
	    cmn_err(CE_CONT, "CardServices: called for function %s (0x%x)\n",
				cs_error2text(function, CSFUN2TEXT_FUNCTION),
				function);
	}
#endif

	va_start(arglist, function);

	/*
	 * Here's the Card Services waterfall
	 */
	switch (function) {
	/*
	 * We got here as a result of the CIS module calling us
	 *	in response to cs_ss_init() calling the CIS module
	 *	at CIS_PARSER(CISP_CIS_SETUP, ...)
	 */
	    case CISRegister: {
		cisregister_t *cisr;

		    cisr = va_arg(arglist, cisregister_t *);

		    if (cisr->cis_magic != PCCS_MAGIC ||
			cisr->cis_version != PCCS_VERSION) {
			    cmn_err(CE_WARN,
				"CS: CISRegister (%lx, %lx, %lx, %lx) *ERROR*",
					(long)cisr->cis_magic,
					(long)cisr->cis_version,
					(long)cisr->cis_parser,
					(long)cisr->cistpl_std_callout);
			retcode = CS_BAD_ARGS;
		    } else {
			/*
			 * Replace the CIS Parser entry point if
			 *	necessary.
			 */
			if (cisr->cis_parser != NULL)
			    cis_parser = cisr->cis_parser;
			cis_cistpl_std_callout = cisr->cistpl_std_callout;
			retcode = CS_SUCCESS;
		    }
		}
		break;
	    case CISUnregister:	/* XXX - should we do some more checking */
		/* XXX - need to protect this by a mutex */
		cis_parser = NULL;
		cis_cistpl_std_callout = NULL;
		retcode = CS_SUCCESS;
		break;
	    case InitCISWindow:
		socp	= va_arg(arglist, cs_socket_t *);
		offp	= va_arg(arglist, uint32_t *);
		hp	= va_arg(arglist, acc_handle_t *);
		retcode = cs_init_cis_window(socp, offp, hp,
				va_arg(arglist, uint32_t));
		break;
	    case RegisterClient:
		chp = va_arg(arglist, client_handle_t *),
		retcode = cs_register_client(chp,
				va_arg(arglist, client_reg_t *));
		break;
	    case DeregisterClient:
		retcode = cs_deregister_client(
				va_arg(arglist, client_handle_t));
		break;
	    case GetStatus:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_get_status(ch,
				va_arg(arglist, get_status_t *));
		break;
	    case ResetFunction:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_reset_function(ch,
				va_arg(arglist, reset_function_t *));
		break;
	    case SetEventMask:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_set_event_mask(ch,
				va_arg(arglist, sockevent_t *));
		break;
	    case GetEventMask:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_get_event_mask(ch,
				va_arg(arglist, sockevent_t *));
		break;
	    case RequestIO:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_request_io(ch,
				va_arg(arglist, io_req_t *));
		break;
	    case ReleaseIO:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_release_io(ch,
				va_arg(arglist, io_req_t *));
		break;
	    case RequestIRQ:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_request_irq(ch,
				va_arg(arglist, irq_req_t *));
		break;
	    case ReleaseIRQ:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_release_irq(ch,
				va_arg(arglist, irq_req_t *));
		break;
	    case RequestWindow:
		ch = va_arg(arglist, client_handle_t);
		whp = va_arg(arglist, window_handle_t *);
		retcode = cs_request_window(ch, whp,
				va_arg(arglist, win_req_t *));
		break;
	    case ReleaseWindow:
		retcode = cs_release_window(
				va_arg(arglist, window_handle_t));
		break;
	    case ModifyWindow:
		wh = va_arg(arglist, window_handle_t);
		retcode = cs_modify_window(wh,
				va_arg(arglist, modify_win_t *));
		break;
	    case MapMemPage:
		wh = va_arg(arglist, window_handle_t);
		retcode = cs_map_mem_page(wh,
				va_arg(arglist, map_mem_page_t *));
		break;
	    case RequestSocketMask:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_request_socket_mask(ch,
				va_arg(arglist, request_socket_mask_t *));
		break;
	    case ReleaseSocketMask:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_release_socket_mask(ch,
				va_arg(arglist, release_socket_mask_t *));
		break;
	    case RequestConfiguration:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_request_configuration(ch,
				va_arg(arglist, config_req_t *));
		break;
	    case GetPhysicalAdapterInfo:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_get_physical_adapter_info(ch,
				va_arg(arglist, get_physical_adapter_info_t *));
		break;
	    case GetCardServicesInfo:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_get_cardservices_info(ch,
				va_arg(arglist, get_cardservices_info_t *));
		break;
	    case GetConfigurationInfo:
		chp = va_arg(arglist, client_handle_t *);
		retcode = cs_get_configuration_info(chp,
				va_arg(arglist, get_configuration_info_t *));
		break;
	    case ModifyConfiguration:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_modify_configuration(ch,
				va_arg(arglist, modify_config_t *));
		break;
	    case AccessConfigurationRegister:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_access_configuration_register(ch,
				va_arg(arglist, access_config_reg_t *));
		break;
	    case ReleaseConfiguration:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_release_configuration(ch,
				va_arg(arglist, release_config_t *));
		break;
	    case OpenMemory:
		cmn_err(CE_CONT, "CS: OpenMemory\n");
		break;
	    case ReadMemory:
		cmn_err(CE_CONT, "CS: ReadMemory\n");
		break;
	    case WriteMemory:
		cmn_err(CE_CONT, "CS: WriteMemory\n");
		break;
	    case CopyMemory:
		cmn_err(CE_CONT, "CS: CopyMemory\n");
		break;
	    case RegisterEraseQueue:
		cmn_err(CE_CONT, "CS: RegisterEraseQueue\n");
		break;
	    case CheckEraseQueue:
		cmn_err(CE_CONT, "CS: CheckEraseQueue\n");
		break;
	    case DeregisterEraseQueue:
		cmn_err(CE_CONT, "CS: DeregisterEraseQueue\n");
		break;
	    case CloseMemory:
		cmn_err(CE_CONT, "CS: CloseMemory\n");
		break;
	    case GetFirstRegion:
		cmn_err(CE_CONT, "CS: GetFirstRegion\n");
		break;
	    case GetNextRegion:
		cmn_err(CE_CONT, "CS: GetNextRegion\n");
		break;
	    case GetFirstPartition:
		cmn_err(CE_CONT, "CS: GetFirstPartition\n");
		break;
	    case GetNextPartition:
		cmn_err(CE_CONT, "CS: GetNextPartition\n");
		break;
	    case ReturnSSEntry:
		cmn_err(CE_CONT, "CS: ReturnSSEntry\n");
		break;
	    case MapLogSocket:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_map_log_socket(ch,
				va_arg(arglist, map_log_socket_t *));
		break;
	    case MapPhySocket:
		cmn_err(CE_CONT, "CS: MapPhySocket\n");
		break;
	    case MapLogWindow:
		cmn_err(CE_CONT, "CS: MapLogWindow\n");
		break;
	    case MapPhyWindow:
		cmn_err(CE_CONT, "CS: MapPhyWindow\n");
		break;
	    case RegisterMTD:
		cmn_err(CE_CONT, "CS: RegisterMTD\n");
		break;
	    case RegisterTimer:
		cmn_err(CE_CONT, "CS: RegisterTimer\n");
		break;
	    case SetRegion:
		cmn_err(CE_CONT, "CS: SetRegion\n");
		break;
	    case RequestExclusive:
		cmn_err(CE_CONT, "CS: RequestExclusive\n");
		break;
	    case ReleaseExclusive:
		cmn_err(CE_CONT, "CS: ReleaseExclusive\n");
		break;
	    case GetFirstClient:
		retcode = cs_get_firstnext_client(
				va_arg(arglist, get_firstnext_client_t *),
				CS_GET_FIRST_FLAG);
		break;
	    case GetNextClient:
		retcode = cs_get_firstnext_client(
				va_arg(arglist, get_firstnext_client_t *),
				CS_GET_NEXT_FLAG);
		break;
	    case GetClientInfo:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_get_client_info(ch,
				va_arg(arglist, client_info_t *));
		break;
	    case AddSocketServices:
		cmn_err(CE_CONT, "CS: AddSocketServices\n");
		break;
	    case ReplaceSocketServices:
		cmn_err(CE_CONT, "CS: ReplaceSocketServices\n");
		break;
	    case VendorSpecific:
		cmn_err(CE_CONT, "CS: VendorSpecific\n");
		break;
	    case AdjustResourceInfo:
		cmn_err(CE_CONT, "CS: AdjustResourceInfo\n");
		break;
	    case ValidateCIS:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_validate_cis(ch,
				va_arg(arglist, cisinfo_t *));
		break;
	    case GetFirstTuple:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_get_firstnext_tuple(ch,
				va_arg(arglist, tuple_t *),
				CS_GET_FIRST_FLAG);
		break;
	    case GetNextTuple:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_get_firstnext_tuple(ch,
				va_arg(arglist, tuple_t *),
				CS_GET_NEXT_FLAG);
		break;
	    case GetTupleData:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_get_tuple_data(ch,
				va_arg(arglist, tuple_t *));
		break;
	    case ParseTuple:
		ch = va_arg(arglist, client_handle_t);
		tuple = va_arg(arglist, tuple_t *);
		cisparse = va_arg(arglist, cisparse_t *);
		retcode = cs_parse_tuple(ch, tuple, cisparse,
				va_arg(arglist, uint_t));
		break;
	    case MakeDeviceNode:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_make_device_node(ch,
				va_arg(arglist, make_device_node_t *));
		break;
	    case RemoveDeviceNode:
		ch = va_arg(arglist, client_handle_t);
		retcode = cs_remove_device_node(ch,
				va_arg(arglist, remove_device_node_t *));
		break;
	    case ConvertSpeed:
		retcode = cs_convert_speed(
				va_arg(arglist, convert_speed_t *));
		break;
	    case ConvertSize:
		retcode = cs_convert_size(
				va_arg(arglist, convert_size_t *));
		break;
	    case Event2Text:
		retcode = cs_event2text(
				va_arg(arglist, event2text_t *), 1);
		break;
	    case Error2Text: {
		error2text_t *cft;

		cft = va_arg(arglist, error2text_t *);
		(void) strcpy(cft->text,
				cs_error2text(cft->item, CSFUN2TEXT_RETURN));
		retcode = CS_SUCCESS;
		}
		break;
	    case CS_DDI_Info:
		retcode = cs_ddi_info(va_arg(arglist, cs_ddi_info_t *));
		break;
	    case CS_Sys_Ctl:
		retcode = cs_sys_ctl(va_arg(arglist, cs_sys_ctl_t *));
		break;
	    default:
		cmn_err(CE_CONT, "CS: {unknown function %d}\n", function);
		break;
	} /* switch(function) */

	va_end(arglist);

#ifdef	CS_DEBUG
	if (cs_debug > 127) {
	    cmn_err(CE_CONT, "CardServices: returning %s (0x%x)\n",
				cs_error2text(retcode, CSFUN2TEXT_RETURN),
				retcode);
	}
#endif

	return (retcode);
}

/*
 * ==== tuple and CIS handling section ====
 */

/*
 * cs_parse_tuple - This function supports the CS ParseTuple function call.
 *
 *    returns:	CS_SUCCESS - if tuple parsed sucessfully
 *		CS_NO_CARD - if no card in socket
 *		CS_BAD_ARGS - if passed CIS list pointer is NULL
 *		CS_UNKNOWN_TUPLE - if unknown tuple passed to CIS parser
 *		CS_BAD_CIS - if generic parser error
 *		CS_NO_CIS - if no CIS for card/function
 *
 *    See notes for the cs_get_firstnext_tuple function.
 */
static int
cs_parse_tuple(client_handle_t client_handle, tuple_t *tuple,
				cisparse_t *cisparse, cisdata_t cisdata)
{
	cs_socket_t *sp;
	client_t *client;
	uint32_t fn;
	int ret;

	if ((ret = cs_get_socket(client_handle, &tuple->Socket,
					&fn, &sp, &client)) != CS_SUCCESS)
	    return (ret);

	/*
	 * If there's no card in the socket or the card in the socket is not
	 *	for this client, then return an error.
	 */
	if (!(client->flags & CLIENT_CARD_INSERTED))
	    return (CS_NO_CARD);

	/*
	 * Sanity check to be sure that we've got a non-NULL CIS list
	 *	pointer.
	 */
	if (!(tuple->CISOffset))
	    return (CS_BAD_ARGS);

	mutex_enter(&sp->cis_lock);

	/*
	 * Check to see if there is a valid CIS for this function.
	 *	There is an implicit assumption here that if this
	 *	is a multi-function CIS and the specified function
	 *	number is not CS_GLOBAL_CIS that in order for there
	 *	to be a valid function-specific CIS, there also must
	 *	be a valid global CIS. This means that we don't need
	 *	to know whether this tuple came from the global CIS
	 *	or from the function-specific CIS.
	 */
	if ((sp->cis_flags & CW_VALID_CIS) &&
				(sp->cis[fn].flags & CW_VALID_CIS)) {
	    ret = (int)(uintptr_t)CIS_PARSER(CISP_CIS_PARSE_TUPLE,
				cis_cistpl_std_callout,
				tuple->CISOffset,
				(tuple->Attributes & TUPLE_RETURN_NAME)?
							HANDTPL_RETURN_NAME:
							HANDTPL_PARSE_LTUPLE,
				cisparse, cisdata);
	    mutex_exit(&sp->cis_lock);
	    if (ret == CISTPLF_UNKNOWN)
		return (CS_UNKNOWN_TUPLE);
	    if (ret != CISTPLF_NOERROR)
		return (CS_BAD_CIS);
	    ret = CS_SUCCESS;
	} else {
	    mutex_exit(&sp->cis_lock);
	    ret = CS_NO_CIS;
	} /* if (CW_VALID_CIS) */

	return (ret);
}

/*
 * cs_get_firstnext_tuple - returns the first/next tuple of the specified type
 *				this is to support the GetFirstTuple and
 *				GetNextTuple function call
 *
 *    flags - one of:
 *		CS_GET_FIRST_FLAG causes function to support GetFirstTuple
 *		CS_GET_NEXT_FLAG causes function to support GetNextTuple
 *
 *	tuple_t->Attributes flags:
 *		TUPLE_RETURN_LINK - XXX Not implemented, see notes below.
 *		TUPLE_RETURN_IGNORED_TUPLES - return tuples with
 *				CISTPLF_IGNORE_TUPLE set in the
 *				cistpl_t->flags member.
 *
 *    Notes for regular PC card driver callers:
 *
 *	On a single-function card, the caller will get back all the tuples in
 *	the CIS.
 *
 *	On a multi-function card, the caller will get the tuples from the
 *	global CIS followed by the tuples in the function-specific CIS. The
 *	caller will not get any tuples from a function-specific CIS that
 *	does not belong to the caller's function.
 *
 *    Notes for Socket Services, the "super-client" or CSI driver callers:
 *
 *	On a single-function card, the operation is the same as for regular
 *	PC card driver callers with the addition that if the function number
 *	is set to CS_GLOBAL_CIS this function will return CS_NO_CIS.
 *
 *	On a multi-function card, the operation is the same as for regular
 *	PC card driver callers with the addition that if the function number
 *	is set to CS_GLOBAL_CIS the caller will only get tuples from the
 *	global CIS. If a particular function nubmer does not exist, this
 *	function will return CS_NO_CIS for that function.
 *
 *    General notes:
 *
 *	On both a single-function card and a multi-function card, if the tuple
 *	comes from the global CIS chain, the CISTPLF_GLOBAL_CIS flag will be
 *	set in the tuple_t->flags member.
 *
 *	On a multi-function card, if the tuple comes from the function-specific
 *	CIS chain, the CISTPLF_MF_CIS flag will be set in the tuple_t->flags
 *	member.
 *
 *	For other flags that are set in the tuple_t->flags member, see the
 *	comments for the cis_list_lcreate function in the cis.c file.
 *
 *	The CIS parser may not include all the tuples that are in the CIS in
 *	the private CIS list that it creates and maintains. See the CIS
 *	parser documentation for a list of tuples that the parser does not
 *	include in the list.
 *
 *	If a tuple has the CISTPLF_IGNORE_TUPLE flag set and the flags
 *	parameter CIS_GET_LTUPLE_IGNORE is not set, that tuple will not
 *	be returned to the caller. Instead, the next tuple that matches
 *	the calling criteria will be returned (or NULL if no other tuples
 *	match the calling criteria). If CIS_GET_LTUPLE_IGNORE is set in
 *	the flags paramter, tuples in the CIS list that match the calling
 *	criteria will be returned.
 *
 * XXX The PC Card 95 Standard says that if the TUPLE_RETURN_LINK flag in
 *	the tuple_t->Attributes member is not set, then we don't return
 *	any of the link tuples. This function ignores this flag and always
 *	returns link tuples.
 *
 *    Return codes:
 *		CS_SUCCESS - if tuple sucessfully found and returned
 *		CS_NO_CARD - if no card inserted
 *		CS_NO_CIS - if no CIS for the specified card/function
 *		CS_NO_MORE_ITEMS - if tuple not found or no more tuples
 *					to return
 *
 *    See notes for cs_get_socket for a description of valid client, socket
 *	and function number combinations.
 */
static int
cs_get_firstnext_tuple(client_handle_t client_handle,
    tuple_t *tuple, uint32_t flags)
{
	cs_socket_t *sp;
	client_t *client;
	uint32_t fn;
	int ret;

	if ((ret = cs_get_socket(client_handle, &tuple->Socket, &fn,
						&sp, &client)) != CS_SUCCESS)
	    return (ret);

	/*
	 * If there's no card in the socket or the card in the socket is not
	 *	for this client, then return an error.
	 */
	if (!(client->flags & CLIENT_CARD_INSERTED))
	    return (CS_NO_CARD);

	mutex_enter(&sp->cis_lock);

	/*
	 * If there's no CIS on this card or no CIS for the specified
	 *	function, then we can't do much.
	 */
	if ((!(sp->cis_flags & CW_VALID_CIS)) ||
				(!(sp->cis[fn].flags & CW_VALID_CIS))) {
	    mutex_exit(&sp->cis_lock);
	    return (CS_NO_CIS);
	}

	/*
	 * This will set the CIS_GET_LTUPLE_IGNORE flag if the
	 *	TUPLE_RETURN_IGNORED_TUPLES flag is set. The
	 *	assumption here is that the CIS_GET_LTUPLE_IGNORE
	 *	flag and the TUPLE_RETURN_IGNORED_TUPLES flag
	 *	shares the same bit position. If this ever changes,
	 *	we'll ahve to re-work this section of code.
	 */
	if (tuple->Attributes & TUPLE_RETURN_IGNORED_TUPLES)
	    flags |= CIS_GET_LTUPLE_IGNORE;

	/*
	 * Are we GetFirstTuple or GetNextTuple?
	 */
	if ((flags & CIS_GET_LTUPLE_OPMASK) & CS_GET_FIRST_FLAG) {
	/*
	 * Initialize the tuple structure; we need this information when
	 *	we have to process a GetNextTuple or ParseTuple call.
	 * If this card has a multi-function CIS, then we always start out
	 *	delivering tuples from the global CIS chain. If this card does
	 *	not have a multi-function CIS, then the function 0 CIS chain
	 *	will contain the complete CIS list.
	 * If this is a multi-function card, then use the GET_FIRST_LTUPLE
	 *	macro to return the first tuple in the CIS list - we do this
	 *	since we don't want to return tuples with CISTPLF_IGNORE_TUPLE
	 *	set unless CIS_GET_LTUPLE_IGNORE is set in the flags parameter.
	 * Note that we don't have to cross over into the fucntion-specific
	 *	CIS chain if GET_FIRST_LTUPLE returns NULL, since a MF CIS will
	 *	always have at least a CISTPL_LONGLINK_MFC tuple in the global
	 *	CIS chain - the test for NULL is just a sanity check.
	 */
	    if (sp->cis_flags & CW_MULTI_FUNCTION_CIS) {
		if ((tuple->CISOffset =
			GET_FIRST_LTUPLE(sp->cis[CS_GLOBAL_CIS].cis,
							flags)) == NULL) {
		    mutex_exit(&sp->cis_lock);
		    return (CS_NO_MORE_ITEMS);
		} /* GET_FIRST_LTUPLE */
	    } else {
		tuple->CISOffset = sp->cis[0].cis;
	    } /* CW_MULTI_FUNCTION_CIS */
	} else {
	    cistpl_t *tp;

		/*
		 * Check to be sure that we have a non-NULL tuple list pointer.
		 *	This is necessary in the case where the caller calls us
		 *	with get next tuple requests but we don't have any more
		 *	tuples to give back.
		 */
	    if (tuple->CISOffset == NULL) {
		mutex_exit(&sp->cis_lock);
		return (CS_NO_MORE_ITEMS);
	    }

		/*
		 * Point to the next tuple in the list.  If we're searching for
		 *	a particular tuple, FIND_LTUPLE_FWD will find it.
		 *
		 * If there are no more tuples in the chain that we're looking
		 *	at, then if we're looking at the global portion of a
		 *	multi-function CIS, switch to the function-specific list
		 *	and start looking there.
		 */
	    if ((tp = GET_NEXT_TUPLE(tuple->CISOffset, flags)) == NULL) {
		if (sp->cis_flags & CW_MULTI_FUNCTION_CIS) {
		    if ((tuple->CISOffset->flags & CISTPLF_GLOBAL_CIS) &&
							(fn != CS_GLOBAL_CIS)) {
			tp = GET_FIRST_LTUPLE(sp->cis[fn].cis, flags);
		    } /* CISTPLF_GLOBAL_CIS */
		} /* CW_MULTI_FUNCTION_CIS */
	    } /* GET_NEXT_TUPLE */

		/*
		 * If there are no more tuples in the chain, then return.
		 */
	    if ((tuple->CISOffset = tp) == NULL) {
		mutex_exit(&sp->cis_lock);
		return (CS_NO_MORE_ITEMS);
	    }
	} /* CS_GET_FIRST_FLAG */

	/*
	 * Check if we want to get the first of a particular type of tuple
	 *	or just the first tuple in the chain.
	 * If there are no more tuples of the type we're searching for in
	 *	the chain that we're looking at, then if we're looking at
	 *	the global portion of a multi-function CIS, switch to the
	 *	function-specific list and start looking there.
	 */
	if (tuple->DesiredTuple != RETURN_FIRST_TUPLE) {
	    cistpl_t *tp;

	    if ((tp = FIND_LTUPLE_FWD(tuple->CISOffset,
					tuple->DesiredTuple, flags)) == NULL) {
		if (sp->cis_flags & CW_MULTI_FUNCTION_CIS) {
		    if ((tuple->CISOffset->flags & CISTPLF_GLOBAL_CIS) &&
							(fn != CS_GLOBAL_CIS)) {
			tp = FIND_FIRST_LTUPLE(sp->cis[fn].cis,
						tuple->DesiredTuple, flags);
		    } /* CISTPLF_GLOBAL_CIS */
		} /* CW_MULTI_FUNCTION_CIS */
	    } /* FIND_LTUPLE_FWD */

		/*
		 * If there are no more tuples in the chain, then return.
		 */
	    if ((tuple->CISOffset = tp) == NULL) {
		mutex_exit(&sp->cis_lock);
		return (CS_NO_MORE_ITEMS);
	    }
	} /* !RETURN_FIRST_TUPLE */

	/*
	 * We've got a tuple, now fill out the rest of the tuple_t
	 *	structure.  Callers can use the flags member to
	 *	determine whether or not the tuple data was copied
	 *	to the linked list or if it's still on the card.
	 */
	tuple->Flags = tuple->CISOffset->flags;
	tuple->TupleCode = tuple->CISOffset->type;
	tuple->TupleLink = tuple->CISOffset->len;
	tuple->TupleDataLen = tuple->CISOffset->len;

	mutex_exit(&sp->cis_lock);

	return (CS_SUCCESS);
}

/*
 * cs_get_tuple_data - get the data portion of a tuple; this is to
 *	support the GetTupleData function call.
 *
 *    Note that if the data body of a tuple was not read from the CIS,
 *	then this function will return CS_NO_MORE_ITEMS.
 *
 *    For flags that are set in the tuple_t->flags member, see the
 *	comments for the cis_list_lcreate function in the cis.c file.
 *	These flags are copied into the tuple_t->flags member by the
 *	cs_get_firstnext_tuple function call.
 *
 *    See notes for the cs_get_firstnext_tuple function.
 */
static int
cs_get_tuple_data(client_handle_t client_handle, tuple_t *tuple)
{
	cs_socket_t *sp;
	client_t *client;
	int ret, nbytes;
	uint32_t fn, flags;
	cisdata_t *tsd, *tdd;
	uint32_t newoffset;
	acc_handle_t cis_handle;

	if ((ret = cs_get_socket(client_handle, &tuple->Socket, &fn,
						&sp, &client)) != CS_SUCCESS)
	    return (ret);

	/*
	 * If there's no card in the socket or the card in the socket is not
	 *	for this client, then return an error.
	 */
	if (!(client->flags & CLIENT_CARD_INSERTED))
	    return (CS_NO_CARD);

	mutex_enter(&sp->cis_lock);

	if ((sp->cis_flags & CW_VALID_CIS) &&
				(sp->cis[fn].flags & CW_VALID_CIS)) {

		/*
		 * Check to be sure that we have a non-NULL pointer to
		 *	a CIS list.
		 */
	    if (!(tuple->CISOffset)) {
		mutex_exit(&sp->cis_lock);
		return (CS_NO_MORE_ITEMS);
	    }

	/*
	 * Since the tuple data buffer that the caller calls us with
	 *	is preallocated in the tuple_t structure, we ignore any
	 *	TupleDataMax value that the caller has setup and use the
	 *	actual size of the tuple data buffer in the structure.
	 */
	    tuple->TupleDataMax = sizeof (tuple->TupleData);

	/*
	 * Make sure the requested offset is not past the end of the
	 *	tuple data body nor past the end of the user-supplied
	 *	buffer.
	 */
	    if ((int)tuple->TupleOffset >= min((int)tuple->TupleLink,
						(int)tuple->TupleDataMax)) {
		mutex_exit(&sp->cis_lock);
		return (CS_NO_MORE_ITEMS);
	    }

	    tuple->TupleDataLen = tuple->TupleLink;

	    if ((nbytes = min((int)tuple->TupleDataMax -
						(int)tuple->TupleOffset,
						(int)tuple->TupleDataLen -
						(int)tuple->TupleOffset)) < 1) {
		mutex_exit(&sp->cis_lock);
		return (CS_BAD_ARGS);
	    }

	/*
	 * The tuple data destination is always the tuple_t->TupleData
	 *	buffer in the tuple_t structure no matter where we read the
	 *	tuple data from.
	 */
	    tdd = tuple->TupleData;
	    bzero((caddr_t)tdd, sizeof (tuple->TupleData));

	/*
	 * Do we have a copy of the tuple data?  If not, we have to
	 *	get a pointer to the CIS and read the tuple data from the
	 *	card itself.
	 */
	    switch (tuple->CISOffset->flags & CISTPLF_SPACE_MASK) {
		case CISTPLF_LM_SPACE:
		    tsd = (tuple->CISOffset->data +
					(unsigned)tuple->TupleOffset);
		    while (nbytes--)
			*tdd++ = *tsd++;
		    break;
		case CISTPLF_AM_SPACE:
		case CISTPLF_CM_SPACE:
		    newoffset = tuple->CISOffset->offset;

		/*
		 * Setup the proper space flags as well as setup the
		 *	address offset to point to the start of the tuple
		 *	data area; we need to do the latter since the
		 *	cis_store_cis_addr function in cis.c sets up the
		 *	tuple->CISOffset->offset offset to point to the
		 *	start of the tuple.
		 */
		    if (tuple->CISOffset->flags & CISTPLF_AM_SPACE) {
			flags = CISTPLF_AM_SPACE;
			newoffset += ((tuple->TupleOffset * 2) + 4);
		    } else {
			flags = CISTPLF_CM_SPACE;
			newoffset += (tuple->TupleOffset + 2);
		    }

		    if (cs_init_cis_window(sp, &newoffset, &cis_handle,
							flags) != CS_SUCCESS) {
			mutex_exit(&sp->cis_lock);
			cmn_err(CE_CONT, "cs_get_tuple_data: socket %d "
						"can't init CIS window\n",
							sp->socket_num);
			return (CS_GENERAL_FAILURE);
		    } /* cs_init_cis_window */
		    while (nbytes--) {
			*tdd++ = csx_Get8(cis_handle, newoffset++);
			if (tuple->CISOffset->flags & CISTPLF_AM_SPACE)
			    newoffset++;
		    } /* while */
		    break;
		default:
		    mutex_exit(&sp->cis_lock);
		    return (CS_GENERAL_FAILURE);
	    } /* switch */

	    ret = CS_SUCCESS;
	} else {
	    ret = CS_NO_CIS;
	} /* if (CW_VALID_CIS) */

	mutex_exit(&sp->cis_lock);

	return (ret);
}

/*
 * cs_validate_cis - validates the CIS on a card in the given socket; this
 *			is to support the ValidateCIS function call.
 *
 *    Notes for regular PC card driver callers:
 *
 *	Regular PC card drivers calling ValidateCIS will get the meaning of
 *	the structure members as specified in the standard.
 *
 *    Notes for Socket Services, the "super-client" or CSI driver callers:
 *
 *		with: Function Number = CS_GLOBAL_CIS
 *
 *	For a single-function card, CS_NO_CIS will be returned and the
 *	cisinfo_t->Chains and cisinfo_t->Tuples members will be set to 0.
 *
 *	For a multi-function card, cisinfo_t->Chains will contain a count of
 *	the number of CIS chains in the global portion of the CIS, and
 *	cisinfo_t->Tuples will contain a count of the number of tuples in
 *	the global portion of the CIS.
 *
 *		with: 0 <= Function Number < CIS_MAX_FUNCTIONS
 *
 *	For a single-function card, if the function number is equal to 0 and
 *	has a CIS, cisinfo_t->Chains will contain a count of the number of
 *	CIS chains in the CIS, and cisinfo_t->Tuples will contain a count of
 *	the number of tuples in the CIS. If the card does not have a CIS, or
 *	if the function number is not equal to 0, CS_NO_CIS will be returned
 *	and the cisinfo_t->Chains and cisinfo_t->Tuples members will be set
 *	to 0.
 *
 *	For a multi-function card, cisinfo_t->Chains will contain a count of
 *	the number of CIS chains in the global and function-specific
 *	portions of the CIS, and cisinfo_t->Tuples will contain a count of
 *	the number of tuples in the global and function-specific portions of
 *	the CIS. If the function does not exist or has no CIS, CS_NO_CIS
 *	will be returned and the cisinfo_t->Chains and cisinfo_t->Tuples
 *	members will be set to 0.
 *
 *    General notes:
 *
 *	If the card does not have a CIS, or if the function does not exist
 *	or has no CIS, CS_NO_CIS will be returned and the cisinfo_t->Chains
 *	and cisinfo_t->Tuples members will be set to 0.
 *
 *	Most of the work of validating the CIS has already been done by the
 *	CIS parser module, so we don't have to do much here except for
 *	looking at the various flags and tuple/chain counts that were already
 *	setup by the CIS parser.
 *
 *    See notes for the cs_get_firstnext_tuple function.
 */
static int
cs_validate_cis(client_handle_t client_handle, cisinfo_t *cisinfo)
{
	cs_socket_t *sp;
	client_t *client;
	uint32_t fn;
	int ret;

	if ((ret = cs_get_socket(client_handle, &cisinfo->Socket, &fn,
						&sp, &client)) != CS_SUCCESS)
	    return (ret);

	/*
	 * If there's no card in the socket or the card in the socket is not
	 *	for this client, then return an error.
	 */
	if (!(client->flags & CLIENT_CARD_INSERTED))
	    return (CS_NO_CARD);

	mutex_enter(&sp->cis_lock);
	if ((sp->cis_flags & CW_VALID_CIS) &&
				(sp->cis[fn].flags & CW_VALID_CIS)) {
	    cisinfo->Chains = sp->cis[fn].nchains;
	    cisinfo->Tuples = sp->cis[fn].ntuples;

	    if ((fn != CS_GLOBAL_CIS) &&
			(sp->cis[CS_GLOBAL_CIS].flags & CW_VALID_CIS)) {
		cisinfo->Chains += sp->cis[CS_GLOBAL_CIS].nchains;
		cisinfo->Tuples += sp->cis[CS_GLOBAL_CIS].ntuples;
	    } /* !CS_GLOBAL_CIS */

	    ret = CS_SUCCESS;
	} else {
	    cisinfo->Chains = 0;
	    cisinfo->Tuples = 0;
	    ret = CS_NO_CIS;
	}
	mutex_exit(&sp->cis_lock);

	return (ret);
}

/*
 * cs_init_cis_window - initializes the CIS window for the passed socket
 *
 *	calling: *sp - pointer to the per-socket structure
 *		 *offset - offset from start of AM or CM space
 *		 *hp - pointer to acc_handle_t to store modified
 *				window access handle in
 *		 flags - one of:
 *				CISTPLF_AM_SPACE - set window to AM space
 *				CISTPLF_CM_SPACE - set window to CM space
 *
 *	returns: CS_SUCCESS if CIS window was set up
 *		 *offset - contains adjusted offset to use to access
 *				requested space
 *		 CS_BAD_WINDOW if CIS window could not be setup
 *		 CS_GENERAL_FAILURE if socket has a CIS window number
 *					but the window flags are wrong
 *
 *	Note: This function will check to be sure that there is a valid
 *		CIS window allocated to this socket.
 *	      If there is an error in setting up the window hardware, the
 *		CIS window information for this socket is cleared.
 *	      This function is also used by routines that need to get
 *		a pointer to the base of AM space to access the card's
 *		configuration registers.
 *	      The passed offset is the un-window-size-aligned offset.
 */
int
cs_init_cis_window(cs_socket_t *sp, uint32_t *offset,
    acc_handle_t *hp, uint32_t flags)
{
	set_window_t sw;
	get_window_t gw;
	inquire_window_t iw;
	set_page_t set_page;
	cs_window_t *cw;

	/*
	 * Check to be sure that we have a valid CIS window
	 */
	if (!SOCKET_HAS_CIS_WINDOW(sp)) {
	    cmn_err(CE_CONT,
			"cs_init_cis_window: socket %d has no CIS window\n",
				sp->socket_num);
	    return (CS_BAD_WINDOW);
	}

	/*
	 * Check to be sure that this window is allocated for CIS use
	 */
	if ((cw = cs_get_wp(sp->cis_win_num)) == NULL)
	    return (CS_BAD_WINDOW);

	if (!(cw->state & CW_CIS)) {
	    cmn_err(CE_CONT,
		"cs_init_cis_window: socket %d invalid CIS window state 0x%x\n",
				sp->socket_num, cw->state);
	    return (CS_BAD_WINDOW);
	}

	/*
	 * Get the characteristics of this window - we use this to
	 *	determine whether we need to re-map the window or
	 *	just move the window offset on the card.
	 */
	iw.window = sp->cis_win_num;
	SocketServices(SS_InquireWindow, &iw);

	/*
	 * We've got a window, now set up the hardware. If we've got
	 *	a variable sized window, then all we need to do is to
	 *	get a valid mapping to the base of the window using
	 *	the current window size; if we've got a fixed-size
	 *	window, then we need to get a mapping to the window
	 *	starting at offset zero of the window.
	 */
	if (iw.mem_win_char.MemWndCaps & WC_SIZE) {
	    sw.WindowSize = sp->cis_win_size;
	    set_page.offset = ((*offset / sp->cis_win_size) *
						sp->cis_win_size);
	} else {
	    set_page.offset = ((*offset / iw.mem_win_char.MinSize) *
						iw.mem_win_char.MinSize);
	    sw.WindowSize = (((*offset & ~(PAGESIZE - 1)) &
					(set_page.offset - 1)) + PAGESIZE);
	}

	/*
	 * Return a normalized base offset; this takes care of the case
	 *	where the required offset is greater than the window size.
	 * BugID 1236404
	 *	code was:
	 *		*offset = *offset & (set_page.offset - 1);
	 */
	*offset = *offset - set_page.offset;

#ifdef	CS_DEBUG
	if (cs_debug > 1)
	    cmn_err(CE_CONT, "cs_init_cis_window: WindowSize 0x%x "
							"offset 0x%x\n",
							(int)sw.WindowSize,
							(int)set_page.offset);
	if (cs_debug > 1)
	    cmn_err(CE_CONT, "\t*offset = 0x%x space = %s\n",
							(int)*offset,
					(flags & CISTPLF_AM_SPACE)?
					"CISTPLF_AM_SPACE":"CISTPLF_CM_SPACE");
#endif

	sw.window = sp->cis_win_num;
	sw.socket = sp->socket_num;
	sw.state = (WS_ENABLED | WS_EXACT_MAPIN);
	sw.attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
	sw.attr.devacc_attr_endian_flags = DDI_NEVERSWAP_ACC;
	sw.attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;

	/*
	 * The PCMCIA SS spec specifies this be expressed in
	 *	a device speed format per 5.2.7.1.3 but
	 *	our implementation of SS_SetWindow uses
	 *	actual nanoseconds.
	 */
	sw.speed = CIS_DEFAULT_SPEED;
	sw.base = 0;
	/*
	 * Set up the window - if this fails, then just set the
	 *	CIS window number back to it's initialized value so
	 *	that we'll fail when we break out of the loop.
	 */
	if (SocketServices(SS_SetWindow, &sw) != SUCCESS) {
	    sp->cis_win_num = PCMCIA_MAX_WINDOWS;
	    cw->state = 0; /* XXX do we really want to do this? */
	    return (CS_BAD_WINDOW);
	} else {
		set_page.window = sp->cis_win_num;
		set_page.page = 0;
		set_page.state = PS_ENABLED;
		if (flags & CISTPLF_AM_SPACE)
		    set_page.state |= PS_ATTRIBUTE;

		if (SocketServices(SS_SetPage, &set_page) != SUCCESS) {
		    sp->cis_win_num = PCMCIA_MAX_WINDOWS;
		    cw->state = 0; /* XXX do we really want to do this? */
		    return (CS_BAD_WINDOW);
		} /* if (SS_SetPage) */
	} /* if (SS_SetWindow) */

	/*
	 * Get the window information for the CIS window for this socket.
	 */
	gw.window = sp->cis_win_num;
	gw.socket = sp->socket_num; /* XXX - SS_GetWindow should set this */
	if (SocketServices(SS_GetWindow, &gw) != SUCCESS)
	    return (CS_BAD_WINDOW);

	*hp = (acc_handle_t)gw.handle;

	return (CS_SUCCESS);
}

/*
 * ==== client registration/deregistration section ====
 */

/*
 * cs_register_client - This supports the RegisterClient call.
 *
 * Upon successful registration, the client_handle_t * handle argument will
 *	contain the new client handle and we return CS_SUCCESS.
 */
static int
cs_register_client(client_handle_t *ch, client_reg_t *cr)
{
	uint32_t sn;
	int super_client = 0;
	sclient_reg_t *scr = cr->priv;
	struct sclient_list_t *scli;

	/*
	 * See if we're not supposed to register any new clients.
	 */
	if (cs_globals.init_state & GLOBAL_INIT_STATE_NO_CLIENTS)
	    return (CS_OUT_OF_RESOURCE);

	/*
	 * Do a version check - if the client expects a later version of
	 *	Card Services than what we are, return CS_BAD_VERSION.
	 * XXX - How do we specify just a PARTICULAR version of CS??
	 */
	if (CS_VERSION < cr->Version)
	    return (CS_BAD_VERSION);

	/*
	 * Check to be sure that the client has given us a valid set of
	 *	client type flags.  We also use this opportunity to see
	 *	if the registering client is Socket Services or is a
	 *	"super-client" or a CSI client.
	 *
	 * Note that SS can not set any flag in the Attributes field other
	 *	than the INFO_SOCKET_SERVICES flag.
	 *
	 * Valid combinations of cr->Attributes and cr->EventMask flags:
	 *
	 *  for Socket Services:
	 *	cr->Attributes:
	 *	    set:
	 *		INFO_SOCKET_SERVICES
	 *	    clear:
	 *		{all other flags}
	 *	cr->EventMask:
	 *	    don't care:
	 *		{all flags}
	 *
	 *  for regular clients:
	 *	cr->Attributes:
	 *	    only one of:
	 *		INFO_IO_CLIENT
	 *		INFO_MTD_CLIENT
	 *		INFO_MEM_CLIENT
	 *	    don't care:
	 *		INFO_CARD_SHARE
	 *		INFO_CARD_EXCL
	 *	cr->EventMask:
	 *	    clear:
	 *		CS_EVENT_ALL_CLIENTS
	 *	    don't care:
	 *		{all other flags}
	 *
	 *  for CSI clients:
	 *	cr->Attributes:
	 *	    set:
	 *		INFO_IO_CLIENT
	 *		INFO_CSI_CLIENT
	 *	    clear:
	 *		INFO_MTD_CLIENT
	 *		INFO_MEM_CLIENT
	 *	    don't care:
	 *		INFO_CARD_SHARE
	 *		INFO_CARD_EXCL
	 *	cr->EventMask:
	 *	    don't care:
	 *		{all flags}
	 *
	 *  for "super-clients":
	 *	cr->Attributes:
	 *	    set:
	 *		INFO_IO_CLIENT
	 *		INFO_MTD_CLIENT
	 *		INFO_SOCKET_SERVICES
	 *		INFO_CARD_SHARE
	 *	    clear:
	 *		INFO_MEM_CLIENT
	 *		INFO_CARD_EXCL
	 *	cr->EventMask:
	 *	    don't care:
	 *		{all flags}
	 */
	switch (cr->Attributes & INFO_CLIENT_TYPE_MASK) {
	/*
	 * Check first to see if this is Socket Services registering; if
	 *	so, we don't do anything but return the client handle that is
	 *	in the global SS client.
	 */
	    case INFO_SOCKET_SERVICES:
		*ch = cs_socket_services_client.client_handle;
		return (CS_SUCCESS);
		/* NOTREACHED */
	    /* CSI clients */
	    case (INFO_CSI_CLIENT | INFO_IO_CLIENT):
		break;
	    /* regular clients */
	    case INFO_IO_CLIENT:
	    case INFO_MTD_CLIENT:
	    case INFO_MEM_CLIENT:
		if (cr->EventMask & CS_EVENT_ALL_CLIENTS)
		    return (CS_BAD_ATTRIBUTE);
		break;
	    /* "super-client" clients */
	    case (INFO_IO_CLIENT | INFO_MTD_CLIENT | INFO_SOCKET_SERVICES):
		if ((!(cr->Attributes & INFO_CARD_SHARE)) ||
				(cr->Attributes & INFO_CARD_EXCL))
		    return (CS_BAD_ATTRIBUTE);
		/*
		 * We only allow one "super-client" per system.
		 */
		mutex_enter(&cs_globals.global_lock);
		if (cs_globals.flags & GLOBAL_SUPER_CLIENT_REGISTERED) {
		    mutex_exit(&cs_globals.global_lock);
		    return (CS_NO_MORE_ITEMS);
		}
		cs_globals.flags |= GLOBAL_SUPER_CLIENT_REGISTERED;
		mutex_exit(&cs_globals.global_lock);
		super_client = CLIENT_SUPER_CLIENT;
		break;
	    default:
		return (CS_BAD_ATTRIBUTE);
	} /* switch (cr->Attributes) */

	/*
	 * Now, actually create the client node on the socket; this will
	 *	also return the new client handle if there were no errors
	 *	creating the client node.
	 * The DIP2SOCKET_NUM macro will return the socket and function
	 *	number using the encoding specified in the cs_priv.h file.
	 */
	if (super_client != CLIENT_SUPER_CLIENT) {
	    if (cr->Attributes & INFO_CSI_CLIENT)
		sn = (uint32_t)(uintptr_t)cr->priv;
	    else
		sn = DIP2SOCKET_NUM(cr->dip);
	    return (cs_add_client_to_socket(sn, ch, cr, super_client));
	} /* CLIENT_SUPER_CLIENT */

	/*
	 * This registering client is a "super-client", so we create one
	 *	client node for each socket in the system.  We use the
	 *	client_reg_t.priv structure member to point to a struct
	 *	that the "super-client" client knows about.  The client
	 *	handle pointer is not used in this case.
	 * We return CS_SUCCESS if at least one client node could be
	 *	created.  The client must check the error codes in the
	 *	error code array to determine which clients could not
	 *	be created on which sockets.
	 * We return CS_BAD_HANDLE if no client nodes could be created.
	 */
	scr->num_clients = 0;
	scr->max_socket_num = cs_globals.max_socket_num;
	scr->num_sockets = cs_globals.num_sockets;
	scr->num_windows = cs_globals.num_windows;

	*(scr->sclient_list) = cs_globals.sclient_list;

	for (sn = 0; sn < scr->num_sockets; sn++) {
	    scli = scr->sclient_list[sn];
	    if ((scli->error = cs_add_client_to_socket(sn, &scli->client_handle,
					    cr, super_client)) == CS_SUCCESS) {
		scr->num_clients++;
	    }
	}

	/*
	 * If we couldn't create any client nodes at all, then
	 *	return an error.
	 */
	if (!scr->num_clients) {
	/*
	 * XXX - The global superclient lock now gets
	 * cleared in cs_deregister_client
	 */
	    /* cs_clear_superclient_lock(super_client); */
	    return (CS_BAD_HANDLE);
	}

	return (CS_SUCCESS);
}

/*
 * cs_add_client_to_socket - this function creates the client node on the
 *				requested socket.
 *
 * Note that if we return an error, there is no state that can be cleaned
 *	up.  The only way that we can return an error with allocated resources
 *	would be if one of the client handle functions had an internal error.
 *	Since we wouldn't get a valid client handle in this case anyway, there
 *	would be no way to find out what was allocated and what wasn't.
 */
static int
cs_add_client_to_socket(unsigned sn, client_handle_t *ch,
					client_reg_t *cr, int super_client)
{
	cs_socket_t *sp;
	client_t *client, *cclp;
	int error, cie = 1;
	int client_lock_acquired;

	if (cr->event_handler == NULL)
	    return (CS_BAD_ARGS);

	if ((sp = cs_get_sp(sn)) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 * Run through all of the registered clients and compare the passed
	 *	dip to the dip of each client to make sure that this client
	 *	is not trying to register more than once.  If they are, then
	 *	display a message and return an error.
	 * XXX - we should really check all the sockets in case the client
	 *	manipulates the instance number in the dip.
	 * XXX - if we check each socket, we ned to also check for the
	 *	"super-client" since it will use the same dip for all
	 *	of it's client nodes.
	 */
	mutex_enter(&sp->lock);
	client = sp->client_list;
	while (client) {
	    if (!(cr->Attributes & INFO_CSI_CLIENT) &&
						(client->dip == cr->dip)) {
		mutex_exit(&sp->lock);
		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		cmn_err(CE_CONT, "cs_add_client_to_socket: socket %d "
					"function 0x%x\n"
					"\tclient already registered with "
					"handle 0x%x\n",
						(int)CS_GET_SOCKET_NUMBER(sn),
						(int)CS_GET_FUNCTION_NUMBER(sn),
						(int)client->client_handle);
		return (CS_BAD_HANDLE);
	    }
	    client = client->next;
	} /* while (client) */
	mutex_exit(&sp->lock);

	/*
	 * Create a unique client handle then make sure that we can find it.
	 *	This has the side effect of getting us a pointer to the
	 *	client structure as well.
	 * Create a client list entry - cs_create_client_handle will use this
	 *	as the new client node.
	 * We do it here so that we can grab the sp->lock mutex for the
	 *	duration of our manipulation of the client list.
	 * If this function fails, then it will not have added the newly
	 *	allocated client node to the client list on this socket,
	 *	so we have to free the node that we allocated.
	 */
	cclp = (client_t *)kmem_zalloc(sizeof (client_t), KM_SLEEP);

	mutex_enter(&sp->lock);
	if (!(*ch = cs_create_client_handle(sn, cclp))) {
	    mutex_exit(&sp->lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    kmem_free(cclp, sizeof (client_t));
	    return (CS_OUT_OF_RESOURCE);
	}

	/*
	 *  Make sure that this is a valid client handle.  We should never
	 *	fail this since we just got a valid client handle.
	 * If this fails, then we have an internal error so don't bother
	 *	trying to clean up the allocated client handle since the
	 *	whole system is probably hosed anyway and will shortly
	 *	esplode.
	 * It doesn't make sense to call cs_deregister_client at this point
	 *	to clean up this broken client since the deregistration
	 *	code will also call cs_find_client and most likely fail.
	 */
	if (!(client = cs_find_client(*ch, &error))) {
	    mutex_exit(&sp->lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    cmn_err(CE_CONT, "cs_add_client_to_socket: socket %d function 0x%x "
				"invalid client handle created handle 0x%x\n",
						(int)CS_GET_SOCKET_NUMBER(sn),
						(int)CS_GET_FUNCTION_NUMBER(sn),
						(int)*ch);
	    return (error);
	}

	/*
	 * Save the DDI information.
	 */
	client->dip = cr->dip;
	cr->driver_name[MODMAXNAMELEN - 1] = NULL;
	client->driver_name = (char *)kmem_zalloc(strlen(cr->driver_name) + 1,
								KM_SLEEP);
	(void) strcpy(client->driver_name, cr->driver_name);
	client->instance = ddi_get_instance(cr->dip);

	/*
	 * Copy over the interesting items that the client gave us.
	 */
	client->flags = (cr->Attributes & INFO_CLIENT_TYPE_MASK);
	client->event_callback_handler = cr->event_handler;
	bcopy((caddr_t)&cr->event_callback_args,
				(caddr_t)&client->event_callback_args,
				sizeof (event_callback_args_t));
	/*
	 * Set the client handle since the client needs a client handle
	 *	when they call us for their event handler.
	 */
	client->event_callback_args.client_handle = *ch;

	/*
	 * Initialize the IO window numbers; if an IO window number is equal
	 *	to PCMCIA_MAX_WINDOWS it means that IO range is not in use.
	 */
	client->io_alloc.Window1 = PCMCIA_MAX_WINDOWS;
	client->io_alloc.Window2 = PCMCIA_MAX_WINDOWS;

	/*
	 * Give the client the iblock and idevice cookies to use in
	 *	the client's event handler high priority mutex.
	 */
	cr->iblk_cookie = sp->iblk;
	cr->idev_cookie = sp->idev;

	/*
	 * Set up the global event mask information; we copy this directly
	 *	from the client; since we are the only source of events,
	 *	any bogus bits that the client puts in here won't matter
	 *	because we'll never look at them.
	 */
	client->global_mask = cr->EventMask;

	/*
	 * If this client registered as a CSI client, set the appropriate
	 *	flag in the client's flags area.
	 */
	if (cr->Attributes & INFO_CSI_CLIENT)
	    client->flags |= CLIENT_CSI_CLIENT;

	/*
	 * If this client registered as a "super-client" set the appropriate
	 *	flag in the client's flags area.
	 */
	if (super_client == CLIENT_SUPER_CLIENT)
	    client->flags |= CLIENT_SUPER_CLIENT;

	/*
	 * Save other misc information that this client gave us - it is
	 *	used in the GetClientInfo function.
	 */
	client->flags |= (cr->Attributes & INFO_CARD_FLAGS_MASK);

	/*
	 * Determine if we should give artificial card insertion events and
	 *	a registration complete event. Since we don't differentiate
	 *	between sharable and exclusive use cards when giving clients
	 *	event notification, we modify the definition of the share/excl
	 *	flags as follows:
	 *
	 *	    If either INFO_CARD_SHARE or INFO_CARD_EXCL is set,
	 *	    the client will receive artificial card insertion
	 *	    events (if the client's card is currently in the
	 *	    socket) and a registration complete event.
	 *
	 *	    If neither of the INFO_CARD_SHARE or INFO_CARD_EXCL is
	 *	    set, the client will not receive an artificial card
	 *	    insertion event nor a registration complete event
	 *	    due to the client's call to register client.
	 *
	 *	    The client's event mask is not affected by the setting
	 *	    of these two bits.
	 */
	if (cr->Attributes & (INFO_CARD_SHARE | INFO_CARD_EXCL))
	    client->pending_events = CS_EVENT_REGISTRATION_COMPLETE;

	/*
	 * Check to see if the card for this client is currently in
	 *	the socket. If it is, then set CLIENT_CARD_INSERTED
	 *	since clients that are calling GetStatus at attach
	 *	time will typically check to see if their card is
	 *	currently installed.
	 * If this is the CSI client, we also need to check to see
	 *	if there is any card inserted in the socket, since
	 *	the cs_card_for_client function will always return
	 *	TRUE for a CSI client.
	 * XXX What about super-clients?
	 */
	if (client->flags & CLIENT_CSI_CLIENT) {
	    get_ss_status_t get_ss_status;

	    get_ss_status.socket = sp->socket_num;

	    if (SocketServices(SS_GetStatus, &get_ss_status) != SUCCESS) {
		mutex_exit(&sp->lock);
		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		return (CS_BAD_SOCKET);
	    } /* SS_GetStatus */

	    if (!(cs_sbm2cse(get_ss_status.CardState) &
			CS_EVENT_CARD_INSERTION))
		cie = 0;

	} /* CLIENT_CSI_CLIENT */

	if (cs_card_for_client(client) && (cie != 0)) {
	    client->pending_events |= CS_EVENT_CARD_INSERTION;
	    client->flags |= CLIENT_CARD_INSERTED;
	} /* cs_card_for_client */

	sp->num_clients++;
	mutex_exit(&sp->lock);
	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);

	return (CS_SUCCESS);
}

/*
 * cs_deregister_client - This supports the DeregisterClient call.
 */
static int
cs_deregister_client(client_handle_t client_handle)
{
	cs_socket_t *sp;
	client_t *client;
	int error, super_client = 0;
	int client_lock_acquired;

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't do anything except for return success.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_SUCCESS);

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (error);
	}

	/*
	 * Make sure that any resources allocated by this client are
	 *	not still allocated, and that if this is an MTD that
	 *	no MTD operations are still in progress.
	 */
	if (client->flags &    (CLIENT_IO_ALLOCATED	|
				CLIENT_IRQ_ALLOCATED	|
				CLIENT_WIN_ALLOCATED	|
				REQ_CONFIGURATION_DONE	|
				REQ_SOCKET_MASK_DONE	|
				REQ_IO_DONE		|
				REQ_IRQ_DONE)) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_BUSY);
	}

	if (client->flags & CLIENT_MTD_IN_PROGRESS) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_IN_USE);
	}

	/*
	 * Any previously allocated resources are not allocated anymore, and
	 *	no MTD operations are in progress, so if this is an MTD client
	 *	then do any MTD-specific client deregistration, and then
	 *	nuke this client.
	 * We expect cs_deregister_mtd to never fail.
	 */
	if (client->flags & INFO_MTD_CLIENT)
	    (void) cs_deregister_mtd(client_handle);

	if (client->flags & CLIENT_SUPER_CLIENT)
	    super_client = CLIENT_SUPER_CLIENT;

	kmem_free(client->driver_name, strlen(client->driver_name) + 1);

	error = cs_destroy_client_handle(client_handle);

	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);

	/*
	 * If this was the "super-client" deregistering, then this
	 *	will clear the global "super-client" lock.
	 * XXX - move this outside the per-socket code.
	 */
	cs_clear_superclient_lock(super_client);

	return (error);
}

/*
 * cs_create_next_client_minor - returns the next available client minor
 *					number or 0 if none available
 *
 * Note that cs_find_client will always return a valid pointer to the
 *	global Socket Services client which has a client minor number
 *	of 0; this means that this function can never return a 0 as the
 *	next valid available client minor number.
 */
unsigned
cs_create_next_client_minor(unsigned socket_num, unsigned next_minor)
{
	unsigned max_client_handles = cs_max_client_handles;

	do {
	    next_minor &= CS_MAX_CLIENTS_MASK;
	    if (!cs_find_client(MAKE_CLIENT_HANDLE(
					CS_GET_SOCKET_NUMBER(socket_num),
					CS_GET_FUNCTION_NUMBER(socket_num),
							next_minor), NULL)) {
		return (next_minor);
	    }
	    next_minor++;
	} while (max_client_handles--);

	return (0);
}

/*
 * cs_find_client - finds the client pointer associated with the client handle
 *			or NULL if client not found
 *
 * returns:	(client_t *)NULL - if client not found or an error occured
 *					If the error argument is not NULL,
 *					it is set to:
 *			CS_BAD_SOCKET - socket number in client_handle_t is
 *						invalid
 *			CS_BAD_HANDLE - client not found
 *			If no error, the error argument is not modified.
 *		(client_t *) - pointer to client_t structure
 *
 * Note that each socket always has a pseudo client with a client minor number
 *	of 0; this client minor number is used for Socket Services access to
 *	Card Services functions. The client pointer returned for client minor
 *	number 0 is the global Socket Services client pointer.
 */
static client_t *
cs_find_client(client_handle_t client_handle, int *error)
{
	cs_socket_t *sp;
	client_t *clp;

	/*
	 * If we are being asked to see if a client with a minor number
	 *	of 0 exists, always return a pointer to the global Socket
	 *	Services client, since this client always exists, and is
	 *	only for use by Socket Services.  There is no socket
	 *	associated with this special client handle.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (&cs_socket_services_client);

	/*
	 * Check to be sure that the socket number is in range
	 */
	if (!(CHECK_SOCKET_NUM(GET_CLIENT_SOCKET(client_handle),
					cs_globals.max_socket_num))) {
	    if (error)
		*error = CS_BAD_SOCKET;
	    return (NULL);
	}

	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL) {
	    if (error)
		*error = CS_BAD_SOCKET;
	    return (NULL);
	}

	clp = sp->client_list;

	while (clp) {
	    if (clp->client_handle == client_handle)
		return (clp);
	    clp = clp->next;
	}

	if (error)
	    *error = CS_BAD_HANDLE;

	return (NULL);
}

/*
 * cs_destroy_client_handle - destroys client handle and client structure of
 *				passed client handle
 *
 * returns:	CS_SUCCESS - if client handle sucessfully destroyed
 *		CS_BAD_HANDLE - if client handle is invalid or if trying
 *					to destroy global SS client
 *		{other errors} - other errors from cs_find_client()
 */
static int
cs_destroy_client_handle(client_handle_t client_handle)
{
	client_t *clp;
	cs_socket_t *sp;
	int error = CS_BAD_HANDLE;

	/*
	 * See if we were passed a valid client handle or if we're being asked
	 *	to destroy the Socket Services client
	 */
	if ((!(clp = cs_find_client(client_handle, &error))) ||
			(CLIENT_HANDLE_IS_SS(client_handle)))
	    return (error);

	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	/*
	 * Recycle this client's minor number.  This will most likely
	 *	be the next client minor number we use, but it is also
	 *	a hint to cs_create_client_handle, and that function
	 *	may actually create a new client handle using a minor
	 *	number different that this number.
	 */
	mutex_enter(&sp->lock);
	sp->next_cl_minor = GET_CLIENT_MINOR(client_handle);

	/*
	 * See if we're the first or not in the client list; if we're
	 *	not first, then just adjust the client behind us to
	 *	point to the client ahead of us; this could be NULL
	 *	if we're the last client in the list.
	 */
	if (clp->prev) {
	    clp->prev->next = clp->next;
	} else {
	/*
	 * We are first, so adjust the client list head pointer
	 *	in the socket to point to the client structure that
	 *	follows us; this could turn out to be NULL if we're
	 *	the only client on this socket.
	 */
	    sp->client_list = clp->next;
	}

	/*
	 * If we're not the last client in the list, point the next
	 *	client to the client behind us; this could turn out
	 *	to be NULL if we're the first client on this socket.
	 */
	if (clp->next)
	    clp->next->prev = clp->prev;

	sp->num_clients--;
	mutex_exit(&sp->lock);

	/*
	 * Free this client's memory.
	 */
	kmem_free(clp, sizeof (client_t));

	return (CS_SUCCESS);
}

/*
 * cs_create_client_handle - create a new client handle for the passed
 *				socket and function number
 *
 * returns:	0 -  if can't create client for some reason
 *		client_handle_t - new client handle
 */
static client_handle_t
cs_create_client_handle(unsigned socket_num, client_t *cclp)
{
	client_t *clp;
	cs_socket_t *sp;
	unsigned next_minor;
	client_handle_t client_handle;

	if ((sp = cs_get_sp(socket_num)) == NULL)
	    return (0);

	/*
	 * Get the next available minor number that we can use.  We use the
	 *	next_cl_minor number as a hint to cs_create_next_client_minor
	 *	and in most cases this will be the minor number we get back.
	 * If for some reason we can't get a minor number, return an error.
	 *	The only way we could get an error would be if there are
	 *	already the maximum number of clients for this socket. Since
	 *	the maximum number of clients per socket is pretty large,
	 *	this error is unlikely to occur.
	 */
	if (!(next_minor =
		cs_create_next_client_minor(socket_num, sp->next_cl_minor)))
	    return (0);

	/*
	 * Got a new client minor number, now create a new client handle.
	 */
	client_handle = MAKE_CLIENT_HANDLE(CS_GET_SOCKET_NUMBER(socket_num),
					CS_GET_FUNCTION_NUMBER(socket_num),
					next_minor);

	/*
	 * If this client handle exists, then we have an internal
	 *	error; this should never happen, BTW.  This is really
	 *	a double-check on the cs_create_next_client_minor
	 *	function, which also calls cs_find_client.
	 */
	if (cs_find_client(client_handle, NULL)) {
	    cmn_err(CE_CONT,
		"cs_create_client_handle: duplicate client handle 0x%x\n",
							(int)client_handle);
	    return (0);
	}

	/*
	 * If we don't have any clients on this socket yet, create
	 *	a new client and hang it on the socket client list.
	 */
	if (!sp->client_list) {
	    sp->client_list = cclp;
	    clp = sp->client_list;
	} else {
	/*
	 * There are other clients on this socket, so look for
	 *	the last client and add our new client after it.
	 */
	    clp = sp->client_list;
	    while (clp->next) {
		clp = clp->next;
	    }

	    clp->next = cclp;
	    clp->next->prev = clp;
	    clp = clp->next;
	} /* if (!sp->client_list) */

	/*
	 * Assign the new client handle to this new client structure.
	 */
	clp->client_handle = client_handle;

	/*
	 * Create the next available client minor number for this socket
	 *	and save it away.
	 */
	sp->next_cl_minor =
		cs_create_next_client_minor(socket_num, sp->next_cl_minor);

	return (client_handle);
}

/*
 * cs_clear_superclient_lock - clears the global "super-client" lock
 *
 * Note: this function uses the cs_globals.global_lock so observe proper
 *		nexting of locks!!
 */
static void
cs_clear_superclient_lock(int super_client)
{

	/*
	 * If this was a "super-client" registering then we need
	 *	to clear the GLOBAL_SUPER_CLIENT_REGISTERED flag
	 *	so that other "super-clients" can register.
	 */
	if (super_client == CLIENT_SUPER_CLIENT) {
	    mutex_enter(&cs_globals.global_lock);
	    cs_globals.flags &= ~GLOBAL_SUPER_CLIENT_REGISTERED;
	    mutex_exit(&cs_globals.global_lock);
	}
}

/*
 * ==== event handling section ====
 */

/*
 * cs_event - CS event hi-priority callback handler
 *
 *	This function gets called by SS and is passed the event type in
 *		the "event" argument, and the socket number in the "sn"
 *		argument. The "sn" argument is a valid logical socket
 *		number for all events except the PCE_SS_READY event.
 *
 *	The PCE_SS_INIT_STATE, PCE_ADD_SOCKET and PCE_DROP_SOCKET events
 *		are never called at high priority. These events return
 *		the following return codes:
 *
 *			CS_SUCCESS - operation sucessful
 *			CS_BAD_SOCKET - unable to complete operation
 *			CS_UNSUPPORTED_FUNCTION - bad subfunction of
 *							PCE_SS_INIT_STATE
 *
 *		The caller MUST look at these return codes!
 *
 *	This function is called at high-priority interrupt time for standard
 *		Card Services events, and the only standard Card Services
 *		event that it handles directly is the CS_EVENT_CARD_REMOVAL
 *		event, which gets shuttled right into the client's event
 *		handler.  All other events are just queued up and the socket
 *		event thread is woken up via the soft interrupt handler.
 *	Note that CS_EVENT_CARD_INSERTION events are not set in the clients'
 *		event field, since the CS card insertion/card ready processing
 *		code is responsible for setting this event in a client's
 *		event field.
 *
 */
/*ARGSUSED*/
uint32_t
cs_event(event_t event, uint32_t sn, uint32_t arg)
{
	client_t *client;
	cs_socket_t *sp;
	client_types_t *ct;
	uint32_t ret = CS_SUCCESS;

	/*
	 * Handle special SS<->CS events
	 */
	switch (event) {
	    case PCE_SS_INIT_STATE:
		mutex_enter(&cs_globals.global_lock);
		switch (sn) {
		    case PCE_SS_STATE_INIT:
			if ((ret = cs_ss_init()) == CS_SUCCESS)
			    cs_globals.init_state |= GLOBAL_INIT_STATE_SS_READY;
			break;
		    case PCE_SS_STATE_DEINIT:
			cs_globals.init_state &= ~GLOBAL_INIT_STATE_SS_READY;
			break;
		    default:
			ret = CS_UNSUPPORTED_FUNCTION;
			cmn_err(CE_CONT, "cs_event: PCE_SS_INIT_STATE invalid "
						"directive: 0x%x\n", sn);
			break;
		} /* switch (sn) */
		mutex_exit(&cs_globals.global_lock);
		return (ret);
	    case PCE_ADD_SOCKET:
		return (cs_add_socket(sn));
	    case PCE_DROP_SOCKET:
		return (cs_drop_socket(sn));
	} /* switch (event) */

	if ((sp = cs_get_sp(sn)) == NULL)
	    return (CS_BAD_SOCKET);

	/*
	 * Check to see if CS wants to unload - we do this since it's possible
	 *	to disable certain sockets.  Do NOT acquire any locks yet.
	 */
	if (sp->flags & SOCKET_UNLOAD_MODULE) {
	    if (event == PCE_CARD_INSERT)
		cmn_err(CE_CONT, "PCMCIA: socket %d disabled - please "
							"remove card\n", sn);
	    return (CS_SUCCESS);
	}

	mutex_enter(&sp->lock);

#ifdef	CS_DEBUG
	if (cs_debug > 1) {
	    event2text_t event2text;

	    event2text.event = event;
	    (void) cs_event2text(&event2text, 0);
	    cmn_err(CE_CONT, "cs_event: event=%s (x%x), socket=0x%x\n",
				event2text.text, (int)event, (int)sn);
	}
#endif

	/*
	 * Convert SS events to CS events; handle the PRR if necessary.
	 */
	sp->events |= ss_to_cs_events(sp, event);

	/*
	 * We want to maintain the required event dispatching order as
	 *	specified in the PCMCIA spec, so we cycle through all
	 *	clients on this socket to make sure that they are
	 *	notified in the correct order of any high-priority
	 *	events.
	 */
	ct = &client_types[0];
	while (ct) {
	/*
	 * Point to the head of the client list for this socket, and go
	 *	through each client to set up the client events as well as
	 *	call the client's event handler directly if we have a high
	 *	priority event that we need to tell the client about.
	 */
	    client = sp->client_list;

	    if (ct->order & CLIENT_EVENTS_LIFO) {
		client_t *clp = NULL;

		while (client) {
		    clp = client;
		    client = client->next;
		}
		client = clp;
	    }

	    while (client) {
		client->events |= ((sp->events & ~CS_EVENT_CARD_INSERTION) &
				    (client->event_mask | client->global_mask));
		if (client->flags & ct->type) {
#ifdef	CS_DEBUG
		    if (cs_debug > 1) {
			cmn_err(CE_CONT, "cs_event: socket %d client [%s] "
						"events 0x%x flags 0x%x\n",
						sn, client->driver_name,
						(int)client->events,
						(int)client->flags);
		    }
#endif

		/*
		 * Handle the suspend and card removal events
		 *	specially here so that the client can receive
		 *	these events at high-priority.
		 */
		    if (client->events & CS_EVENT_PM_SUSPEND) {
			if (client->flags & CLIENT_CARD_INSERTED) {
			    CLIENT_EVENT_CALLBACK(client, CS_EVENT_PM_SUSPEND,
							CS_EVENT_PRI_HIGH);
			} /* if (CLIENT_CARD_INSERTED) */
			client->events &= ~CS_EVENT_PM_SUSPEND;
		    } /* if (CS_EVENT_PM_SUSPEND) */

		    if (client->events & CS_EVENT_CARD_REMOVAL) {
			if (client->flags & CLIENT_CARD_INSERTED) {
			    client->flags &= ~(CLIENT_CARD_INSERTED |
						CLIENT_SENT_INSERTION);
			    CLIENT_EVENT_CALLBACK(client,
							CS_EVENT_CARD_REMOVAL,
							CS_EVENT_PRI_HIGH);
			/*
			 * Check to see if the client wants low priority
			 *	removal events as well.
			 */
			    if ((client->event_mask | client->global_mask) &
						CS_EVENT_CARD_REMOVAL_LOWP) {
				client->events |= CS_EVENT_CARD_REMOVAL_LOWP;
			    }
			} /* if (CLIENT_CARD_INSERTED) */
			client->events &= ~CS_EVENT_CARD_REMOVAL;
		    } /* if (CS_EVENT_CARD_REMOVAL) */

		} /* if (ct->type) */
		if (ct->order & CLIENT_EVENTS_LIFO) {
		    client = client->prev;
		} else {
		    client = client->next;
		}
	    } /* while (client) */

	    ct = ct->next;
	} /* while (ct) */

	/*
	 * Set the SOCKET_NEEDS_THREAD flag so that the soft interrupt
	 *	handler will wakeup this socket's event thread.
	 */
	if (sp->events)
	    sp->flags |= SOCKET_NEEDS_THREAD;

	/*
	 * Fire off a soft interrupt that will cause the socket thread
	 *	to be woken up and any remaining events to be sent to
	 *	the clients on this socket.
	 */
	if ((sp->init_state & SOCKET_INIT_STATE_SOFTINTR) &&
			!(cs_globals.init_state & GLOBAL_INIT_STATE_UNLOADING))
	    ddi_trigger_softintr(sp->softint_id);

	mutex_exit(&sp->lock);

	return (CS_SUCCESS);
}

/*
 * cs_card_insertion - handle card insertion and card ready events
 *
 * We read the CIS, if present, and store it away, then tell SS that
 *	we have read the CIS and it's ready to be parsed.  Since card
 *	insertion and card ready events are pretty closely intertwined,
 *	we handle both here.  For card ready events that are not the
 *	result of a card insertion event, we expect that the caller has
 *	already done the appropriate processing and that we will not be
 *	called unless we received a card ready event right after a card
 *	insertion event, i.e. that the SOCKET_WAIT_FOR_READY flag in
 *	sp->thread_state was set or if we get a CARD_READY event right
 *	after a CARD_INSERTION event.
 *
 *    calling:	sp - pointer to socket structure
 *		event - event to handle, one of:
 *				CS_EVENT_CARD_INSERTION
 *				CS_EVENT_CARD_READY
 *				CS_EVENT_SS_UPDATED
 */
static int
cs_card_insertion(cs_socket_t *sp, event_t event)
{
	int ret;

	/*
	 * Since we're only called while waiting for the card insertion
	 *	and card ready sequence to occur, we may have a pending
	 *	card ready timer that hasn't gone off yet if we got a
	 *	real card ready event.
	 */
	UNTIMEOUT(sp->rdybsy_tmo_id);

#ifdef	CS_DEBUG
	if (cs_debug > 1) {
	    cmn_err(CE_CONT, "cs_card_insertion: event=0x%x, socket=0x%x\n",
						(int)event, sp->socket_num);
	}
#endif

	/*
	 * Handle card insertion processing
	 */
	if (event & CS_EVENT_CARD_INSERTION) {
	    set_socket_t set_socket;
	    get_ss_status_t gs;

	/*
	 * Check to be sure that we have a valid CIS window
	 */
	    if (!SOCKET_HAS_CIS_WINDOW(sp)) {
		cmn_err(CE_CONT,
			"cs_card_insertion: socket %d has no "
							"CIS window\n",
				sp->socket_num);
		return (CS_GENERAL_FAILURE);
	    }

	/*
	 * Apply power to the socket, enable card detect and card ready
	 *	events, then reset the socket.
	 */
	    mutex_enter(&sp->lock);
	    sp->event_mask =   (CS_EVENT_CARD_REMOVAL   |
				CS_EVENT_CARD_READY);
	    mutex_exit(&sp->lock);
	    set_socket.socket = sp->socket_num;
	    set_socket.SCIntMask = (SBM_CD | SBM_RDYBSY);
	    set_socket.IREQRouting = 0;
	    set_socket.IFType = IF_MEMORY;
	    set_socket.CtlInd = 0; /* turn off controls and indicators */
	    set_socket.State = (unsigned)~0;	/* clear latched state bits */

	    (void) cs_convert_powerlevel(sp->socket_num, 50, VCC,
						&set_socket.VccLevel);
	    (void) cs_convert_powerlevel(sp->socket_num, 50, VPP1,
						&set_socket.Vpp1Level);
	    (void) cs_convert_powerlevel(sp->socket_num, 50, VPP2,
						&set_socket.Vpp2Level);

	    if ((ret = SocketServices(SS_SetSocket, &set_socket)) != SUCCESS) {
		cmn_err(CE_CONT,
		    "cs_card_insertion: socket %d SS_SetSocket failure %d\n",
				sp->socket_num, ret);
		return (ret);
	    }

	/*
	 * Clear the ready and ready_timeout events since they are now
	 *	bogus since we're about to reset the socket.
	 * XXX - should these be cleared right after the RESET??
	 */
	    mutex_enter(&sp->lock);

	    sp->events &= ~(CS_EVENT_CARD_READY | CS_EVENT_READY_TIMEOUT);
	    mutex_exit(&sp->lock);

	    SocketServices(SS_ResetSocket, sp->socket_num,
						RESET_MODE_CARD_ONLY);

	/*
	 * We are required by the PCMCIA spec to wait some number of
	 *	milliseconds after reset before we access the card, so
	 *	we set up a timer here that will wake us up and allow us
	 *	to continue with our card initialization.
	 */
	    mutex_enter(&sp->lock);
	    sp->thread_state |= SOCKET_RESET_TIMER;
	    (void) timeout(cs_ready_timeout, sp,
		drv_usectohz(cs_reset_timeout_time * 1000));
	    cv_wait(&sp->reset_cv, &sp->lock);
	    sp->thread_state &= ~SOCKET_RESET_TIMER;
	    mutex_exit(&sp->lock);

#ifdef	CS_DEBUG
	    if (cs_debug > 2) {
		cmn_err(CE_CONT, "cs_card_insertion: socket %d out of RESET "
		    "for %d mS sp->events 0x%x\n",
		    sp->socket_num, cs_reset_timeout_time, (int)sp->events);
	    }
#endif

	/*
	 * If we have a pending CS_EVENT_CARD_REMOVAL event it
	 *	means that we likely got CD line bounce on the
	 *	insertion, so terminate this processing.
	 */
	    if (sp->events & CS_EVENT_CARD_REMOVAL) {
#ifdef	CS_DEBUG
		if (cs_debug > 0) {
		    cmn_err(CE_CONT, "cs_card_insertion: socket %d "
						"CS_EVENT_CARD_REMOVAL event "
						"terminating insertion "
						"processing\n",
							sp->socket_num);
		}
#endif
	    return (CS_SUCCESS);
	    } /* if (CS_EVENT_CARD_REMOVAL) */

	/*
	 * If we got a card ready event after the reset, then don't
	 *	bother setting up a card ready timer, since we'll blast
	 *	right on through to the card ready processing.
	 * Get the current card status to see if it's ready; if it
	 *	is, we probably won't get a card ready event.
	 */
	    gs.socket = sp->socket_num;
	    gs.CardState = 0;
	    if ((ret = SocketServices(SS_GetStatus, &gs)) != SUCCESS) {
		cmn_err(CE_CONT,
		    "cs_card_insertion: socket %d SS_GetStatus failure %d\n",
				sp->socket_num, ret);
		return (ret);
	    }

	    mutex_enter(&sp->lock);
	    if ((sp->events & CS_EVENT_CARD_READY) ||
					(gs.CardState & SBM_RDYBSY)) {
		event = CS_EVENT_CARD_READY;
#ifdef	CS_DEBUG
		if (cs_debug > 1) {
		    cmn_err(CE_CONT, "cs_card_insertion: socket %d card "
						"READY\n", sp->socket_num);
		}
#endif

	    } else {
#ifdef	CS_DEBUG
		if (cs_debug > 1) {
		    cmn_err(CE_CONT, "cs_card_insertion: socket %d setting "
					"READY timer\n", sp->socket_num);
		}
#endif

		sp->rdybsy_tmo_id = timeout(cs_ready_timeout, sp,
		    READY_TIMEOUT_TIME);
		sp->thread_state |= SOCKET_WAIT_FOR_READY;

	    } /* if (CS_EVENT_CARD_READY) */

	    mutex_exit(&sp->lock);

	} /* if (CS_EVENT_CARD_INSERTION) */

	/*
	 * Handle card ready processing.  This is only card ready processing
	 *	for card ready events in conjunction with a card insertion.
	 */
	if (event == CS_EVENT_CARD_READY) {
	    get_socket_t get_socket;
	    set_socket_t set_socket;

	/*
	 * The only events that we want to see now are card removal
	 *	events.
	 */
	    mutex_enter(&sp->lock);
	    sp->event_mask = CS_EVENT_CARD_REMOVAL;
	    mutex_exit(&sp->lock);
	    get_socket.socket = sp->socket_num;
	    if (SocketServices(SS_GetSocket, &get_socket) != SUCCESS) {
		cmn_err(CE_CONT,
			"cs_card_insertion: socket %d SS_GetSocket failed\n",
							sp->socket_num);
		return (CS_BAD_SOCKET);
	    }

	    set_socket.socket = sp->socket_num;
	    set_socket.SCIntMask = SBM_CD;
	    set_socket.VccLevel = get_socket.VccLevel;
	    set_socket.Vpp1Level = get_socket.Vpp1Level;
	    set_socket.Vpp2Level = get_socket.Vpp2Level;
	    set_socket.IREQRouting = get_socket.IRQRouting;
	    set_socket.IFType = get_socket.IFType;
	    set_socket.CtlInd = get_socket.CtlInd;
	    /* XXX (is ~0 correct here?) to reset latched values */
	    set_socket.State = (unsigned)~0;

	    if (SocketServices(SS_SetSocket, &set_socket) != SUCCESS) {
		cmn_err(CE_CONT,
			"cs_card_insertion: socket %d SS_SetSocket failed\n",
							sp->socket_num);

		return (CS_BAD_SOCKET);
	    }

		/*
		 * Grab the cis_lock mutex to protect the CIS-to-be and
		 *	the CIS window, then fire off the CIS parser to
		 *	create a local copy of the card's CIS.
		 */
		mutex_enter(&sp->cis_lock);

		if ((ret = cs_create_cis(sp)) != CS_SUCCESS) {
		    mutex_exit(&sp->cis_lock);
		    return (ret);
		}

		mutex_exit(&sp->cis_lock);

		/*
		 * If we have a pending CS_EVENT_CARD_REMOVAL event it
		 *	means that we likely got CD line bounce on the
		 *	insertion, so destroy the CIS and terminate this
		 *	processing. We'll get called back to handle the
		 *	insertion again later.
		 */
		if (sp->events & CS_EVENT_CARD_REMOVAL) {
		    mutex_enter(&sp->cis_lock);
		    (void) cs_destroy_cis(sp);
		    mutex_exit(&sp->cis_lock);
		} else {
			/*
			 * Schedule the call to the Socket Services work thread.
			 */
		    mutex_enter(&sp->ss_thread_lock);
		    sp->ss_thread_state |= SOCKET_THREAD_CSCISInit;
		    cv_broadcast(&sp->ss_thread_cv);
		    mutex_exit(&sp->ss_thread_lock);
		} /* if (CS_EVENT_CARD_REMOVAL) */
	} /* if (CS_EVENT_CARD_READY) */

	/*
	 * Socket Services has parsed the CIS and has done any other
	 *	work to get the client driver loaded and attached if
	 *	necessary, so setup the per-client state.
	 */
	if (event == CS_EVENT_SS_UPDATED) {
	    client_t *client;

	/*
	 * Now that we and SS are done handling the card insertion
	 *	semantics, go through each client on this socket and set
	 *	the CS_EVENT_CARD_INSERTION event in each client's event
	 *	field.  We do this here instead of in cs_event so that
	 *	when a client gets a CS_EVENT_CARD_INSERTION event, the
	 *	card insertion and ready processing has already been done
	 *	and SocketServices has had a chance to create a dip for
	 *	the card in this socket.
	 */
	    mutex_enter(&sp->lock);
	    client = sp->client_list;
	    while (client) {
		client->events |= (CS_EVENT_CARD_INSERTION &
				(client->event_mask | client->global_mask));
		client = client->next;
	    } /* while (client) */

	    mutex_exit(&sp->lock);

	} /* if (CS_EVENT_SS_UPDATED) */

	return (CS_SUCCESS);
}

/*
 * cs_card_removal - handle card removal events
 *
 * Destroy the CIS.
 *
 *    calling:	sp - pointer to socket structure
 *
 */
static int
cs_card_removal(cs_socket_t *sp)
{
	set_socket_t set_socket;
	int ret;

#ifdef	CS_DEBUG
	if (cs_debug > 0) {
	    cmn_err(CE_CONT, "cs_card_removal: socket %d\n", sp->socket_num);
	}
#endif

	/*
	 * Remove any pending card ready timer
	 */
	UNTIMEOUT(sp->rdybsy_tmo_id);

	/*
	 * Clear various flags so that everyone else knows that there's
	 *	nothing on this socket anymore.  Note that we clear the
	 *	SOCKET_CARD_INSERTED and SOCKET_IS_IO flags in the
	 *	ss_to_cs_events event mapping function.
	 */
	mutex_enter(&sp->lock);
	sp->thread_state &= ~(SOCKET_WAIT_FOR_READY | SOCKET_RESET_TIMER);

	/*
	 * Turn off socket power and set the socket back to memory mode.
	 * Disable all socket events except for CARD_INSERTION events.
	 */
	sp->event_mask = CS_EVENT_CARD_INSERTION;
	mutex_exit(&sp->lock);
	set_socket.socket = sp->socket_num;
	set_socket.SCIntMask = SBM_CD;
	set_socket.IREQRouting = 0;
	set_socket.IFType = IF_MEMORY;
	set_socket.CtlInd = 0; /* turn off controls and indicators */
	set_socket.State = (unsigned)~0;	/* clear latched state bits */

	(void) cs_convert_powerlevel(sp->socket_num, 0, VCC,
					&set_socket.VccLevel);
	(void) cs_convert_powerlevel(sp->socket_num, 0, VPP1,
					&set_socket.Vpp1Level);
	(void) cs_convert_powerlevel(sp->socket_num, 0, VPP2,
					&set_socket.Vpp2Level);

	if ((ret = SocketServices(SS_SetSocket, &set_socket)) != SUCCESS) {
	    cmn_err(CE_CONT,
		"cs_card_removal: socket %d SS_SetSocket failure %d\n",
				sp->socket_num, ret);
	    return (ret);
	}

#ifdef	CS_DEBUG
	if (cs_debug > 2) {
	    cmn_err(CE_CONT, "cs_card_removal: socket %d "
					"calling cs_destroy_cis\n",
							sp->socket_num);
	}
#endif

	/*
	 * Destroy the CIS and tell Socket Services that we're done
	 *	handling the card removal event.
	 */
	mutex_enter(&sp->cis_lock);
	(void) cs_destroy_cis(sp);
	mutex_exit(&sp->cis_lock);

#ifdef	CS_DEBUG
	if (cs_debug > 2) {
	    cmn_err(CE_CONT, "cs_card_removal: calling CSCardRemoved\n");
	}
#endif

	SocketServices(CSCardRemoved, sp->socket_num);

	return (CS_SUCCESS);
}

/*
 * ss_to_cs_events - convert Socket Services events to Card Services event
 *			masks; this function will not read the PRR if the
 *			socket is in IO mode; this happens in cs_event_thread
 *
 * This function returns a bit mask of events.
 *
 * Note that we do some simple hysterious on card insertion and card removal
 *	events to prevent spurious insertion and removal events from being
 *	propogated down the chain.
 */
static event_t
ss_to_cs_events(cs_socket_t *sp, event_t event)
{
	event_t revent = 0;

	switch (event) {
	    case PCE_CARD_STATUS_CHANGE:
		revent |= CS_EVENT_STATUS_CHANGE;
		break;
	    case PCE_CARD_REMOVAL:
		if (sp->flags & SOCKET_CARD_INSERTED) {
		    sp->flags &= ~(SOCKET_CARD_INSERTED | SOCKET_IS_IO);
		    revent |= CS_EVENT_CARD_REMOVAL;
			/*
			 * If we're processing a removal event, it makes
			 *	no sense to keep any insertion or ready events,
			 *	so nuke them here.  This will not clear any
			 *	insertion events in the per-client event field.
			 */
		    sp->events &= ~(CS_EVENT_CARD_INSERTION |
				    CS_EVENT_CARD_READY |
				    CS_EVENT_READY_TIMEOUT);

		/*
		 * We also don't need to wait for READY anymore since
		 *	it probably won't show up, or if it does, it will
		 *	be a bogus READY event as the card is sliding out
		 *	of the socket.  Since we never do a cv_wait on the
		 *	card ready timer, it's OK for that timer to either
		 *	never go off (via an UNTIMEOUT in cs_card_removal)
		 *	or to go off but not do a cv_broadcast (since the
		 *	SOCKET_WAIT_FOR_READY flag is cleared here).
		 */
		    sp->thread_state &= ~SOCKET_WAIT_FOR_READY;

		}
		break;
	    case PCE_CARD_INSERT:
		if (!(sp->flags & SOCKET_CARD_INSERTED)) {
		    sp->flags |= SOCKET_CARD_INSERTED;
		    revent |= CS_EVENT_CARD_INSERTION;
		}
		break;
	    case PCE_CARD_READY:
		if (sp->flags & SOCKET_CARD_INSERTED)
		    revent |= CS_EVENT_CARD_READY;
		break;
	    case PCE_CARD_BATTERY_WARN:
		if (sp->flags & SOCKET_CARD_INSERTED)
		    revent |= CS_EVENT_BATTERY_LOW;
		break;
	    case PCE_CARD_BATTERY_DEAD:
		if (sp->flags & SOCKET_CARD_INSERTED)
		    revent |= CS_EVENT_BATTERY_DEAD;
		break;
	    case PCE_CARD_WRITE_PROTECT:
		if (sp->flags & SOCKET_CARD_INSERTED)
		    revent |= CS_EVENT_WRITE_PROTECT;
		break;
	    case PCE_PM_RESUME:
		revent |= CS_EVENT_PM_RESUME;
		break;
	    case PCE_PM_SUSPEND:
		revent |= CS_EVENT_PM_SUSPEND;
		break;
	    default:
		cmn_err(CE_CONT, "ss_to_cs_events: unknown event 0x%x\n",
								(int)event);
		break;
	} /* switch(event) */

	return (revent);
}

/*
 * cs_ready_timeout - general purpose READY/BUSY and RESET timer
 *
 * Note that we really only expect one of the two events to be asserted when
 *	we are called.  XXX - Perhaps this might be a problem later on??
 *
 *	There is also the problem of cv_broadcast dropping the interrupt
 *	priority, even though we have our high-priority mutex held.  If
 *	we hold our high-priority mutex (sp->lock) over a cv_broadcast, and
 *	we get a high-priority interrupt during this time, the system will
 *	deadlock or panic.  Thanks to Andy Banta for finding this out in
 *	the SPC/S (stc.c) driver.
 *
 * This callback routine can not grab the sp->client_lock mutex or deadlock
 *	will result.
 */
void
cs_ready_timeout(void *arg)
{
	cs_socket_t *sp = arg;
	kcondvar_t *cvp = NULL;

	mutex_enter(&sp->lock);

	if (sp->thread_state & SOCKET_RESET_TIMER) {
#ifdef	CS_DEBUG
	if (cs_debug > 1) {
	    cmn_err(CE_CONT, "cs_ready_timeout: SOCKET_RESET_TIMER socket %d\n",
							sp->socket_num);
	}
#endif

	    cvp = &sp->reset_cv;
	}

	if (sp->thread_state & SOCKET_WAIT_FOR_READY) {
	    sp->events |= CS_EVENT_READY_TIMEOUT;
	    cvp = &sp->thread_cv;

#ifdef	CS_DEBUG
	    if (cs_debug > 1) {
		cmn_err(CE_CONT, "cs_ready_timeout: SOCKET_WAIT_FOR_READY "
						"socket %d\n", sp->socket_num);
	    }
#endif

	}

	mutex_exit(&sp->lock);

	if (cvp)
	    cv_broadcast(cvp);
}

/*
 * cs_event_softintr_timeout - wrapper function to call cs_socket_event_softintr
 */
/* ARGSUSED */
void
cs_event_softintr_timeout(void *arg)
{

	/*
	 * If we're trying to unload this module, then don't do
	 *	anything but exit.
	 * We acquire the cs_globals.global_lock mutex here so that
	 *	we can correctly synchronize with cs_deinit when it
	 *	is telling us to shut down. XXX - is this bogus??
	 */
	mutex_enter(&cs_globals.global_lock);
	if (!(cs_globals.init_state & GLOBAL_INIT_STATE_UNLOADING)) {
	    mutex_exit(&cs_globals.global_lock);
	    (void) cs_socket_event_softintr(NULL);
	    cs_globals.sotfint_tmo = timeout(cs_event_softintr_timeout,
		NULL, SOFTINT_TIMEOUT_TIME);
	} else {
	    mutex_exit(&cs_globals.global_lock);
	}
}

/*
 * cs_socket_event_softintr - This function just does a cv_broadcast on behalf
 *				of the high-priority interrupt handler.
 *
 *	Note: There is no calling argument.
 */
/*ARGSUSED*/
uint32_t
cs_socket_event_softintr(caddr_t notused)
{
	cs_socket_t *sp;
	uint32_t sn;
	int ret = DDI_INTR_UNCLAIMED;

	/*
	 * If the module is on it's way out, then don't bother
	 *	to do anything else except return.
	 */
	mutex_enter(&cs_globals.global_lock);
	if ((cs_globals.init_state & GLOBAL_INIT_STATE_UNLOADING) ||
				(cs_globals.init_state & GLOBAL_IN_SOFTINTR)) {
		mutex_exit(&cs_globals.global_lock);

		/*
		 * Note that we return DDI_INTR_UNCLAIMED here
		 *	since we don't want to be constantly
		 *	called back.
		 */
		return (ret);
	} else {
	    cs_globals.init_state |= GLOBAL_IN_SOFTINTR;
	    mutex_exit(&cs_globals.global_lock);
	}

	/*
	 * Go through each socket and dispatch the appropriate events.
	 *	We have to funnel everything through this one routine because
	 *	we can't do a cv_broadcast from a high level interrupt handler
	 *	and we also can't have more than one soft interrupt handler
	 *	on a single dip and using the same handler address.
	 */
	for (sn = 0; sn < cs_globals.max_socket_num; sn++) {
	    if ((sp = cs_get_sp(sn)) != NULL) {
		if (sp->init_state & SOCKET_INIT_STATE_READY) {
			/*
			 * If we're being asked to unload CS, then don't bother
			 *	waking up the socket event thread handler.
			 */
		    if (!(sp->flags & SOCKET_UNLOAD_MODULE) &&
					(sp->flags & SOCKET_NEEDS_THREAD)) {
			ret = DDI_INTR_CLAIMED;
			mutex_enter(&sp->client_lock);
			cv_broadcast(&sp->thread_cv);
			mutex_exit(&sp->client_lock);
		    } /* if (SOCKET_NEEDS_THREAD) */
		} /* if (SOCKET_INIT_STATE_READY) */
	    } /* cs_get_sp */
	} /* for (sn) */

	mutex_enter(&cs_globals.global_lock);
	cs_globals.init_state &= ~GLOBAL_IN_SOFTINTR;
	mutex_exit(&cs_globals.global_lock);

	return (ret);
}

/*
 * cs_event_thread - This is the per-socket event thread.
 */
static void
cs_event_thread(uint32_t sn)
{
	cs_socket_t	*sp;
	client_t	*client;
	client_types_t	*ct;

	if ((sp = cs_get_sp(sn)) == NULL)
	    return;

#ifdef	CS_DEBUG
	if (cs_debug > 1) {
	    cmn_err(CE_CONT, "cs_event_thread: socket %d thread started\n",
								sp->socket_num);
	}
#endif

	CALLB_CPR_INIT(&sp->cprinfo_cs, &sp->client_lock,
					callb_generic_cpr, "cs_event_thread");

	mutex_enter(&sp->client_lock);

	for (;;) {

	    CALLB_CPR_SAFE_BEGIN(&sp->cprinfo_cs);
	    cv_wait(&sp->thread_cv, &sp->client_lock);
	    CALLB_CPR_SAFE_END(&sp->cprinfo_cs, &sp->client_lock);

	    mutex_enter(&sp->lock);
	    sp->flags &= ~SOCKET_NEEDS_THREAD;
	    mutex_exit(&sp->lock);

	/*
	 * Check to see if there are any special thread operations that
	 *	we are being asked to perform.
	 */
	    if (sp->thread_state & SOCKET_THREAD_EXIT) {
#ifdef	CS_DEBUG
		if (cs_debug > 1) {
		    cmn_err(CE_CONT, "cs_event_thread: socket %d "
							"SOCKET_THREAD_EXIT\n",
							sp->socket_num);
		}
#endif
		CALLB_CPR_EXIT(&sp->cprinfo_cs);
		cv_broadcast(&sp->caller_cv);	/* wakes up cs_deinit */
		mutex_exit(&sp->client_lock);
		return;
	    } /* if (SOCKET_THREAD_EXIT) */

#ifdef	CS_DEBUG
	    if (cs_debug > 1) {
		cmn_err(CE_CONT, "cs_event_thread: socket %d sp->events 0x%x\n",
							sp->socket_num,
							(int)sp->events);
	    }
#endif

	/*
	 * Handle CS_EVENT_CARD_INSERTION events
	 */
	    if (sp->events & CS_EVENT_CARD_INSERTION) {
		mutex_enter(&sp->lock);
		sp->events &= ~CS_EVENT_CARD_INSERTION;
		mutex_exit(&sp->lock);

		/*
		 * If we have a pending CS_EVENT_CARD_REMOVAL event it
		 *	means that we likely got CD line bounce on the
		 *	insertion, so terminate this processing.
		 */
		if ((sp->events & CS_EVENT_CARD_REMOVAL) == 0) {
		    (void) cs_card_insertion(sp, CS_EVENT_CARD_INSERTION);
		}
#ifdef	CS_DEBUG
		else if (cs_debug > 0) {
			cmn_err(CE_CONT, "cs_event_thread: socket %d "
					"CS_EVENT_CARD_REMOVAL event "
					"terminating "
					"CS_EVENT_CARD_INSERTION "
					"processing\n", sp->socket_num);
		    }
#endif
	} /* if (CS_EVENT_CARD_INSERTION) */

	/*
	 * Handle CS_EVENT_CARD_READY and CS_EVENT_READY_TIMEOUT events
	 */
	    if (sp->events & (CS_EVENT_CARD_READY | CS_EVENT_READY_TIMEOUT)) {
		mutex_enter(&sp->lock);
		sp->events &= ~(CS_EVENT_CARD_READY | CS_EVENT_READY_TIMEOUT);
		mutex_exit(&sp->lock);
		if (sp->thread_state & SOCKET_WAIT_FOR_READY) {
		    mutex_enter(&sp->lock);
		    sp->thread_state &= ~SOCKET_WAIT_FOR_READY;
		    mutex_exit(&sp->lock);
		    (void) cs_card_insertion(sp, CS_EVENT_CARD_READY);
		} /* if (SOCKET_WAIT_FOR_READY) */
	    } /* if (CS_EVENT_CARD_READY) */

	/*
	 * Handle CS_EVENT_SS_UPDATED events
	 */
	    if (sp->events & CS_EVENT_SS_UPDATED) {
		mutex_enter(&sp->lock);
		sp->events &= ~CS_EVENT_SS_UPDATED;
		mutex_exit(&sp->lock);
		(void) cs_card_insertion(sp, CS_EVENT_SS_UPDATED);
	    } /* if (CS_EVENT_SS_UPDATED) */

	/*
	 * Handle CS_EVENT_STATUS_CHANGE events
	 */
	    if (sp->events & CS_EVENT_STATUS_CHANGE) {
		event_t revent;

		mutex_enter(&sp->cis_lock);
		mutex_enter(&sp->lock);
		sp->events &= ~CS_EVENT_STATUS_CHANGE;

		/*
		 * Go through each client and add any events that we saw to
		 *	the client's event list if the client has that event
		 *	enabled in their event mask.
		 * Remove any events that may be pending for this client if
		 *	the client's event mask says that the client doesn't
		 *	want to see those events anymore. This handles the
		 *	case where the client had an event enabled in it's
		 *	event mask when the event came in but between that
		 *	time and the time we're called here the client
		 *	disabled that event.
		 */
		client = sp->client_list;

		while (client) {
			/*
			 * Read the PRR (if it exists) and check for any events.
			 * The PRR will only be read if the socket is in IO
			 * mode, if there is a card in the socket, and if there
			 * is a PRR.
			 * We don't have to clear revent before we call the
			 * cs_read_event_status function since it will
			 * clear it before adding any current events.
			 */
		    if (client->flags & CLIENT_CARD_INSERTED) {
			(void) cs_read_event_status(sp, client,
							&revent, NULL, 0);

			client->events = ((client->events | revent) &
						(client->event_mask |
							client->global_mask));
		    } /* CLIENT_CARD_INSERTED */
		    client = client->next;
		} /* while (client) */

		mutex_exit(&sp->lock);
		mutex_exit(&sp->cis_lock);
	    } /* if (CS_EVENT_STATUS_CHANGE) */

	/*
	 * We want to maintain the required event dispatching order as
	 *	specified in the PCMCIA spec, so we cycle through all
	 *	clients on this socket to make sure that they are
	 *	notified in the correct order.
	 */
	    ct = &client_types[0];
	    while (ct) {
		/*
		 * Point to the head of the client list for this socket, and go
		 *	through each client to set up the client events as well
		 *	as call the client's event handler directly if we have
		 *	a high priority event that we need to tell the client
		 *	about.
		 */
		client = sp->client_list;

		if (ct->order & CLIENT_EVENTS_LIFO) {
		    client_t *clp = NULL;

		    while (client) {
			clp = client;
			client = client->next;
		    }
		    client = clp;
		}

		while (client) {
		    if (client->flags & ct->type) {
			    uint32_t bit = 0;
			    event_t event;

			while (client->events) {

			    switch (event = CS_BIT_GET(client->events, bit)) {
				/*
				 * Clients always receive registration complete
				 *	events, even if there is no card of
				 *	their type currently in the socket.
				 */
				case CS_EVENT_REGISTRATION_COMPLETE:
				    CLIENT_EVENT_CALLBACK(client, event,
							CS_EVENT_PRI_LOW);
				    break;
				/*
				 * The client only gets a card insertion event
				 *	if there is currently a card in the
				 *	socket that the client can control.
				 *	The nexus determines this. We also
				 *	prevent the client from receiving
				 *	multiple CS_EVENT_CARD_INSERTION
				 *	events without receiving intervening
				 *	CS_EVENT_CARD_REMOVAL events.
				 */
				case CS_EVENT_CARD_INSERTION:
				    if (cs_card_for_client(client)) {
					int send_insertion;

					mutex_enter(&sp->lock);
					send_insertion = client->flags;
					client->flags |=
						(CLIENT_CARD_INSERTED |
						CLIENT_SENT_INSERTION);
					mutex_exit(&sp->lock);
					if (!(send_insertion &
						    CLIENT_SENT_INSERTION)) {
					    CLIENT_EVENT_CALLBACK(client,
						event, CS_EVENT_PRI_LOW);
					} /* if (!CLIENT_SENT_INSERTION) */
				    }
				    break;
				/*
				 * The CS_EVENT_CARD_REMOVAL_LOWP is a low
				 *	priority CS_EVENT_CARD_REMOVAL event.
				 */
				case CS_EVENT_CARD_REMOVAL_LOWP:
				    mutex_enter(&sp->lock);
				    client->flags &= ~CLIENT_SENT_INSERTION;
				    mutex_exit(&sp->lock);
				    CLIENT_EVENT_CALLBACK(client,
							CS_EVENT_CARD_REMOVAL,
							CS_EVENT_PRI_LOW);
				    break;
				/*
				 * The hardware card removal events are handed
				 *	to the client in cs_event at high
				 *	priority interrupt time; this card
				 *	removal event is a software-generated
				 *	event.
				 */
				case CS_EVENT_CARD_REMOVAL:
				    if (client->flags & CLIENT_CARD_INSERTED) {
					mutex_enter(&sp->lock);
					client->flags &=
						~(CLIENT_CARD_INSERTED |
						CLIENT_SENT_INSERTION);
					mutex_exit(&sp->lock);
					CLIENT_EVENT_CALLBACK(client, event,
							CS_EVENT_PRI_LOW);
				    }
				    break;
				/*
				 * Write protect events require the info field
				 *	of the client's event callback args to
				 *	be zero if the card is not write
				 *	protected and one if it is.
				 */
				case CS_EVENT_WRITE_PROTECT:
				    if (client->flags & CLIENT_CARD_INSERTED) {
					get_ss_status_t gs;

					mutex_enter(&sp->cis_lock);
					mutex_enter(&sp->lock);
					(void) cs_read_event_status(sp, client,
									NULL,
									&gs, 0);
					if (gs.CardState & SBM_WP) {
					    client->event_callback_args.info =
						(void *)
						CS_EVENT_WRITE_PROTECT_WPON;
					} else {
					    client->event_callback_args.info =
						(void *)
						CS_EVENT_WRITE_PROTECT_WPOFF;
					}
					mutex_exit(&sp->lock);
					mutex_exit(&sp->cis_lock);
					CLIENT_EVENT_CALLBACK(client, event,
							CS_EVENT_PRI_LOW);
				    } /* CLIENT_CARD_INSERTED */
				    break;
				case CS_EVENT_CLIENT_INFO:
				    CLIENT_EVENT_CALLBACK(client, event,
							CS_EVENT_PRI_LOW);
				    break;
				case 0:
				    break;
				default:
				    if (client->flags & CLIENT_CARD_INSERTED) {
					CLIENT_EVENT_CALLBACK(client, event,
							CS_EVENT_PRI_LOW);
				    }
				    break;
			    } /* switch */
			    mutex_enter(&sp->lock);
			    CS_BIT_CLEAR(client->events, bit);
			    mutex_exit(&sp->lock);
			    bit++;
			} /* while (client->events) */
		    } /* if (ct->type) */
		    if (ct->order & CLIENT_EVENTS_LIFO) {
			client = client->prev;
		    } else {
			client = client->next;
		    }
		} /* while (client) */

		ct = ct->next;
	    } /* while (ct) */

	/*
	 * Handle CS_EVENT_CARD_REMOVAL events
	 */
	    if (sp->events & CS_EVENT_CARD_REMOVAL) {
		mutex_enter(&sp->lock);
		sp->events &= ~CS_EVENT_CARD_REMOVAL;
		mutex_exit(&sp->lock);
		(void) cs_card_removal(sp);
	    } /* if (CS_EVENT_CARD_REMOVAL) */

		/*
		 * If someone is waiting for us to complete, signal them now.
		 */
	    if (sp->thread_state & SOCKET_WAIT_SYNC) {
		mutex_enter(&sp->lock);
		sp->thread_state &= ~SOCKET_WAIT_SYNC;
		mutex_exit(&sp->lock);
		cv_broadcast(&sp->caller_cv);
	    } /* SOCKET_WAIT_SYNC */

	} /* for (;;) */
}

/*
 * cs_card_for_client - checks to see if a card that the client can control
 *			is currently inserted in the socket.  Socket Services
 *			has to tell us if this is the case.
 */
static int
cs_card_for_client(client_t *client)
{

	/*
	 * If the client has set the CS_EVENT_ALL_CLIENTS it means that they
	 *	want to get all events for all clients, irrespective of
	 *	whether or not there is a card in the socket.  Such clients
	 *	have to be very careful if they touch the card hardware in
	 *	any way to prevent causing problems for other clients on the
	 *	same socket.  This flag will typically only be set by the
	 *	"super-client" or CSI types of clients that wish to get
	 *	information on other clients or cards in the system.
	 * Note that the CS_EVENT_ALL_CLIENTS must be set in either the
	 *	client's global event mask or client event mask.
	 * The client must also have registered as a "super-client" or as a
	 *	CSI client for this socket.
	 */
	if ((client->flags & (CLIENT_SUPER_CLIENT | CLIENT_CSI_CLIENT)) &&
			((client->global_mask | client->event_mask) &
							CS_EVENT_ALL_CLIENTS))
	    return (1);

	/*
	 * Look for the PCM_DEV_ACTIVE property on this client's dip; if
	 *	it's found, it means that this client can control the card
	 *	that is currently in the socket.  This is a boolean
	 *	property managed by Socket Services.
	 */
	if (ddi_getprop(DDI_DEV_T_ANY, client->dip,    (DDI_PROP_CANSLEEP |
							DDI_PROP_NOTPROM),
							PCM_DEV_ACTIVE, NULL)) {
#ifdef	CS_DEBUG
	    if (cs_debug > 1) {
		cmn_err(CE_CONT, "cs_card_for_client: client handle 0x%x "
					"driver [%s] says %s found\n",
						(int)client->client_handle,
						client->driver_name,
						PCM_DEV_ACTIVE);
	    }
#endif
	    return (1);
	}

	return (0);
}

/*
 * cs_ss_thread - This is the Socket Services work thread. We fire off
 *			any calls to Socket Services here that we want
 *			to run on a thread that is seperate from the
 *			per-socket event thread.
 */
static void
cs_ss_thread(uint32_t sn)
{
	cs_socket_t *sp;

	if ((sp = cs_get_sp(sn)) == NULL)
	    return;

	/*
	 * Tell CPR that we've started a new thread.
	 */
	CALLB_CPR_INIT(&sp->cprinfo_ss, &sp->ss_thread_lock,
					callb_generic_cpr, "cs_ss_thread");

	mutex_enter(&sp->ss_thread_lock);

	for (;;) {

	    CALLB_CPR_SAFE_BEGIN(&sp->cprinfo_ss);
	    cv_wait(&sp->ss_thread_cv, &sp->ss_thread_lock);
	    CALLB_CPR_SAFE_END(&sp->cprinfo_ss, &sp->ss_thread_lock);

		/*
		 * Check to see if there are any special thread operations
		 * that we are being asked to perform.
		 */
	    if (sp->ss_thread_state & SOCKET_THREAD_EXIT) {
#ifdef	CS_DEBUG
		if (cs_debug > 1) {
		    cmn_err(CE_CONT, "cs_ss_thread: socket %d "
					"SOCKET_THREAD_EXIT\n",
						sp->socket_num);
		}
#endif
		CALLB_CPR_EXIT(&sp->cprinfo_ss);
		cv_broadcast(&sp->ss_caller_cv);	/* wake up cs_deinit */
		mutex_exit(&sp->ss_thread_lock);
		return;
	    } /* if (SOCKET_THREAD_EXIT) */

#ifdef	CS_DEBUG
	    if (cs_debug > 1) {
		cmn_err(CE_CONT, "cs_ss_thread: socket %d "
					"ss_thread_state = 0x%x\n",
						(int)sp->socket_num,
						(int)sp->ss_thread_state);
	    }
#endif

		/*
		 * Call SocketServices(CSCISInit) to have SS parse the
		 *	CIS and load/attach any client drivers necessary.
		 */
	    if (sp->ss_thread_state & SOCKET_THREAD_CSCISInit) {

		sp->ss_thread_state &= ~SOCKET_THREAD_CSCISInit;

		if (!(sp->flags & SOCKET_CARD_INSERTED)) {
		    cmn_err(CE_CONT, "cs_ss_thread %d "
					"card NOT inserted\n",
					sp->socket_num);
		}

#ifdef	CS_DEBUG
		if (cs_debug > 1) {
		    cmn_err(CE_CONT, "cs_ss_thread: socket %d calling "
						"CSCISInit\n", sp->socket_num);
		}
#endif

		/*
		 * Tell SS that we have a complete CIS and that it can now
		 *	be parsed.
		 * Note that in some cases the client driver may block in
		 *	their attach routine, causing this call to block until
		 *	the client completes their attach.
		 */
		SocketServices(CSCISInit, sp->socket_num);

		/*
		 * Set the CS_EVENT_SS_UPDATED event for this socket so that the
		 *	event thread can continue any card insertion processing
		 *	that it has to do.
		 */
		mutex_enter(&sp->lock);
		sp->events |= CS_EVENT_SS_UPDATED;
		mutex_exit(&sp->lock);

		/*
		 * Wake up this socket's event thread so that clients can
		 *	continue any card insertion or attach processing
		 *	that they need to do.
		 */
		cv_broadcast(&sp->thread_cv);
	    } /* if ST_CSCISInit */

	} /* for (;;) */
}

/*
 * cs_request_socket_mask - set the client's event mask as well as causes
 *				any events pending from RegisterClient to
 *				be scheduled to be sent to the client
 */
static int
cs_request_socket_mask(client_handle_t client_handle,
					request_socket_mask_t *se)
{
	cs_socket_t *sp;
	client_t *client;
	int error;
	int client_lock_acquired;

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't do anything except for return success.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_SUCCESS);

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (error);
	}

	mutex_enter(&sp->lock);

	/*
	 * If this client has already done a RequestSocketMask without
	 *	a corresponding ReleaseSocketMask, then return an error.
	 */
	if (client->flags & REQ_SOCKET_MASK_DONE) {
	    mutex_exit(&sp->lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_IN_USE);
	}

	/*
	 * Set up the event mask information; we copy this directly from
	 *	the client; since we are the only source of events, any
	 *	bogus bits that the client puts in here won't matter
	 *	because we'll never look at them.
	 */
	client->event_mask = se->EventMask;

	/*
	 * If RegisterClient left us some events to process, set these
	 *	events up here.
	 */
	if (client->pending_events) {
	    client->events |= client->pending_events;
	    client->pending_events = 0;
#ifdef	CS_DEBUG
	    if (cs_debug > 1) {
		cmn_err(CE_CONT, "cs_request_socket_mask: client_handle = 0x%x "
				"driver_name = [%s] events = 0x%x\n",
					(int)client->client_handle,
					client->driver_name,
					(int)client->events);
	    }
#endif
	}

	client->flags |= REQ_SOCKET_MASK_DONE;

	/*
	 * Merge all the clients' event masks and set the socket
	 *	to generate the appropriate events.
	 */
	(void) cs_set_socket_event_mask(sp, cs_merge_event_masks(sp, client));

	mutex_exit(&sp->lock);

	/*
	 * Wakeup the event thread if there are any client events to process.
	 */
	if (client->events) {
	    cv_broadcast(&sp->thread_cv);
#ifdef	CS_DEBUG
	    if (cs_debug > 1) {
		cmn_err(CE_CONT, "cs_request_socket_mask: did cv_broadcast for "
				"client_handle = 0x%x "
				"driver_name = [%s] events = 0x%x\n",
					(int)client->client_handle,
					client->driver_name,
					(int)client->events);
	    }
#endif

	}
	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);

	return (CS_SUCCESS);
}

/*
 * cs_release_socket_mask - clear the client's event mask
 *
 * Once this function returns, the client is guaranteed
 *	not to get any more event callbacks.
 */
/*ARGSUSED*/
static int
cs_release_socket_mask(client_handle_t client_handle,
					release_socket_mask_t *rsm)
{
	cs_socket_t *sp;
	client_t *client;
	int error;
	int client_lock_acquired;

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't do anything except for return success.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_SUCCESS);

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (error);
	}

	mutex_enter(&sp->lock);

	/*
	 * If this client has already done a RequestSocketMask without
	 *	a corresponding ReleaseSocketMask, then return an error.
	 */
	if (!(client->flags & REQ_SOCKET_MASK_DONE)) {
	    mutex_exit(&sp->lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_BAD_SOCKET);
	}

	/*
	 * Clear both the client event mask and the global event mask.
	 *	We clear both since the semantics of this function are
	 *	that once it returns, the client will not be called at
	 *	it's event handler for any events until RequestSocketMask
	 *	is called again.
	 */
	client->event_mask = 0;
	client->global_mask = 0;
	client->flags &= ~REQ_SOCKET_MASK_DONE;

	/*
	 * Merge all the clients' event masks and set the socket
	 *	to generate the appropriate events.
	 */
	(void) cs_set_socket_event_mask(sp, cs_merge_event_masks(sp, client));

	mutex_exit(&sp->lock);
	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);

	return (CS_SUCCESS);
}

/*
 * cs_get_event_mask - return the event mask for this client
 */
static int
cs_get_event_mask(client_handle_t client_handle, sockevent_t *se)
{
	cs_socket_t *sp;
	client_t *client;
	int error;
	int client_lock_acquired;

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't do anything except for return success.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_SUCCESS);

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (error);
	}

	mutex_enter(&sp->lock);

#ifdef	XXX
	/*
	 * If there's no card in the socket or the card in the socket is not
	 *	for this client, then return an error.
	 * XXX - how can a client get their event masks if their card
	 *	goes away?
	 */
	if (!(client->flags & CLIENT_CARD_INSERTED)) {
	    mutex_exit(&sp->lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_NO_CARD);
	}
#endif

	/*
	 * We are only allowed to get the client event mask if a
	 *	RequestSocketMask has been called previously.  We
	 *	are allowed to get the global event mask at any
	 *	time.
	 * The global event mask is initially set by the client
	 *	in the call to RegisterClient.  The client event
	 *	mask is set by the client in calls to SetEventMask
	 *	and RequestSocketMask and gotten in calls to
	 *	GetEventMask.
	 */
	if (se->Attributes & CONF_EVENT_MASK_CLIENT) {
	    if (!(client->flags & REQ_SOCKET_MASK_DONE)) {
		mutex_exit(&sp->lock);
		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		return (CS_BAD_SOCKET);
	    }
	    se->EventMask = client->event_mask;
	} else {
	    se->EventMask = client->global_mask;
	}

	mutex_exit(&sp->lock);
	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);

	return (CS_SUCCESS);
}

/*
 * cs_set_event_mask - set the event mask for this client
 */
static int
cs_set_event_mask(client_handle_t client_handle, sockevent_t *se)
{
	cs_socket_t *sp;
	client_t *client;
	int error;
	int client_lock_acquired;

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't do anything except for return success.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_SUCCESS);

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (error);
	}

	mutex_enter(&sp->lock);

#ifdef	XXX
	/*
	 * If there's no card in the socket or the card in the socket is not
	 *	for this client, then return an error.
	 */
	if (!(client->flags & CLIENT_CARD_INSERTED)) {
	    mutex_exit(&sp->lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_NO_CARD);
	}
#endif

	/*
	 * We are only allowed to set the client event mask if a
	 *	RequestSocketMask has been called previously.  We
	 *	are allowed to set the global event mask at any
	 *	time.
	 * The global event mask is initially set by the client
	 *	in the call to RegisterClient.  The client event
	 *	mask is set by the client in calls to SetEventMask
	 *	and RequestSocketMask and gotten in calls to
	 *	GetEventMask.
	 */
	if (se->Attributes & CONF_EVENT_MASK_CLIENT) {
	    if (!(client->flags & REQ_SOCKET_MASK_DONE)) {
		mutex_exit(&sp->lock);
		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		return (CS_BAD_SOCKET);
	    }
	    client->event_mask = se->EventMask;
	} else {
	    client->global_mask = se->EventMask;
	}

	/*
	 * Merge all the clients' event masks and set the socket
	 *	to generate the appropriate events.
	 */
	(void) cs_set_socket_event_mask(sp, cs_merge_event_masks(sp, client));

	mutex_exit(&sp->lock);
	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);

	return (CS_SUCCESS);
}

/*
 * cs_read_event_status - handles PRR events and returns card status
 *
 *	calling: *sp - socket struct point
 *		 *client - client to check events on
 *		 *revent - pointer to event mask to update; if NULL, will
 *				not be updated, if non-NULL, will be updated
 *				with CS-format events; it is NOT necessary
 *				to clear this value before calling this
 *				function
 *		 *gs - pointer to a get_ss_status_t used for the SS GetStatus
 *				call; it is not necessary to initialize any
 *				members in this structure; set to NULL if
 *				not used
 *		flags - if CS_RES_IGNORE_NO_CARD is set, the check for a
 *				card present will not be done
 *
 *	returns: CS_SUCCESS
 *		 CS_NO_CARD - if no card is in the socket and the flags arg
 *				is not set to CS_RES_IGNORE_NO_CARD
 *		 CS_BAD_SOCKET - if the SS_GetStatus function returned an
 *					error
 *
 *	Note that if the client that configured this socket has told us that
 *		the READY pin in the PRR isn't valid and the socket is in IO
 *		mode, we always return that the card is READY.
 *
 *	Note that if gs is not NULL, the current card state will be returned
 *		in the gs->CardState member; this will always reflect the
 *		current card state and the state will come from both the
 *		SS_GetStatus call and the PRR, whichever is appropriate for
 *		the mode that the socket is currently in.
 */
static int
cs_read_event_status(cs_socket_t *sp, client_t *client, event_t *revent,
						get_ss_status_t *gs, int flags)
{
	cfg_regs_t prrd = 0;

	/*
	 * SOCKET_IS_IO will only be set if a RequestConfiguration
	 *	has been done by at least one client on this socket.
	 * If there isn't a card in the socket or the caller wants to ignore
	 *	whether the card is in the socket or not, get the current
	 *	card status.
	 */
	if ((sp->flags & SOCKET_CARD_INSERTED) ||
					(flags & CS_RES_IGNORE_NO_CARD)) {
	    if (sp->flags & SOCKET_IS_IO) {
		if (client->present & CONFIG_PINREPL_REG_PRESENT) {
		    acc_handle_t cis_handle;
		    uint32_t newoffset = client->config_regs_offset;

			/*
			 * Get a handle to the CIS window
			 */
		    if (cs_init_cis_window(sp, &newoffset, &cis_handle,
					CISTPLF_AM_SPACE) != CS_SUCCESS) {
			cmn_err(CE_CONT, "cs_read_event_status: socket %d "
					    "can't init CIS window\n",
							sp->socket_num);
			return (CS_GENERAL_FAILURE);
		    } /* cs_init_cis_window */

		    prrd = csx_Get8(cis_handle, client->config_regs.prr_p);
		    prrd &= client->pin;

#ifdef	CS_DEBUG
		    if (cs_debug > 1) {
			cmn_err(CE_CONT, "cs_read_event_status: "
						"prrd 0x%x client->pin 0x%x\n",
								(int)prrd,
								client->pin);
			cmn_err(CE_CONT, "PRR(1) = [%s%s%s%s%s%s%s%s]\n",
						((prrd & PRR_WP_STATUS)?
							"PRR_WP_STATUS ":""),
						((prrd & PRR_READY_STATUS)?
							"PRR_READY_STATUS ":""),
						((prrd & PRR_BVD2_STATUS)?
							"PRR_BVD2_STATUS ":""),
						((prrd & PRR_BVD1_STATUS)?
							"PRR_BVD1_STATUS ":""),
						((prrd & PRR_WP_EVENT)?
							"PRR_WP_EVENT ":""),
						((prrd & PRR_READY_EVENT)?
							"PRR_READY_EVENT ":""),
						((prrd & PRR_BVD2_EVENT)?
							"PRR_BVD2_EVENT ":""),
						((prrd & PRR_BVD1_EVENT)?
							"PRR_BVD1_EVENT ":""));
		    }
#endif

			/*
			 * The caller wants the event changes sent back and
			 * the PRR event change bits cleared.
			 */
		    if (revent) {
			get_socket_t get_socket;
			set_socket_t set_socket;

			/*
			 * Bug ID: 1193636 - Card Services sends bogus
			 *	events on CS_EVENT_STATUS_CHANGE events
			 * Clear this before we OR-in any values.
			 */
			*revent = 0;

			PRR_EVENT(prrd, PRR_WP_EVENT, PRR_WP_STATUS,
					CS_EVENT_WRITE_PROTECT, *revent);

			PRR_EVENT(prrd, PRR_READY_EVENT, PRR_READY_STATUS,
					CS_EVENT_CARD_READY, *revent);

			PRR_EVENT(prrd, PRR_BVD2_EVENT, PRR_BVD2_STATUS,
					CS_EVENT_BATTERY_LOW, *revent);

			PRR_EVENT(prrd, PRR_BVD1_EVENT, PRR_BVD1_STATUS,
					CS_EVENT_BATTERY_DEAD, *revent);


#ifdef	CS_DEBUG
			if (cs_debug > 1) {

			    cmn_err(CE_CONT, "PRR() = [%s%s%s%s%s%s%s%s]\n",
						((prrd & PRR_WP_STATUS)?
							"PRR_WP_STATUS ":""),
						((prrd & PRR_READY_STATUS)?
							"PRR_READY_STATUS ":""),
						((prrd & PRR_BVD2_STATUS)?
							"PRR_BVD2_STATUS ":""),
						((prrd & PRR_BVD1_STATUS)?
							"PRR_BVD1_STATUS ":""),
						((prrd & PRR_WP_EVENT)?
							"PRR_WP_EVENT ":""),
						((prrd & PRR_READY_EVENT)?
							"PRR_READY_EVENT ":""),
						((prrd & PRR_BVD2_EVENT)?
							"PRR_BVD2_EVENT ":""),
						((prrd & PRR_BVD1_EVENT)?
							"PRR_BVD1_EVENT ":""));
			}
#endif

			if (prrd)
			    csx_Put8(cis_handle, client->config_regs.prr_p,
				prrd);

			/*
			 * We now have to reenable the status change interrupts
			 *	if there are any valid bits in the PRR. Since
			 *	the BVD1 signal becomes the STATUS_CHANGE
			 *	signal when the socket is in IO mode, we just
			 *	have to set the SBM_BVD1 enable bit in the
			 *	event mask.
			 */
			if (client->pin) {
			    get_socket.socket = sp->socket_num;
			    SocketServices(SS_GetSocket, &get_socket);
			    set_socket.socket = sp->socket_num;
			    set_socket.SCIntMask =
					get_socket.SCIntMask | SBM_BVD1;
			    set_socket.VccLevel = get_socket.VccLevel;
			    set_socket.Vpp1Level = get_socket.Vpp1Level;
			    set_socket.Vpp2Level = get_socket.Vpp2Level;
			    set_socket.IREQRouting = get_socket.IRQRouting;
			    set_socket.IFType = get_socket.IFType;
			    set_socket.CtlInd = get_socket.CtlInd;
			    set_socket.State = get_socket.state;
			    SocketServices(SS_SetSocket, &set_socket);
			} /* if (client->pin) */
		    } /* if (revent) */

		} /* if (CONFIG_PINREPL_REG_PRESENT) */
	    } /* if (SOCKET_IS_IO) */

	/*
	 * The caller wants the current card state; we just read
	 *	it and return a copy of it but do not clear any of
	 *	the event changed bits (if we're reading the PRR).
	 */
	    if (gs) {
		gs->socket = sp->socket_num;
		gs->CardState = 0;
		if (SocketServices(SS_GetStatus, gs) != SUCCESS)
		    return (CS_BAD_SOCKET);
		if (sp->flags & SOCKET_IS_IO) {
		/*
		 * If the socket is in IO mode, then clear the
		 *	gs->CardState bits that are now in the PRR
		 */
		    gs->CardState &= ~(SBM_WP | SBM_BVD1 |
						SBM_BVD2 | SBM_RDYBSY);

		/*
		 * Convert PRR status to SS_GetStatus status
		 */
		    if (prrd & PRR_WP_STATUS)
			gs->CardState |= SBM_WP;
		    if (prrd & PRR_BVD2_STATUS)
			gs->CardState |= SBM_BVD2;
		    if (prrd & PRR_BVD1_STATUS)
			gs->CardState |= SBM_BVD1;

		/*
		 * If the client has indicated that there is no
		 *	PRR or that the READY bit in the PRR isn't
		 *	valid, then we simulate the READY bit by
		 *	always returning READY.
		 */
		    if (!(client->present & CONFIG_PINREPL_REG_PRESENT) ||
			((client->present & CONFIG_PINREPL_REG_PRESENT) &&
			!((client->pin &
			    (PRR_READY_STATUS | PRR_READY_EVENT)) ==
				(PRR_READY_STATUS | PRR_READY_EVENT))) ||
				(prrd & PRR_READY_STATUS))
			gs->CardState |= SBM_RDYBSY;

#ifdef	CS_DEBUG
			if (cs_debug > 1) {
			    cmn_err(CE_CONT, "cs_read_event_status: prrd 0x%x "
				"client->pin 0x%x "
				"gs->CardState 0x%x\n",
				prrd, client->pin, gs->CardState);
			}
#endif

		} /* if (SOCKET_IS_IO) */
	    } /* if (gs) */
	    return (CS_SUCCESS);
	} /* if (SOCKET_CARD_INSERTED) */

	return (CS_NO_CARD);
}

/*
 * cs_get_status - gets live card status and latched card status changes
 *			supports the GetStatus CS call
 *
 *	returns: CS_SUCCESS
 *		 CS_BAD_HANDLE if the passed client handle is invalid
 *
 *	Note: This function resets the latched status values maintained
 *		by Socket Services
 */
static int
cs_get_status(client_handle_t client_handle, get_status_t *gs)
{
	cs_socket_t *sp;
	client_t *client;
	get_ss_status_t get_ss_status;
	get_socket_t get_socket;
	set_socket_t set_socket;
	int error;
	int client_lock_acquired;

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't do anything except for return success.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_SUCCESS);

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (error);
	}

	/*
	 * Get the current card status as well as the latched card
	 *	state.  Set the CS_RES_IGNORE_NO_CARD so that even
	 *	if there is no card in the socket we'll still get
	 *	a valid status.
	 * Note that it is not necessary to initialize any values
	 *	in the get_ss_status structure.
	 */
	mutex_enter(&sp->cis_lock);
	if ((error = cs_read_event_status(sp, client, NULL, &get_ss_status,
					CS_RES_IGNORE_NO_CARD)) != CS_SUCCESS) {
	    mutex_exit(&sp->cis_lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (error);
	}

	mutex_exit(&sp->cis_lock);

	gs->raw_CardState = cs_sbm2cse(get_ss_status.CardState);

	/*
	 * Assign the "live" card state to the "real" card state. If there's
	 *	no card in the socket or the card in the socket is not
	 *	for this client, then we lie and tell the caller that the
	 *	card is not inserted.
	 */
	gs->CardState = gs->raw_CardState;
	if (!(client->flags & CLIENT_CARD_INSERTED))
	    gs->CardState &= ~CS_EVENT_CARD_INSERTION;

	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);

	get_socket.socket = sp->socket_num;
	if (SocketServices(SS_GetSocket, &get_socket) != SUCCESS)
	    return (CS_BAD_SOCKET);

	gs->SocketState = cs_sbm2cse(get_socket.state);

	set_socket.socket = sp->socket_num;
	set_socket.SCIntMask = get_socket.SCIntMask;
	set_socket.VccLevel = get_socket.VccLevel;
	set_socket.Vpp1Level = get_socket.Vpp1Level;
	set_socket.Vpp2Level = get_socket.Vpp2Level;
	set_socket.IREQRouting = get_socket.IRQRouting;
	set_socket.IFType = get_socket.IFType;
	set_socket.CtlInd = get_socket.CtlInd;
	/* XXX (is ~0 correct here?) reset latched values */
	set_socket.State = (unsigned)~0;

	if (SocketServices(SS_SetSocket, &set_socket) != SUCCESS)
	    return (CS_BAD_SOCKET);

	return (CS_SUCCESS);
}

/*
 * cs_cse2sbm - converts a CS event mask to an SS (SBM_XXX) event mask
 */
static event_t
cs_cse2sbm(event_t event_mask)
{
	event_t sbm_event = 0;

	/*
	 * XXX - we need to handle PM_CHANGE and RESET here as well
	 */
	if (event_mask & CS_EVENT_WRITE_PROTECT)
	    sbm_event |= SBM_WP;
	if (event_mask & CS_EVENT_BATTERY_DEAD)
	    sbm_event |= SBM_BVD1;
	if (event_mask & CS_EVENT_BATTERY_LOW)
	    sbm_event |= SBM_BVD2;
	if (event_mask & CS_EVENT_CARD_READY)
	    sbm_event |= SBM_RDYBSY;
	if (event_mask & CS_EVENT_CARD_LOCK)
	    sbm_event |= SBM_LOCKED;
	if (event_mask & CS_EVENT_EJECTION_REQUEST)
	    sbm_event |= SBM_EJECT;
	if (event_mask & CS_EVENT_INSERTION_REQUEST)
	    sbm_event |= SBM_INSERT;
	if (event_mask & (CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL))
	    sbm_event |= SBM_CD;

	return (sbm_event);
}

/*
 * cs_sbm2cse - converts SBM_xxx state to CS event bits
 *
 * This function should never set any of the following bits:
 *
 *		CS_EVENT_MTD_REQUEST
 *		CS_EVENT_CLIENT_INFO
 *		CS_EVENT_TIMER_EXPIRED
 *		CS_EVENT_CARD_REMOVAL
 *		CS_EVENT_CARD_REMOVAL_LOWP
 *		CS_EVENT_ALL_CLIENTS
 *		CS_EVENT_READY_TIMEOUT
 *
 *	These bits are defined in the CS_STATUS_XXX series and are
 *	used by GetStatus.
 */
static uint32_t
cs_sbm2cse(uint32_t state)
{
	uint32_t rstate = 0;

	/*
	 * XXX - we need to handle PM_CHANGE and RESET here as well
	 */
	if (state & SBM_WP)
	    rstate |= CS_EVENT_WRITE_PROTECT;
	if (state & SBM_BVD1)
	    rstate |= CS_EVENT_BATTERY_DEAD;
	if (state & SBM_BVD2)
	    rstate |= CS_EVENT_BATTERY_LOW;
	if (state & SBM_RDYBSY)
	    rstate |= CS_EVENT_CARD_READY;
	if (state & SBM_LOCKED)
	    rstate |= CS_EVENT_CARD_LOCK;
	if (state & SBM_EJECT)
	    rstate |= CS_EVENT_EJECTION_REQUEST;
	if (state & SBM_INSERT)
	    rstate |= CS_EVENT_INSERTION_REQUEST;
	if (state & SBM_CD)
	    rstate |= CS_EVENT_CARD_INSERTION;

	return (rstate);
}

/*
 * cs_merge_event_masks - merge the CS global socket event mask with the
 *				passed client's event masks
 */
static unsigned
cs_merge_event_masks(cs_socket_t *sp, client_t *client)
{
	unsigned SCIntMask;
	uint32_t event_mask;

	/*
	 * We always want to see card detect and status change events.
	 */
	SCIntMask = SBM_CD;

	event_mask = client->event_mask | client->global_mask |
							sp->event_mask;

	if (!(sp->flags & SOCKET_IS_IO)) {
	    SCIntMask |= cs_cse2sbm(event_mask);
	} else {
		/*
		 * If the socket is in IO mode and there is a PRR present,
		 *	then we may need to enable PCE_CARD_STATUS_CHANGE
		 *	events.
		 */
	    if (client->present & CONFIG_PINREPL_REG_PRESENT) {

		SCIntMask |= (cs_cse2sbm(event_mask) &
				~(SBM_WP | SBM_BVD1 | SBM_BVD2 | SBM_RDYBSY));

		if ((client->pin & (PRR_WP_STATUS | PRR_WP_EVENT)) ==
					(PRR_WP_STATUS | PRR_WP_EVENT))
		    if (event_mask & CS_EVENT_WRITE_PROTECT)
			SCIntMask |= SBM_BVD1;

		if ((client->pin & (PRR_READY_STATUS | PRR_READY_EVENT)) ==
					(PRR_READY_STATUS | PRR_READY_EVENT))
		    if (event_mask & CS_EVENT_CARD_READY)
			    SCIntMask |= SBM_BVD1;

		if ((client->pin & (PRR_BVD2_STATUS | PRR_BVD2_EVENT)) ==
					(PRR_BVD2_STATUS | PRR_BVD2_EVENT))
		    if (event_mask & CS_EVENT_BATTERY_LOW)
			    SCIntMask |= SBM_BVD1;

		if ((client->pin & (PRR_BVD1_STATUS | PRR_BVD1_EVENT)) ==
					(PRR_BVD1_STATUS | PRR_BVD1_EVENT))
		    if (event_mask & CS_EVENT_BATTERY_DEAD)
			    SCIntMask |= SBM_BVD1;

	    } /* if (CONFIG_PINREPL_REG_PRESENT) */
	} /* if (!SOCKET_IS_IO) */

	return (SCIntMask);
}

/*
 * cs_set_socket_event_mask - set the event mask for the socket
 */
static int
cs_set_socket_event_mask(cs_socket_t *sp, unsigned event_mask)
{
	get_socket_t get_socket;
	set_socket_t set_socket;

	get_socket.socket = sp->socket_num;
	if (SocketServices(SS_GetSocket, &get_socket) != SUCCESS)
	    return (CS_BAD_SOCKET);

	set_socket.socket = sp->socket_num;
	set_socket.SCIntMask = event_mask;
	set_socket.VccLevel = get_socket.VccLevel;
	set_socket.Vpp1Level = get_socket.Vpp1Level;
	set_socket.Vpp2Level = get_socket.Vpp2Level;
	set_socket.IREQRouting = get_socket.IRQRouting;
	set_socket.IFType = get_socket.IFType;
	set_socket.CtlInd = get_socket.CtlInd;
	/* XXX (is ~0 correct here?) reset latched values */
	set_socket.State = (unsigned)~0;

	if (SocketServices(SS_SetSocket, &set_socket) != SUCCESS)
	    return (CS_BAD_SOCKET);

	return (CS_SUCCESS);
}

/*
 * ==== MTD handling section ====
 */
static int
cs_deregister_mtd(client_handle_t client_handle)
{

	cmn_err(CE_CONT, "cs_deregister_mtd: client_handle 0x%x\n",
							(int)client_handle);

	return (CS_SUCCESS);
}

/*
 * ==== memory window handling section ====
 */

/*
 * cs_request_window  - searches through window list for the socket to find a
 *			memory window that matches the requested criteria;
 *			this is RequestWindow
 *
 * calling:  cs_request_window(client_handle_t, *window_handle_t, win_req_t *)
 *
 *	On sucessful return, the window_handle_t * pointed to will
 *		contain a valid window handle for this window.
 *
 *	returns: CS_SUCCESS - if window found
 *		 CS_OUT_OF_RESOURCE - if no windows match requirements
 *		 CS_BAD_HANDLE - client handle is invalid
 *		 CS_BAD_SIZE - if requested size can not be met
 *		 CS_BAD_WINDOW - if an internal error occured
 *		 CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
 *		 CS_NO_CARD - if no card is in socket
 *		 CS_BAD_ATTRIBUTE - if any of the unsupported Attrbute
 *					flags are set
 */
static int
cs_request_window(client_handle_t client_handle,
				window_handle_t *wh,
				win_req_t *rw)
{
	cs_socket_t *sp;
	cs_window_t *cw;
	client_t *client;
	modify_win_t mw;
	inquire_window_t iw;
	uint32_t aw;
	int error;
	int client_lock_acquired;
	uint32_t socket_num;

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't support SS using this call.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_UNSUPPORTED_FUNCTION);

	/*
	 * Make sure that none of the unsupported flags are set.
	 */
	if (rw->Attributes &   (/* Compatability */
				WIN_PAGED |
				WIN_SHARED |
				WIN_FIRST_SHARED |
				WIN_BINDING_SPECIFIC |
				/* CS internal */
				WIN_DATA_WIDTH_VALID |
				/* IO window flags */
				WIN_MEMORY_TYPE_IO |
				/* CardBus flags */
				WIN_DATA_WIDTH_32 |
				WIN_PREFETCH_CACHE_MASK |
				WIN_BAR_MASK))
	    return (CS_BAD_ATTRIBUTE);

	mutex_enter(&cs_globals.window_lock);

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (error);
	}

	mutex_enter(&sp->lock);

	/*
	 * If there's no card in the socket or the card in the socket is not
	 *	for this client, then return an error.
	 */
	if (!(client->flags & CLIENT_CARD_INSERTED)) {
	    mutex_exit(&sp->lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_NO_CARD);
	}

	mutex_exit(&sp->lock);

	socket_num = CS_MAKE_SOCKET_NUMBER(GET_CLIENT_SOCKET(client_handle),
	    GET_CLIENT_FUNCTION(client_handle));


	/*
	 * See if we can find a window that matches the caller's criteria.
	 *	If we can't, then thre's not much more that we can do except
	 *	for return an error.
	 */
	if ((error = cs_find_mem_window(sp->socket_num, rw, &aw)) !=
								CS_SUCCESS) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (error);
	}

	/*
	 * We got a window, now synthesize a new window handle for this
	 *	client and get a pointer to the global window structs
	 *	and assign this window to this client.
	 * We don't have to check for errors from cs_create_window_handle
	 *	since that function always returns a valid window handle
	 *	if it is given a valid window number.
	 */
	*wh = cs_create_window_handle(aw);
	if ((cw = cs_get_wp(aw)) == NULL) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_BAD_WINDOW);
	}

	cw->window_handle = *wh;
	cw->client_handle = client_handle;
	cw->socket_num = sp->socket_num;
	cw->state |= (CW_ALLOCATED | CW_MEM);

	mw.Attributes = (
				rw->Attributes |
				WIN_DATA_WIDTH_VALID |
				WIN_ACCESS_SPEED_VALID);
	mw.AccessSpeed = rw->win_params.AccessSpeed;

	if ((error = cs_modify_mem_window(*wh, &mw, rw, socket_num)) !=
	    CS_SUCCESS) {
	    cw->state = 0;
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (error);
	}

	/*
	 * Get any required card offset and pass it back to the client.
	 *	This is not defined in the current PCMCIA spec.  It is
	 *	an aid to clients that want to use it to generate an
	 *	optimum card offset.
	 */
	iw.window = GET_WINDOW_NUMBER(*wh);
	SocketServices(SS_InquireWindow, &iw);

	if (iw.mem_win_char.MemWndCaps & WC_CALIGN)
	    rw->ReqOffset = rw->Size;
	else
	    rw->ReqOffset = iw.mem_win_char.ReqOffset;

	/*
	 * Increment the client's memory window count; this is how we know
	 *	when a client has any allocated memory windows.
	 */
	client->memwin_count++;

	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	mutex_exit(&cs_globals.window_lock);

	return (CS_SUCCESS);
}

/*
 * cs_release_window - deallocates the window associated with the passed
 *			window handle; this is ReleaseWindow
 *
 *	returns: CS_SUCCESS if window handle is valid and window was
 *			sucessfully deallocated
 *		 CS_BAD_HANDLE if window handle is invalid or if window
 *			handle is valid but window is not allocated
 */
static int
cs_release_window(window_handle_t wh)
{
	cs_socket_t *sp;
	cs_window_t *cw;
	client_t *client;
	int error;
	int client_lock_acquired;

	mutex_enter(&cs_globals.window_lock);

	if (!(cw = cs_find_window(wh))) {
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_BAD_HANDLE);
	}

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't support SS using this call.
	 */
	if (CLIENT_HANDLE_IS_SS(cw->client_handle)) {
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_UNSUPPORTED_FUNCTION);
	}

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(cw->client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(cw->client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (error);
	}

	/*
	 * Mark this window as not in use anymore.
	 */
	cw->state &= ~CW_WIN_IN_USE;

	/*
	 * Decrement the client's memory window count; this is how we know
	 *	when a client has any allocated memory windows.
	 */
	if (!(--(client->memwin_count)))
	    client->flags &= ~CLIENT_WIN_ALLOCATED;

	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	mutex_exit(&cs_globals.window_lock);

	return (CS_SUCCESS);
}

/*
 * cs_modify_window - modifies a window's characteristics; this is ModifyWindow
 */
static int
cs_modify_window(window_handle_t wh, modify_win_t *mw)
{
	cs_socket_t *sp;
	cs_window_t *cw;
	client_t *client;
	int error;
	int client_lock_acquired;

	mutex_enter(&cs_globals.window_lock);

	/*
	 * Do some sanity checking - make sure that we can find a pointer
	 *	to the window structure, and if we can, get the client that
	 *	has allocated that window.
	 */
	if (!(cw = cs_find_window(wh))) {
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_BAD_HANDLE);
	}

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(cw->client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	if (!(client = cs_find_client(cw->client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (error);
	}

	mutex_enter(&sp->lock);

	/*
	 * If there's no card in the socket or the card in the socket is not
	 *	for this client, then return an error.
	 */
	if (!(client->flags & CLIENT_CARD_INSERTED)) {
	    mutex_exit(&sp->lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_NO_CARD);
	}

	mutex_exit(&sp->lock);

	mw->Attributes &= (
				WIN_MEMORY_TYPE_MASK |
				WIN_ENABLE |
				WIN_ACCESS_SPEED_VALID |
				WIN_ACC_ENDIAN_MASK |
				WIN_ACC_ORDER_MASK);

	mw->Attributes &= ~WIN_DATA_WIDTH_VALID;

	if ((error = cs_modify_mem_window(wh, mw, NULL, NULL)) != CS_SUCCESS) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (error);
	}

	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	mutex_exit(&cs_globals.window_lock);

	return (CS_SUCCESS);
}

/*
 * cs_modify_mem_window - modifies a window's characteristics; used internally
 *				by Card Services
 *
 *    If *wr is NULL, it means that we're being called by ModifyWindow
 *    If *wr is non-NULL, it means that we are being called by RequestWindow
 *	and so we can't use SS_GetWindow.
 */
static int
cs_modify_mem_window(window_handle_t wh, modify_win_t *mw,
						win_req_t *wr, int sn)
{
	get_window_t gw;
	set_window_t sw;
	set_page_t set_page;
	get_page_t get_page;

	/*
	 * If the win_req_t struct pointer is NULL, it means that
	 *	we're being called by ModifyWindow, so get the
	 *	current window characteristics.
	 */
	if (!wr) {
	    gw.window = GET_WINDOW_NUMBER(wh);
	    if (SocketServices(SS_GetWindow, &gw) != SUCCESS)
		return (CS_BAD_WINDOW);
	    sw.state = gw.state;
	    sw.socket = gw.socket;
	    sw.WindowSize = gw.size;
	} else {
	    sw.state = 0;
	    sw.socket = sn;
	    sw.WindowSize = wr->Size;
	}

	/*
	 * If we're being called by RequestWindow, we must always have
	 *	WIN_ACCESS_SPEED_VALID set since get_window_t is not
	 *	defined.
	 */
	if (mw->Attributes & WIN_ACCESS_SPEED_VALID) {
	    convert_speed_t convert_speed;

	    convert_speed.Attributes = CONVERT_DEVSPEED_TO_NS;
	    convert_speed.devspeed = mw->AccessSpeed;

	    if (cs_convert_speed(&convert_speed) != CS_SUCCESS)
		return (CS_BAD_SPEED);

	    sw.speed = convert_speed.nS;
	} else {
	    sw.speed = gw.speed;
	}

	if (!wr) {
	    get_page.window = GET_WINDOW_NUMBER(wh);
	    get_page.page = 0;
	    if (SocketServices(SS_GetPage, &get_page) != SUCCESS)
		return (CS_BAD_WINDOW);
	    set_page.state = get_page.state;
	    set_page.offset = get_page.offset;
	} else {
	    set_page.state = 0;
	    set_page.offset = 0;
	}

	if (mw->Attributes & WIN_ENABLE) {
	    sw.state |= WS_ENABLED;
	    set_page.state |= PS_ENABLED;
	} else {
	    sw.state &= ~WS_ENABLED;
	    set_page.state &= ~PS_ENABLED;
	}

	if (mw->Attributes & WIN_DATA_WIDTH_VALID) {
	    if (mw->Attributes & WIN_DATA_WIDTH_16)
		sw.state |= WS_16BIT;
	    else
		sw.state &= ~WS_16BIT;
	}

	sw.window = GET_WINDOW_NUMBER(wh);
	sw.base = 0;

	cs_set_acc_attributes(&sw, mw->Attributes);

	if (SocketServices(SS_SetWindow, &sw) != SUCCESS)
	    return (CS_BAD_WINDOW);

	if (mw->Attributes & WIN_MEMORY_TYPE_AM)
	    set_page.state |= PS_ATTRIBUTE;
	else
	    set_page.state &= ~PS_ATTRIBUTE;

	set_page.window = GET_WINDOW_NUMBER(wh);
	set_page.page = 0;
	if (SocketServices(SS_SetPage, &set_page) != SUCCESS)
	    return (CS_BAD_OFFSET);

	/*
	 * Return the current base address of this window
	 */
	if (wr) {
	    gw.window = GET_WINDOW_NUMBER(wh);
	    if (SocketServices(SS_GetWindow, &gw) != SUCCESS)
		return (CS_BAD_WINDOW);

	    wr->Base.handle = (acc_handle_t)gw.handle;
	}

	return (CS_SUCCESS);
}

/*
 * cs_map_mem_page - sets the card offset of the mapped window
 */
static int
cs_map_mem_page(window_handle_t wh, map_mem_page_t *mmp)
{
	cs_socket_t *sp;
	cs_window_t *cw;
	client_t *client;
	inquire_window_t iw;
	get_window_t gw;
	set_page_t set_page;
	get_page_t get_page;
	int error;
	uint32_t size;
	int client_lock_acquired;

	/*
	 * We don't support paged windows, so never allow a page number
	 *	of other than 0
	 */
	if (mmp->Page)
	    return (CS_BAD_PAGE);

	mutex_enter(&cs_globals.window_lock);

	/*
	 * Do some sanity checking - make sure that we can find a pointer
	 *	to the window structure, and if we can, get the client that
	 *	has allocated that window.
	 */
	if (!(cw = cs_find_window(wh))) {
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_BAD_HANDLE);
	}

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(cw->client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	if (!(client = cs_find_client(cw->client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (error);
	}

	mutex_enter(&sp->lock);

	/*
	 * If there's no card in the socket or the card in the socket is not
	 *	for this client, then return an error.
	 */
	if (!(client->flags & CLIENT_CARD_INSERTED)) {
	    mutex_exit(&sp->lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_NO_CARD);
	}

	mutex_exit(&sp->lock);

	gw.window = GET_WINDOW_NUMBER(wh);
	SocketServices(SS_GetWindow, &gw);

	iw.window = GET_WINDOW_NUMBER(wh);
	SocketServices(SS_InquireWindow, &iw);

	if (iw.mem_win_char.MemWndCaps & WC_CALIGN)
	    size = gw.size;
	else
	    size = iw.mem_win_char.ReqOffset;

	if (((mmp->CardOffset/size)*size) != mmp->CardOffset) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_BAD_OFFSET);
	}

	get_page.window = GET_WINDOW_NUMBER(wh);
	get_page.page = 0;
	SocketServices(SS_GetPage, &get_page);

	set_page.window = GET_WINDOW_NUMBER(wh);
	set_page.page = 0;
	set_page.state = get_page.state;
	set_page.offset = mmp->CardOffset;
	if (SocketServices(SS_SetPage, &set_page) != SUCCESS) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_BAD_OFFSET);
	}

	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	mutex_exit(&cs_globals.window_lock);

	return (CS_SUCCESS);
}

/*
 * cs_find_window - finds the window associated with the passed window
 *			handle; if the window handle is invalid or no
 *			windows match the passed window handle, NULL
 *			is returned.  Note that the window must be
 *			allocated for this function to return a valid
 *			window pointer.
 *
 *	returns: cs_window_t * pointer to the found window
 *		 NULL if window handle invalid or window not allocated
 */
cs_window_t *
cs_find_window(window_handle_t wh)
{
	cs_window_t *cw;

	if ((GET_WINDOW_NUMBER(wh) > cs_globals.num_windows) ||
			(GET_WINDOW_MAGIC(wh) != WINDOW_HANDLE_MAGIC))
	    return ((cs_window_t *)NULL);

	if ((cw = cs_get_wp(GET_WINDOW_NUMBER(wh))) == NULL)
	    return (NULL);

	if ((cw->state & CW_ALLOCATED) && (cw->state & CW_MEM))
	    return (cw);

	return ((cs_window_t *)NULL);
}

/*
 * cs_create_window_handle - creates a unique window handle based on the
 *				passed window number.
 */
static window_handle_t
cs_create_window_handle(uint32_t aw)
{
	return (WINDOW_HANDLE_MAGIC | (aw & WINDOW_HANDLE_MASK));
}

/*
 * cs_find_mem_window - tries to find a memory window matching the caller's
 *			criteria
 *
 *	We return the first window that matches the requested criteria.
 *
 *	returns: CS_SUCCESS - if memory window found
 *		 CS_OUT_OF_RESOURCE - if no windows match requirements
 *		 CS_BAD_SIZE - if requested size can not be met
 *		 CS_BAD_WINDOW - if an internal error occured
 */
/* BEGIN CSTYLED */
static int
cs_find_mem_window(uint32_t sn, win_req_t *rw, uint32_t *assigned_window)
{
	uint32_t wn;
	int error = CS_OUT_OF_RESOURCE;
	uint32_t window_num = PCMCIA_MAX_WINDOWS;
	uint32_t min_size = UINT_MAX;
	inquire_window_t inquire_window, *iw;
	uint32_t MinSize, MaxSize, ReqGran, MemWndCaps, WndCaps;
	uint32_t tws;

	iw = &inquire_window;

	for (wn = 0; wn < cs_globals.num_windows; wn++) {
	    cs_window_t *cw;

	    /*
	     * If we can't get a pointer to this window, we should contine
	     *	with scanning the next window, since this window might have
	     *	been dropped.
	     */
	    if ((cw = cs_get_wp(wn)) != NULL) {
	      iw->window = wn;

	      if (SocketServices(SS_InquireWindow, iw) != SUCCESS)
		return (CS_BAD_WINDOW);

	      MinSize = iw->mem_win_char.MinSize;
	      MaxSize = iw->mem_win_char.MaxSize;
	      ReqGran = iw->mem_win_char.ReqGran;
	      MemWndCaps = iw->mem_win_char.MemWndCaps;
	      WndCaps = iw->WndCaps;

	      if (WINDOW_FOR_SOCKET(iw->Sockets, sn) &&
					WINDOW_AVAILABLE_FOR_MEM(cw) &&
					WndCaps & (WC_COMMON|WC_ATTRIBUTE)) {
		if ((error = cs_valid_window_speed(iw, rw->win_params.AccessSpeed)) ==
					CS_SUCCESS) {
		    error = CS_OUT_OF_RESOURCE;
		    if (cs_memwin_space_and_map_ok(iw, rw)) {
			error = CS_BAD_SIZE;
			if (!rw->Size) {
			    min_size = min(min_size, MinSize);
			    window_num = wn;
			    goto found_window;
			} else {
			    if (!(MemWndCaps & WC_SIZE)) {
				if (rw->Size == MinSize) {
				    min_size = MinSize;
				    window_num = wn;
				    goto found_window;
				}
			    } else { /* WC_SIZE */
			      if (!ReqGran) {
				error = CS_BAD_WINDOW;
			      } else {
				if ((rw->Size >= MinSize) &&
							(rw->Size <= MaxSize)) {
				    if (MemWndCaps & WC_POW2) {
				      unsigned rg = ReqGran;
					for (tws = MinSize; tws <= MaxSize;
								rg = (rg<<1)) {
					    if (rw->Size == tws) {
						min_size = tws;
						window_num = wn;
						goto found_window;
					    }
					    tws += rg;
					  } /* for (tws) */
				    } else {
					for (tws = MinSize; tws <= MaxSize;
							tws += ReqGran) {
					    if (rw->Size == tws) {
						min_size = tws;
						window_num = wn;
						goto found_window;
					    }
					  } /* for (tws) */
				    } /* if (!WC_POW2) */
				} /* if (Size >= MinSize) */
			      } /* if (!ReqGran) */
			    } /* if (WC_SIZE) */
			} /* if (rw->Size) */
		    } /* if (cs_space_and_map_ok) */
		} /* if (cs_valid_window_speed) */
	      } /* if (WINDOW_FOR_SOCKET) */
	    } /* if (cs_get_wp) */
	} /* for (wn) */

	/*
	 * If we got here and the window_num wasn't set by any window
	 *	 matches in the above code, it means that we didn't
	 *	find a window matching the caller's criteria.
	 * If the error is CS_BAD_TYPE, it means that the last reason
	 *	that we couldn't match a window was because the caller's
	 *	requested speed was out of range of the last window that
	 *	we checked.  We convert this error code to CS_OUT_OF_RESOURCE
	 *	to conform to the RequestWindow section of the PCMCIA
	 *	Card Services spec.
	 */
	if (window_num == PCMCIA_MAX_WINDOWS) {
	    if (error == CS_BAD_TYPE)
		error = CS_OUT_OF_RESOURCE;
	    return (error);
	}

found_window:
	rw->Size = min_size;
	*assigned_window = window_num;
	iw->window = window_num;
	SocketServices(SS_InquireWindow, iw);
	MemWndCaps = iw->mem_win_char.MemWndCaps;

	if (MemWndCaps & WC_CALIGN)
	    rw->Attributes |= WIN_OFFSET_SIZE;
	else
	    rw->Attributes &= ~WIN_OFFSET_SIZE;
	return (CS_SUCCESS);
}
/* END CSTYLED */

/*
 * cs_memwin_space_and_map_ok - checks to see if the passed window mapping
 *				capabilities and window speeds are in the
 *				range of the passed window.
 *
 *	returns: 0 - if the capabilities are out of range
 *		 1 - if the capabilities are in range
 */
static int
cs_memwin_space_and_map_ok(inquire_window_t *iw, win_req_t *rw)
{

#ifdef	CS_DEBUG
	if (cs_debug > 240)
	    printf("-> s&m_ok: Attributes 0x%x AccessSpeed 0x%x "
					"WndCaps 0x%x MemWndCaps 0x%x\n",
					(int)rw->Attributes,
					(int)rw->win_params.AccessSpeed,
					iw->WndCaps,
					iw->mem_win_char.MemWndCaps);
#endif

	if (rw->win_params.AccessSpeed & WIN_USE_WAIT) {
	    if (!(iw->WndCaps & WC_WAIT))
		return (0);
	}

	if (rw->Attributes & WIN_DATA_WIDTH_16) {
	    if (!(iw->mem_win_char.MemWndCaps & WC_16BIT))
		return (0);
	} else {
	    if (!(iw->mem_win_char.MemWndCaps & WC_8BIT))
		return (0);
	}

	if (rw->Attributes & WIN_MEMORY_TYPE_AM) {
	    if (!(iw->WndCaps & WC_ATTRIBUTE))
		return (0);
	}

	if (rw->Attributes & WIN_MEMORY_TYPE_CM) {
	    if (!(iw->WndCaps & WC_COMMON))
		return (0);
	}

	return (1);
}

/*
 * cs_valid_window_speed - checks to see if requested window speed
 *				is in range of passed window
 *
 *	The inquire_window_t struct gives us speeds in nS, and we
 *	get speeds in the AccessSpeed variable as a devspeed code.
 *
 *	returns: CS_BAD_SPEED - if AccessSpeed is invalid devspeed code
 *		 CS_BAD_TYPE -	if AccessSpeed is not in range of valid
 *				speed for this window
 *		 CS_SUCCESS -	if window speed is in range
 */
static int
cs_valid_window_speed(inquire_window_t *iw, uint32_t AccessSpeed)
{
	convert_speed_t convert_speed, *cs;

	cs = &convert_speed;

	cs->Attributes = CONVERT_DEVSPEED_TO_NS;
	cs->devspeed = AccessSpeed;

	if (cs_convert_speed(cs) != CS_SUCCESS)
	    return (CS_BAD_SPEED);

	if ((cs->nS < iw->mem_win_char.Fastest) ||
		(cs->nS > iw->mem_win_char.Slowest))
	    return (CS_BAD_TYPE);

	return (CS_SUCCESS);
}

/*
 * ==== IO window handling section ====
 */

/*
 * cs_request_io - provides IO resources for clients; this is RequestIO
 *
 *	calling: cs_request_io(client_handle_t, io_req_t *)
 *
 *	returns: CS_SUCCESS - if IO resources available for client
 *		 CS_OUT_OF_RESOURCE - if no windows match requirements
 *		 CS_BAD_HANDLE - client handle is invalid
 *		 CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
 *		 CS_NO_CARD - if no card is in socket
 *		 CS_BAD_ATTRIBUTE - if any of the unsupported Attribute
 *					flags are set
 *		 CS_BAD_BASE - if either or both base port addresses
 *					are invalid or out of range
 *		 CS_CONFIGURATION_LOCKED - a RequestConfiguration has
 *					already been done
 *		 CS_IN_USE - IO ports already in use or function has
 *					already been called
 *		 CS_BAD_WINDOW - if failure while trying to set window
 *					characteristics
 */
static int
cs_request_io(client_handle_t client_handle, io_req_t *ior)
{
	cs_socket_t *sp;
	client_t *client;
	int error;
	int client_lock_acquired;
	uint32_t socket_num;

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't support SS using this call.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_UNSUPPORTED_FUNCTION);

	/*
	 * If the client has only requested one IO range, then make sure
	 *	that the Attributes2 filed is clear.
	 */
	if (!ior->NumPorts2)
	    ior->Attributes2 = 0;

	/*
	 * Make sure that none of the unsupported or reserved flags are set.
	 */
	if ((ior->Attributes1 | ior->Attributes2) &    (IO_SHARED |
							IO_FIRST_SHARED |
							IO_FORCE_ALIAS_ACCESS |
							IO_DEALLOCATE_WINDOW |
							IO_DISABLE_WINDOW))
	    return (CS_BAD_ATTRIBUTE);

	/*
	 * Make sure that we have a port count for the first region.
	 */
	if (!ior->NumPorts1)
	    return (CS_BAD_BASE);

	/*
	 * If we're being asked for multiple IO ranges, then both base port
	 *	members must be non-zero.
	 */
	if ((ior->NumPorts2) && !(ior->BasePort1.base && ior->BasePort2.base))
	    return (CS_BAD_BASE);

	mutex_enter(&cs_globals.window_lock);

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (error);
	}

	/*
	 * If RequestConfiguration has already been done, we don't allow
	 *	this call.
	 */
	if (client->flags & REQ_CONFIGURATION_DONE) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_CONFIGURATION_LOCKED);
	}

	/*
	 * If RequestIO has already been done, we don't allow this call.
	 */
	if (client->flags & REQ_IO_DONE) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_IN_USE);
	}

	mutex_enter(&sp->lock);

	/*
	 * If there's no card in the socket or the card in the socket is not
	 *	for this client, then return an error.
	 */
	if (!(client->flags & CLIENT_CARD_INSERTED)) {
	    mutex_exit(&sp->lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_NO_CARD);
	}

	mutex_exit(&sp->lock);

	/*
	 * If we're only being asked for one IO range, then set BasePort2 to
	 *	zero, since we use it later on.
	 */
	if (!ior->NumPorts2)
	    ior->BasePort2.base = 0;

	/*
	 * See if we can allow Card Services to select the base address
	 *	value for this card; if the client has specified a non-zero
	 *	base IO address but the card doesn't decode enough IO
	 *	address lines to uniquely use that address, then we have
	 *	the flexibility to choose an alternative base address.
	 * Note that if the client specifies that the card decodes zero
	 *	IO address lines, then we have to use the NumPortsX
	 *	values to figure out how many address lines the card
	 *	actually decodes, and we have to round the NumPortsX
	 *	values up to the closest power of two.
	 */
	if (ior->IOAddrLines) {
	    ior->BasePort1.base = IOADDR_FROBNITZ(ior->BasePort1.base,
		ior->IOAddrLines);
	    ior->BasePort2.base = IOADDR_FROBNITZ(ior->BasePort2.base,
		ior->IOAddrLines);
	} else {
	    ior->BasePort1.base = ior->BasePort1.base &
				((IONUMPORTS_FROBNITZ(ior->NumPorts1) +
				IONUMPORTS_FROBNITZ(ior->NumPorts2)) - 1);
	    ior->BasePort2.base = ior->BasePort2.base &
				((IONUMPORTS_FROBNITZ(ior->NumPorts1) +
				IONUMPORTS_FROBNITZ(ior->NumPorts2)) - 1);
	}

	socket_num = CS_MAKE_SOCKET_NUMBER(GET_CLIENT_SOCKET(client_handle),
	    GET_CLIENT_FUNCTION(client_handle));


#ifdef	USE_IOMMAP_WINDOW
	/*
	 * Here is where the code diverges, depending on the type of IO windows
	 *	that this socket supports.  If this socket supportes memory
	 *	mapped IO windows, as determined by cs_init allocating an
	 *	io_mmap_window_t structure on the socket structure, then we
	 *	use one IO window for all the clients on this socket.  We can
	 *	do this safely since a memory mapped IO window implies that
	 *	only this socket shares the complete IO space of the card.
	 * See the next major block of code for a description of what we do
	 *	if a socket doesn't support memory mapped IO windows.
	 */
	if (sp->io_mmap_window) {
	    cs_window_t *cw;
	    io_mmap_window_t *imw = sp->io_mmap_window;
	    uint32_t offset;

		/*
		 * If we haven't allocated an IO window yet, do it now.
		 * Try to allocate the IO window that cs_init found for us;
		 * if that fails, then call cs_find_io_win to find a window.
		 */
	    if (!imw->count) {
		set_window_t set_window;

		if (!WINDOW_AVAILABLE_FOR_IO(imw->number)) {
		    iowin_char_t iowin_char;

		    iowin_char.IOWndCaps = (WC_IO_RANGE_PER_WINDOW |
					    WC_8BIT |
					    WC_16BIT);
		    if ((error = cs_find_io_win(sp->socket_num, &iowin_char,
				    &imw->number, &imw->size)) != CS_SUCCESS) {
			EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
			mutex_exit(&cs_globals.window_lock);
		    } /* cs_find_io_win */
		} /* if (!WINDOW_AVAILABLE_FOR_IO) */

		set_window.socket = socket_num;
		set_window.window = imw->number;
		set_window.speed = IO_WIN_SPEED;
		set_window.base.base = 0;
		set_window.WindowSize = imw->size;
		set_window.state = (WS_ENABLED | WS_16BIT |
				    WS_EXACT_MAPIN | WS_IO);

		/* XXX - what to d here? XXX */
		cs_set_acc_attributes(&set_window, Attributes);

		if (SocketServices(SS_SetWindow, &set_window) != SUCCESS) {
		    (void) cs_setup_io_win(socket_num, imw->number,
						NULL, NULL, NULL,
						(IO_DEALLOCATE_WINDOW |
						IO_DISABLE_WINDOW));
		    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		    mutex_exit(&cs_globals.window_lock);
		    return (CS_BAD_WINDOW);
		}

		imw->handle = set_window.base.handle;
		imw->size = set_window.WindowSize;

		/*
		 * Check the caller's port requirements to be sure that they
		 *	fit within our found IO window.
		 */
		if ((ior->BasePort1.base + ior->NumPorts1 +
			ior->BasePort2.base + ior->NumPorts2) > imw->size) {
		    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		    mutex_exit(&cs_globals.window_lock);
		    return (CS_BAD_BASE);
		}

		if ((cw = cs_get_wp(imw->number)) == NULL) {
		    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		    mutex_exit(&cs_globals.window_lock);
		    return (CS_BAD_WINDOW)
		}
		cw->state |= (CW_ALLOCATED | CW_IO);

	    } /* if (!imw->count) */

	    imw->count++;

		/*
		 * All common access handles for this type of adapter are
		 * duped.  We never give the original back to the caller.
		 */
	    /* XXX need to set endianess and data ordering flags */
	    csx_DupHandle(imw->handle, &ior->BasePort1.handle, 0);
	    csx_GetHandleOffset(ior->BasePort1.handle, &offset);
	    csx_SetHandleOffset(ior->BasePort1.handle,
		ior->BasePort1.base + offset);

	    if (ior->NumPorts2) {
		/* XXX need to set endianess and data ordering flags */
		csx_DupHandle(imw->handle, &ior->BasePort2.handle, 0);
		csx_GetHandleOffset(ior->BasePort2.handle, &offset);
		csx_SetHandleOffset(ior->BasePort2.handle,
		    ior->BasePort1.base + offset);
	    }

		/*
		 * We don't really use these two values if we've got a memory
		 * mapped IO window since the assigned window number is stored
		 * in imw->number.
		 */
	    client->io_alloc.Window1 = imw->number;
	    client->io_alloc.Window2 = PCMCIA_MAX_WINDOWS;

	/*
	 * This socket supports only IO port IO windows.
	 */
	} else {
#else	/* USE_IOMMAP_WINDOW */
	{
#endif	/* USE_IOMMAP_WINDOW */
	    baseaddru_t baseaddru;

	    baseaddru.base = ior->BasePort1.base;

	    if ((error = cs_allocate_io_win(sp->socket_num, ior->Attributes1,
		&client->io_alloc.Window1)) != CS_SUCCESS) {

		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		mutex_exit(&cs_globals.window_lock);
		return (error);
	    } /* if (cs_allocate_io_win(1)) */

		/*
		 * Setup the window hardware; if this fails, then we need to
		 *	deallocate the previously allocated window.
		 */
	    if ((error = cs_setup_io_win(socket_num,
						client->io_alloc.Window1,
						&baseaddru,
						&ior->NumPorts1,
						ior->IOAddrLines,
						ior->Attributes1)) !=
								CS_SUCCESS) {
		(void) cs_setup_io_win(socket_num, client->io_alloc.Window1,
					NULL, NULL, NULL,
					(
						IO_DEALLOCATE_WINDOW |
						IO_DISABLE_WINDOW));

		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		mutex_exit(&cs_globals.window_lock);
		return (error);
	    } /* if (cs_setup_io_win(1)) */

	    ior->BasePort1.handle = (acc_handle_t)baseaddru.handle;
	    ior->BasePort1.base = baseaddru.base;

		/*
		 * See if the client wants two IO ranges.
		 */
	    if (ior->NumPorts2) {
		baseaddru_t baseaddru;

		baseaddru.base = ior->BasePort2.base;

		/*
		 * If we fail to allocate this window, then we must deallocate
		 *	the previous IO window that is already allocated.
		 */
		if ((error = cs_allocate_io_win(sp->socket_num,
						ior->Attributes2,
						&client->io_alloc.Window2)) !=
								CS_SUCCESS) {
		    (void) cs_setup_io_win(socket_num,
						client->io_alloc.Window2,
						NULL, NULL, NULL,
						(
							IO_DEALLOCATE_WINDOW |
							IO_DISABLE_WINDOW));
		    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		    mutex_exit(&cs_globals.window_lock);
		    return (error);
		} /* if (cs_allocate_io_win(2)) */
		/*
		 * Setup the window hardware; if this fails, then we need to
		 *	deallocate the previously allocated window.
		 */
		if ((error = cs_setup_io_win(socket_num,
						client->io_alloc.Window2,
						&baseaddru,
						&ior->NumPorts2,
						ior->IOAddrLines,
						ior->Attributes2)) !=
								CS_SUCCESS) {
		    (void) cs_setup_io_win(socket_num,
						client->io_alloc.Window1,
						NULL, NULL, NULL,
						(
							IO_DEALLOCATE_WINDOW |
							IO_DISABLE_WINDOW));
		    (void) cs_setup_io_win(socket_num,
						client->io_alloc.Window2,
						NULL, NULL, NULL,
						(
							IO_DEALLOCATE_WINDOW |
							IO_DISABLE_WINDOW));
		    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		    mutex_exit(&cs_globals.window_lock);
		    return (error);
		} /* if (cs_setup_io_win(2)) */

		ior->BasePort2.handle = (acc_handle_t)baseaddru.handle;
		ior->BasePort2.base = baseaddru.base;

	    } else {
		client->io_alloc.Window2 = PCMCIA_MAX_WINDOWS;
	    } /* if (ior->NumPorts2) */
	} /* if (sp->io_mmap_window) */

	/*
	 * Save a copy of the client's port information so that we
	 *	can use it in the RequestConfiguration call.  We set
	 *	the IO window number(s) allocated in the respective
	 *	section of code, above.
	 */
	client->io_alloc.BasePort1.base = ior->BasePort1.base;
	client->io_alloc.BasePort1.handle = ior->BasePort1.handle;
	client->io_alloc.NumPorts1 = ior->NumPorts1;
	client->io_alloc.Attributes1 = ior->Attributes1;
	client->io_alloc.BasePort2.base = ior->BasePort2.base;
	client->io_alloc.BasePort2.handle = ior->BasePort2.handle;
	client->io_alloc.NumPorts2 = ior->NumPorts2;
	client->io_alloc.Attributes2 = ior->Attributes2;
	client->io_alloc.IOAddrLines = ior->IOAddrLines;

	/*
	 * Mark this client as having done a successful RequestIO call.
	 */
	client->flags |= (REQ_IO_DONE | CLIENT_IO_ALLOCATED);

	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	mutex_exit(&cs_globals.window_lock);

	return (CS_SUCCESS);
}

/*
 * cs_release_io - releases IO resources allocated by RequestIO; this is
 *			ReleaseIO
 *
 *	calling: cs_release_io(client_handle_t, io_req_t *)
 *
 *	returns: CS_SUCCESS - if IO resources sucessfully deallocated
 *		 CS_BAD_HANDLE - client handle is invalid
 *		 CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
 *		 CS_CONFIGURATION_LOCKED - a RequestConfiguration has been
 *				done without a ReleaseConfiguration
 *		 CS_IN_USE - no RequestIO has been done
 */
static int
cs_release_io(client_handle_t client_handle, io_req_t *ior)
{
	cs_socket_t *sp;
	client_t *client;
	int error;
	int client_lock_acquired;
	uint32_t socket_num;

#ifdef	lint
	ior = NULL;
#endif

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't support SS using this call.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_UNSUPPORTED_FUNCTION);

	mutex_enter(&cs_globals.window_lock);

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (error);
	}

	/*
	 * If RequestConfiguration has already been done, we don't allow
	 *	this call.
	 */
	if (client->flags & REQ_CONFIGURATION_DONE) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_CONFIGURATION_LOCKED);
	}

	/*
	 * If RequestIO has not been done, we don't allow this call.
	 */
	if (!(client->flags & REQ_IO_DONE)) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_IN_USE);
	}

	socket_num = CS_MAKE_SOCKET_NUMBER(GET_CLIENT_SOCKET(client_handle),
	    GET_CLIENT_FUNCTION(client_handle));

#ifdef	XXX
	/*
	 * Check the passed IO allocation with the stored allocation; if
	 *	they don't match, then return an error.
	 */
	if ((client->io_alloc.BasePort1 != ior->BasePort1) ||
	    (client->io_alloc.NumPorts1 != ior->NumPorts1) ||
	    (client->io_alloc.Attributes1 != ior->Attributes1) ||
	    (client->io_alloc.BasePort2 != ior->BasePort2) ||
	    (client->io_alloc.NumPorts2 != ior->NumPorts2) ||
	    (client->io_alloc.Attributes2 != ior->Attributes2) ||
	    (client->io_alloc.IOAddrLines != ior->IOAddrLines)) {
		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		mutex_exit(&cs_globals.window_lock);
		return (CS_BAD_ARGS);
	}
#endif

#ifdef	USE_IOMMAP_WINDOW
	/*
	 * The code diverges here depending on if this socket supports
	 *	memory mapped IO windows or not.  See comments in the
	 *	cs_request_io function for a description of what's
	 *	going on here.
	 */
	if (sp->io_mmap_window) {
	    io_mmap_window_t *imw = sp->io_mmap_window;

		/*
		 * We should never see this; if we do, it's an internal
		 *	consistency error.
		 */
	    if (!imw->count) {
		cmn_err(CE_CONT, "cs_release_io: socket %d !imw->count\n",
							    sp->socket_num);
		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		mutex_exit(&cs_globals.window_lock);
		return (CS_GENERAL_FAILURE);
	    }

		/*
		 * All common access handles for this type of adapter are
		 *	duped. We never give the original back to the caller,
		 *	so it's OK to unconditionally free the handle here.
		 */
	    csx_FreeHandle(&ior->BasePort1.handle);

		/*
		 * If the IO window referance count is zero, then deallocate
		 * and disable this window.
		 */
	    if (!--(imw->count)) {
		(void) cs_setup_io_win(socket_num, imw->number, NULL,
								NULL, NULL,
						(
							IO_DEALLOCATE_WINDOW |
							IO_DISABLE_WINDOW));
	    } /* if (imw->count) */
	} else {
#endif	/* USE_IOMMAP_WINDOW */
	    (void) cs_setup_io_win(socket_num, client->io_alloc.Window1,
						NULL, NULL, NULL,
						(
							IO_DEALLOCATE_WINDOW |
							IO_DISABLE_WINDOW));
	    if (client->io_alloc.Window2 != PCMCIA_MAX_WINDOWS)
		(void) cs_setup_io_win(socket_num, client->io_alloc.Window2,
						NULL, NULL, NULL,
						(
							IO_DEALLOCATE_WINDOW |
							IO_DISABLE_WINDOW));
#ifdef	USE_IOMMAP_WINDOW
	} /* if (sp->io_mmap_window) */
#endif	/* USE_IOMMAP_WINDOW */

	/*
	 * Mark the client as not having any IO resources allocated.
	 */
	client->flags &= ~(REQ_IO_DONE | CLIENT_IO_ALLOCATED);

	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	mutex_exit(&cs_globals.window_lock);
	return (CS_SUCCESS);
}

/*
 * cs_find_io_win - finds an IO window that matches the parameters specified
 *			in the flags argument
 *
 *	calling: sn - socket number to look for IO window on
 *		 *iwc - other window characteristics to match
 *		 *assigned_window - pointer to where we return the assigned
 *					window number if we found a window or
 *					undefined otherwise
 *		 *size - if non-NULL, the found window size will be stored here
 *
 *	returns: CS_SUCCESS - if IO window found
 *		 CS_OUT_OF_RESOURCE - if no windows match requirements
 */
static int
cs_find_io_win(uint32_t sn, iowin_char_t *iwc, uint32_t *assigned_window,
    uint32_t *size)
{
	inquire_window_t inquire_window, *iw;
	unsigned wn;

	iw = &inquire_window;

	for (wn = 0; wn < cs_globals.num_windows; wn++) {
	    iowin_char_t *iowc;
	    cs_window_t *cw;

	    if ((cw = cs_get_wp(wn)) != NULL) {

		iw->window = wn;
		SocketServices(SS_InquireWindow, iw);

		iowc = &iw->iowin_char;

		if (WINDOW_FOR_SOCKET(iw->Sockets, sn) &&
		    WINDOW_AVAILABLE_FOR_IO(cw) &&
		    (iw->WndCaps & WC_IO) &&
		    ((iowc->IOWndCaps & iwc->IOWndCaps) == iwc->IOWndCaps)) {

			*assigned_window = wn;

			if (size)
			    *size = iw->iowin_char.ReqGran;
			return (CS_SUCCESS);
		    } /* if (WINDOW_FOR_SOCKET) */
	    } /* cs_get_wp */
	} /* for (wn) */

	return (CS_OUT_OF_RESOURCE);
}

/*
 * cs_allocate_io_win - finds and allocates an IO window
 *
 *	calling: sn - socket number to look for window on
 *		 Attributes - window attributes in io_req_t.Attributes format
 *		 *assigned_window - pointer to return assigned window number
 *
 *	returns: CS_SUCCESS - IO window found and allocated
 *		 CS_OUT_OF_RESOURCE - if cs_find_io_win couldn't find a
 *				window that matches the passed criteria
 *
 * Note: This fucntion will find and allocate an IO window.  The caller is
 *	responsible for deallocating the window.
 */
static int
cs_allocate_io_win(uint32_t sn, uint32_t Attributes, uint32_t *assigned_window)
{
	iowin_char_t iowin_char;
	cs_window_t *cw;

	iowin_char.IOWndCaps =
		((Attributes & IO_DATA_PATH_WIDTH_16)?WC_16BIT:WC_8BIT);

	if (cs_find_io_win(sn, &iowin_char, assigned_window, NULL) ==
								CS_SUCCESS) {
	    if ((cw = cs_get_wp(*assigned_window)) == NULL)
		return (CS_OUT_OF_RESOURCE);

	    cw->state = (cw->state & CW_WINDOW_VALID) | (CW_ALLOCATED | CW_IO);
	    return (CS_SUCCESS);
	}

	return (CS_OUT_OF_RESOURCE);
}

/*
 * cs_setup_io_win - setup and destroy an IO window
 *
 *	calling: sn - socket number
 *		 wn - window number
 * XXX Base - pointer to XXX
 *		 *NumPorts - pointer to number of allocated ports to return
 *		 IOAddrLines - number of IO address lines decoded by this card
 *		 Attributes - either io_req_t attributes, or a combination of
 *				the following flags:
 *				    IO_DEALLOCATE_WINDOW - deallocate the window
 *				    IO_DISABLE_WINDOW - disable the window
 *				When either of these two flags are set, *Base
 *				    and NumPorts should be NULL.
 *
 *	returns: CS_SUCCESS - if no failure
 *		 CS_BAD_WINDOW - if error while trying to configure window
 *
 * Note: We use the IOAddrLines value to determine what base address to pass
 *		to Socket Services.
 */
static int
cs_setup_io_win(uint32_t sn, uint32_t wn, baseaddru_t *Base, uint32_t *NumPorts,
    uint32_t IOAddrLines, uint32_t Attributes)
{
	set_window_t set_window;

	if (Attributes & (IO_DEALLOCATE_WINDOW | IO_DISABLE_WINDOW)) {

	    if (Attributes & IO_DEALLOCATE_WINDOW) {
		cs_window_t *cw;

		if ((cw = cs_get_wp(wn)) == NULL)
		    return (CS_BAD_WINDOW);
		cw->state &= CW_WINDOW_VALID;

	    } /* IO_DEALLOCATE_WINDOW */

	    if (Attributes & IO_DISABLE_WINDOW) {
		get_window_t get_window;

		get_window.window = wn;

		SocketServices(SS_GetWindow, &get_window);

		set_window.socket = get_window.socket;
		set_window.window = get_window.window;
		set_window.speed = get_window.speed;
		set_window.base = 0;
		set_window.WindowSize = get_window.size;
		set_window.state = get_window.state & ~WS_ENABLED;

		cs_set_acc_attributes(&set_window, Attributes);

		SocketServices(SS_SetWindow, &set_window);
	    } /* IO_DISABLE_WINDOW */

	    return (CS_SUCCESS);

	} /* if (IO_DEALLOCATE_WINDOW | IO_DISABLE_WINDOW) */

	/*
	 * See if we can allow Socket Services to select the base address
	 *	value for this card; if the client has specified a non-zero
	 *	base IO address but the card doesn't decode enough IO
	 *	address lines to uniquely use that address, then we have
	 *	the flexibility to choose an alternative base address.
	 * XXX - Is this really correct in all cases?
	 */
	if (!IOAddrLines)
	    Base->base = 0;
	else
	    Base->base = IOADDR_FROBNITZ(Base->base, IOAddrLines);

	set_window.socket = sn;
	set_window.window = wn;
	set_window.speed = IO_WIN_SPEED;
	set_window.base = Base->base;
	set_window.WindowSize = *NumPorts;
	set_window.state = (WS_ENABLED | WS_IO |
			((Attributes & IO_DATA_PATH_WIDTH_16)?WS_16BIT:0));

	cs_set_acc_attributes(&set_window, Attributes);

	if (SocketServices(SS_SetWindow, &set_window) != SUCCESS)
	    return (CS_BAD_WINDOW);

	Base->base = set_window.base;
	Base->handle = set_window.handle;
	*NumPorts = set_window.WindowSize;

	return (CS_SUCCESS);
}

/*
 * ==== IRQ handling functions ====
 */

/*
 * cs_request_irq - add's client's IRQ handler; supports RequestIRQ
 *
 *	calling: irq_req_t.Attributes - must have the IRQ_TYPE_EXCLUSIVE
 *			flag set, and all other flags clear, or
 *			CS_BAD_ATTRIBUTE will be returned
 *
 *	returns: CS_SUCCESS - if IRQ resources available for client
 *		 CS_BAD_IRQ - if IRQ can not be allocated
 *		 CS_BAD_HANDLE - client handle is invalid
 *		 CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
 *		 CS_NO_CARD - if no card is in socket
 *		 CS_BAD_ATTRIBUTE - if any of the unsupported Attribute
 *					flags are set
 *		 CS_CONFIGURATION_LOCKED - a RequestConfiguration has
 *					already been done
 *		 CS_IN_USE - IRQ ports already in use or function has
 *					already been called
 *
 * Note: We only allow level-mode interrupts.
 */
static int
cs_request_irq(client_handle_t client_handle, irq_req_t *irqr)
{
	cs_socket_t *sp;
	client_t *client;
	set_irq_handler_t set_irq_handler;
	int error;
	int client_lock_acquired;

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't support SS using this call.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_UNSUPPORTED_FUNCTION);

	/*
	 * Make sure that none of the unsupported or reserved flags are set.
	 */
	if ((irqr->Attributes &	(IRQ_TYPE_TIME | IRQ_TYPE_DYNAMIC_SHARING |
				IRQ_FIRST_SHARED | IRQ_PULSE_ALLOCATED |
				IRQ_FORCED_PULSE)) ||
		!(irqr->Attributes & IRQ_TYPE_EXCLUSIVE))
	    return (CS_BAD_ATTRIBUTE);

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (error);
	}

	/*
	 * If RequestConfiguration has already been done, we don't allow
	 *	this call.
	 */
	if (client->flags & REQ_CONFIGURATION_DONE) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_CONFIGURATION_LOCKED);
	}

	/*
	 * If RequestIRQ has already been done, we don't allow this call.
	 */
	if (client->flags & REQ_IRQ_DONE) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_IN_USE);
	}

	/*
	 * If there's no card in the socket or the card in the socket is not
	 *	for this client, then return an error.
	 */
	if (!(client->flags & CLIENT_CARD_INSERTED)) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_NO_CARD);
	}

	/*
	 * Set up the parameters and ask Socket Services to give us an IRQ
	 *	for this client.  We don't really do much, since the IRQ
	 *	resources are managed by SS and the kernel.  We also don't
	 *	care which IRQ level we are given.
	 */
	set_irq_handler.socket =
		CS_MAKE_SOCKET_NUMBER(GET_CLIENT_SOCKET(client_handle),
					GET_CLIENT_FUNCTION(client_handle));
	set_irq_handler.irq = IRQ_ANY;

	set_irq_handler.handler_id = client_handle;
	set_irq_handler.handler = (f_t *)irqr->irq_handler;
	set_irq_handler.arg1 = irqr->irq_handler_arg;
	set_irq_handler.arg2 = NULL;

	if ((error = SocketServices(SS_SetIRQHandler,
					&set_irq_handler)) != SUCCESS) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_BAD_IRQ);
	}

	irqr->iblk_cookie = set_irq_handler.iblk_cookie;
	irqr->idev_cookie = set_irq_handler.idev_cookie;

	/*
	 * Save the allocated IRQ information for this client.
	 */
	client->irq_alloc.Attributes = irqr->Attributes;
	client->irq_alloc.irq = set_irq_handler.irq;
	client->irq_alloc.handler_id = set_irq_handler.handler_id;
	client->irq_alloc.irq_handler = (f_t *)set_irq_handler.handler;
	client->irq_alloc.irq_handler_arg1 = set_irq_handler.arg1;
	client->irq_alloc.irq_handler_arg2 = set_irq_handler.arg2;

#ifdef	CS_DEBUG
	if (cs_debug > 0)
	    cmn_err(CE_CONT, "cs_request_irq: socket %d irqr->Attributes 0x%x "
						"set_irq_handler.irq 0x%x\n",
						sp->socket_num,
						(int)irqr->Attributes,
						set_irq_handler.irq);
#endif

	/*
	 * Mark this client as having done a successful RequestIRQ call.
	 */
	client->flags |= (REQ_IRQ_DONE | CLIENT_IRQ_ALLOCATED);

	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	return (CS_SUCCESS);
}

/*
 * cs_release_irq - releases IRQ resources allocated by RequestIRQ; this is
 *			ReleaseIRQ
 *
 *	calling: cs_release_irq(client_handle_t, irq_req_t *)
 *
 *	returns: CS_SUCCESS - if IRQ resources sucessfully deallocated
 *		 CS_BAD_IRQ - if IRQ can not be deallocated
 *		 CS_BAD_HANDLE - client handle is invalid
 *		 CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
 *		 CS_CONFIGURATION_LOCKED - a RequestConfiguration has been
 *				done without a ReleaseConfiguration
 *		 CS_IN_USE - no RequestIRQ has been done
 */
static int
cs_release_irq(client_handle_t client_handle, irq_req_t *irqr)
{
	cs_socket_t *sp;
	client_t *client;
	clear_irq_handler_t clear_irq_handler;
	int error;
	int client_lock_acquired;

#ifdef	lint
	irqr = NULL;
#endif

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't support SS using this call.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_UNSUPPORTED_FUNCTION);

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (error);
	}

	/*
	 * If RequestConfiguration has already been done, we don't allow
	 *	this call.
	 */
	if (client->flags & REQ_CONFIGURATION_DONE) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_CONFIGURATION_LOCKED);
	}

	/*
	 * If RequestIRQ has not been done, we don't allow this call.
	 */
	if (!(client->flags & REQ_IRQ_DONE)) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_IN_USE);
	}

	/*
	 * Tell Socket Services that we want to deregister this client's
	 *	IRQ handler.
	 */
	clear_irq_handler.socket =
		CS_MAKE_SOCKET_NUMBER(GET_CLIENT_SOCKET(client_handle),
				GET_CLIENT_FUNCTION(client_handle));
	clear_irq_handler.handler_id = client->irq_alloc.handler_id;
	clear_irq_handler.handler = (f_t *)client->irq_alloc.irq_handler;

	/*
	 * At this point, we should never fail this SS call; if we do, it
	 *	means that there is an internal consistancy error in either
	 *	Card Services or Socket Services.
	 */
	if ((error = SocketServices(SS_ClearIRQHandler, &clear_irq_handler)) !=
								SUCCESS) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_BAD_IRQ);
	}

	/*
	 * Mark the client as not having any IRQ resources allocated.
	 */
	client->flags &= ~(REQ_IRQ_DONE | CLIENT_IRQ_ALLOCATED);

	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	return (CS_SUCCESS);
}

/*
 * ==== configuration handling functions ====
 */

/*
 * cs_request_configuration - sets up socket and card configuration on behalf
 *		of the client; this is RequestConfiguration
 *
 *	returns: CS_SUCCESS - if configuration sucessfully set
 *		 CS_BAD_SOCKET - if Socket Services returns an error
 *		 CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
 *		 CS_BAD_ATTRIBUTE - if any unsupported or reserved flags
 *					are set
 *		 CS_BAD_TYPE - if the socket doesn't support a mem and IO
 *				interface (SOCKET_INTERFACE_MEMORY_AND_IO set)
 *		 CS_CONFIGURATION_LOCKED - a RequestConfiguration has
 *					already been done
 *		 CS_BAD_VCC - if Vcc value is not supported by socket
 *		 CS_BAD_VPP1 - if Vpp1 value is not supported by socket
 *		 CS_BAD_VPP2 - if Vpp2 value is not supported by socket
 *
 * Bug ID: 1193637 - Card Services RequestConfiguration does not conform
 *	to PCMCIA standard
 * We allow clients to do a RequestConfiguration even if they haven't
 *	done a RequestIO or RequestIRQ.
 */
static int
cs_request_configuration(client_handle_t client_handle, config_req_t *cr)
{
	cs_socket_t *sp;
	client_t *client;
	volatile config_regs_t *crt;
	set_socket_t set_socket;
	get_socket_t get_socket;
	acc_handle_t cis_handle;
	int error;
	uint32_t newoffset;
	int client_lock_acquired;

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't support SS using this call.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_UNSUPPORTED_FUNCTION);

#ifdef	XXX
	/*
	 * If the client specifies Vcc = 0 and any non-zero value for
	 *	either of the Vpp members, that's an illegal condition.
	 */
	if (!(cr->Vcc) && (cr->Vpp1 || cr->Vpp2))
	    return (CS_BAD_VCC);
#endif

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	/*
	 * If the client is asking for a memory and IO interface on this
	 *	socket, then check the socket capabilities to be sure that
	 *	this socket supports this configuration.
	 */
	if (cr->IntType & SOCKET_INTERFACE_MEMORY_AND_IO) {
	    inquire_socket_t inquire_socket;

	    inquire_socket.socket = sp->socket_num;

	    if (SocketServices(SS_InquireSocket, &inquire_socket) != SUCCESS)
		return (CS_BAD_SOCKET);

	    if (!(inquire_socket.SocketCaps & IF_IO))
		return (CS_BAD_TYPE);

	} /* if (SOCKET_INTERFACE_MEMORY_AND_IO) */

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (error);
	}

	/*
	 * If RequestConfiguration has already been done, we don't allow
	 *	this call.
	 */
	if (client->flags & REQ_CONFIGURATION_DONE) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_CONFIGURATION_LOCKED);
	}

	/*
	 * If there's no card in the socket or the card in the socket is not
	 *	for this client, then return an error.
	 */
	if (!(client->flags & CLIENT_CARD_INSERTED)) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_NO_CARD);
	}

	/*
	 * At this point, most of the client's calling parameters have been
	 *	validated, so we can go ahead and configure the socket and
	 *	the card.
	 */
	mutex_enter(&sp->cis_lock);

	/*
	 * Configure the socket with the interface type and voltages requested
	 *	by the client.
	 */
	get_socket.socket = sp->socket_num;

	if (SocketServices(SS_GetSocket, &get_socket) != SUCCESS) {
	    mutex_exit(&sp->cis_lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_BAD_SOCKET);
	}

#ifdef	CS_DEBUG
	if (cs_debug > 0)
	    cmn_err(CE_CONT, "cs_request_configuration: socket %d "
					"client->irq_alloc.irq 0x%x "
					"get_socket.IRQRouting 0x%x\n",
						sp->socket_num,
						(int)client->irq_alloc.irq,
						get_socket.IRQRouting);
#endif

	bzero(&set_socket, sizeof (set_socket));
	set_socket.socket = sp->socket_num;
	set_socket.IREQRouting = client->irq_alloc.irq & ~IRQ_ENABLE;

	set_socket.CtlInd = get_socket.CtlInd;
	set_socket.State = 0;	/* don't reset latched values */

	if (cs_convert_powerlevel(sp->socket_num, cr->Vcc, VCC,
					&set_socket.VccLevel) != CS_SUCCESS) {
	    mutex_exit(&sp->cis_lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_BAD_VCC);
	}

	if (cs_convert_powerlevel(sp->socket_num, cr->Vpp1, VPP1,
					&set_socket.Vpp1Level) != CS_SUCCESS) {
	    mutex_exit(&sp->cis_lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_BAD_VPP);
	}

	if (cs_convert_powerlevel(sp->socket_num, cr->Vpp2, VPP2,
					&set_socket.Vpp2Level) != CS_SUCCESS) {
	    mutex_exit(&sp->cis_lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_BAD_VPP);
	}

	if (!(cr->IntType & SOCKET_INTERFACE_MEMORY_AND_IO))
		set_socket.IFType = IF_MEMORY;
	else {
		set_socket.IFType = IF_IO;

		/*
		 * The Cirrus Logic PD6710/672X/others? adapters will write
		 * protect the CIS if the socket is in MEMORY mode and the
		 * WP/IOCS16 pin is true.  When this happens, the CIS registers
		 * will fail to be written.  Go ahead and set the socket,
		 * even though the event mask isn't complete yet, so we can
		 * configure the adapter.  Afterwards, set the socket again
		 * to make sure the event mask is correct.
		 */
		if (SocketServices(SS_SetSocket, &set_socket) != SUCCESS) {
			sp->flags &= ~SOCKET_IS_IO;
			mutex_exit(&sp->cis_lock);
			EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
			return (CS_BAD_SOCKET);
		}
	}

	if (cs_rc2_delay)
	    drv_usecwait(cs_rc2_delay * 1000);

	/*
	 * Get a pointer to a window that contains the configuration
	 *	registers.
	 */
	mutex_enter(&sp->lock);
	client->config_regs_offset = cr->ConfigBase;
	newoffset = client->config_regs_offset;
	mutex_exit(&sp->lock);
	if (cs_init_cis_window(sp, &newoffset, &cis_handle,
					CISTPLF_AM_SPACE) != CS_SUCCESS) {
	    mutex_exit(&sp->cis_lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    cmn_err(CE_CONT, "cs_request_configuration: socket %d can't init "
				"CIS window\n", sp->socket_num);
	    return (CS_GENERAL_FAILURE);
	}

	/*
	 * Setup the config register pointers.
	 * Note that these pointers are not the complete virtual address;
	 *	the complete address is constructed each time the registers
	 *	are accessed.
	 */
	mutex_enter(&sp->lock);
	crt = &client->config_regs;
	client->present = cr->Present;

	bzero((char *)crt, sizeof (config_regs_t));

	/* Configuration Option Register */
	if (client->present & CONFIG_OPTION_REG_PRESENT)
	    crt->cor_p = (newoffset + CONFIG_OPTION_REG_OFFSET);

	/* Configuration and Status Register */
	if (client->present & CONFIG_STATUS_REG_PRESENT)
	    crt->ccsr_p = (newoffset + CONFIG_STATUS_REG_OFFSET);

	/* Pin Replacement Register */
	if (client->present & CONFIG_PINREPL_REG_PRESENT)
	    crt->prr_p = (newoffset + CONFIG_PINREPL_REG_OFFSET);

	/* Socket and Copy Register */
	if (client->present & CONFIG_COPY_REG_PRESENT)
	    crt->scr_p = (newoffset + CONFIG_COPY_REG_OFFSET);

	/* Extended Status Register */
	if (client->present & CONFIG_EXSTAT_REG_PRESENT)
	    crt->exstat_p = (newoffset + CONFIG_EXSTAT_REG_OFFSET);

	/* IO Base 0 Register */
	if (client->present & CONFIG_IOBASE0_REG_PRESENT)
	    crt->iobase0_p = (newoffset + CONFIG_IOBASE0_REG_OFFSET);

	/* IO Base 1 Register */
	if (client->present & CONFIG_IOBASE1_REG_PRESENT)
	    crt->iobase1_p = (newoffset + CONFIG_IOBASE1_REG_OFFSET);

	/* IO Base 2 Register */
	if (client->present & CONFIG_IOBASE2_REG_PRESENT)
	    crt->iobase2_p = (newoffset + CONFIG_IOBASE2_REG_OFFSET);

	/* IO Base 3 Register */
	if (client->present & CONFIG_IOBASE3_REG_PRESENT)
	    crt->iobase3_p = (newoffset + CONFIG_IOBASE3_REG_OFFSET);

	/* IO Limit Register */
	if (client->present & CONFIG_IOLIMIT_REG_PRESENT)
	    crt->iolimit_p = (newoffset + CONFIG_IOLIMIT_REG_OFFSET);

	/*
	 * Setup the bits in the PRR mask that are valid; this is easy, just
	 *	copy the Pin value that the client gave us.  Note that for
	 *	this to work, the client must set both of the XXX_STATUS
	 *	and the XXX_EVENT bits in the Pin member.
	 */
	client->pin = cr->Pin;

#ifdef	CS_DEBUG
	if (cs_debug > 128)
	    cmn_err(CE_CONT, "cs_request_configuration: client->pin 0x%x "
		"client->config_regs_offset 0x%x newoffset 0x%x cor_p 0x%x "
		"ccsr_p 0x%x prr_p 0x%x scr_p 0x%x\n",
		client->pin, (int)client->config_regs_offset, newoffset,
		(int)crt->cor_p, (int)crt->ccsr_p, (int)crt->prr_p,
		(int)crt->scr_p);
#endif

	/*
	 * If the socket isn't in IO mode, WP is asserted,  and we're going to
	 * write any of the config registers, issue a warning.
	 */
	if ((client->present != 0) &&
	    (!(cr->IntType & SOCKET_INTERFACE_MEMORY_AND_IO)) &&
	    (get_socket.state & SBM_WP)) {
		cmn_err(CE_NOTE, "!cs_request_configuration: attempting to "
		    "write CIS config regs with WP set\n");
	}

	/*
	 * Write any configuration registers that the client tells us are
	 *	present to the card; save a copy of what we wrote so that we
	 *	can return them if the client calls GetConfigurationInfo.
	 * The order in which we write the configuration registers is
	 *	specified by the PCMCIA spec; we must write the socket/copy
	 *	register first (if it exists), and then we can write the
	 *	registers in any arbitrary order.
	 */
	/* Socket and Copy Register */
	if (client->present & CONFIG_COPY_REG_PRESENT) {
	    crt->scr = cr->Copy;
	    csx_Put8(cis_handle, crt->scr_p, crt->scr);
	}

	/* Pin Replacement Register */
	if (client->present & CONFIG_PINREPL_REG_PRESENT) {
	    crt->prr = cr->Pin;
	    csx_Put8(cis_handle, crt->prr_p, crt->prr);
	}

	/* Configuration and Status Register */
	/* XXX should we set CCSR_SIG_CHG in the CCSR? XXX */
	if (client->present & CONFIG_STATUS_REG_PRESENT) {
	    crt->ccsr = cr->Status;
	    csx_Put8(cis_handle, crt->ccsr_p, crt->ccsr);
	}

	/* Extended Status Register */
	if (client->present & CONFIG_EXSTAT_REG_PRESENT) {
	    crt->exstat = cr->ExtendedStatus;
	    csx_Put8(cis_handle, crt->exstat_p, crt->exstat);
	}

	/*
	 * If any IO base and limit registers exist, and this client
	 *	has done a RequestIO, setup the IO Base and IO Limit
	 *	registers.
	 */
	if (client->flags & REQ_IO_DONE) {
	    if (client->present & CONFIG_IOBASE0_REG_PRESENT) {
		uint32_t base = client->io_alloc.BasePort1.base;
		uint32_t present = (client->present &
					CONFIG_IOBASE_REG_MASK) >>
						CONFIG_IOBASE_REG_SHIFT;
		uint32_t reg = crt->iobase0_p;

		do {
		    csx_Put8(cis_handle, reg, base & 0x0ff);
		    reg = reg + 2;
		    base = base >> 8;
		    present = present >> 1;
		} while (present);
	    } /* CONFIG_IOBASE0_REG_PRESENT */

	    if (client->present & CONFIG_IOLIMIT_REG_PRESENT) {
		uint32_t np = client->io_alloc.NumPorts1 +
					client->io_alloc.NumPorts2;
		uint32_t limit, do_bit = 0;
		int lm;

		limit = (IONUMPORTS_FROBNITZ(np) - 1);

		for (lm = 7; lm >= 0; lm--) {
		    if (limit & (1 << lm))
			do_bit = 1;
		    if (do_bit)
			limit |= (1 << lm);
		} /* for */

		csx_Put8(cis_handle, crt->iolimit_p, limit);
	    } /* CONFIG_IOLIMIT_REG_PRESENT */
	} /* REQ_IO_DONE */

	/*
	 * Mark the socket as being in IO mode.
	 */
	if (cr->IntType & SOCKET_INTERFACE_MEMORY_AND_IO)
	    sp->flags |= SOCKET_IS_IO;

	mutex_exit(&sp->lock);

	/*
	 * Enable the interrupt if needed
	 */
	if (cr->Attributes & CONF_ENABLE_IRQ_STEERING)
	    set_socket.IREQRouting |= IRQ_ENABLE;

	/*
	 * Now that we know if the PRR is present and if it is, which
	 *	bits in the PRR are valid, we can construct the correct
	 *	socket event mask.
	 */
	set_socket.SCIntMask = cs_merge_event_masks(sp, client);

	/*
	 * Configuration Option Register - we handle this specially since
	 *	we don't allow the client to manipulate the RESET or
	 *	INTERRUPT bits (although a client can manipulate these
	 *	bits via an AccessConfigurationRegister call - explain
	 *	THAT logic to me).
	 * XXX - we force level-mode interrupts (COR_LEVEL_IRQ)
	 * XXX - we always enable the function on a multi-function card
	 */
	if (client->present & CONFIG_OPTION_REG_PRESENT) {
	    crt->cor = (cr->ConfigIndex & ~COR_SOFT_RESET) | COR_LEVEL_IRQ;
	    if (client->present & CONFIG_IOBASE0_REG_PRESENT)
		crt->cor |= COR_ENABLE_BASE_LIMIT;
	    if (sp->cis_flags & CW_MULTI_FUNCTION_CIS) {
		crt->cor |= COR_ENABLE_FUNCTION;
		crt->cor &= ~COR_ENABLE_IREQ_ROUTING;
		if (cr->Attributes & CONF_ENABLE_IRQ_STEERING)
		    crt->cor |= COR_ENABLE_IREQ_ROUTING;
	    } /* CW_MULTI_FUNCTION_CIS */

#ifdef  CS_DEBUG
	if (cs_debug > 0)
		cmn_err(CE_CONT, "cs_request_configuration "
		    "cor=x%x ConfigIndex=x%x Attributes=x%x flags=x%x\n"
		    "present=x%x cis_handle=%p cor_p=x%x\n",
		    crt->cor, cr->ConfigIndex, cr->Attributes, sp->cis_flags,
		    client->present, cis_handle, crt->cor_p);
#endif

	    csx_Put8(cis_handle, crt->cor_p, crt->cor);
	} /* CONFIG_OPTION_REG_PRESENT */

	if (cs_rc1_delay)
	    drv_usecwait(cs_rc1_delay * 1000);

	/*
	 * Set the socket to the parameters that the client requested.
	 */
	if (SocketServices(SS_SetSocket, &set_socket) != SUCCESS) {
	    if (client->present & CONFIG_OPTION_REG_PRESENT) {
		crt->cor = 0; /* XXX is 0 the right thing here? */
		csx_Put8(cis_handle, crt->cor_p, crt->cor);
	    }
	    sp->flags &= ~SOCKET_IS_IO;
	    mutex_exit(&sp->cis_lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_BAD_SOCKET);
	}

	if (cs_rc2_delay)
	    drv_usecwait(cs_rc2_delay * 1000);

	/*
	 * Mark this client as having done a successful RequestConfiguration
	 *	call.
	 */
	client->flags |= REQ_CONFIGURATION_DONE;

	mutex_exit(&sp->cis_lock);
	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);

	return (CS_SUCCESS);
}

/*
 * cs_release_configuration - releases configuration previously set via the
 *		RequestConfiguration call; this is ReleaseConfiguration
 *
 *	returns: CS_SUCCESS - if configuration sucessfully released
 *		 CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
 *		 CS_BAD_SOCKET - if Socket Services returns an error
 *		 CS_BAD_HANDLE - a RequestConfiguration has not been done
 */
/*ARGSUSED*/
static int
cs_release_configuration(client_handle_t client_handle, release_config_t *rcfg)
{
	cs_socket_t *sp;
	client_t *client;
	volatile config_regs_t *crt;
	set_socket_t set_socket;
	get_socket_t get_socket;
	acc_handle_t cis_handle;
	int error;
	uint32_t newoffset;
	int client_lock_acquired;

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't support SS using this call.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_UNSUPPORTED_FUNCTION);

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (error);
	}

	/*
	 * If RequestConfiguration has not been done, we don't allow
	 *	this call.
	 */
	if (!(client->flags & REQ_CONFIGURATION_DONE)) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_BAD_HANDLE);
	}

#ifdef  CS_DEBUG
	if (cs_debug > 0)
		cmn_err(CE_CONT, "cs_release_configuration: "
		    "flags=0x%x CW_MULTI_FUNCTION_CIS =0x%x \n",
		    sp->cis_flags, CW_MULTI_FUNCTION_CIS);

#endif
	mutex_enter(&sp->cis_lock);

	/*
	 * Set the card back to a memory-only interface byte writing a zero
	 *	to the COR.  Note that we don't update our soft copy of the
	 *	COR state since the PCMCIA spec only requires us to maintain
	 *	the last value that was written to that register during a
	 *	call to RequestConfiguration.
	 */
	crt = &client->config_regs;

	newoffset = client->config_regs_offset;
	if (cs_init_cis_window(sp, &newoffset, &cis_handle,
					CISTPLF_AM_SPACE) != CS_SUCCESS) {
	    mutex_exit(&sp->cis_lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    cmn_err(CE_CONT, "cs_release_configuration: socket %d can't init "
				"CIS window\n", sp->socket_num);
	    return (CS_GENERAL_FAILURE);
	}

	if (sp->cis_flags & CW_MULTI_FUNCTION_CIS) {
		/*
		 * For the Multifunction cards do not reset the socket
		 * to a memory only interface but do clear the
		 * Configuration Option Register and  mark this client
		 * as not having a configuration by clearing the
		 * REQ_CONFIGURATION_DONE flag.
		 */
		client->flags &= ~REQ_CONFIGURATION_DONE;
		csx_Put8(cis_handle, crt->cor_p, 0);

		mutex_exit(&sp->cis_lock);
		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		return (CS_SUCCESS);
	}

	/*
	 * Set the socket back to a memory-only interface; don't change
	 *	any other parameter of the socket.
	 */
	get_socket.socket = sp->socket_num;

	if (SocketServices(SS_GetSocket, &get_socket) != SUCCESS) {
	    mutex_exit(&sp->cis_lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_BAD_SOCKET);
	}

	mutex_enter(&sp->lock);
	sp->flags &= ~SOCKET_IS_IO;
	set_socket.SCIntMask = cs_merge_event_masks(sp, client);
	mutex_exit(&sp->lock);

	set_socket.socket = sp->socket_num;
	set_socket.IREQRouting = 0;
	set_socket.CtlInd = get_socket.CtlInd;
	set_socket.State = 0;	/* don't reset latched values */
	set_socket.VccLevel = get_socket.VccLevel;
	set_socket.Vpp1Level = get_socket.Vpp1Level;
	set_socket.Vpp2Level = get_socket.Vpp2Level;
	set_socket.IFType = IF_MEMORY;

	if (client->present & CONFIG_OPTION_REG_PRESENT)
	    csx_Put8(cis_handle, crt->cor_p, 0);

	if (SocketServices(SS_SetSocket, &set_socket) != SUCCESS) {
	    mutex_exit(&sp->cis_lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_BAD_SOCKET);
	}

	/*
	 * Mark this client as not having a configuration.
	 */
	client->flags &= ~REQ_CONFIGURATION_DONE;

	mutex_exit(&sp->cis_lock);
	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);

	return (CS_SUCCESS);
}

/*
 * cs_modify_configuration - modifies a configuration established by
 *		RequestConfiguration; this is ModifyConfiguration
 *
 *	returns: CS_SUCCESS - if configuration sucessfully modified
 *		 CS_BAD_SOCKET - if Socket Services returns an error
 *		 CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
 *		 CS_BAD_HANDLE - a RequestConfiguration has not been done
 *		 CS_NO_CARD - if no card in socket
 *		 CS_BAD_ATTRIBUTE - if any unsupported or reserved flags
 *					are set
 *		 CS_BAD_VCC - if Vcc value is not supported by socket
 *		 CS_BAD_VPP1 - if Vpp1 value is not supported by socket
 *		 CS_BAD_VPP2 - if Vpp2 value is not supported by socket
 */
static int
cs_modify_configuration(client_handle_t client_handle, modify_config_t *mc)
{
	cs_socket_t *sp;
	client_t *client;
	set_socket_t set_socket;
	get_socket_t get_socket;
	int error;
	int client_lock_acquired;

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't support SS using this call.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_UNSUPPORTED_FUNCTION);

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (error);
	}

	/*
	 * If RequestConfiguration has not been done, we don't allow
	 *	this call.
	 */
	if (!(client->flags & REQ_CONFIGURATION_DONE)) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_BAD_HANDLE);
	}

	/*
	 * If there's no card in the socket or the card in the socket is not
	 *	for this client, then return an error.
	 */
	if (!(client->flags & CLIENT_CARD_INSERTED)) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_NO_CARD);
	}

	/*
	 * Get the current socket parameters so that we can modify them.
	 */
	get_socket.socket = sp->socket_num;

	if (SocketServices(SS_GetSocket, &get_socket) != SUCCESS) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_BAD_SOCKET);
	}

#ifdef	CS_DEBUG
	if (cs_debug > 0)
	    cmn_err(CE_CONT, "cs_modify_configuration: socket %d "
				"client->irq_alloc.irq 0x%x "
				"get_socket.IRQRouting 0x%x\n",
				sp->socket_num, (int)client->irq_alloc.irq,
				get_socket.IRQRouting);
#endif

	set_socket.socket = sp->socket_num;
	set_socket.SCIntMask = get_socket.SCIntMask;
	set_socket.CtlInd = get_socket.CtlInd;
	set_socket.State = 0;	/* don't reset latched values */
	set_socket.IFType = get_socket.IFType;

	set_socket.IREQRouting = get_socket.IRQRouting;

	/*
	 * Modify the IRQ routing if the client wants it modified.
	 */
	if (mc->Attributes & CONF_IRQ_CHANGE_VALID) {
	    set_socket.IREQRouting &= ~IRQ_ENABLE;

	    if ((sp->cis_flags & CW_MULTI_FUNCTION_CIS) &&
			(client->present & CONFIG_OPTION_REG_PRESENT)) {
		config_regs_t *crt = &client->config_regs;
		acc_handle_t cis_handle;
		uint32_t newoffset = client->config_regs_offset;

		/*
		 * Get a pointer to a window that contains the configuration
		 *	registers.
		 */
		if (cs_init_cis_window(sp, &newoffset, &cis_handle,
					CISTPLF_AM_SPACE) != CS_SUCCESS) {
		    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		    cmn_err(CE_CONT,
			"cs_modify_configuration: socket %d can't init "
			"CIS window\n", sp->socket_num);
		    return (CS_GENERAL_FAILURE);
		} /* cs_init_cis_window */

		crt->cor &= ~COR_ENABLE_IREQ_ROUTING;

		if (mc->Attributes & CONF_ENABLE_IRQ_STEERING)
		    crt->cor |= COR_ENABLE_IREQ_ROUTING;

#ifdef  CS_DEBUG
		if (cs_debug > 0)
			cmn_err(CE_CONT, "cs_modify_configuration:"
			    " cor_p=0x%x cor=0x%x\n",
			    crt->cor_p, crt->cor);
#endif
		csx_Put8(cis_handle, crt->cor_p, crt->cor);

	    } /* CW_MULTI_FUNCTION_CIS */

	    if (mc->Attributes & CONF_ENABLE_IRQ_STEERING)
		set_socket.IREQRouting |= IRQ_ENABLE;

	} /* CONF_IRQ_CHANGE_VALID */

	/*
	 * Modify the voltage levels that the client specifies.
	 */
	set_socket.VccLevel = get_socket.VccLevel;

	if (mc->Attributes & CONF_VPP1_CHANGE_VALID) {
	    if (cs_convert_powerlevel(sp->socket_num, mc->Vpp1, VPP1,
					&set_socket.Vpp1Level) != CS_SUCCESS) {
		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		return (CS_BAD_VPP);
	    }
	} else {
	    set_socket.Vpp1Level = get_socket.Vpp1Level;
	}

	if (mc->Attributes & CONF_VPP2_CHANGE_VALID) {
	    if (cs_convert_powerlevel(sp->socket_num, mc->Vpp2, VPP2,
					&set_socket.Vpp2Level) != CS_SUCCESS) {
		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		return (CS_BAD_VPP);
	    }
	} else {
	    set_socket.Vpp2Level = get_socket.Vpp2Level;
	}

	/*
	 * Setup the modified socket configuration.
	 */
	if (SocketServices(SS_SetSocket, &set_socket) != SUCCESS) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_BAD_SOCKET);
	}

	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	return (CS_SUCCESS);
}

/*
 * cs_access_configuration_register - provides a client access to the card's
 *		configuration registers; this is AccessConfigurationRegister
 *
 *	returns: CS_SUCCESS - if register accessed successfully
 *		 CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
 *		 CS_BAD_ARGS - if arguments are out of range
 *		 CS_NO_CARD - if no card in socket
 *		 CS_BAD_BASE - if no config registers base address
 *		 CS_UNSUPPORTED_MODE - if no RequestConfiguration has
 *				been done yet
 */
static int
cs_access_configuration_register(client_handle_t client_handle,
						access_config_reg_t *acr)
{
	cs_socket_t *sp;
	client_t *client;
	acc_handle_t cis_handle;
	int error;
	uint32_t newoffset;
	int client_lock_acquired;

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't support SS using this call.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_UNSUPPORTED_FUNCTION);

	/*
	 * Make sure that the specifed offset is in range.
	 */
	if (acr->Offset > ((CISTPL_CONFIG_MAX_CONFIG_REGS * 2) - 2))
	    return (CS_BAD_ARGS);

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (error);
	}

	/*
	 * If there's no card in the socket or the card in the socket is not
	 *	for this client, then return an error.
	 */
	if (!(client->flags & CLIENT_CARD_INSERTED)) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_NO_CARD);
	}

	/*
	 * If RequestConfiguration has not been done, we don't allow
	 *	this call.
	 */
	if (!(client->flags & REQ_CONFIGURATION_DONE)) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_UNSUPPORTED_MODE);
	}

	mutex_enter(&sp->cis_lock);

	/*
	 * Get a pointer to the CIS window
	 */
	newoffset = client->config_regs_offset + acr->Offset;
	if (cs_init_cis_window(sp, &newoffset, &cis_handle,
					CISTPLF_AM_SPACE) != CS_SUCCESS) {
	    mutex_exit(&sp->cis_lock);
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    cmn_err(CE_CONT, "cs_ACR: socket %d can't init CIS window\n",
							sp->socket_num);
	    return (CS_GENERAL_FAILURE);
	}

	/*
	 * Create the address for the config register that the client
	 *	wants to access.
	 */
	mutex_enter(&sp->lock);

#ifdef	CS_DEBUG
	if (cs_debug > 1) {
	    cmn_err(CE_CONT, "cs_ACR: config_regs_offset 0x%x "
		"Offset 0x%x newoffset 0x%x\n",
		(int)client->config_regs_offset,
		(int)acr->Offset, newoffset);
	}
#endif

	/*
	 * Determine what the client wants us to do.  The client is
	 *	allowed to specify any valid offset, even if it would
	 *	cause an unimplemented configuration register to be
	 *	accessed.
	 */
	error = CS_SUCCESS;
	switch (acr->Action) {
	    case CONFIG_REG_READ:
		acr->Value = csx_Get8(cis_handle, newoffset);
		break;
	    case CONFIG_REG_WRITE:
		csx_Put8(cis_handle, newoffset, acr->Value);
		break;
	    default:
		error = CS_BAD_ARGS;
		break;
	} /* switch */

	mutex_exit(&sp->lock);
	mutex_exit(&sp->cis_lock);
	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);

	return (error);
}

/*
 * ==== RESET and general info functions ====
 */

/*
 * cs_reset_function - RESET the requested function on the card; this
 *			is ResetFunction
 *
 *    Note: We don't support this functionality yet, and the standard
 *		says it's OK to reutrn CS_IN_USE if we can't do this
 *		operation.
 */
/*ARGSUSED*/
static int
cs_reset_function(client_handle_t ch, reset_function_t *rf)
{
	return (CS_IN_USE);
}

/*
 * cs_get_configuration_info - return configuration info for the passed
 *				socket and function number to the caller;
 *				this is GetConfigurationInfo
 */
/*ARGSUSED*/
static int
cs_get_configuration_info(client_handle_t *chp, get_configuration_info_t *gci)
{
	cs_socket_t *sp;
	uint32_t fn;
	client_t *client;
	int client_lock_acquired;

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(CS_GET_SOCKET_NUMBER(gci->Socket))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);
	mutex_enter(&sp->lock);

	fn = CS_GET_FUNCTION_NUMBER(gci->Socket);

	client = sp->client_list;
	while (client) {

	    if (GET_CLIENT_FUNCTION(client->client_handle) == fn) {

		/*
		 * If there's no card in the socket or the card in the
		 *	socket is not for this client, then return
		 *	an error.
		 */
		if (!(client->flags & CLIENT_CARD_INSERTED)) {
		    mutex_exit(&sp->lock);
		    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		    return (CS_NO_CARD);
		}

		mutex_exit(&sp->lock);
		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		return (CS_SUCCESS);

	    } /* GET_CLIENT_FUNCTION == fn */

	    client = client->next;
	} /* while (client) */

	mutex_exit(&sp->lock);
	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);

	return (CS_BAD_SOCKET);
}

/*
 * cs_get_cardservices_info - return info about Card Services to the
 *	caller; this is GetCardServicesInfo
 */
/*ARGSUSED*/
static int
cs_get_cardservices_info(client_handle_t ch, get_cardservices_info_t *gcsi)
{
	gcsi->Signature[0] = 'C';
	gcsi->Signature[1] = 'S';
	gcsi->NumSockets = cs_globals.num_sockets;
	gcsi->Revision = CS_INTERNAL_REVISION_LEVEL;
	gcsi->CSLevel = CS_VERSION;
	gcsi->FuncsPerSocket = CIS_MAX_FUNCTIONS;
	(void) strncpy(gcsi->VendorString,
					CS_GET_CARDSERVICES_INFO_VENDOR_STRING,
					CS_GET_CARDSERVICES_INFO_MAX_VS_LEN);

	return (CS_SUCCESS);
}

/*
 * cs_get_physical_adapter_info - returns information about the requested
 *					physical adapter; this is
 *					GetPhysicalAdapterInfo
 *
 *	calling: client_handle_t:
 *			NULL - use map_log_socket_t->LogSocket member
 *				to specify logical socket number
 *			!NULL - extract logical socket number from
 *				client_handle_t
 *
 *	returns: CS_SUCCESS
 *		 CS_BAD_SOCKET - if client_handle_t is NULL and invalid
 *					socket number is specified in
 *					map_log_socket_t->LogSocket
 *		 CS_BAD_HANDLE - if client_handle_t is !NULL and invalid
 *					client handle is specified
 */
static int
cs_get_physical_adapter_info(client_handle_t ch,
					get_physical_adapter_info_t *gpai)
{
	cs_socket_t *sp;
	int client_lock_acquired;

	if (ch == NULL)
	    gpai->PhySocket = CS_GET_SOCKET_NUMBER(gpai->LogSocket);
	else
	    gpai->PhySocket = GET_CLIENT_SOCKET(ch);

	/*
	 * Determine if the passed socket number is valid or not.
	 */
	if ((sp = cs_get_sp(CS_GET_SOCKET_NUMBER(gpai->PhySocket))) == NULL)
	    return ((ch == NULL) ? CS_BAD_SOCKET : CS_BAD_HANDLE);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 * If we were passed a client handle, determine if it's valid or not.
	 */
	if (ch != NULL) {
	    if (cs_find_client(ch, NULL) == NULL) {
		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		return (CS_BAD_HANDLE);
	    } /* cs_find_client */
	} /* ch != NULL */

	gpai->flags = sp->adapter.flags;
	(void) strcpy(gpai->name, sp->adapter.name);
	gpai->major = sp->adapter.major;
	gpai->minor = sp->adapter.minor;
	gpai->instance = sp->adapter.instance;
	gpai->number = sp->adapter.number;
	gpai->num_sockets = sp->adapter.num_sockets;
	gpai->first_socket = sp->adapter.first_socket;

	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);

	return (CS_SUCCESS);
}

/*
 * ==== general functions ====
 */

/*
 * cs_map_log_socket - returns the physical socket number associated with
 *			either the passed client handle or the passed
 *			logical socket number; this is MapLogSocket
 *
 *	calling: client_handle_t:
 *			NULL - use map_log_socket_t->LogSocket member
 *				to specify logical socket number
 *			!NULL - extract logical socket number from
 *				client_handle_t
 *
 *	returns: CS_SUCCESS
 *		 CS_BAD_SOCKET - if client_handle_t is NULL and invalid
 *					socket number is specified in
 *					map_log_socket_t->LogSocket
 *		 CS_BAD_HANDLE - if client_handle_t is !NULL and invalid
 *					client handle is specified
 *
 * Note: We provide this function since the instance number of a client
 *		driver doesn't necessary correspond to the physical
 *		socket number
 */
static int
cs_map_log_socket(client_handle_t ch, map_log_socket_t *mls)
{
	cs_socket_t *sp;
	int client_lock_acquired;

	if (ch == NULL)
	    mls->PhySocket = CS_GET_SOCKET_NUMBER(mls->LogSocket);
	else
	    mls->PhySocket = GET_CLIENT_SOCKET(ch);

	/*
	 * Determine if the passed socket number is valid or not.
	 */
	if ((sp = cs_get_sp(CS_GET_SOCKET_NUMBER(mls->PhySocket))) == NULL)
	    return ((ch == NULL) ? CS_BAD_SOCKET : CS_BAD_HANDLE);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 * If we were passed a client handle, determine if it's valid or not.
	 */
	if (ch != NULL) {
	    if (cs_find_client(ch, NULL) == NULL) {
		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		return (CS_BAD_HANDLE);
	    } /* cs_find_client */
	} /* ch != NULL */

	mls->PhyAdapter = sp->adapter.number;

	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);

	return (CS_SUCCESS);
}

/*
 * cs_convert_speed - convers nS to devspeed and devspeed to nS
 *
 * The actual function is is in the CIS parser module; this
 *	is only a wrapper.
 */
static int
cs_convert_speed(convert_speed_t *cs)
{
	return ((int)(uintptr_t)CIS_PARSER(CISP_CIS_CONV_DEVSPEED, cs));
}

/*
 * cs_convert_size - converts a devsize value to a size in bytes value
 *			or a size in bytes value to a devsize value
 *
 * The actual function is is in the CIS parser module; this
 *	is only a wrapper.
 */
static int
cs_convert_size(convert_size_t *cs)
{
	return ((int)(uintptr_t)CIS_PARSER(CISP_CIS_CONV_DEVSIZE, cs));
}

/*
 * cs_convert_powerlevel - converts a power level in tenths of a volt
 *			to a power table entry for the specified socket
 *
 *	returns: CS_SUCCESS - if volts converted to a valid power level
 *		 CS_BAD_ADAPTER - if SS_InquireAdapter fails
 *		 CS_BAD_ARGS - if volts are not supported on this socket
 *				and adapter
 */
static int
cs_convert_powerlevel(uint32_t sn, uint32_t volts, uint32_t flags, unsigned *pl)
{
	inquire_adapter_t inquire_adapter;
	int i;

#ifdef	lint
	if (sn == 0)
	    panic("lint panic");
#endif

	*pl = 0;

	if (SocketServices(SS_InquireAdapter, &inquire_adapter) != SUCCESS)
	    return (CS_BAD_ADAPTER);

	for (i = 0; (i < inquire_adapter.NumPower); i++) {
	    if ((inquire_adapter.power_entry[i].ValidSignals & flags) &&
		(inquire_adapter.power_entry[i].PowerLevel == volts)) {
		*pl = i;
		return (CS_SUCCESS);
	    }
	}

	return (CS_BAD_ARGS);
}

/*
 * cs_event2text - returns text string(s) associated with the event; this
 *			function supports the Event2Text CS call.
 *
 *	calling: event2text_t * - pointer to event2text struct
 *		 int event_source - specifies event type in event2text_t:
 *					0 - SS event
 *					1 - CS event
 *
 *	returns: CS_SUCCESS
 */
static int
cs_event2text(event2text_t *e2t, int event_source)
{
	event_t event;
	char *sepchar = "|";

	/*
	 * If event_source is 0, this is a SS event
	 */
	if (!event_source) {
	    for (event = 0; event < MAX_SS_EVENTS; event++) {
		if (cs_ss_event_text[event].ss_event == e2t->event) {
		    (void) strcpy(e2t->text, cs_ss_event_text[event].text);
		    return (CS_SUCCESS);
		}
	    }
	    (void) strcpy(e2t->text, cs_ss_event_text[MAX_CS_EVENTS].text);
	    return (CS_SUCCESS);
	} else {
		/*
		 * This is a CS event
		 */
	    e2t->text[0] = '\0';
	    for (event = 0; event < MAX_CS_EVENTS; event++) {
		if (cs_ss_event_text[event].cs_event & e2t->event) {
		    (void) strcat(e2t->text, cs_ss_event_text[event].text);
		    (void) strcat(e2t->text, sepchar);
		} /* if (cs_ss_event_text) */
	    } /* for (event) */
	    if (e2t->text[0])
		e2t->text[strlen(e2t->text)-1] = NULL;
	} /* if (!event_source) */

	return (CS_SUCCESS);
}

/*
 * cs_error2text - returns a pointer to a text string containing the name
 *			of the passed Card Services function or return code
 *
 *	This function supports the Error2Text CS call.
 */
static char *
cs_error2text(int function, int type)
{
	cs_csfunc2text_strings_t *cfs;
	int end_marker;

	if (type == CSFUN2TEXT_FUNCTION) {
	    cfs = cs_csfunc2text_funcstrings;
	    end_marker = CSFuncListEnd;
	} else {
	    cfs = cs_csfunc2text_returnstrings;
	    end_marker = CS_ERRORLIST_END;
	}

	while (cfs->item != end_marker) {
	    if (cfs->item == function)
		return (cfs->text);
	    cfs++;
	}

	return (cfs->text);
}

/*
 * cs_make_device_node - creates/removes device nodes on a client's behalf;
 *				this is MakeDeviceNode and RemoveDeviceNode
 *
 *	returns: CS_SUCCESS - if all device nodes successfully created/removed
 *		 CS_BAD_ATTRIBUTE - if NumDevNodes is not zero when Action
 *				is REMOVAL_ALL_DEVICES
 *		 CS_BAD_ARGS - if an invalid Action code is specified
 *		 CS_UNSUPPORTED_FUNCTION - if SS is trying to call us
 *		 CS_OUT_OF_RESOURCE - if can't create/remove device node
 */
static int
cs_make_device_node(client_handle_t client_handle, make_device_node_t *mdn)
{
	cs_socket_t *sp;
	client_t *client;
	ss_make_device_node_t ss_make_device_node;
	int error, i;
	int client_lock_acquired;

	/*
	 * Check to see if this is the Socket Services client handle; if it
	 *	is, we don't support SS using this call.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle))
	    return (CS_UNSUPPORTED_FUNCTION);

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	/*
	 *  Make sure that this is a valid client handle.
	 */
	if (!(client = cs_find_client(client_handle, &error))) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (error);
	}

#ifdef	XXX
	/*
	 * If there's no card in the socket or the card in the socket is not
	 *	for this client, then return an error.
	 */
	if (!(client->flags & CLIENT_CARD_INSERTED)) {
	    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	    return (CS_NO_CARD);
	}
#endif

	/*
	 * Setup the client's dip, since we use it later on.
	 */
	ss_make_device_node.dip = client->dip;

	/*
	 * Make sure that we're being given a valid Action.  Set the default
	 *	error code as well.
	 */
	error = CS_BAD_ARGS;	/* for default case */
	switch (mdn->Action) {
	    case CREATE_DEVICE_NODE:
	    case REMOVE_DEVICE_NODE:
		break;
	    case REMOVAL_ALL_DEVICE_NODES:
		if (mdn->NumDevNodes) {
		    error = CS_BAD_ATTRIBUTE;
		} else {
		    ss_make_device_node.flags = SS_CSINITDEV_REMOVE_DEVICE;
		    ss_make_device_node.name = NULL;
		    SocketServices(CSInitDev, &ss_make_device_node);
		    error = CS_SUCCESS;
		}
		/* fall-through case */
	    default:
		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		return (error);
		/* NOTREACHED */
	} /* switch */

	/*
	 * Loop through the device node descriptions and create or destroy
	 *	the device node.
	 */
	for (i = 0; i < mdn->NumDevNodes; i++) {
	    devnode_desc_t *devnode_desc = &mdn->devnode_desc[i];

	    ss_make_device_node.name = devnode_desc->name;
	    ss_make_device_node.spec_type = devnode_desc->spec_type;
	    ss_make_device_node.minor_num = devnode_desc->minor_num;
	    ss_make_device_node.node_type = devnode_desc->node_type;

	/*
	 * Set the appropriate flag for the action that we want
	 *	SS to perform. Note that if we ever OR-in the flag
	 *	here, we need to be sure to clear the flags member
	 *	since we sometimes OR-in other flags below.
	 */
	    if (mdn->Action == CREATE_DEVICE_NODE) {
		ss_make_device_node.flags = SS_CSINITDEV_CREATE_DEVICE;
	    } else {
		ss_make_device_node.flags = SS_CSINITDEV_REMOVE_DEVICE;
	    }

	/*
	 * If this is not the last device to process, then we need
	 *	to tell SS that more device process requests are on
	 *	their way after this one.
	 */
	    if (i < (mdn->NumDevNodes - 1))
		ss_make_device_node.flags |= SS_CSINITDEV_MORE_DEVICES;

	    if (SocketServices(CSInitDev, &ss_make_device_node) != SUCCESS) {
		EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		return (CS_OUT_OF_RESOURCE);
	    } /* CSInitDev */
	} /* for (mdn->NumDevNodes) */

	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	return (CS_SUCCESS);
}

/*
 * cs_remove_device_node - removes device nodes
 *
 *	(see cs_make_device_node for a description of the calling
 *		and return parameters)
 */
static int
cs_remove_device_node(client_handle_t client_handle, remove_device_node_t *rdn)
{

	/*
	 * XXX - Note the assumption here that the make_device_node_t and
	 *	remove_device_node_t structures are identical.
	 */
	return (cs_make_device_node(client_handle, (make_device_node_t *)rdn));
}

/*
 * cs_ddi_info - this function is used by clients that need to support
 *			the xxx_getinfo function; this is CS_DDI_Info
 */
static int
cs_ddi_info(cs_ddi_info_t *cdi)
{
	cs_socket_t *sp;
	client_t *client;
	int client_lock_acquired;

	if (cdi->driver_name == NULL)
	    return (CS_BAD_ATTRIBUTE);

#ifdef	CS_DEBUG
	if (cs_debug > 0) {
	    cmn_err(CE_CONT, "cs_ddi_info: socket %d client [%s]\n",
					(int)cdi->Socket, cdi->driver_name);
	}
#endif

	/*
	 * Check to see if the socket number is in range - the system
	 *	framework may cause a client driver to call us with
	 *	a socket number that used to be present but isn't
	 *	anymore. This is not a bug, and it's OK to return
	 *	an error if the socket number is out of range.
	 */
	if (!CHECK_SOCKET_NUM(cdi->Socket, cs_globals.max_socket_num)) {

#ifdef	CS_DEBUG
	    if (cs_debug > 0) {
		cmn_err(CE_CONT, "cs_ddi_info: socket %d client [%s] "
						"SOCKET IS OUT OF RANGE\n",
							(int)cdi->Socket,
							cdi->driver_name);
	    }
#endif

	    return (CS_BAD_SOCKET);
	} /* if (!CHECK_SOCKET_NUM) */

	/*
	 * Get a pointer to this client's socket structure.
	 */
	if ((sp = cs_get_sp(cdi->Socket)) == NULL)
	    return (CS_BAD_SOCKET);

	EVENT_THREAD_MUTEX_ENTER(client_lock_acquired, sp);

	client = sp->client_list;
	while (client) {

#ifdef	CS_DEBUG
	    if (cs_debug > 0) {
		cmn_err(CE_CONT, "cs_ddi_info: socket %d checking client [%s] "
							"handle 0x%x\n",
						(int)cdi->Socket,
						client->driver_name,
						(int)client->client_handle);
	    }
#endif

	    if (client->driver_name != NULL) {
		if (!(strcmp(client->driver_name, cdi->driver_name))) {
		    cdi->dip = client->dip;
		    cdi->instance = client->instance;

#ifdef	CS_DEBUG
		    if (cs_debug > 0) {
			cmn_err(CE_CONT, "cs_ddi_info: found client [%s] "
						"instance %d handle 0x%x\n",
					client->driver_name, client->instance,
					(int)client->client_handle);
		    }
#endif

		    EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
		    return (CS_SUCCESS);
		} /* strcmp */
	    } /* driver_name != NULL */
	    client = client->next;
	} /* while (client) */

	EVENT_THREAD_MUTEX_EXIT(client_lock_acquired, sp);
	return (CS_BAD_SOCKET);
}

/*
 * cs_sys_ctl - Card Services system control; this is CS_Sys_Ctl
 */
static int
cs_sys_ctl(cs_sys_ctl_t *csc)
{
	cs_socket_t *sp;
	client_t *cp;
	int sn, ret = CS_UNSUPPORTED_MODE;

	switch (csc->Action) {
	    case CS_SYS_CTL_SEND_EVENT:
		if (csc->Flags & CS_SYS_CTL_EVENT_SOCKET)
		    sn = CS_GET_SOCKET_NUMBER(csc->Socket);
		else
		    sn = GET_CLIENT_SOCKET(csc->client_handle);
		if ((sp = cs_get_sp(sn)) == NULL)
		    return (CS_BAD_SOCKET);
		mutex_enter(&sp->client_lock);
		mutex_enter(&sp->lock);
		csc->Events &= CS_EVENT_CLIENT_EVENTS_MASK;
		if (csc->Flags & CS_SYS_CTL_EVENT_SOCKET)
		    sp->events |= csc->Events;
		if (csc->Flags & CS_SYS_CTL_EVENT_CLIENT) {
		    if ((cp = cs_find_client(csc->client_handle, &ret)) ==
									NULL) {
			mutex_exit(&sp->lock);
			mutex_exit(&sp->client_lock);
			return (ret);
		    } /* cs_find_client */
			/*
			 * Setup the events that we want to send to the client.
			 */
		    cp->events |= (csc->Events &
					(cp->event_mask | cp->global_mask));
		} /* CS_SYS_CTL_EVENT_CLIENT */

		if (csc->Flags & CS_SYS_CTL_WAIT_SYNC) {
		    sp->thread_state |= SOCKET_WAIT_SYNC;
		    mutex_exit(&sp->lock);
		    cv_broadcast(&sp->thread_cv);
		    cv_wait(&sp->caller_cv, &sp->client_lock);
		} else {
		    mutex_exit(&sp->lock);
		    cv_broadcast(&sp->thread_cv);
		} /* CS_SYS_CTL_WAIT_SYNC */
		mutex_exit(&sp->client_lock);
		ret = CS_SUCCESS;
		break;
	    default:
		break;
	} /* switch */

	return (ret);
}

/*
 * cs_get_sp - returns pointer to per-socket structure for passed
 *		socket number
 *
 *	return:	(cs_socket_t *) - pointer to socket structure
 *		NULL - invalid socket number passed in
 */
static cs_socket_t *
cs_get_sp(uint32_t sn)
{
	cs_socket_t *sp = cs_globals.sp;

	if (!(cs_globals.init_state & GLOBAL_INIT_STATE_SS_READY))
	    return (NULL);

	if ((sp = cs_find_sp(sn)) == NULL)
	    return (NULL);

	if (sp->flags & SOCKET_IS_VALID)
	    return (sp);

	return (NULL);
}

/*
 * cs_find_sp - searches socket list and returns pointer to passed socket
 *			number
 *
 *	return:	(cs_socket_t *) - pointer to socket structure if found
 *		NULL - socket not found
 */
static cs_socket_t *
cs_find_sp(uint32_t sn)
{
	cs_socket_t *sp = cs_globals.sp;

	while (sp) {
	    if (sp->socket_num == CS_GET_SOCKET_NUMBER(sn))
		return (sp);
	    sp = sp->next;
	} /* while */

	return (NULL);
}

/*
 * cs_add_socket - add a socket
 *
 *	call:	sn - socket number to add
 *
 *	return:	CS_SUCCESS - operation sucessful
 *		CS_BAD_SOCKET - unable to add socket
 *		CS_BAD_WINDOW - unable to get CIS window for socket
 *
 * We get called here once for each socket that the framework wants to
 *	add. When we are called, the framework guarentees that until we
 *	complete this routine, no other adapter instances will be allowed
 *	to attach and thus no other PCE_ADD_SOCKET events will occur.
 *	It is safe to call SS_InquireAdapter to get the number of
 *	windows that the framework currently knows about.
 */
static uint32_t
cs_add_socket(uint32_t sn)
{
	cs_socket_t *sp;
	sservice_t sservice;
	get_cookies_and_dip_t *gcad;
	win_req_t win_req;
	convert_speed_t convert_speed;
	set_socket_t set_socket;
	cs_window_t *cw;
	inquire_adapter_t inquire_adapter;
	inquire_window_t inquire_window;
	int ret, added_windows;

	if (!(cs_globals.init_state & GLOBAL_INIT_STATE_SS_READY))
	    return (CS_BAD_SOCKET);

	/*
	 * See if this socket has already been added - if it has, we
	 *	fail this. If we can't find the socket, then allocate
	 *	a new socket structure. If we do find the socket, then
	 *	check to see if it's already added; if it is, then
	 *	this is an error and return CS_BAD_SOCKET; if not,
	 *	then traverse the socket structure list and add this
	 *	next socket strcture to the end of the list.
	 * XXX What about locking this list while we update it? Is
	 *	that necessary since we're using the SOCKET_IS_VALID
	 *	flag and since we never delete a socket from the
	 *	list once it's been added?
	 */
	if ((sp = cs_find_sp(sn)) == NULL) {
	    cs_socket_t *spp = cs_globals.sp;

	    sp = (cs_socket_t *)kmem_zalloc(sizeof (cs_socket_t), KM_SLEEP);

	    if (cs_globals.sp == NULL)
		cs_globals.sp = sp;
	    else
		while (spp) {
		    if (spp->next == NULL) {
			spp->next = sp;
			break;
		    } /* if */
		    spp = spp->next;
		} /* while */

	} else {
	    if (sp->flags & SOCKET_IS_VALID)
		return (CS_BAD_SOCKET);
	} /* cs_find_sp */

	/*
	 * Setup the socket number
	 */
	sp->socket_num = sn;

	/*
	 * Find out how many windows the framework knows about
	 *	so far. If this number of windows is greater
	 *	than our current window count, bump up our
	 *	current window count.
	 * XXX Note that there is a BIG assumption here and that
	 *	is that once the framework tells us that it has
	 *	a window (as reflected in the NumWindows
	 *	value) it can NEVER remove that window.
	 *	When we really get the drop socket and drop
	 *	window mechanism working correctly, we'll have
	 *	to revisit this.
	 */
	SocketServices(SS_InquireAdapter, &inquire_adapter);

	mutex_enter(&cs_globals.window_lock);
	added_windows = inquire_adapter.NumWindows - cs_globals.num_windows;
	if (added_windows > 0) {
	    if (cs_add_windows(added_windows,
				cs_globals.num_windows) != CS_SUCCESS) {
		mutex_exit(&cs_globals.window_lock);
		return (CS_BAD_WINDOW);
	    } /* cs_add_windows */

	    cs_globals.num_windows = inquire_adapter.NumWindows;

	} /* if (added_windows) */

	/*
	 * Find a window that we can use for this socket's CIS window.
	 */
	sp->cis_win_num = PCMCIA_MAX_WINDOWS;

	convert_speed.Attributes = CONVERT_NS_TO_DEVSPEED;
	convert_speed.nS = CIS_DEFAULT_SPEED;
	(void) cs_convert_speed(&convert_speed);

	win_req.win_params.AccessSpeed = convert_speed.devspeed;
	win_req.Attributes = (WIN_MEMORY_TYPE_AM | WIN_DATA_WIDTH_8);
	win_req.Attributes = (WIN_MEMORY_TYPE_AM | WIN_MEMORY_TYPE_CM);
	win_req.Base.base = 0;
	win_req.Size = 0;

	if ((ret = cs_find_mem_window(sp->socket_num, &win_req,
					&sp->cis_win_num)) != CS_SUCCESS) {
	    mutex_exit(&cs_globals.window_lock);
	    sp->cis_win_num = PCMCIA_MAX_WINDOWS;
	    cmn_err(CE_CONT, "cs_add_socket: socket %d can't get CIS "
						"window - error 0x%x\n",
						sp->socket_num, ret);
	    return (CS_BAD_WINDOW);
	} /* cs_find_mem_window */

	if ((cw = cs_get_wp(sp->cis_win_num)) == NULL) {
	    mutex_exit(&cs_globals.window_lock);
	    return (CS_BAD_WINDOW);
	}

	inquire_window.window = sp->cis_win_num;
	SocketServices(SS_InquireWindow, &inquire_window);

	/*
	 * If the CIS window is a variable sized window, then use
	 *	the size that cs_find_mem_window returned to us,
	 *	since this will be the minimum size that we can
	 *	set this window to. If the CIS window is a fixed
	 *	sized window, then use the system pagesize as the
	 *	CIS window size.
	 */
	if (inquire_window.mem_win_char.MemWndCaps & WC_SIZE) {
	    sp->cis_win_size = win_req.Size;
	} else {
	    sp->cis_win_size = PAGESIZE;
	}

	cw->state |= (CW_CIS | CW_ALLOCATED);
	cw->socket_num = sp->socket_num;

	mutex_exit(&cs_globals.window_lock);

#if defined(CS_DEBUG)
	    if (cs_debug > 1) {
		cmn_err(CE_CONT, "cs_add_socket: socket %d using CIS window %d "
					"size 0x%x\n", (int)sp->socket_num,
					(int)sp->cis_win_num,
					(int)sp->cis_win_size);
	    }
#endif

	/*
	 * Get the adapter information associated with this socket so
	 *	that we can initialize the mutexes, condition variables,
	 *	soft interrupt handler and per-socket adapter info.
	 */
	gcad = &sservice.get_cookies;
	gcad->socket = sp->socket_num;
	if (SocketServices(CSGetCookiesAndDip, &sservice) != SUCCESS) {
	    cmn_err(CE_CONT, "cs_add_socket: socket %d CSGetCookiesAndDip "
						"failure\n", sp->socket_num);
	    return (CS_BAD_SOCKET);
	} /* CSGetCookiesAndDip */

	/*
	 * Save the iblock and idev cookies for RegisterClient
	 */
	sp->iblk = gcad->iblock;
	sp->idev = gcad->idevice;

	/*
	 * Setup the per-socket adapter info
	 */
	sp->adapter.flags = 0;
	(void) strcpy(sp->adapter.name, gcad->adapter_info.name);
	sp->adapter.major = gcad->adapter_info.major;
	sp->adapter.minor = gcad->adapter_info.minor;
	sp->adapter.instance = ddi_get_instance(gcad->dip);
	sp->adapter.number = gcad->adapter_info.number;
	sp->adapter.num_sockets = gcad->adapter_info.num_sockets;
	sp->adapter.first_socket = gcad->adapter_info.first_socket;

	/* Setup for cs_event and cs_event_thread */
	mutex_init(&sp->lock, NULL, MUTEX_DRIVER, *(gcad->iblock));
	mutex_init(&sp->client_lock, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&sp->cis_lock, NULL, MUTEX_DRIVER, NULL);

	/* Setup for Socket Services work thread */
	mutex_init(&sp->ss_thread_lock, NULL, MUTEX_DRIVER, NULL);

	sp->init_state |= SOCKET_INIT_STATE_MUTEX;

	/* Setup for cs_event_thread */
	cv_init(&sp->thread_cv, NULL, CV_DRIVER, NULL);
	cv_init(&sp->caller_cv, NULL, CV_DRIVER, NULL);
	cv_init(&sp->reset_cv, NULL, CV_DRIVER, NULL);

	/* Setup for Socket Services work thread */
	cv_init(&sp->ss_thread_cv, NULL, CV_DRIVER, NULL);
	cv_init(&sp->ss_caller_cv, NULL, CV_DRIVER, NULL);

	sp->init_state |= SOCKET_INIT_STATE_CV;

	/*
	 * If we haven't installed it yet, then install the soft interrupt
	 *	handler and save away the softint id.
	 */
	if (!(cs_globals.init_state & GLOBAL_INIT_STATE_SOFTINTR)) {
	    if (ddi_add_softintr(gcad->dip, DDI_SOFTINT_HIGH,
						&sp->softint_id,
						NULL, NULL,
						cs_socket_event_softintr,
						(caddr_t)NULL) != DDI_SUCCESS) {
		    cmn_err(CE_CONT, "cs_add_socket: socket %d can't add "
						"softintr\n", sp->socket_num);
		    return (CS_BAD_SOCKET);
	    } /* ddi_add_softintr */

	    mutex_enter(&cs_globals.global_lock);
	    cs_globals.softint_id = sp->softint_id;
	    cs_globals.init_state |= GLOBAL_INIT_STATE_SOFTINTR;
	    /* XXX this timer is hokey at best... */
	    cs_globals.sotfint_tmo = timeout(cs_event_softintr_timeout,
		NULL, SOFTINT_TIMEOUT_TIME);
	    mutex_exit(&cs_globals.global_lock);
	} else {
		/*
		 * We've already added the soft interrupt handler, so just
		 *	store away the softint id.
		 */
	    sp->softint_id = cs_globals.softint_id;
	} /* if (!GLOBAL_INIT_STATE_SOFTINTR) */

	/*
	 * While this next flag doesn't really describe a per-socket
	 *	resource, we still set it for each socket.  When the soft
	 *	interrupt handler finally gets removed in cs_deinit, this
	 *	flag will get cleared.
	 */
	sp->init_state |= SOCKET_INIT_STATE_SOFTINTR;

	/*
	 * Socket Services defaults all sockets to power off and
	 *	clears all event masks.  We want to receive at least
	 *	card insertion events, so enable them.  Turn off power
	 *	to the socket as well.  We will turn it on again when
	 *	we get a card insertion event.
	 */
	sp->event_mask = CS_EVENT_CARD_INSERTION;
	set_socket.socket = sp->socket_num;
	set_socket.SCIntMask = SBM_CD;
	set_socket.IREQRouting = 0;
	set_socket.IFType = IF_MEMORY;
	set_socket.CtlInd = 0; /* turn off controls and indicators */
	set_socket.State = (unsigned)~0;	/* clear latched state bits */

	(void) cs_convert_powerlevel(sp->socket_num, 0, VCC,
						&set_socket.VccLevel);
	(void) cs_convert_powerlevel(sp->socket_num, 0, VPP1,
						&set_socket.Vpp1Level);
	(void) cs_convert_powerlevel(sp->socket_num, 0, VPP2,
						&set_socket.Vpp2Level);

	if ((ret = SocketServices(SS_SetSocket, &set_socket)) != SUCCESS) {
	    cmn_err(CE_CONT, "cs_add_socket: socket %d SS_SetSocket "
					"failure %d\n", sp->socket_num, ret);
		return (CS_BAD_SOCKET);
	} /* SS_SetSocket */

	/*
	 * The various socket-specific variables are now set up, so
	 *	increment the global socket count and also mark the
	 *	socket as available. We need to set this before we
	 *	start any of the per-socket threads so that the threads
	 *	can get a valid socket pointer when they start.
	 */
	mutex_enter(&cs_globals.global_lock);
	cs_globals.num_sockets++;
	cs_globals.max_socket_num =
			max(cs_globals.max_socket_num, sp->socket_num + 1);
	mutex_exit(&cs_globals.global_lock);
	sp->flags = SOCKET_IS_VALID;

	/*
	 * Create the per-socket event handler thread.
	 */
	sp->event_thread = CREATE_SOCKET_EVENT_THREAD(cs_event_thread,
		(uintptr_t)sn);

	mutex_enter(&sp->lock);
	sp->init_state |= SOCKET_INIT_STATE_THREAD;
	mutex_exit(&sp->lock);

	/*
	 * Create the per-socket Socket Services work thread.
	 */
	sp->ss_thread = CREATE_SOCKET_EVENT_THREAD(cs_ss_thread,
		(uintptr_t)sn);

	mutex_enter(&sp->lock);
	sp->init_state |= (SOCKET_INIT_STATE_SS_THREAD |
						SOCKET_INIT_STATE_READY);
	sp->event_mask = CS_EVENT_CARD_INSERTION;
	mutex_exit(&sp->lock);

	return (CS_SUCCESS);
}

/*
 * cs_drop_socket - drop a socket
 *
 *	call:	sn - socket number to drop
 *
 *	return:	CS_SUCCESS - operation sucessful
 *		CS_BAD_SOCKET - unable to drop socket
 */
/*ARGSUSED*/
static uint32_t
cs_drop_socket(uint32_t sn)
{
#ifdef	XXX
	cs_socket_t *sp;

	/*
	 * Tell the socket event thread to exit and then wait for it
	 *	to do so.
	 */
	mutex_enter(&sp->client_lock);
	sp->thread_state |= SOCKET_THREAD_EXIT;
	cv_broadcast(&sp->thread_cv);
	cv_wait(&sp->caller_cv, &sp->client_lock);
	mutex_exit(&sp->client_lock);

	/*
	 * Tell the socket SS thread to exit and then wait for it
	 *	to do so.
	 */

	/*
	 * Mark the socket as dropped.
	 */
	sp->flags &= ~SOCKET_IS_VALID;

#endif	/* XXX */

	/* XXX for now don't allow dropping sockets XXX */
	return (CS_BAD_SOCKET);
}

/*
 * cs_get_socket - returns the socket and function numbers and a pointer
 *			to the socket structure
 *
 * calling:	client_handle_t client_handle - client handle to extract
 *						socket number from
 *		uint32_t *socket -  pointer to socket number to use if
 *					client_handle is for the SS client;
 *					this value will be filled in on
 *					return with the correct socket
 *					and function numbers if we
 *					return CS_SUCCESS
 *		uint32_t *function - pointer to return function number into
 *					if not NULL
 *		cs_socket_t **sp - pointer to a pointer where a pointer
 *					to the socket struct will be
 *					placed if this is non-NULL
 *		client_t **clp - pointer to a pointer where a pointer
 *					to the client struct will be
 *					placed if this is non-NULL
 *
 *    The socket and function numbers are derived as follows:
 *
 *	Client Type		Socket Number		Function Number
 *	PC card client		From client_handle	From client_handle
 *	Socket Services client	From *socket		From *socket
 *	CSI client		From client_handle	From *socket
 */
static uint32_t
cs_get_socket(client_handle_t client_handle, uint32_t *socket,
    uint32_t *function, cs_socket_t **csp, client_t **clp)
{
	cs_socket_t *sp;
	client_t *client;
	uint32_t sn, fn;
	int ret;

	sn = *socket;

	/*
	 * If this is the Socket Services client, then return the
	 *	socket and function numbers specified in the passed
	 *	socket number parameter, otherwise extract the socket
	 *	and function numbers from the client handle.
	 */
	if (CLIENT_HANDLE_IS_SS(client_handle)) {
	    fn = CS_GET_FUNCTION_NUMBER(sn);
	    sn = CS_GET_SOCKET_NUMBER(sn);
	} else {
	    fn = GET_CLIENT_FUNCTION(client_handle);
	    sn = GET_CLIENT_SOCKET(client_handle);
	}

	/*
	 * Check to be sure that the socket number is in range
	 */
	if (!(CHECK_SOCKET_NUM(sn, cs_globals.max_socket_num)))
	    return (CS_BAD_SOCKET);

	if ((sp = cs_get_sp(sn)) == NULL)
	    return (CS_BAD_SOCKET);

	/*
	 * If we were given a pointer, then fill it in with a pointer
	 *	to this socket.
	 */
	if (csp)
	    *csp = sp;

	/*
	 * Search for the client; if it's not found, return an error.
	 */
	mutex_enter(&sp->lock);
	if (!(client = cs_find_client(client_handle, &ret))) {
	    mutex_exit(&sp->lock);
	    return (ret);
	}

	/*
	 * If we're a CIS client, then extract the function number
	 *	from the socket number.
	 */
	if (client->flags & CLIENT_CSI_CLIENT)
	    fn = CS_GET_FUNCTION_NUMBER(*socket);

	mutex_exit(&sp->lock);

	/*
	 * Return the found client pointer if the caller wants it.
	 */
	if (clp)
	    *clp = client;

	/*
	 * Return a socket number that is made up of the socket number
	 *	and the function number.
	 */
	*socket = CS_MAKE_SOCKET_NUMBER(sn, fn);

	/*
	 * Return the function number if the caller wants it.
	 */
	if (function)
	    *function = fn;

	return (CS_SUCCESS);
}

/*
 * cs_get_wp - returns pointer to passed window number
 *
 *	return: (cs_window_t *) - pointer to window structure
 *		NULL - if invalid window number passed in
 */
static cs_window_t *
cs_get_wp(uint32_t wn)
{
	cs_window_t *cw;

	if (!(cs_globals.init_state & GLOBAL_INIT_STATE_SS_READY))
	    return (NULL);

	if ((cw = cs_find_wp(wn)) == NULL)
	    return (NULL);

	if (cw->state & CW_WINDOW_VALID)
	    return (cw);

#ifdef  CS_DEBUG
	if (cs_debug > 0) {
		cmn_err(CE_CONT, "cs_get_wp(): wn=%d  cw=%p\n",
		    (int)wn, (void *)cw);
	}
#endif

	return (NULL);
}

/*
 * cs_find_wp - searches window list and returns pointer to passed window
 *			number
 *
 *	return: (cs_window_t *) - pointer to window structure
 *		NULL - window not found
 */
static cs_window_t *
cs_find_wp(uint32_t wn)
{
	cs_window_t *cw = cs_globals.cw;

	while (cw) {
	    if (cw->window_num == wn)
		return (cw);
	    cw = cw->next;
	} /* while */

#ifdef  CS_DEBUG
	if (cs_debug > 0) {
		cmn_err(CE_CONT, "cs_find_wp(): wn=%d  window_num=%d cw=%p\n",
		    (int)wn, (int)cw->window_num, (void *)cw);
	}
#endif

	return (NULL);
}

/*
 * cs_add_windows - adds number of windows specified in "aw" to
 *			the global window list; start the window
 *			numbering at "bn"
 *
 *	return: CS_SUCCESS - if windows added sucessfully
 *		CS_BAD_WINDOW - if unable to add windows
 *
 * Note: The window list must be protected by a lock by the caller.
 */
static int
cs_add_windows(int aw, uint32_t bn)
{
	cs_window_t *cwp = cs_globals.cw;
	cs_window_t *cw, *cwpp;

	if (aw <= 0)
	    return (CS_BAD_WINDOW);

	while (cwp) {
	    cwpp = cwp;
	    cwp = cwp->next;
	}

	while (aw--) {
	    cw = (cs_window_t *)kmem_zalloc(sizeof (cs_window_t), KM_SLEEP);

	    if (cs_globals.cw == NULL) {
		cs_globals.cw = cw;
		cwpp = cs_globals.cw;
	    } else {
		cwpp->next = cw;
		cwpp = cwpp->next;
	    }

	    cwpp->window_num = bn++;
	    cwpp->state = CW_WINDOW_VALID;

	} /* while (aw) */

	return (CS_SUCCESS);
}

/*
 * cs_ss_init - initialize CS items that need to wait until we receive
 *			a PCE_SS_INIT_STATE/PCE_SS_STATE_INIT event
 *
 *	return: CS_SUCESS - if sucessfully initialized
 *		(various) if error initializing
 *
 *	At this point, we expect that Socket Services has setup the
 *	following global variables for us:
 *
 *		cs_socket_services - Socket Services entry point
 *		cis_parser - CIS parser entry point
 */
static uint32_t
cs_ss_init()
{
	cs_register_cardservices_t rcs;
	csregister_t csr;
	uint32_t ret;

	/*
	 * Fill out the parameters for CISP_CIS_SETUP
	 */
	csr.cs_magic = PCCS_MAGIC;
	csr.cs_version = PCCS_VERSION;
	csr.cs_card_services = CardServices;
	csr.cs_event = NULL;

	/*
	 * Call into the CIS module and tell it what the private
	 *	Card Services entry point is. The CIS module will
	 *	call us back at CardServices(CISRegister, ...)
	 *	with the address of various CIS-specific global
	 *	data structures.
	 */
	CIS_PARSER(CISP_CIS_SETUP, &csr);

	/*
	 * Register with the Card Services kernel stubs module
	 */
	rcs.magic = CS_STUBS_MAGIC;
	rcs.function = CS_ENTRY_REGISTER;
	rcs.cardservices = CardServices;

	if ((ret = csx_register_cardservices(&rcs)) != CS_SUCCESS) {
	    cmn_err(CE_CONT, "cs_ss_init: can't register with "
					"cs_stubs, retcode = 0x%x\n", ret);
		return (ret);
	} /* csx_register_cardservices */

	return (CS_SUCCESS);
}

/*
 * cs_create_cis - reads CIS on card in socket and creates CIS lists
 *
 * Most of the work is done in the CIS module in the CISP_CIS_LIST_CREATE
 *	function.
 *
 * This function returns:
 *
 *	CS_SUCCESS - if the CIS lists were created sucessfully
 *	CS_BAD_WINDOW or CS_GENERAL_FAILURE - if CIS window could
 *			not be setup
 *	CS_BAD_CIS - if error creating CIS chains
 *	CS_BAD_OFFSET - if the CIS parser tried to read past the
 *			boundries of the allocated CIS window
 */
static int
cs_create_cis(cs_socket_t *sp)
{
	uint32_t ret;

	ret = (uint32_t)(uintptr_t)CIS_PARSER(CISP_CIS_LIST_CREATE,
	    cis_cistpl_std_callout, sp);

#ifdef	CS_DEBUG
	if (ret == CS_NO_CIS) {
	    if (cs_debug > 0)
		cmn_err(CE_CONT, "cs_create_cis: socket %d has no CIS\n",
								sp->socket_num);
	} else if (ret != CS_SUCCESS) {
	    if (cs_debug > 0)
		cmn_err(CE_CONT, "cs_create_cis: socket %d ERROR = 0x%x\n",
							sp->socket_num, ret);
	    return (ret);
	}
#else
	if (ret != CS_NO_CIS)
	    if (ret != CS_SUCCESS)
		return (ret);
#endif

	/*
	 * If this card didn't have any CIS at all, there's not much
	 *	else for us to do.
	 */
	if (!(sp->cis_flags & CW_VALID_CIS))
	    return (CS_SUCCESS);

	/*
	 * If this is a single-function card, we need to move the CIS list
	 *	that is currently on CS_GLOBAL_CIS to the function zero
	 *	CIS list.
	 */
	if (!(sp->cis_flags & CW_MULTI_FUNCTION_CIS)) {
	    bcopy((caddr_t)&sp->cis[CS_GLOBAL_CIS],
				(caddr_t)&sp->cis[0], sizeof (cis_info_t));
	    bzero((caddr_t)&sp->cis[CS_GLOBAL_CIS], sizeof (cis_info_t));
	} /* !CW_MULTI_FUNCTION_CIS */

	return (CS_SUCCESS);
}

/*
 * cs_destroy_cis - destroys CIS list for socket
 */
static int
cs_destroy_cis(cs_socket_t *sp)
{
	CIS_PARSER(CISP_CIS_LIST_DESTROY, sp);

	return (CS_SUCCESS);
}

/*
 * cs_get_client_info - This function is GetClientInfo.
 *
 *    calling:	client_handle_t - client handle to get client info on
 *		client_info_t * - pointer to a client_info_t structure
 *					to return client information in
 *
 *    returns:	CS_SUCCESS - if client info retreived from client
 *		CS_BAD_SOCKET, CS_BAD_HANDLE - if invalid client
 *					handle passed in
 *		CS_NO_MORE_ITEMS - if client does not handle the
 *					CS_EVENT_CLIENT_INFO event
 *					or if invalid client info
 *					retreived from client
 */
static int
cs_get_client_info(client_handle_t client_handle, client_info_t *ci)
{
	cs_socket_t *sp;
	client_t *client;
	client_info_t *cinfo;
	int ret = CS_SUCCESS;

	if (CLIENT_HANDLE_IS_SS(client_handle)) {
	    ci->Attributes = (CS_CLIENT_INFO_SOCKET_SERVICES |
						CS_CLIENT_INFO_VALID);
	    return (CS_SUCCESS);
	} /* CLIENT_HANDLE_IS_SS */

	if ((sp = cs_get_sp(GET_CLIENT_SOCKET(client_handle))) == NULL)
	    return (CS_BAD_SOCKET);

	mutex_enter(&sp->client_lock);
	mutex_enter(&sp->lock);

	if ((client = cs_find_client(client_handle, &ret)) == NULL) {
	    mutex_exit(&sp->lock);
	    mutex_exit(&sp->client_lock);
	    return (ret);
	} /* cs_find_client */

	/*
	 * If this client is not handling CS_EVENT_CLIENT_INFO events,
	 *	then don't bother to even wake up the event thread.
	 */
	if (!((client->event_mask | client->global_mask) &
					CS_EVENT_CLIENT_INFO)) {
	    mutex_exit(&sp->lock);
	    mutex_exit(&sp->client_lock);
	    return (CS_NO_MORE_ITEMS);
	} /* !CS_EVENT_CLIENT_INFO */

	cinfo = &client->event_callback_args.client_info;

	bzero((caddr_t)cinfo, sizeof (client_info_t));
	cinfo->Attributes = (ci->Attributes & CS_CLIENT_INFO_SUBSVC_MASK);

	client->events |= CS_EVENT_CLIENT_INFO;

	sp->thread_state |= SOCKET_WAIT_SYNC;
	mutex_exit(&sp->lock);
	cv_broadcast(&sp->thread_cv);
	cv_wait(&sp->caller_cv, &sp->client_lock);

	if (cinfo->Attributes & CS_CLIENT_INFO_VALID) {
	    bcopy((caddr_t)cinfo, (caddr_t)ci, sizeof (client_info_t));
	    ci->Attributes &= (CS_CLIENT_INFO_FLAGS_MASK |
					CS_CLIENT_INFO_SUBSVC_MASK);
	    ci->Attributes &= ~(CS_CLIENT_INFO_CLIENT_MASK |
						INFO_CARD_FLAGS_MASK |
						CS_CLIENT_INFO_CLIENT_ACTIVE);
	    ci->Attributes |= (client->flags & (CS_CLIENT_INFO_CLIENT_MASK |
						INFO_CARD_FLAGS_MASK));
	    (void) strcpy(ci->DriverName, client->driver_name);
	    if (cs_card_for_client(client))
		ci->Attributes |= CS_CLIENT_INFO_CLIENT_ACTIVE;
	} else {
	    ret = CS_NO_MORE_ITEMS;
	} /* CS_CLIENT_INFO_VALID */

	mutex_exit(&sp->client_lock);

	return (ret);
}

/*
 * cs_get_firstnext_client - This function is GetFirstClient and
 *				GetNextClient
 *
 *    calling:	get_firstnext_client_t * - pointer to a get_firstnext_client_t
 *					structure to return client handle and
 *					attributes in
 *		flags - one of the following:
 *				CS_GET_FIRST_FLAG - get first client handle
 *				CS_GET_NEXT_FLAG - get next client handle
 *
 *    returns:	CS_SUCCESS - if client info retreived from client
 *		CS_BAD_SOCKET, CS_BAD_HANDLE - if invalid client
 *					handle passed in
 *		CS_NO_MORE_ITEMS - if client does not handle the
 *					CS_EVENT_CLIENT_INFO event
 *					or if invalid client info
 *					retreived from client
 */
static int
cs_get_firstnext_client(get_firstnext_client_t *fnc, uint32_t flags)
{
	cs_socket_t *sp;
	client_t *client;
	uint32_t sn = 0;
	int ret = CS_SUCCESS;

	switch (flags) {
	    case CS_GET_FIRST_FLAG:
		if (fnc->Attributes & CS_GET_FIRSTNEXT_CLIENT_ALL_CLIENTS) {
		    while (sn < cs_globals.max_socket_num) {
			if ((sp = cs_get_sp(sn)) != NULL) {
			    mutex_enter(&sp->client_lock);
			    if ((client = sp->client_list) != NULL)
				break;
			    mutex_exit(&sp->client_lock);
			} /* if */
			sn++;
		    } /* while */

		    if (sn == cs_globals.max_socket_num)
			return (CS_NO_MORE_ITEMS);
		} else if (fnc->Attributes &
					CS_GET_FIRSTNEXT_CLIENT_SOCKET_ONLY) {
		    if ((sp = cs_get_sp(CS_GET_SOCKET_NUMBER(fnc->Socket))) ==
									NULL)
			return (CS_BAD_SOCKET);
		    mutex_enter(&sp->client_lock);
		    if ((client = sp->client_list) == NULL) {
			mutex_exit(&sp->client_lock);
			return (CS_NO_MORE_ITEMS);
		    }
		} else {
		    return (CS_BAD_ATTRIBUTE);
		}

		fnc->client_handle = client->client_handle;
		fnc->num_clients = sp->num_clients;
		mutex_exit(&sp->client_lock);
		break;
	    case CS_GET_NEXT_FLAG:
		if (fnc->Attributes & CS_GET_FIRSTNEXT_CLIENT_ALL_CLIENTS) {
		    sn = GET_CLIENT_SOCKET(fnc->client_handle);

		    if ((sp = cs_get_sp(sn)) == NULL)
			return (CS_BAD_SOCKET);

		    mutex_enter(&sp->client_lock);
		    if ((client = cs_find_client(fnc->client_handle,
				&ret)) == NULL) {
			mutex_exit(&sp->client_lock);
			return (ret);
		    }
		    if ((client = client->next) == NULL) {
			mutex_exit(&sp->client_lock);
			sn++;
			while (sn < cs_globals.max_socket_num) {
			    if ((sp = cs_get_sp(sn)) != NULL) {
				mutex_enter(&sp->client_lock);
				if ((client = sp->client_list) != NULL)
				    break;
				mutex_exit(&sp->client_lock);
			    } /* if */
			    sn++;
			} /* while */

			if (sn == cs_globals.max_socket_num)
			    return (CS_NO_MORE_ITEMS);
		    } /* client = client->next */

		} else if (fnc->Attributes &
					CS_GET_FIRSTNEXT_CLIENT_SOCKET_ONLY) {
		    sp = cs_get_sp(GET_CLIENT_SOCKET(fnc->client_handle));
		    if (sp == NULL)
			return (CS_BAD_SOCKET);
		    mutex_enter(&sp->client_lock);
		    if ((client = cs_find_client(fnc->client_handle,
				&ret)) == NULL) {
			mutex_exit(&sp->client_lock);
			return (ret);
		    }
		    if ((client = client->next) == NULL) {
			mutex_exit(&sp->client_lock);
			return (CS_NO_MORE_ITEMS);
		    }
		} else {
		    return (CS_BAD_ATTRIBUTE);
		}

		fnc->client_handle = client->client_handle;
		fnc->num_clients = sp->num_clients;
		mutex_exit(&sp->client_lock);
		break;
	    default:
		ret = CS_BAD_ATTRIBUTE;
		break;

	} /* switch */

	return (ret);
}

/*
 * cs_set_acc_attributes - converts Card Services endianness and
 *				data ordering values to values
 *				that Socket Services understands
 *
 *	calling: *sw - pointer to a set_window_t to set attributes in
 *		 Attributes - CS attributes
 */
static void
cs_set_acc_attributes(set_window_t *sw, uint32_t Attributes)
{
	sw->attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;

	switch (Attributes & WIN_ACC_ENDIAN_MASK) {
	    case WIN_ACC_LITTLE_ENDIAN:
		sw->attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC;
		break;
	    case WIN_ACC_BIG_ENDIAN:
		sw->attr.devacc_attr_endian_flags = DDI_STRUCTURE_BE_ACC;
		break;
	    case WIN_ACC_NEVER_SWAP:
	    default:
		sw->attr.devacc_attr_endian_flags = DDI_NEVERSWAP_ACC;
		break;
	} /* switch */

	switch (Attributes & WIN_ACC_ORDER_MASK) {
	    case WIN_ACC_UNORDERED_OK:
		sw->attr.devacc_attr_dataorder = DDI_UNORDERED_OK_ACC;
		break;
	    case WIN_ACC_MERGING_OK:
		sw->attr.devacc_attr_dataorder = DDI_MERGING_OK_ACC;
		break;
	    case WIN_ACC_LOADCACHING_OK:
		sw->attr.devacc_attr_dataorder = DDI_LOADCACHING_OK_ACC;
		break;
	    case WIN_ACC_STORECACHING_OK:
		sw->attr.devacc_attr_dataorder = DDI_STORECACHING_OK_ACC;
		break;
	    case WIN_ACC_STRICT_ORDER:
	    default:
		sw->attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;
		break;
	} /* switch */
}