pcmcia - zygaena/hammerhead

root / base / usr / src / uts / common / pcmcia
pcmcia Plain Text 24118 lines 680.5 KB
/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * This is a collection of routines that make up the Card Information
 *	Structure (CIS) interpreter.  The algorigthms used are based
 *	on the Release 2.01 PCMCIA standard.
 *
 * Note that a bunch of comments are not indented correctly with the
 *	code that they are commenting on. This is because cstyle is
 *	inflexible concerning 4-column indenting.
 */

#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/kstat.h>
#include <sys/kmem.h>
#include <sys/modctl.h>
#include <sys/kobj.h>
#include <sys/callb.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/cis_protos.h>
#include <pcmcia/sys/cs_stubs.h>

/*
 * Function declarations
 */
void *CISParser(int function, ...);
static int (*cis_card_services)(int, ...) = NULL;

static int cis_process_longlink(cistpl_callout_t *, cistpl_t *,
						cis_info_t *, cisparse_t *);
static int cis_create_cis_chain(cs_socket_t *, cistpl_callout_t *,
					cisptr_t *, cis_info_t *, cisparse_t *);
static void cis_store_cis_addr(cistpl_t *, cisptr_t *);

extern cistpl_callout_t cistpl_std_callout[];
extern cistpl_devspeed_struct_t cistpl_devspeed_struct;

#ifdef	CIS_DEBUG
int	cis_debug = 0;
#endif

/*
 * cisp_init - initialize the CIS parser
 */
void
cisp_init()
{
#ifdef	XXX
	csregister_t csr;

	/*
	 * Fill out the function for CISSetAddress
	 */
	csr.cs_magic = PCCS_MAGIC;
	csr.cs_version = PCCS_VERSION;
	csr.cs_event = (f_t *)CISParser;

	/*
	 * We have to call SS instead of CS to register because we
	 *	can't do a _depends_on for CS
	 */
	SocketServices(CISSetAddress, &csr);
#endif	/* XXX */
}

/*
 * cis_deinit - deinitialize the CIS parser
 */
void
cis_deinit()
{

	/*
	 * Tell CS that we're gone.
	 */
	if (cis_card_services)
	    CIS_CARD_SERVICES(CISUnregister);

	return;

}

/*
 * CISParser - this is the entrypoint for all of the CIS Interpreter
 *		functions
 */
void *
CISParser(int function, ...)
{
	va_list arglist;
	void *retcode = (void *)CS_UNSUPPORTED_FUNCTION;

#if defined(CIS_DEBUG)
	if (cis_debug > 1) {
	    cmn_err(CE_CONT, "CISParser: called with function 0x%x\n",
				function);
	}
#endif

	va_start(arglist, function);

	/*
	 * ...and here's the CIS Interpreter waterfall
	 */
	switch (function) {
	    case CISP_CIS_SETUP: {
		csregister_t *csr;
		cisregister_t cisr;

		    csr = va_arg(arglist, csregister_t *);
		    cis_card_services = csr->cs_card_services;

		    cisr.cis_magic = PCCS_MAGIC;
		    cisr.cis_version = PCCS_VERSION;
		    cisr.cis_parser = NULL;	/* let the framework do this */
		    cisr.cistpl_std_callout = cistpl_std_callout;

			/*
			 * Tell CS that we're here and what our
			 *	entrypoint address is.
			 */
		    CIS_CARD_SERVICES(CISRegister, &cisr);
		} /* CISP_CIS_SETUP */
		break;
	    case CISP_CIS_LIST_CREATE: {
		cistpl_callout_t *cistpl_callout;
		cs_socket_t *sp;

		    cistpl_callout = va_arg(arglist, cistpl_callout_t *);
		    sp = va_arg(arglist, cs_socket_t *);

		    retcode = (void *)
			(uintptr_t)cis_list_create(cistpl_callout, sp);
		}
		break;
	    case CISP_CIS_LIST_DESTROY: {
		cs_socket_t *sp;

		    sp = va_arg(arglist, cs_socket_t *);

		    retcode = (void *)(uintptr_t)cis_list_destroy(sp);
		}
		break;
	    case CISP_CIS_GET_LTUPLE: {
		cistpl_t *tp;
		cisdata_t type;
		int flags;

		    tp = va_arg(arglist, cistpl_t *);
		    type = va_arg(arglist, uint_t);
		    flags = va_arg(arglist, int);

		    retcode = (void *)cis_get_ltuple(tp, type, flags);
		}
		break;

	    case CISP_CIS_PARSE_TUPLE: {
		cistpl_callout_t *co;
		cistpl_t *tp;
		int flags;
		void *arg;
		cisdata_t subtype;

		co = va_arg(arglist, cistpl_callout_t *);
		tp = va_arg(arglist, cistpl_t *);
		flags = va_arg(arglist, int);
		arg = va_arg(arglist, void *);
		subtype = va_arg(arglist, uint_t);

		retcode = (void *)(uintptr_t)cis_tuple_handler(co, tp,
		    flags, arg, subtype);
		}
		break;

	    case CISP_CIS_CONV_DEVSPEED:
		retcode = (void *)(uintptr_t)cis_convert_devspeed(
				va_arg(arglist, convert_speed_t *));
		break;

	    case CISP_CIS_CONV_DEVSIZE:
		retcode = (void *)(uintptr_t)cis_convert_devsize(
				va_arg(arglist, convert_size_t *));
		break;

	    default:
		break;
	}

	va_end(arglist);

	return (retcode);
}

/*
 * cis_list_lcreate - read a PC card's CIS and create a local linked CIS list
 *
 *	cistpl_callout_t *cistpl_callout - pointer to callout structure
 *				array to use to find tuples.
 *	cisptr_t cisptr - pointer to a structure containing the handle and
 *				offset from where we should start reading
 *				CIS bytes as well as misc flags.
 *	cis_info_t *cis_info - pointer to a cis_info_t structure; pass
 *				the cis_info->cis member as a NULL pointer
 *				if you want to create a new list.
 *	cisparse_t *cisparse - pointer to a cisparse_t struture to put
 *				parsed longlink tuple data into.
 *      cs_socket_t *sp - pointer to a cs_socket_t structure that describes
 *				 the socket and card in this socket.
 *
 * We return the a count of the number of tuples that we saw, not including
 *	any CISTPL_END or CISTPL_NULL tuples if there were no problems
 *	processing the CIS.  If a tuple handler returns an error, we
 *	immediately return with the error code from the handler. An
 *	error return code will always have the HANDTPL_ERROR bit set
 *	to allow the caller to distinguish an error from a valid tuple
 *	count.
 *
 * The nchains and ntuples counters in  the cis_info_t structure are also
 *	updated to reflect the number of chains and number of tuples in
 *	this chain.
 *
 * XXX need to add CISTPL_END and CISTPL_NULL tuples to the list, and need
 *	to be sure that the tuple count reflects these tuples
 *
 * If we attempt to read beyond the end of the mapped in CIS address space,
 *	the BAD_CIS_ADDR error code is returned.
 *
 * This function only interprets the CISTPL_END and CISTPL_NULL tuples as
 *	well as any tuple with a link field of CISTPL_END.
 *
 * Tuples of type CISTPL_END or CISTPL_NULL are not added to the list.
 *
 * To append tuples to end of a local linked CIS list, pass a pointer to the
 *	address of the last element in the list that you want tuples appended
 *	to. This pointer should be passed in cis_info->cis.
 *
 * To process tuple chains with any long link targets, call this routine
 *	for each tuple chain you want to process using the list append method
 *	described above.  The caller is responsible for vaildating any link
 *	target tuples to be sure that they describe a valid CIS chain.
 *
 * The cis_info->flags member is updated as follows:
 *
 *		CW_VALID_CIS - if the CIS is valid
 *		CW_LONGLINK_MFC_FOUND - if a CISTPL_LONGLINK_MFC tuple
 *					was seen
 *		CW_LONGLINK_A_FOUND - if a CISTPL_LONGLINK_A tuple was
 *					seen
 *		CW_LONGLINK_C_FOUND - if a CISTPL_LONGLINK_C tuple was
 *					seen
 *
 *	If a CISTPL_LONGLINK_MFC, CISTPL_LONGLINK_A or CISTPL_LONGLINK_C
 *	tuple is seen, the *cisparse argument will return an appropriate
 *	parsed longlink structure as follows:
 *
 *		CW_LONGLINK_MFC_FOUND:
 *			*cisparse --> cistpl_longlink_mfc_t *
 *		CW_LONGLINK_A_FOUND, CW_LONGLINK_C_FOUND:
 *			*cisparse --> cistpl_longlink_ac_t *
 *
 *	These flags are set and the tuples are parsed so that the caller does
 *	not have to traverse the CIS list to find out if any of these tuples
 *	have been seen.
 *
 * For each tuple that we see, the following flags in the tuple_t->flags member
 *	are set/cleared:
 *
 *		CISTPLF_COPYOK - OK to copy tuple data
 *		CISTPLF_GLOBAL_CIS - tuple from global CIS
 *		CISTPLF_MF_CIS - tuple from MF CIS chain
 *		CISTPLF_FROM_AM - tuple read from AM space
 *		CISTPLF_FROM_CM - tuple read from CM space
 *		CISTPLF_LINK_INVALID - tuple link is invalid
 *		CISTPLF_PARAMS_INVALID - tuple body is invalid
 *		CISTPLF_AM_SPACE - this tuple is in AM space
 *		CISTPLF_CM_SPACE - this tuple is in CM space
 *		CISTPLF_LM_SPACE - this tuple is in local memory
 */
uint32_t
cis_list_lcreate(cistpl_callout_t *cistpl_callout, cisptr_t *cisptr,
    cis_info_t *cis_info, cisparse_t *cisparse, cs_socket_t *sp)
{
	cistpl_t *cp, *tp = NULL;
	cisdata_t tl, td, *dp;
	int done = 0, err;
	get_socket_t get_socket;


	/*
	 * If we were passed a non-NULL list base, that means that we should
	 *	parse the CIS and add any tuples we find to the end of the list
	 *	we were handed a pointer to.
	 */
	if (cis_info->cis) {
		tp = cis_info->cis;
	}

	get_socket.socket = sp->socket_num;
	if (SocketServices(SS_GetSocket, &get_socket) != SUCCESS) {
		cmn_err(CE_CONT,
		    "cis_list_lcreate: socket %d SS_GetSocket failed\n",
		    sp->socket_num);
		return (CS_BAD_SOCKET);
	}

	/*
	 * If this is primary CIS chain, the first tuple must be one
	 *	from the following list.
	 * Ref. PC Card 95, Metaformat Specification, Page 7.
	 * XXX Need to think this out a bit more to deal with 3.3V
	 *	cards and the description of where a CISTPL_DEVICE
	 *	can show up.
	 */

#if defined(CIS_DEBUG)
	if (cis_debug > 1) {
		cmn_err(CE_CONT, "cis_list_lcreate: td=0x%x cisptr=%p\n",
		    GET_CIS_DATA(cisptr), (void *)cisptr);
		cmn_err(CE_CONT, "\t flags=0x%x CW_CHECK_PRIMARY_CHAIN=0x%x\n",
		    cis_info->flags,  CW_CHECK_PRIMARY_CHAIN);
		cmn_err(CE_CONT, "\t IFType=0x%x IF_MEMORY=0x%x\n",
		    get_socket.IFType, IF_MEMORY);
	}
#endif

	if (cis_info->flags & CW_CHECK_PRIMARY_CHAIN) {
	switch (td = GET_CIS_DATA(cisptr)) {
		case CISTPL_DEVICE:
		case CISTPL_END:
		case CISTPL_LINKTARGET:
		    break;
		case CISTPL_NULL:
		/*
		 * Magicram memory cards without attribute memory
		 * do not have a CIS and return CISTPL_NULL.
		 */
		    if (get_socket.IFType == IF_MEMORY)
			return (0);
		    break;

		default:
		    return (0);
	    } /* switch */
	} /* CW_CHECK_PRIMARY_CHAIN */

	/*
	 * Update the number of chains counter
	 */
	cis_info->nchains++;

	/*
	 * The main tuple processing loop.  We'll exit this loop when either
	 *	a tuple's link field is CISTPL_END or we've seen a tuple type
	 *	field of CISTPL_END.
	 *
	 * Note that we also silently throw away CISTPL_NULL tuples, and don't
	 *	include them in the tuple count that we return.
	 */
	while (!done && ((td = GET_CIS_DATA(cisptr)) !=
						(cisdata_t)CISTPL_END)) {

#if defined(CIS_DEBUG)
		if ((cis_debug > 1) && (td != 0)) {
			cmn_err(CE_CONT, "cis_list_lcreate: td=0x%x cisptr=%p"
			    "offset=0x%x\n",
			    td, (void *)cisptr, cisptr->offset);
		}
#endif

		/*
		 * Ignore CISTPL_NULL tuples
		 */
		if (td != (cisdata_t)CISTPL_NULL) {
			/*
			 * point to tuple link field and get the link value
			 */
			if (!NEXT_CIS_ADDR(cisptr))
			    return ((uint32_t)BAD_CIS_ADDR);
			tl = GET_CIS_DATA(cisptr);
		/*
		 * This is an ugly PCMCIA hack - ugh! since the standard allows
		 *	a link byte of CISTPL_END to signify that this is the
		 *	last tuple.  The problem is that this tuple might
		 *	actually contain useful information, but we don't know
		 *	the size of it.
		 * We do know that it can't be more than CIS_MAX_TUPLE_DATA_LEN
		 *	bytes in length, however.  So, we pretend that the link
		 *	byte is CIS_MAX_TUPLE_DATA_LEN and also set a flag so
		 *	that when we're done processing this tuple, we will
		 *	break out of the while loop.
		 */
			if (tl == (cisdata_t)CISTPL_END) {
				tl = CIS_MAX_TUPLE_DATA_LEN;
				done = 1;
			}

		/*
		 * point to first byte of tuple data, allocate a new list
		 *	element and diddle with the list base and list
		 *	control pointers
		 */
			if (!NEXT_CIS_ADDR(cisptr))
			    return ((uint32_t)BAD_CIS_ADDR);
			cp = (cistpl_t *)CIS_MEM_ALLOC(sizeof (cistpl_t));
			cp->next = NULL;
			/*
			 * if we're not the first in the list, point to our
			 *	next
			 */
			if (tp)
				tp->next = cp;
			/*
			 * will be NULL if we're the first element of the
			 *	list
			 */
			cp->prev = tp;
			tp = cp;
			/*
			 * if this is the first element, save it's address
			 */
			if (!cis_info->cis)
				cis_info->cis = tp;
			tp->type = td;
			tp->len = tl;

			/*
			 * Save the address in CIS space that this tuple
			 *	begins at, as well as set tuple flags.
			 */
			cis_store_cis_addr(tp, cisptr);

			/*
			 * If this tuple has tuple data, we might need to
			 *	copy it.
			 * Note that the tuple data pointer (tp->data) will
			 *	be set to NULL for a tuple with no data.
			 */
#ifdef	XXX
			if (tl) {
#endif
			/*
			 * Read the data in the tuple and store it
			 *	away locally if we're allowed to. If
			 *	the CISTPLF_COPYOK flag is set, it means
			 *	that it's OK to touch the data portion
			 *	of the tuple.
			 *
			 * We need to make this check since some
			 *	tuples might contain active registers
			 *	that can alter the device state if they
			 *	are read before the card is correctly
			 *	initialized.  What a stupid thing to
			 *	allow in a standard, BTW.
			 *
			 * We first give the tuple handler a chance
			 *	to set any tuple flags that it wants
			 *	to, then we (optionally) do the data
			 *	copy, and give the tuple handler another
			 *	shot at the tuple.
			 *
			 * ref. PC Card Standard Release 2.01 in the
			 *	Card Metaformat section, section 5.2.6,
			 *	page 5-12.
			 */
			if ((err = cis_tuple_handler(cistpl_callout, tp,
						HANDTPL_SET_FLAGS, NULL, 0)) &
								HANDTPL_ERROR)
			    return (err);

			if (tl > (unsigned)0) {

				/*
				 * if we're supposed to make a local copy of
				 *	the tuple data, allocate space for it,
				 *	otherwise just record the PC card
				 *	starting address of this tuple.
				 * The address was saved by cis_store_cis_addr.
				 */
				if (tp->flags & CISTPLF_COPYOK) {
				    tp->data = (cisdata_t *)CIS_MEM_ALLOC(tl);
				    dp = tp->data;
				} else {
				    tp->data = GET_CIS_ADDR(tp);
				}

				while (tl--) {
				    if (tp->flags & CISTPLF_COPYOK)
					*dp++ = GET_CIS_DATA(cisptr);
				    if (!NEXT_CIS_ADDR(cisptr))
					return ((uint32_t)BAD_CIS_ADDR);
				}

				/*
				 * If we made a local copy of the tuple data,
				 *	then clear the AM and CM flags; if the
				 *	tuple data is still on the card, then
				 *	leave the flags alone.
				 */
				if (tp->flags & CISTPLF_COPYOK) {
				    tp->flags &= ~CISTPLF_SPACE_MASK;
				    tp->flags |= CISTPLF_LM_SPACE;
				}

			/*
			 * This is a tuple with no data in it's body, so
			 *	we just set the data pointer to NULL.
			 */
			} else {

			    tp->data = NULL;
				/*
				 * tp->flags &= ~(CISTPLF_SPACE_MASK |
				 *		CISTPLF_FROM_MASK);
				 */

			} /* if (tl > 0) */

			/*
			 * The main idea behind this call is to give
			 *	the handler a chance to validate the
			 *	tuple.
			 */
			if ((err = cis_tuple_handler(cistpl_callout, tp,
						HANDTPL_COPY_DONE, NULL, 0)) &
								HANDTPL_ERROR)
			    return (err);

#ifdef	XXX
			} else { /* if (tl) */
			    tp->data = NULL;
			}
#endif

			/*
			 * Check to see if this is a longlink tuple and if
			 *	so, do the necessary processing.
			 */
			if ((err = cis_process_longlink(cistpl_callout, tp,
								cis_info,
								cisparse)) &
								HANDTPL_ERROR)
			    return (err);

			cis_info->ntuples++;
		} else { /* if (td == CISTPL_NULL) */
			/*
			 * If we're a CISTPL_NULL we need to skip to
			 *	the beginning of the next tuple.
			 */
			if (!NEXT_CIS_ADDR(cisptr))
			    return ((uint32_t)BAD_CIS_ADDR);
		}
	} /* while (!done && !CISTPL_END) */

#if defined(CIS_DEBUG)
	if (cis_debug > 1) {
	    cmn_err(CE_CONT, "cis_list_lcreate: exit nchains=%x ntuples=%x\n",
		cis_info->nchains, cis_info->ntuples);
	}
#endif

	return (cis_info->ntuples);
}

/*
 * cis_process_longlink - processes longlink tuples
 *
 *	This function examines the passed-in tuple type and if it is a
 *	longlink tuple, the tuple is parsed and the appropriate flags in
 *	cis_info->flags are set.
 *
 *	If there is an error parsing the tuple, HANDTPL_ERROR is returned
 *	and the CW_LONGLINK_FOUND flags in cis_info->flags are cleared.
 */
static int
cis_process_longlink(cistpl_callout_t *cistpl_callout, cistpl_t *tp,
				cis_info_t *cis_info, cisparse_t *cisparse)
{
	/*
	 * If this is a CISTPL_LONGLINK_A, CISTPL_LONGLINK_C
	 *	or CISTPL_LONGLINK_MFC tuple, parse the tuple
	 *	and set appropriate CW_LONGLINK_XXX_FOUND flags.
	 * If this is a CISTPL_NO_LINK tuple, or if there is an
	 *	error parsing the tuple, clear all the
	 *	CW_LONGLINK_XXX_FOUND flags.
	 */
	switch (tp->type) {
	    case CISTPL_LONGLINK_A:
	    case CISTPL_LONGLINK_C:
	    case CISTPL_LONGLINK_MFC:
		cis_info->flags &= ~CW_LONGLINK_FOUND;
		if (cis_tuple_handler(cistpl_callout, tp,
						HANDTPL_PARSE_LTUPLE,
						cisparse, 0) &
							HANDTPL_ERROR)
		    return (HANDTPL_ERROR);
		switch (tp->type) {
		    case CISTPL_LONGLINK_A:
			cis_info->flags |= CW_LONGLINK_A_FOUND;
			break;
		    case CISTPL_LONGLINK_C:
			cis_info->flags |= CW_LONGLINK_C_FOUND;
			break;
		    case CISTPL_LONGLINK_MFC:
			cis_info->flags |= CW_LONGLINK_MFC_FOUND;
			break;
		} /* switch (tp->type) */
		break;
	    case CISTPL_NO_LINK:
		cis_info->flags &= ~CW_LONGLINK_FOUND;
		break;
	} /* switch (tp->type) */

	return (HANDTPL_NOERROR);
}

/*
 * cis_list_ldestroy - function to destroy a linked tuple list
 *
 *	cistpl_t *cistplbase - pointer to a pointer to the base of a
 *				local linked CIS list to destroy; the
 *				data that this pointer points to is
 *				also destroyed
 *
 * Once this function returns, cistplbase is set to NULL.
 */
uint32_t
cis_list_ldestroy(cistpl_t **cistplbase)
{
	cistpl_t *cp, *tp;
	int tpcnt = 0;

	/*
	 * First, check to see if we've got a
	 *	non-NULL list pointer.
	 */
	if ((tp = *cistplbase) == NULL)
	    return (0);

	while (tp) {
		/*
		 * Free any data that may be allocated
		 */
	    if ((tp->flags & CISTPLF_COPYOK) &&
			(tp->flags & CISTPLF_LM_SPACE) &&
						(tp->data))
		CIS_MEM_FREE((caddr_t)tp->data);

	    cp = tp->next;

		/*
		 * Free this tuple
		 */
	    CIS_MEM_FREE((caddr_t)tp);

	    tp = cp;

	    tpcnt++;
	}

	/*
	 * Now clear the pointer to the non-existant
	 *	linked list.
	 */
	*cistplbase = NULL;

	return (tpcnt);

}

/*
 * cis_get_ltuple - function to walk local linked CIS list and return
 *			a tuple based on various criteria
 *
 *	cistpl_t *tp - pointer to any valid tuple in the list
 *	cisdata_t type - type of tuple to search for
 *	int flags - type of action to perform (each is mutually exclusive)
 *		GET_FIRST_LTUPLEF, GET_LAST_LTUPLEF:
 *		    Returns the {first|last} tuple in the list.
 *		FIND_LTUPLE_FWDF, FIND_LTUPLE_BACKF:
 *		FIND_NEXT_LTUPLEF, FIND_PREV_LTUPLEF:
 *		    Returns the first tuple that matches the passed tuple type,
 *			searching the list {forward|backward}.
 *		GET_NEXT_LTUPLEF, GET_PREV_LTUPLEF:
 *		    Returns the {next|previous} tuple in the list.
 *
 *	    The following bits can be set in the flags parameter:
 *		CIS_GET_LTUPLE_IGNORE - return tuples with
 *				CISTPLF_IGNORE_TUPLE set in cistpl_t->flags
 *
 * Note on searching:
 *	When using the FIND_LTUPLE_FWDF and FIND_LTUPLE_BACKF flags,
 *	the search starts at the passed tuple.  Continually calling this
 *	function with a tuple that is the same type as the passed type will
 *	continually return the same tuple.
 *
 *	When using the FIND_NEXT_LTUPLEF and FIND_PREV_LTUPLEF flags,
 *	the search starts at the {next|previous} tuple from the passed tuple.
 *
 * returns:
 *	cistpl_t * - pointer to tuple in list
 *	NULL - if error while processing list or tuple not found
 */
#define	GET_NEXT_LTUPLE(tp)	((tp->next)?tp->next:NULL)
#define	GET_PREV_LTUPLE(tp)	((tp->prev)?tp->prev:NULL)
cistpl_t *
cis_get_ltuple(cistpl_t *tp, cisdata_t type, uint32_t flags)
{
	cistpl_t *ltp = NULL;

	if (!tp)
	    return (NULL);

	switch (flags & CIS_GET_LTUPLE_OPMASK) {
	    case GET_FIRST_LTUPLEF:	/* return first tuple in list */
		do {
			ltp = tp;
		} while ((tp = GET_PREV_LTUPLE(tp)) != NULL);

		if (!(flags & CIS_GET_LTUPLE_IGNORE))
		    while (ltp && (ltp->flags & CISTPLF_IGNORE_TUPLE))
			ltp = GET_NEXT_LTUPLE(ltp);
		break;
	    case GET_LAST_LTUPLEF:	/* return last tuple in list */
		do {
			ltp = tp;
		} while ((tp = GET_NEXT_LTUPLE(tp)) != NULL);

		if (!(flags & CIS_GET_LTUPLE_IGNORE))
		    while (ltp && (ltp->flags & CISTPLF_IGNORE_TUPLE))
			ltp = GET_PREV_LTUPLE(ltp);
		break;
	    case FIND_LTUPLE_FWDF:	/* find tuple, fwd search from tp */
		do {
			if (tp->type == type)
			    if ((flags & CIS_GET_LTUPLE_IGNORE) ||
					(!(tp->flags & CISTPLF_IGNORE_TUPLE)))
				return (tp);	/* note return here */
		} while ((tp = GET_NEXT_LTUPLE(tp)) != NULL);
		break;
	    case FIND_LTUPLE_BACKF:
		/* find tuple, backward search from tp */
		do {
			if (tp->type == type)
			    if ((flags & CIS_GET_LTUPLE_IGNORE) ||
					(!(tp->flags & CISTPLF_IGNORE_TUPLE)))
				return (tp);	/* note return here */
		} while ((tp = GET_PREV_LTUPLE(tp)) != NULL);
		break;
	    case FIND_NEXT_LTUPLEF:	/* find tuple, fwd search from tp+1 */
		while ((tp = GET_NEXT_LTUPLE(tp)) != NULL) {
			if (tp->type == type)
			    if ((flags & CIS_GET_LTUPLE_IGNORE) ||
					(!(tp->flags & CISTPLF_IGNORE_TUPLE)))
				return (tp);	/* note return here */
		} /* while */
		break;
	    case FIND_PREV_LTUPLEF:
		/* find tuple, backward search from tp-1 */
		while ((tp = GET_PREV_LTUPLE(tp)) != NULL) {
			if (tp->type == type)
			    if ((flags & CIS_GET_LTUPLE_IGNORE) ||
					(!(tp->flags & CISTPLF_IGNORE_TUPLE)))
				return (tp);	/* note return here */
		} /* while */
		break;
	    case GET_NEXT_LTUPLEF:	/* return next tuple in list */
		ltp = tp;
		while (((ltp = GET_NEXT_LTUPLE(ltp)) != NULL) &&
				(!(flags & CIS_GET_LTUPLE_IGNORE)) &&
					(ltp->flags & CISTPLF_IGNORE_TUPLE))
			;
		break;
	    case GET_PREV_LTUPLEF:	/* return prev tuple in list */
		ltp = tp;
		while (((ltp = GET_PREV_LTUPLE(ltp)) != NULL) &&
				(!(flags & CIS_GET_LTUPLE_IGNORE)) &&
					(ltp->flags & CISTPLF_IGNORE_TUPLE))
			;
		break;
	    default:	/* ltp is already NULL in the initialization */
		break;
	} /* switch */

	return (ltp);
}

/*
 * cis_convert_devspeed - converts a devspeed value to nS or nS
 *				to a devspeed entry
 */
uint32_t
cis_convert_devspeed(convert_speed_t *cs)
{
	cistpl_devspeed_struct_t *cd = &cistpl_devspeed_struct;
	unsigned exponent = 0, mantissa = 0;

	/*
	 * Convert nS to a devspeed value
	 */
	if (cs->Attributes & CONVERT_NS_TO_DEVSPEED) {
	    unsigned tnS, tmanv = 0, i;

	/*
	 * There is no device speed code for 0nS
	 */
	    if (!cs->nS)
		return (CS_BAD_SPEED);

	/*
	 * Handle any nS value below 10nS specially since the code
	 *	below only works for nS values >= 10.  Now, why anyone
	 *	would want to specify a nS value less than 10 is
	 *	certainly questionable, but it is allowed by the spec.
	 */
	    if (cs->nS < 10) {
		tmanv = cs->nS * 10;
		mantissa = CISTPL_DEVSPEED_MAX_MAN;
	    }

	    /* find the exponent */
	    for (i = 0; i < CISTPL_DEVSPEED_MAX_EXP; i++) {
		if ((!(tnS = ((cs->nS)/10))) ||
				(mantissa == CISTPL_DEVSPEED_MAX_MAN)) {
		    /* find the mantissa */
		    for (mantissa = 0; mantissa < CISTPL_DEVSPEED_MAX_MAN;
								mantissa++) {
			if (cd->mantissa[mantissa] == tmanv) {
			    cs->devspeed = ((((mantissa<<3) |
				(exponent & (CISTPL_DEVSPEED_MAX_EXP - 1)))));
			    return (CS_SUCCESS);
			}
		    } /* for (mantissa<CISTPL_DEVSPEED_MAX_MAN) */
		} else {
		    exponent = i + 1;
		    tmanv = cs->nS;
		    cs->nS = tnS;
		} /* if (!tnS) */
	    } /* for (i<CISTPL_DEVSPEED_MAX_EXP) */
	/*
	 * Convert a devspeed value to nS
	 */
	} else if (cs->Attributes & CONVERT_DEVSPEED_TO_NS) {
	    exponent = (cs->devspeed & (CISTPL_DEVSPEED_MAX_TBL - 1));
	    if ((mantissa = (((cs->devspeed)>>3) &
				(CISTPL_DEVSPEED_MAX_MAN - 1))) == 0) {
		if ((cs->nS = cd->table[exponent]) == 0)
		    return (CS_BAD_SPEED);
		return (CS_SUCCESS);
	    } else {
		if ((cs->nS = ((cd->mantissa[mantissa] *
					cd->exponent[exponent]) / 10)) == 0)
		    return (CS_BAD_SPEED);
		return (CS_SUCCESS);
	    }
	} else {
	    return (CS_BAD_ATTRIBUTE);
	}

	return (CS_BAD_SPEED);
}

/*
 * This array is for the cis_convert_devsize function.
 */
static uint32_t cistpl_device_size[8] =
	{ 512, 2*1024, 8*1024, 32*1024, 128*1024, 512*1024, 2*1024*1024, 0 };

/*
 * cis_convert_devsize - converts a devsize value to a size in bytes value
 *				or a size in bytes value to a devsize value
 */
uint32_t
cis_convert_devsize(convert_size_t *cs)
{
	int i;

	if (cs->Attributes & CONVERT_BYTES_TO_DEVSIZE) {
	    if ((cs->bytes < cistpl_device_size[0]) ||
				(cs->bytes > (cistpl_device_size[6] * 32)))
	    return (CS_BAD_SIZE);

	    for (i = 6; i >= 0; i--)
		if (cs->bytes >= cistpl_device_size[i])
		    break;

	    cs->devsize = ((((cs->bytes/cistpl_device_size[i]) - 1) << 3) |
								(i & 7));

	} else if (cs->Attributes & CONVERT_DEVSIZE_TO_BYTES) {
	    if ((cs->devsize & 7) == 7)
		return (CS_BAD_SIZE);
	    cs->bytes =
		cistpl_device_size[cs->devsize & 7] * ((cs->devsize >> 3) + 1);
	} else {
	    return (CS_BAD_ATTRIBUTE);
	}

	return (CS_SUCCESS);
}

/*
 * cis_list_create - reads the card's CIS and creates local CIS lists for
 *			each function on the card
 *
 * This function will read the CIS on the card, follow all CISTPL_LONGLINK_A,
 *	CISTPL_LONGLINK_C and CISTPL_LONGLINK_MFC tuples and create local CIS
 *	lists for each major CIS chain on the card.
 *
 * If there are no errors, the parameters returned are:
 *	For a non-multifunction card:
 *		sp->cis_flags - CW_VALID_CIS set
 *		sp->nfuncs - set to 0x0
 *		sp->cis[CS_GLOBAL_CIS] - contains CIS list
 *		sp->cis[CS_GLOBAL_CIS].cis_flags - CW_VALID_CIS set
 *
 *	For a multifunction card:
 *	    Global CIS values:
 *		sp->cis_flags - CW_VALID_CIS & CW_MULTI_FUNCTION_CIS set
 *		sp->nfuncs - set to number of functions specified in
 *				the CISTPL_LONGLINK_MFC tuple
 *		sp->cis[CS_GLOBAL_CIS] - contains global CIS list
 *		sp->cis[CS_GLOBAL_CIS].cis_flags - CW_VALID_CIS set
 *	    Function-specific CIS values:
 *		sp->cis[0..sp->nfuncs-1] - contains function-specific CIS lists
 *		sp->cis[0..sp->nfuncs-1].cis_flags - CW_VALID_CIS &
 *						CW_MULTI_FUNCTION_CIS set
 *
 *	returns:
 *		CS_SUCCESS - if no errors
 *		CS_NO_CIS - if no CIS on card
 *		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 cis_list_lcreate tried to read past the
 *				boundries of the allocated CIS window
 */
extern cistpl_ignore_list_t cistpl_ignore_list[];
uint32_t
cis_list_create(cistpl_callout_t *cistpl_callout, cs_socket_t *sp)
{
	cisptr_t cisptr;
	cisparse_t cisparse;
	cis_info_t *cis_info;
	cistpl_longlink_ac_t *cistpl_longlink_ac;
	cistpl_longlink_mfc_t cistpl_longlink_mfc, *mfc;
	cistpl_ignore_list_t *cil;
	int fn, ret;

	/*
	 * Initialize the CIS structures
	 */
	bzero((caddr_t)&sp->cis, ((sizeof (cis_info_t)) * CS_MAX_CIS));

	/*
	 * Start reading the primary CIS chain at offset 0x0 of AM. Assume
	 *	that there is a CISTPL_LONGLINK_C tuple that points to
	 *	offset 0x0 of CM space.
	 * Since this is the primary CIS chain, set CW_CHECK_PRIMARY_CHAIN
	 *	so that we'll check for a valid first tuple.
	 */
	cis_info = &sp->cis[CS_GLOBAL_CIS];
	cis_info->flags = (CW_LONGLINK_C_FOUND | CW_CHECK_PRIMARY_CHAIN);
	cisptr.flags = (CISTPLF_AM_SPACE | CISTPLF_GLOBAL_CIS);
	cisptr.size = sp->cis_win_size - 1;
	cisptr.offset = 0;
	cistpl_longlink_ac = (cistpl_longlink_ac_t *)&cisparse;
	cistpl_longlink_ac->flags = CISTPL_LONGLINK_AC_CM;
	cistpl_longlink_ac->tpll_addr = 0;

	if ((ret = cis_create_cis_chain(sp, cistpl_callout, &cisptr,
						cis_info, &cisparse)) !=
								CS_SUCCESS) {
	    return (ret);
	} /* cis_create_cis_chain */

	/*
	 * If there are no tuples in the primary CIS chain, it means that
	 *	this card doesn't have a CIS on it.
	 */
	if (cis_info->ntuples == 0)
	    return (CS_NO_CIS);

	/*
	 * Mark this CIS list as being valid.
	 */
	cis_info->flags |= CW_VALID_CIS;

	/*
	 * Mark this socket as having at least one valid CIS chain.
	 */
	sp->cis_flags |= CW_VALID_CIS;
	sp->nfuncs = 0;

	/*
	 * If the primary CIS chain specified that there are function-specific
	 *	CIS chains, we need to create each of these chains. If not,
	 *	then we're all done and we can return.
	 */
	if (!(cis_info->flags & CW_LONGLINK_MFC_FOUND))
	    return (CS_SUCCESS);

	/*
	 * Mark this socket as having a multi-function CIS.
	 */
	sp->cis_flags |= CW_MULTI_FUNCTION_CIS;

	/*
	 * At this point, cis_create_cis_chain has told us that the primary
	 *	CIS chain says that there are function-specific CIS chains
	 *	on the card that we need to follow. The cisparse variable now
	 *	contains the parsed output of the CISTPL_LONGLINK_MFC
	 *	tuple. We need to save that information and then process
	 *	each function-specific CIS chain.
	 */
	bcopy((caddr_t)&cisparse, (caddr_t)&cistpl_longlink_mfc,
					sizeof (cistpl_longlink_mfc_t));
	mfc = &cistpl_longlink_mfc;
	sp->nfuncs = mfc->nregs;

	/*
	 * Go through and create a CIS list for each function-specific
	 *	CIS chain on the card. Set CW_CHECK_LINKTARGET since all
	 *	function-specific CIS chains must begin with a valid
	 *	CISTPL_LINKTARGET tuple. Also set CW_RET_ON_LINKTARGET_ERROR
	 *	since we want to return an error if the CISTPL_LINKTARGET
	 *	tuple is invalid or missing.
	 */
	for (fn = 0; fn < sp->nfuncs; fn++) {
	    cis_info = &sp->cis[fn];
	    cis_info->flags = (CW_CHECK_LINKTARGET |
					CW_RET_ON_LINKTARGET_ERROR);
		/*
		 * If the function-specific CIS chain starts
		 *	in AM space, then multiply address by
		 *	2 since only even bytes are counted in
		 *	the CIS when AM addresses are specified,
		 *	otherwise use the
		 *	address as specified.
		 */
	    if (mfc->function[fn].tas == CISTPL_LONGLINK_MFC_TAS_AM) {
		cisptr.flags = (CISTPLF_AM_SPACE | CISTPLF_MF_CIS);
		cisptr.offset = mfc->function[fn].addr * 2;
	    } else {
		cisptr.flags = (CISTPLF_CM_SPACE | CISTPLF_MF_CIS);
		cisptr.offset = mfc->function[fn].addr;
	    }

	    if ((ret = cis_create_cis_chain(sp, cistpl_callout, &cisptr,
						cis_info, &cisparse)) !=
								CS_SUCCESS) {
		cmn_err(CE_CONT,
		    "cis_list_create: socket %d ERROR_MFC = 0x%x\n",
		    sp->socket_num, ret);
		return (ret);
	    } /* cis_create_cis_chain */

		/*
		 * Mark this CIS list as being valid and as being a
		 *	function-specific CIS list.
		 */
	    cis_info->flags |= (CW_VALID_CIS | CW_MULTI_FUNCTION_CIS);

		/*
		 * Check for tuples that we want to ignore
		 *	in the global CIS.  If the tuple exists
		 *	in the global CIS and in at least one
		 *	of the function-specific CIS lists, then
		 *	we flag the tuple
		 *	in the global CIS to be ignored.
		 */
	    cil = &cistpl_ignore_list[0];
	    while (cil->type != CISTPL_NULL) {
		if (cis_get_ltuple(sp->cis[fn].cis, cil->type,
					FIND_LTUPLE_FWDF |
					CIS_GET_LTUPLE_IGNORE) != NULL) {
		    cistpl_t *gtp = sp->cis[CS_GLOBAL_CIS].cis;
		    while ((gtp = cis_get_ltuple(gtp, cil->type,
					FIND_LTUPLE_FWDF |
					CIS_GET_LTUPLE_IGNORE)) != NULL) {
			gtp->flags |= CISTPLF_IGNORE_TUPLE;
			gtp = cis_get_ltuple(gtp, 0, GET_NEXT_LTUPLEF |
							CIS_GET_LTUPLE_IGNORE);
		    } /* while */
		} /* if (cis_get_ltuple(cis[fn])) */
		cil++;
	    } /* while */
	} /* for */

	return (CS_SUCCESS);
}

/*
 * cis_create_cis_chain - creates a single CIS chain
 *
 * This function reads the CIS on a card and follows any CISTPL_LONGLINK_A
 *	and CISTPL_LONGLINK_C link tuples to create a single CIS chain. We
 *	keep reading the CIS and following any CISTPL_LONGLINK_A and
 *	CISTPL_LONGLINK_C tuples until we don't see anymore. If we see a
 *	CISTPL_LONGLINK_MFC tuple, we return - the caller is responsible
 *	for following CIS chains on a per-function level.
 *
 * The following parameters must be initialized by the caller:
 *
 *	sp - pointer to a cs_socket_t structure that describes the socket
 *			and card in this socket
 *	cistpl_callout - pointer to a cistpl_callout_t array of structures
 *	cisptr->flags - either CISTPLF_AM_SPACE or CISTPLF_CM_SPACE
 *	cisptr->size - size of CIS window
 *	cisptr->offset - offset in AM or CM space on card to start
 *			reading tuples from
 *	cis_info - pointer to a cis_info_t structure where this list will
 *			be anchored on
 *	cisparse - pointer to a cisparse_t structure where the last longlink
 *			parsed tuple data will be returned
 *
 * To check the CISTPL_LINKTARGET tuple at the beginning of the first
 *	CIS chain that this function encounters, set CW_CHECK_LINKTARGET
 *	in cis_info->flags before calling this function.
 *
 * This function returns:
 *
 *	CS_SUCCESS - if CIS chain was created sucessfully or there
 *			were no tuples found on the first CIS chain
 *	CS_BAD_WINDOW or CS_GENERAL_FAILURE - if CIS window could
 *			not be setup
 *	CS_BAD_CIS - if error creating CIS chain
 *	CS_BAD_OFFSET - if cis_list_lcreate tried to read past the
 *			boundries of the allocated CIS window
 *
 * Note that if the first tuple of the target CIS chain is supposed
 *	to contain a CISTPL_LINKTARGET and the target chain does not
 *	contain that tuple (or that tuple is invalid in some way) and
 *	the CW_RET_ON_LINKTARGET_ERROR flag is not set, we don't flag
 *	this as an error, we just return. This is to handle the case
 *	where the target chain is in uninitialized memory and will be
 *	initialized later.
 * To return an error if an invalid CISTPL_LINKTARGET tuple is seen,
 *	set the CW_RET_ON_LINKTARGET_ERROR flag in cis_info->flags
 *	before calling this function.
 */
static int
cis_create_cis_chain(cs_socket_t *sp, cistpl_callout_t *cistpl_callout,
				cisptr_t *cisptr, cis_info_t *cis_info,
							cisparse_t *cisparse)
{
	cistpl_t *tps = NULL;
	uint32_t ret;

	do {
	    if ((ret = CIS_CARD_SERVICES(InitCISWindow, sp, &cisptr->offset,
				&cisptr->handle, cisptr->flags)) != CS_SUCCESS)
		return (ret);

		/*
		 * If we're pointing at a CIS chain that
		 *	is the target of a longlink tuple,
		 *	we need to validate the target chain
		 *	before we try to process it. If the
		 *	CISTPL_LINKTARGET tuple is invalid,
		 *	and the CW_RET_ON_LINKTARGET_ERROR
		 *	is not set, don't flag it as an error,
		 *	just return.
		 */
	    if (cis_info->flags & CW_CHECK_LINKTARGET) {
		cis_info->flags &= ~CW_CHECK_LINKTARGET;
		if (cis_validate_longlink_acm(cisptr) != CISTPLF_NOERROR) {
		    if (tps != NULL)
			cis_info->cis = tps;
		    if (cis_info->flags & CW_RET_ON_LINKTARGET_ERROR) {
			cis_info->flags &= ~CW_RET_ON_LINKTARGET_ERROR;
			return (CS_BAD_CIS);
		    } else {
			return (CS_SUCCESS);
		    } /* CW_RET_ON_LINKTARGET_ERROR */
		} /* cis_validate_longlink_acm */
	    } /* CW_CHECK_LINKTARGET */

	    ret = cis_list_lcreate(cistpl_callout, cisptr, cis_info, cisparse,
		sp);

#if defined(CIS_DEBUG)
	    if (cis_debug > 1) {
		cmn_err(CE_CONT, "cis_create_cis_chain: ret=0x%x"
		    " BAD_CIS_ADDR=0x%x CS_BAD_SOCKET=0x%x\n",
		    ret, BAD_CIS_ADDR, CS_BAD_SOCKET);
	    }
#endif


	    if ((ret & HANDTPL_ERROR) || (ret == (uint32_t)BAD_CIS_ADDR)) {
		if (tps != NULL)
		    cis_info->cis = tps;
		if (ret == (uint32_t)BAD_CIS_ADDR)
		    return (CS_BAD_OFFSET);
		else
		    return (CS_BAD_CIS);
	    }

		/*
		 * If we're creating the primary CIS chain
		 *	and we haven't seen any tuples,
		 *	then return CS_SUCCESS. The caller will
		 *	have to check cis_info->ntuples to find
		 *	out if any tuples were found.
		 * If we're processing the target of a longlink
		 *	tuple, then by now we have already validated
		 *	the CISTPL_LINKTARGET tuple so that we
		 *	know we'll have at least one tuple in
		 *	our list.
		 */
	    if (cis_info->ntuples == 0)
		return (CS_SUCCESS);

		/*
		 * If we've just created a new list, we need to
		 *	save the pointer to the start of the list.
		 */
	    if (tps == NULL)
		tps = cis_info->cis;

	    switch (cis_info->flags & CW_LONGLINK_FOUND) {
		cistpl_longlink_ac_t *cistpl_longlink_ac;

		case CW_LONGLINK_A_FOUND:
		    cistpl_longlink_ac = (cistpl_longlink_ac_t *)cisparse;
		    cisptr->flags &= ~(CISTPLF_SPACE_MASK | CISTPLF_FROM_MASK);
		    cisptr->flags |= CISTPLF_AM_SPACE;
			/*
			 * Multiply address by 2 since only
			 *	even bytes are counted in the CIS
			 *	when AM addresses are specified.
			 */
		    cisptr->offset = cistpl_longlink_ac->tpll_addr * 2;
		    cis_info->flags |= CW_CHECK_LINKTARGET;

			/*
			 * Point to the last tuple in the list.
			 */
		    cis_info->cis = cis_get_ltuple(cis_info->cis, 0,
							GET_LAST_LTUPLEF);
		    break;
		case CW_LONGLINK_C_FOUND:
		    cistpl_longlink_ac = (cistpl_longlink_ac_t *)cisparse;
		    cisptr->flags &= ~(CISTPLF_SPACE_MASK | CISTPLF_FROM_MASK);
		    cisptr->flags |= CISTPLF_CM_SPACE;
		    cisptr->offset = cistpl_longlink_ac->tpll_addr;
		    cis_info->flags |= CW_CHECK_LINKTARGET;

			/*
			 * Point to the last tuple in the list.
			 */
		    cis_info->cis = cis_get_ltuple(cis_info->cis, 0,
							GET_LAST_LTUPLEF);
		    break;
		case CW_LONGLINK_MFC_FOUND:
		    break;
		default:
		    break;
	    } /* switch (cis_info->flags) */

	} while (cis_info->flags & (CW_LONGLINK_A_FOUND | CW_LONGLINK_C_FOUND));

	/*
	 * If we needed to save a pointer to the start of the list because
	 *	we saw a longlink tuple, restore the list head pointer now.
	 */
	if (tps != NULL)
	    cis_info->cis = tps;

	return (CS_SUCCESS);
}

/*
 * cis_list_destroy - destroys the local CIS list
 */
uint32_t
cis_list_destroy(cs_socket_t *sp)
{
	int fn;

	/*
	 * Destroy any CIS list that we may have created. It's OK to pass
	 *	a non-existant CIS list pointer to cis_list_ldestroy since
	 *	that function will not do anything if there is nothing in
	 *	the passed CIS list to cleanup.
	 */
	for (fn = 0; fn < CS_MAX_CIS; fn++)
	    (void) cis_list_ldestroy(&sp->cis[fn].cis);

	/*
	 * Clear out any remaining state.
	 */
	bzero((caddr_t)&sp->cis, ((sizeof (cis_info_t)) * CS_MAX_CIS));
	sp->cis_flags = 0;
	sp->nfuncs = 0;

	return (CS_SUCCESS);
}

/*
 * cis_store_cis_addr - saves the current CIS address and space type
 *	of the beginning of the tuple into the passed linked list element.
 *	Note that this function will decrement the CIS address by two
 *	elements prior to storing it to the linked list element to point
 *	to the tuple type byte.
 *
 * This function also sets the following flags in tp->flags if they are set
 *	in ptr->flags:
 *
 *		CISTPLF_GLOBAL_CIS - tuple in global CIS
 *		CISTPLF_MF_CIS - tuple in function-specific CIS
 */
static void
cis_store_cis_addr(cistpl_t *tp, cisptr_t *ptr)
{

	if (ptr->flags & CISTPLF_AM_SPACE)
	    tp->offset = ptr->offset - 4;
	else
	    tp->offset = ptr->offset - 2;

	tp->flags &= ~(CISTPLF_SPACE_MASK | CISTPLF_FROM_MASK |
					CISTPLF_GLOBAL_CIS | CISTPLF_MF_CIS);
	tp->flags |= (ptr->flags & (CISTPLF_SPACE_MASK |
					CISTPLF_GLOBAL_CIS | CISTPLF_MF_CIS));

	if (tp->flags & CISTPLF_AM_SPACE)
	    tp->flags |= CISTPLF_FROM_AM;

	if (tp->flags & CISTPLF_CM_SPACE)
	    tp->flags |= CISTPLF_FROM_CM;
}
/*
 * 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 (c) 1995-1996 by Sun Microsystems, Inc.
 * All rights reserved.
 */

/*
 * This file contains an array of structures, each of which refers to
 *	a tuple that we are prepared to handle.  The last structure
 *	in this array must have a type of CISTPL_END.
 *
 * If you want the generic tuple handler to be called for a tuple, use
 *	the cis_no_tuple_handler() entry point.
 */

#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/ddi_impldefs.h>
#include <sys/kstat.h>
#include <sys/kmem.h>
#include <sys/modctl.h>
#include <sys/kobj.h>
#include <sys/callb.h>

#include <sys/pctypes.h>
#include <pcmcia/sys/cs_types.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/cis_protos.h>

/*
 * cistpl_std_callout - callout list for standard tuples
 */
cistpl_callout_t cistpl_std_callout[] = {
	{	CISTPL_DEVICE,			/* device information */
		0,
		0,
		cistpl_device_handler,
		"CISTPL_DEVICE"		},
	{	CISTPL_CHECKSUM,		/* checksum control */
		0,
		0,
		cis_no_tuple_handler,
		"CISTPL_CHECKSUM"	},
	{	CISTPL_LONGLINK_A,		/* long-link to AM */
		0,
		0,
		cistpl_longlink_ac_handler,
		"CISTPL_LONGLINK_A"	},
	{	CISTPL_LONGLINK_C,		/* long-link to CM */
		0,
		0,
		cistpl_longlink_ac_handler,
		"CISTPL_LONGLINK_C"	},
	{	CISTPL_LONGLINK_MFC,		/* long-link to MFC CIS */
		0,
		0,
		cistpl_longlink_mfc_handler,
		"CISTPL_LONGLINK_MFC"	},
	{	CISTPL_LINKTARGET,		/* link-target control */
		0,
		0,
		cistpl_linktarget_handler,
		"CISTPL_LINKTARGET"	},
	{	CISTPL_NO_LINK,			/* no-link control */
		0,
		0,
		cis_no_tuple_handler,
		"CISTPL_NO_LINK"	},
	{	CISTPL_VERS_1,			/* level 1 version info */
		0,
		0,
		cistpl_vers_1_handler,
		"CISTPL_VERS_1"		},
	{	CISTPL_ALTSTR,			/* alternate language string */
		0,
		0,
		cis_no_tuple_handler,
		"CISTPL_ALTSTR"		},
	{	CISTPL_DEVICE_A,		/* AM device information */
		0,
		0,
		cistpl_device_handler,
		"CISTPL_DEVICE_A"	},
	{	CISTPL_JEDEC_C,			/* JEDEC info for CM */
		0,
		0,
		cistpl_jedec_handler,
		"CISTPL_JEDEC_C"	},
	{	CISTPL_JEDEC_A,			/* JEDEC info for AM */
		0,
		0,
		cistpl_jedec_handler,
		"CISTPL_JEDEC_A"	},
	{	CISTPL_CONFIG,			/* configuration */
		0,
		0,
		cistpl_config_handler,
		"CISTPL_CONFIG"		},
	{	CISTPL_CFTABLE_ENTRY,		/* configuration-table-entry */
		0,
		0,
		cistpl_cftable_handler,
		"CISTPL_CFTABLE_ENTRY"	},
	{	CISTPL_DEVICE_OC,		/* other conditions for CM */
		0,
		0,
		cistpl_device_handler,
		"CISTPL_DEVICE_OC"	},
	{	CISTPL_DEVICE_OA,		/* other conditions for AM */
		0,
		0,
		cistpl_device_handler,
		"CISTPL_DEVICE_OA"	},
	{	CISTPL_VERS_2,			/* level 2 version info */
		0,
		0,
		cistpl_vers_2_handler,
		"CISTPL_VERS_2"		},
	{	CISTPL_FORMAT,			/* format type */
		0,
		0,
		cistpl_format_handler,
		"CISTPL_FORMAT"		},
	{	CISTPL_FORMAT_A,		/* Attribute Memory */
		0,				/* recording format */
		0,
		cistpl_format_handler,
		"CISTPL_FORMAT_A"	},
	{	CISTPL_GEOMETRY,		/* geometry */
		0,
		0,
		cistpl_geometry_handler,
		"CISTPL_GEOMETRY"	},
	{	CISTPL_BYTEORDER,		/* byte order */
		0,
		0,
		cistpl_byteorder_handler,
		"CISTPL_BYTEORDER"	},
	{	CISTPL_DATE,			/* card initialization date */
		0,
		0,
		cistpl_date_handler,
		"CISTPL_DATE"		},
	{	CISTPL_BATTERY,			/* battery replacement date */
		0,
		0,
		cistpl_battery_handler,
		"CISTPL_BATTERY"	},
	{	CISTPL_ORG,			/* organization */
		0,
		0,
		cistpl_org_handler,
		"CISTPL_ORG"		},
	{	CISTPL_FUNCID,			/* card function ID */
		0,
		0,
		cistpl_funcid_handler,
		"CISTPL_FUNCID"		},
	{	CISTPL_FUNCE,			/* card function extension */
		TPLFUNC_MULTI,		/* for multifunction cards */
		0,
		cis_no_tuple_handler,
		"CISTPL_FUNCE/MULTI"	},
	{	CISTPL_FUNCE,			/* card function extension */
		TPLFUNC_MEMORY,		/* for memory cards */
		0,
		cis_no_tuple_handler,
		"CISTPL_FUNCE/MEMORY"	},
	{	CISTPL_FUNCE,			/* card function extension */
		TPLFUNC_SERIAL,		/* for serial port cards */
		0,
		cistpl_funce_serial_handler,
		"CISTPL_FUNCE/SERIAL"	},
	{	CISTPL_FUNCE,			/* card function extension */
		TPLFUNC_PARALLEL,		/* for parallel port cards */
		0,
		cis_no_tuple_handler,
		"CISTPL_FUNCE/PARALLEL"	},
	{	CISTPL_FUNCE,			/* card function extension */
		TPLFUNC_FIXED,		/* for fixed disk cards */
		0,
		cis_no_tuple_handler,
		"CISTPL_FUNCE/FIXED"	},
	{	CISTPL_FUNCE,			/* card function extension */
		TPLFUNC_VIDEO,		/* for video cards */
		0,
		cis_no_tuple_handler,
		"CISTPL_FUNCE/VIDEO"	},
	{	CISTPL_FUNCE,			/* card function extension */
		TPLFUNC_LAN,		/* for LAN cards */
		0,
		cistpl_funce_lan_handler,
		"CISTPL_FUNCE/LAN"	},

	{	CISTPL_FUNCE,			/* card function extension */
		TPLFUNC_AIMS,		/* Auto Incrementing Mass Storage */
		0,
		cis_no_tuple_handler,
		"CISTPL_FUNCE/AIMS"	},
	{	CISTPL_FUNCE,			/* card function extension */
		TPLFUNC_SCSI,		/* SCSI bridge */
		0,
		cis_no_tuple_handler,
		"CISTPL_FUNCE/SCSI"	},
	{	CISTPL_FUNCE,			/* card function extension */
		TPLFUNC_VENDOR_SPECIFIC,	/* Vendor Specific */
		0,
		cis_no_tuple_handler,
		"CISTPL_FUNCE/VENDOR_SPECIFIC"	},
	{	CISTPL_FUNCE,			/* card function extension */
		TPLFUNC_UNKNOWN,	/* for unknown functions */
		0,
		cis_no_tuple_handler,
		"CISTPL_FUNCE/unknown"	},
	{	CISTPL_MANFID,			/* manufacturer ID */
		0,
		0,
		cistpl_manfid_handler,
		"CISTPL_MANFID"		},
	{	CISTPL_SPCL,			/* special-purpose tuple */
		0,
		0,
		cis_no_tuple_handler,
		"CISTPL_SPCL"		},
	{	CISTPL_LONGLINK_CB,		/* longlink to next */
		0,				/* tuple chain */
		0,
		cis_no_tuple_handler,
		"CISTPL_LONGLINK_CB"	},
	{	CISTPL_CONFIG_CB,		/* configuration tuple */
		0,
		0,
		cis_no_tuple_handler,
		"CISTPL_CONFIG_CB"	},
	{	CISTPL_CFTABLE_ENTRY_CB,	/* configuration table */
		0,				/* entry */
		0,
		cis_no_tuple_handler,
		"CISTPL_CFTABLE_ENTRY_CB"	},
	{	CISTPL_BAR,			/* Base Address Register */
		0,				/* definition */
		0,
		cis_no_tuple_handler,
		"CISTPL_BAR"		},
	{	CISTPL_DEVICEGEO,		/* Common Memory */
		0,				/* device geometry */
		0,
		cis_no_tuple_handler,
		"CISTPL_DEVICEGEO"	},
	{	CISTPL_DEVICEGEO_A,		/* Attribute Memory */
		0,				/* device geometry */
		0,
		cis_no_tuple_handler,
		"CISTPL_DEVICEGEO_A"	},
	{	CISTPL_SWIL,			/* software interleave */
		0,
		0,
		cis_no_tuple_handler,
		"CISTPL_SWIL"		},
	{	CISTPL_VEND_SPEC_80,		/* vendor-specific 0x80 */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_80"	},
	{	CISTPL_VEND_SPEC_81,		/* vendor-specific 0x81 */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_81"	},
	{	CISTPL_VEND_SPEC_82,		/* vendor-specific 0x82 */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_82"	},
	{	CISTPL_VEND_SPEC_83,		/* vendor-specific 0x83 */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_83"	},
	{	CISTPL_VEND_SPEC_84,		/* vendor-specific 0x84 */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_84"	},
	{	CISTPL_VEND_SPEC_85,		/* vendor-specific 0x85 */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_85"	},
	{	CISTPL_VEND_SPEC_86,		/* vendor-specific 0x86 */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_86"	},
	{	CISTPL_VEND_SPEC_87,		/* vendor-specific 0x87 */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_87"	},
	{	CISTPL_VEND_SPEC_88,		/* vendor-specific 0x88 */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_88"	},
	{	CISTPL_VEND_SPEC_89,		/* vendor-specific 0x89 */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_89"	},
	{	CISTPL_VEND_SPEC_8a,		/* vendor-specific 0x8a */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_8a"	},
	{	CISTPL_VEND_SPEC_8b,		/* vendor-specific 0x8b */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_8b"	},
	{	CISTPL_VEND_SPEC_8c,		/* vendor-specific 0x8c */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_8c"	},
	{	CISTPL_VEND_SPEC_8d,		/* vendor-specific 0x8d */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_8d"	},
	{	CISTPL_VEND_SPEC_8e,		/* vendor-specific 0x8e */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_8e"	},
	{	CISTPL_VEND_SPEC_8f,		/* vendor-specific 0x8f */
		0,
		0,
		cis_unknown_tuple_handler,
		"CISTPL_VEND_SPEC_8f"	},
	{	CISTPL_END,			/* end-of-list tuple */
		0,
		0,
		cis_no_tuple_handler,
		"unknown tuple"		},
	};
/*
 * 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.
 */

/*
 * This file contains the tuple handlers that are called by the CIS
 *	parser.
 *
 * XXX - how about a better explaination??
 */

#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/ddi_impldefs.h>
#include <sys/kstat.h>
#include <sys/kmem.h>
#include <sys/modctl.h>
#include <sys/kobj.h>
#include <sys/callb.h>

#include <sys/pctypes.h>
#include <pcmcia/sys/cs_types.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/cis_protos.h>

/*
 * Function prototypes
 */
static void cistpl_pd_parse(cistpl_t *, cistpl_cftable_entry_pwr_t *);
static void cis_return_name(cistpl_callout_t *, cistpl_get_tuple_name_t *);

/*
 * Fetch data functions.
 */
uint16_t
cis_get_short(cistpl_t *tp)
{
	uint16_t result;

	if (tp->flags & CISTPLF_AM_SPACE) {
		result = GET_AM_BYTE(tp);
		result |= GET_AM_BYTE(tp) << 8;
	} else {
		result = GET_CM_BYTE(tp);
		result |= GET_CM_BYTE(tp) << 8;
	}
	return (result);
}

uint16_t
cis_get_be_short(cistpl_t *tp)
{
	uint16_t result;

	if (tp->flags & CISTPLF_AM_SPACE) {
		result = GET_AM_BYTE(tp) << 8;
		result |= GET_AM_BYTE(tp);
	} else {
		result = GET_CM_BYTE(tp) << 8;
		result |= GET_CM_BYTE(tp);
	}
	return (result);
}

uint32_t
cis_get_int24(cistpl_t *tp)
{
	uint32_t result = cis_get_short(tp);

	result |= GET_BYTE(tp) << 16;
	return (result);
}

uint32_t
cis_get_long(cistpl_t *tp)
{
	uint32_t result = cis_get_short(tp);

	result |= cis_get_short(tp) << 16;
	return (result);
}

/*
 * cis_tuple_handler - call the handler for the tuple described by the
 *				tuple pointer
 *
 *	cistpl_callout_t *co - pointer to callout structure
 *				array to use to find this tuple
 *	cistpl_t *tp - pointer to a tuple structure
 *	int flags - action for the handler to perform
 * XXX - we need a description of the flags passed to the tuple handler
 *	void *arg - argument to pass on to tuple handler
 *
 * If the tuple is not recognized but is is a vendor-specific tuple, we
 *	set the CISTPLF_VENDOR_SPECIFIC flag in the tuple.
 *
 * We return CISTPLF_UNKNOWN if this is an unrecognized	tuple as well as
 *	set the CISTPLF_UNKNOWN flag in the tuple list structure.  Note
 *	that encountering an unknown tuple is not necessarily an error,
 *	so we don't set the HANDTPL_ERROR flag on the return code.  It
 *	is up to the caller to determine what an unrecognized tuple means.
 *
 * If this is a recognized tuple, the apropriate tuple handler is called and
 *	the return value from the handler is returned directly to the caller.
 *
 * The void *arg is optional, and it's meaning is dependent on the
 *	particular tuple handler called and the flags parameter.
 *
 * For the special case of HANDTPL_RETURN_NAME, we don't bother calling the
 *	tuple handler and just return the tuple name to the caller.
 */
uint32_t
cis_tuple_handler(cistpl_callout_t *co, cistpl_t *tp, uint32_t flags,
					void *arg, cisdata_t subtype)
{
	/*
	 * Check to see if this is a vendor-specific tuple.
	 */
	if (CISTPL_IS_VENDOR_SPECIFIC(tp->type))
	    tp->flags |= CISTPLF_VENDOR_SPECIFIC;

	/*
	 * Scan the callout list until we find the tuple passed to us, or we
	 *	encounter a CISTPL_END in the callout list, which signals that
	 *	there are no more tuples in the callout list.
	 */
	while (co->type != (cisdata_t)CISTPL_END) {
	    if (co->type == tp->type &&
		((tp->type != CISTPL_FUNCE) ||
		    (tp->type == CISTPL_FUNCE && co->subtype == subtype))) {
			tp->flags &= ~CISTPLF_UNKNOWN;
			if (flags & HANDTPL_RETURN_NAME) {
			    cis_return_name(co, (cistpl_get_tuple_name_t *)arg);
			    return (CISTPLF_NOERROR);
			} else {
			    return ((*co->handler) (co, tp, flags, arg));
			} /* HANDTPL_RETURN_NAME */
	    } /* if */
	    co++;
	} /* while */

	/*
	 * If we didn't recognize the tuple and the caller wants the tuple
	 *	name back, then return the "unknown tuple" string. At this
	 *	point, "co" will be pointing to the last entry in the
	 *	callout list. It's not an error to not recognize the tuple
	 *	when the operation is HANDTPL_RETURN_NAME.
	 */
	if (flags & HANDTPL_RETURN_NAME) {
	    cis_return_name(co, (cistpl_get_tuple_name_t *)arg);
	    return (CISTPLF_NOERROR);
	}

	tp->flags |= CISTPLF_UNKNOWN;
	return (CISTPLF_UNKNOWN);
}

/*
 * cis_no_tuple_handler - this generic tuple handler is used if no special
 *				tuple processing is required for the passed
 *				tuple
 *
 *	cistpl_callout_t *co - pointer to this tuple's entry in the
 *				tuple callout structure
 *	cistpl_t *tp - pointer to this tuple's entry in the local linked list
 *	int flags - action to perform
 *
 * This handler will set the CISTPLF_COPYOK flag if the tuple link is greater
 *	than zero, indicating that it's OK to copy the tuple data body. It
 *	will also set whatever flags are specified in the callout structure.
 *
 * We always set the CISTPLF_VALID when we're called with HANDTPL_COPY_DONE.
 *
 * We return CISTPLF_UNKNOWN if we're being called to parse the tuple.
 *
 * We return CISTPLF_NOERROR in every other case to indicate that this is a
 *	recognized tuple.
 */
/*ARGSUSED*/
uint32_t
cis_no_tuple_handler(cistpl_callout_t *co, cistpl_t *tp,
					uint32_t flags, void *arg)
{
	if (flags & HANDTPL_SET_FLAGS) {
		tp->flags |= co->flags;	/* XXX - is = the right thing here? */
		if (tp->len > 0)
			tp->flags |= CISTPLF_COPYOK;
	}

	if (flags & HANDTPL_COPY_DONE)
		tp->flags |= CISTPLF_VALID;

	if (flags & HANDTPL_PARSE_LTUPLE)
	    return (CISTPLF_UNKNOWN);

	return (CISTPLF_NOERROR);
}

/*
 * cis_unknown_tuple_handler - this generic tuple handler is used if we don't
 *				understand this tuple
 *
 *	cistpl_callout_t *co - pointer to this tuple's entry in the
 *				tuple callout structure
 *	cistpl_t *tp - pointer to this tuple's entry in the local linked list
 *	int flags - action to perform
 *
 * This handler will not set the CISTPLF_COPYOK flag since we don't know the
 *	contents of a vendor-specific tuple.
 *
 * We always set the CISTPLF_VALID when we're called with HANDTPL_COPY_DONE
 *	to specify that we understand this tuple's code, but not it's data
 *	body.
 *
 * We return CISTPLF_UNKNOWN if we're being called to parse the tuple or to
 *	perform any other operation.
 */
/*ARGSUSED*/
uint32_t
cis_unknown_tuple_handler(cistpl_callout_t *co, cistpl_t *tp,
					uint32_t flags, void *arg)
{
	if (flags & HANDTPL_SET_FLAGS) {
		tp->flags |= co->flags;	/* XXX - is = the right thing here? */
		return (CISTPLF_NOERROR);
	}

	if (flags & HANDTPL_COPY_DONE) {
		tp->flags |= CISTPLF_VALID;
		return (CISTPLF_NOERROR);
	}

	return (CISTPLF_UNKNOWN);
}

/*
 * cistpl_vers_1_handler - handler for the CISTPL_VERS_1 tuple
 *
 *	void *arg - points to a cistpl_vers_1_t * where the
 *			information is stuffed into
 */
uint32_t
cistpl_vers_1_handler(cistpl_callout_t *co, cistpl_t *tp,
					uint32_t flags, void *arg)
{
	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		cistpl_vers_1_t *cs = (cistpl_vers_1_t *)arg;


		RESET_TP(tp);

		cs->major = GET_BYTE(tp);
		cs->minor = GET_BYTE(tp);
		for (cs->ns = 0; GET_LEN(tp) > 0 &&
				/* CSTYLED */
				cs->ns < CISTPL_VERS_1_MAX_PROD_STRINGS; ) {
			(void) strcpy(cs->pi[cs->ns++], cis_getstr(tp));
		} /* for */
	} /* HANDTPL_PARSE_LTUPLE */

	return (CISTPLF_NOERROR);
}

/*
 * cistpl_config_handler - handler for the CISTPL_CONFIG tuple
 *
 *	void *arg - points to a XXX where the information is stuffed into
 *
 * For the first ten config registers we set the present flags in the
 *	cistpl_config_t if the register exists.  The flags that we use
 *	for this are the same as the flags reguired for the Card Services
 *	RequestConfiguration function and they can be used by clients
 *	directly without requiring any remapping of values.
 *
 * XXX we don't handle TPCC_SBTPL subtuples yet
 */

uint32_t	config_regs_present_map[] = {
	CONFIG_OPTION_REG_PRESENT,	/* COR present */
	CONFIG_STATUS_REG_PRESENT,	/* STAT reg present */
	CONFIG_PINREPL_REG_PRESENT,	/* PRR present */
	CONFIG_COPY_REG_PRESENT,	/* COPY reg present */
	CONFIG_EXSTAT_REG_PRESENT,	/* EXSTAT reg present */
	CONFIG_IOBASE0_REG_PRESENT,	/* IOBASE0 reg present */
	CONFIG_IOBASE1_REG_PRESENT,	/* IOBASE1 reg present */
	CONFIG_IOBASE2_REG_PRESENT,	/* IOBASE2 reg present */
	CONFIG_IOBASE3_REG_PRESENT,	/* IOBASE3 reg present */
	CONFIG_IOLIMIT_REG_PRESENT,	/* IOLIMIT reg present */
};

uint32_t
cistpl_config_handler(cistpl_callout_t *co, cistpl_t *tp,
					uint32_t flags, void *arg)
{
	cisdata_t tpcc_sz;
	int i, n, nrb, na, hr = 0;

	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		cistpl_config_t *cr = (cistpl_config_t *)arg;
		int crn = 0;

		RESET_TP(tp);

		tpcc_sz = GET_BYTE(tp);		/* config regs size fields */
		cr->last = GET_BYTE(tp);	/* last config index */

		na = (tpcc_sz&3)+1;		/* config regs address bytes */
		nrb = ((tpcc_sz>>2)&0x0f)+1;	/* number of bytes in config */
						/*	regs presence mask */

		/*
		 * Construct the base offset address for the config registers.
		 *	We jump through these hoops because the base address
		 *	can be between one and four bytes in length.
		 */
		cr->base = 0;
		n = na;
		while (n--)
			cr->base |= ((GET_BYTE(tp) & 0x0ff) <<
							(8 * (na - (n+1))));

		/*
		 * Go through the config register presense mask bit by bit and
		 *	figure out which config registers are present and which
		 *	aren't.
		 * For the first ten config registers, set the appropriate
		 *	bits in the cr->present member so that the caller
		 *	doesn't have to do this.
		 */
		cr->nr = 0;
		cr->present = 0;
		n = nrb;
		while (n--) {
			for (i = 0; i < 8; i++, crn++) {
				if (LOOK_BYTE(tp) & (1<<i)) {
				    if (crn < (sizeof (config_regs_present_map)/
							sizeof (uint32_t)))
					cr->present |=
						config_regs_present_map[crn];
				    cr->nr++;
				    cr->hr = hr;
				    cr->regs[hr] = MAKE_CONFIG_REG_ADDR(
								cr->base, hr);
				} /* LOOK_BYTE */
				hr++;
			} /* for */
			(void) GET_BYTE(tp);
		} /* while */
	}

	return (CISTPLF_NOERROR);
}

/*
 * cistpl_device_handler - handler for the CISTPL_DEVICE, CISTPL_DEVICE_A,
 *				CISTPL_DEVICE_OC and CISTPL_DEVICE_OA tuples
 *
 *	void *arg - points to a cistpl_device_t * where the
 *			information is stuffed into
 *
 * XXX - we only handle CISTPL_DEVICE_MAX_DEVICES device descriptions
 *		described in the tuple
 */
uint32_t
cistpl_device_handler(cistpl_callout_t *co, cistpl_t *tp,
					uint32_t flags, void *arg)
{
	cisdata_t dev_id;

	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		convert_speed_t convert_speed;
		cistpl_device_t *dt = (cistpl_device_t *)arg;
		cistpl_device_node_t *cdn;

		/*
		 * XXX - fix this to look for more than one device definition
		 * XXX - fix this to handle the OC fields for
		 *	CISTPL_DEVICE_OC and CISTPL_DEVICE_OA
		 */
		dt->num_devices = 1;
		cdn = &dt->devnode[0];

		cdn->flags = 0;

		RESET_TP(tp);

		dev_id = GET_BYTE(tp);

		/*
		 * Get the device speed code.  If it's 7, then there is an
		 *	extended speed code table in use, so parse that.
		 *	If it's anything else, get the speed information
		 *	directly from the device speed code.
		 */
		if ((dev_id & 7) == 7) {
		    cdn->nS_speed = cistpl_devspeed(tp, 0, CISTPL_DEVSPEED_EXT);
		} else {
		    cdn->nS_speed = cistpl_devspeed(NULL, dev_id,
							CISTPL_DEVSPEED_TABLE);
		}

		/*
		 * Convert the speed in nS to a device speed code.
		 * XXX -  should check return code from cis_convert_devspeed()
		 */
		convert_speed.Attributes = CONVERT_NS_TO_DEVSPEED;
		convert_speed.nS = cdn->nS_speed;
		(void) cis_convert_devspeed(&convert_speed);
		cdn->speed = convert_speed.devspeed;

		if (dev_id & 8)
			cdn->flags |= CISTPL_DEVICE_WPS;

		/*
		 * Set the device type.  Note that we take the raw value
		 *	from the tuple and pass it back to the caller.
		 *	If the device type codes in the standard change,
		 *	we will have to change our flags as well.
		 */
		cdn->type = (dev_id>>4) & 0x0f;

		/*
		 * XXX - what about the device_size byte?  Is the spec wrong?
		 */
		cdn->size = GET_BYTE(tp);
		/* check for end of list */
		if (cdn->size != 0x0ff) {
		    convert_size_t convert_size;

		    convert_size.devsize = cdn->size;
		    convert_size.Attributes = CONVERT_DEVSIZE_TO_BYTES;
		    (void) cis_convert_devsize(&convert_size);
		    cdn->size_in_bytes = convert_size.bytes;
		}
	}

	return (CISTPLF_NOERROR);
}

/*
 * cistpl_cftable_handler - handler for the CISTPL_CFTABLE_ENTRY tuple
 *
 *	void *arg - points to a XXX where the information is stuffed into
 *
 *    Return:	CISTPLF_NOERROR - if no error parsing tuple
 *		HANDTPL_ERROR - if error parsing tuple
 */
extern uint32_t cistpl_cftable_io_size_table[];
extern uint32_t cistpl_cftable_shift_table[];

uint32_t
cistpl_cftable_handler(cistpl_callout_t *co, cistpl_t *tp,
					uint32_t flags, void *arg)
{
	cisdata_t tpce_indx, tpce_fs, tpce_td, sf, tpce_io, nr;
	cisdata_t ior_desc, tpce_ir, tpce_msd;
	int i, j;

	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		cistpl_cftable_entry_t *ce = (cistpl_cftable_entry_t *)arg;

		RESET_TP(tp);

		/*
		 * Check to see if we have an interface description byte.  If
		 *	we do, grab it and give it directly to the caller, and
		 *	set a flag so the caller knows that it's there.
		 * We also setup the appropriate values in the ce->pin member
		 *	so that clients can feed this value directly to the
		 *	Card Services RequestConfiguration call.
		 */
		if ((tpce_indx = GET_BYTE(tp)) & CISTPL_CFTABLE_TPCE_IFM) {
			ce->ifc = GET_BYTE(tp);

			ce->pin = 0;

			if (ce->ifc & CISTPL_CFTABLE_TPCE_IF_BVD)
			    ce->pin |= (PRR_BVD1_STATUS | PRR_BVD2_STATUS |
					PRR_BVD1_EVENT | PRR_BVD2_EVENT);
			if (ce->ifc & CISTPL_CFTABLE_TPCE_IF_WP)
			    ce->pin |= (PRR_WP_STATUS | PRR_WP_EVENT);
			if (ce->ifc & CISTPL_CFTABLE_TPCE_IF_RDY)
			    ce->pin |= (PRR_READY_STATUS | PRR_READY_EVENT);

			ce->flags |= CISTPL_CFTABLE_TPCE_IF;
		}

		/*
		 * Return the configuration index to the caller, and set the
		 *	default configuration flag if this is a default
		 *	configuration.
		 */
		ce->index = tpce_indx & CISTPL_CFTABLE_TPCE_CFGENTRYM;
		if (tpce_indx & CISTPL_CFTABLE_TPCE_DEFAULTM)
			ce->flags |= CISTPL_CFTABLE_TPCE_DEFAULT;

		/*
		 * Feature selection flags.
		 */
		tpce_fs = GET_BYTE(tp);

		/*
		 * See what types of power information are available,
		 *	and if there is any, set the global power
		 *	information flag as well as a flag for each
		 *	power description available.
		 */
		if (tpce_fs & CISTPL_CFTABLE_TPCE_FS_PWRM) {
		    cistpl_cftable_entry_pd_t *pd = &ce->pd;

		    ce->flags |= CISTPL_CFTABLE_TPCE_FS_PWR;

		    switch (tpce_fs & CISTPL_CFTABLE_TPCE_FS_PWRM) {
			case CISTPL_CFTABLE_TPCE_FS_PWR_VPP2M:
				pd->flags |= CISTPL_CFTABLE_TPCE_FS_PWR_VPP2;
				/* FALLTHROUGH */
			case CISTPL_CFTABLE_TPCE_FS_PWR_VPP1M:
				pd->flags |= CISTPL_CFTABLE_TPCE_FS_PWR_VPP1;
				/* FALLTHROUGH */
			case CISTPL_CFTABLE_TPCE_FS_PWR_VCCM:
				pd->flags |= CISTPL_CFTABLE_TPCE_FS_PWR_VCC;
		    } /* switch */
		} /* if (CISTPL_CFTABLE_TPCE_FS_PWRM) */

		/*
		 * Set up the global memory information flag.
		 */
		if (tpce_fs & CISTPL_CFTABLE_TPCE_FS_MEMM)
			ce->flags |= CISTPL_CFTABLE_TPCE_FS_MEM;

		/*
		 * Parse the various power description structures.
		 */
		if (ce->flags & CISTPL_CFTABLE_TPCE_FS_PWR) {
			cistpl_cftable_entry_pd_t *pd = &ce->pd;
			cistpl_cftable_entry_pwr_t *pwr;
			/*
			 * Collect any Vcc information.
			 */
			if (pd->flags & CISTPL_CFTABLE_TPCE_FS_PWR_VCC) {
				pwr = &pd->pd_vcc;
				cistpl_pd_parse(tp, pwr);
			}
			/*
			 * Collect any Vpp1 information.
			 */
			if (pd->flags & CISTPL_CFTABLE_TPCE_FS_PWR_VPP1) {
				pwr = &pd->pd_vpp1;
				cistpl_pd_parse(tp, pwr);
			}
			/*
			 * Collect any Vpp2 information.
			 */
			if (pd->flags & CISTPL_CFTABLE_TPCE_FS_PWR_VPP2) {
				pwr = &pd->pd_vpp2;
				cistpl_pd_parse(tp, pwr);
			}
		} /* if (CISTPL_CFTABLE_TPCE_FS_PWR) */

		/*
		 * Check to see if there's any timing information, and if
		 *	so, parse the tuple data and store it in the
		 *	caller's structure.  Set a flag in the global
		 *	flag field indicating that there is timing information.
		 */
		if (tpce_fs & CISTPL_CFTABLE_TPCE_FS_TDM) {
			convert_speed_t convert_speed;
			cistpl_cftable_entry_speed_t *sp = &ce->speed;
			ce->flags |= CISTPL_CFTABLE_TPCE_FS_TD;
			tpce_td = GET_BYTE(tp);
			/*
			 * Parse TPCE_TD to get the various timing
			 *	scale factors. Each scale factor has
			 *	a value that indicates that the particular
			 *	timing parameter doesn't exist.
			 */
			if ((sf = (tpce_td &
					CISTPL_CFTABLE_TPCE_FS_TD_WAITM)) !=
			    CISTPL_CFTABLE_TPCE_FS_TD_WAITM) {
				sp->nS_wait = cistpl_devspeed(tp,
						GET_TPCE_FS_TD_WAITS(sf),
						CISTPL_DEVSPEED_EXT);
				convert_speed.Attributes =
							CONVERT_NS_TO_DEVSPEED;
				convert_speed.nS = sp->nS_wait;
				(void) cis_convert_devspeed(&convert_speed);
				sp->wait = convert_speed.devspeed;
				sp->flags |= CISTPL_CFTABLE_TPCE_FS_TD_WAIT;
			}

			if ((sf = (tpce_td & CISTPL_CFTABLE_TPCE_FS_TD_RDYM)) !=
			    CISTPL_CFTABLE_TPCE_FS_TD_RDYM) {
				sp->nS_rdybsy = cistpl_devspeed(tp,
						GET_TPCE_FS_TD_RDYS(sf),
						CISTPL_DEVSPEED_EXT);
				convert_speed.Attributes =
							CONVERT_NS_TO_DEVSPEED;
				convert_speed.nS = sp->nS_rdybsy;
				(void) cis_convert_devspeed(&convert_speed);
				sp->rdybsy = convert_speed.devspeed;
				sp->flags |= CISTPL_CFTABLE_TPCE_FS_TD_RDY;
			}

			if ((sf = (tpce_td &
					CISTPL_CFTABLE_TPCE_FS_TD_RSVDM)) !=
			    CISTPL_CFTABLE_TPCE_FS_TD_RSVDM) {
				sp->nS_rsvd = cistpl_devspeed(tp,
						GET_TPCE_FS_TD_RSVDS(sf),
						CISTPL_DEVSPEED_EXT);
				convert_speed.Attributes =
							CONVERT_NS_TO_DEVSPEED;
				convert_speed.nS = sp->nS_rsvd;
				(void) cis_convert_devspeed(&convert_speed);
				sp->rsvd = convert_speed.devspeed;
				sp->flags |= CISTPL_CFTABLE_TPCE_FS_TD_RSVD;
			}
		} /* if (CISTPL_CFTABLE_TPCE_FS_TDM) */


		/*
		 * Parse any I/O address information.  If there is I/O
		 *	inforamtion, set a flag in the global flag field
		 *	to let the caller know.
		 */
		if (tpce_fs & CISTPL_CFTABLE_TPCE_FS_IOM) {
			cistpl_cftable_entry_io_t *io = &ce->io;

			ce->flags |= CISTPL_CFTABLE_TPCE_FS_IO;
			tpce_io = GET_BYTE(tp);
			/*
			 * Pass any I/O flags that are in the tuple directly
			 *	to the caller.
			 */
			io->flags = tpce_io;
			io->addr_lines = tpce_io &
						CISTPL_CFTABLE_TPCE_FS_IO_ALM;
			/*
			 * If there are any ranges, extract the number of
			 *	ranges and the range descriptions.
			 */
			if (tpce_io & CISTPL_CFTABLE_TPCE_FS_IO_RANGEM) {
				cistpl_cftable_entry_io_range_t *ior;
				ior_desc = GET_BYTE(tp);
				/*
				 * Number of I/O ranges is the value specified
				 *	in the tuple plus one, so there's
				 *	always at least one I/O range if the
				 *	CISTPL_CFTABLE_TPCE_FS_IO_RANGEM bit
				 *	in the I/O flags register is set.
				 */
				nr = (ior_desc & 0x0f) + 1;
				io->ranges = nr;
				/*
				 * Cycle through each I/O range.
				 */
				for (i = 0; i < (int)nr; i++) {
					ior = &io->range[i];
					ior->addr = 0;
					ior->length = 0;
					/*
					 * Gather the address information.
					 *	It's OK if there's no address
					 *	information in which case this
					 *	loop will never execute.
					 */
					for (j = 0; j <
						cistpl_cftable_io_size_table[
							(ior_desc>>4)&3];
									j++)
						ior->addr |= (GET_BYTE(tp) <<
						cistpl_cftable_shift_table[j]);
					/*
					 * Gather the length information.
					 *	It's OK if there's no length
					 *	information in which case this
					 *	loop will never execute.
					 */
					for (j = 0; j <
						cistpl_cftable_io_size_table[
							(ior_desc>>6)&3];
									j++)
						ior->length |= (GET_BYTE(tp) <<
						cistpl_cftable_shift_table[j]);
				} /* for (nr) */
			} /* if (CISTPL_CFTABLE_TPCE_FS_IO_RANGEM) */
		} /* if (CISTPL_CFTABLE_TPCE_FS_IOM) */

		/*
		 * Parse any IRQ information.  If there is IRQ inforamtion,
		 *	set a flag in the global flag field to let the
		 *	caller know.
		 */
		if (tpce_fs & CISTPL_CFTABLE_TPCE_FS_IRQM) {
			cistpl_cftable_entry_irq_t *irq = &ce->irq;

			ce->flags |= CISTPL_CFTABLE_TPCE_FS_IRQ;
			tpce_ir = GET_BYTE(tp);
			/*
			 * Pass any IRQ flags that are in the tuple directly
			 *	to the caller.
			 */
			irq->flags = tpce_ir;
			/*
			 * Check for and parse the extended IRQ bitmask
			 *	if it exists.
			 */
			if (tpce_ir & CISTPL_CFTABLE_TPCE_FS_IRQ_MASKM) {
				irq->irqs = GET_BYTE(tp) & 0x0ff;
				irq->irqs |= (GET_BYTE(tp) << 8)&0x0ff00;
			} else {
				irq->irqs = (1<< (tpce_ir&0x0f));
			}
		} /* if (CISTPL_CFTABLE_TPCE_FS_IRQM) */

		/*
		 * Parse any memory information.
		 *
		 * XXX - should be a cleaner way to parse this information.
		 */
		if (ce->flags & CISTPL_CFTABLE_TPCE_FS_MEM) {
			cistpl_cftable_entry_mem_t *mem = &ce->mem;
			cistpl_cftable_entry_mem_window_t *win;
			/*
			 * Switch on the type of memory description
			 *	information that is available.
			 */
			switch (tpce_fs & CISTPL_CFTABLE_TPCE_FS_MEMM) {
				/*
				 * variable length memory space description
				 */
			case CISTPL_CFTABLE_TPCE_FS_MEM3M:
				mem->flags |= CISTPL_CFTABLE_TPCE_FS_MEM3;
				/* memory space descriptor */
				tpce_msd = GET_BYTE(tp);
				mem->windows = ((tpce_msd &
					(CISTPL_CFTABLE_ENTRY_MAX_MEM_WINDOWS -
								1)) + 1);
				/*
				 * If there's host address information, let
				 *	the caller know.
				 */
				if (tpce_msd & CISTPL_CFTABLE_TPCE_FS_MEM_HOSTM)
					mem->flags |=
						CISTPL_CFTABLE_TPCE_FS_MEM_HOST;
				/*
				 * Cycle through each window space description
				 *	and collect all the interesting bits.
				 */
				for (i = 0; i < mem->windows; i++) {
					win = &mem->window[i];
					win->length = 0;
					win->card_addr = 0;
					win->host_addr = 0;
					/*
					 * Gather the length information.
					 *	It's OK if there's no length
					 *	information in which case this
					 *	loop will never execute.
					 */
					for (j = 0; j <
						(int)((tpce_msd>>3)&3); j++)
						win->length |= (GET_BYTE(tp) <<
						cistpl_cftable_shift_table[j]);
					/*
					 * Gather the card address information.
					 *	It's OK if there's no card
					 *	address information in which
					 *	case this loop will never
					 *	execute.
					 */
					for (j = 0; j <
						(int)((tpce_msd>>5)&3); j++)
						win->card_addr |=
							(GET_BYTE(tp) <<
						cistpl_cftable_shift_table[j]);
					/*
					 * If there's a host address
					 *	description, grab that
					 *	as well.
					 */
					if (mem->flags &
					    CISTPL_CFTABLE_TPCE_FS_MEM_HOST) {
						/*
						 * Gather the host address
						 *	information.  It's OK
						 *	if there's no host
						 *	address information in
						 *	which case this loop
						 *	will never execute.
						 * Note that we use the card
						 *	address size to
						 *	determine how many
						 *	bytes of host address
						 *	are present.
						 */
						for (j = 0; j <
							(int)((tpce_msd>>5)&3);
									j++)
							win->host_addr |=
							(GET_BYTE(tp) <<
						cistpl_cftable_shift_table[j]);
					} else {
						/*
						 * No host address information,
						 *	so the host address is
						 *	equal to the card
						 *	address.
						 */
						win->host_addr = win->card_addr;
					}
				} /* for (i<mem->windows) */
				break;
				/*
				 * single length and card base address specified
				 */
			case CISTPL_CFTABLE_TPCE_FS_MEM2M:
				mem->flags |= CISTPL_CFTABLE_TPCE_FS_MEM2;
				win = &mem->window[0];
				mem->windows = 1;
				/*
				 * Construct the size of the window.
				 */
				win->length = GET_BYTE(tp);
				win->length |= (GET_BYTE(tp)<<8);
				win->length *=
					CISTPL_CFTABLE_TPCE_FS_MEM_PGSIZE;

				/*
				 * Construct the card base address.
				 */
				win->card_addr = GET_BYTE(tp);
				win->card_addr |= (GET_BYTE(tp)<<8);
				win->card_addr *=
					CISTPL_CFTABLE_TPCE_FS_MEM_PGSIZE;

				/*
				 * In this mode, both the host base address
				 *	and the card base address are equal.
				 */
				win->host_addr = win->card_addr;
				break;
				/*
				 * single length specified
				 */
			case CISTPL_CFTABLE_TPCE_FS_MEM1M:
				mem->flags |= CISTPL_CFTABLE_TPCE_FS_MEM1;
				win = &mem->window[0];
				mem->windows = 1;
				win->card_addr = 0;
				win->host_addr = 0;
				/*
				 * Construct the size of the window.
				 */
				win->length = GET_BYTE(tp);
				win->length |= (GET_BYTE(tp)<<8);
				win->length *=
					CISTPL_CFTABLE_TPCE_FS_MEM_PGSIZE;
				break;
			} /* switch (CISTPL_CFTABLE_TPCE_FS_MEMM) */
		} /* if (CISTPL_CFTABLE_TPCE_FS_MEM) */

		/*
		 * Check for and parse any miscellaneous information.
		 *
		 * We only understand how to parse the first
		 *	CISTPL_CFTABLE_TPCE_FS_MISC_MAX extension
		 *	bytes specified in the PC Card 95 standard;
		 *	we throw away any other extension bytes that
		 *	are past these bytes.
		 * XXX Note that the assumption here is that the
		 *	size of cistpl_cftable_entry_misc_t->flags
		 *	is at least CISTPL_CFTABLE_TPCE_FS_MISC_MAX
		 *	bytes in length.
		 */
		if (tpce_fs & CISTPL_CFTABLE_TPCE_FS_MISCM) {
		    cistpl_cftable_entry_misc_t *misc = &ce->misc;
		    int mb = CISTPL_CFTABLE_TPCE_FS_MISC_MAX;

		    ce->flags |= CISTPL_CFTABLE_TPCE_FS_MISC;
		    misc->flags = 0;

		    do {
			if (mb) {
			    misc->flags = (misc->flags << 8) | LOOK_BYTE(tp);
			    mb--;
			}
		    } while ((GET_BYTE(tp) & CISTPL_EXT_BIT) &&
				(!(tp->flags & CISTPLF_MEM_ERR)));

			/*
			 * Check to see if we tried to read past the
			 *	end of the tuple data; if we have,
			 *	there's no point in trying to parse
			 *	any more of the tuple.
			 */
		    if (tp->flags & CISTPLF_MEM_ERR)
			return (HANDTPL_ERROR);
		} /* if (CISTPL_CFTABLE_TPCE_FS_MISCM) */

		/*
		 * Check for and parse any additional subtuple
		 *	information. We know that there is
		 *	additional information if we haven't
		 *	reached the end of the tuple data area
		 *	and if the additional information is
		 *	in standard tuple format.
		 * If we don't recognize the additional info,
		 *	then just silently ignore it, don't
		 *	flag it as an error.
		 */
#ifdef	PARSE_STCE_TUPLES
		if (GET_LEN(tp) > 0) {

		ce->flags |= CISTPL_CFTABLE_TPCE_FS_STCE_EV
		ce->flags |= CISTPL_CFTABLE_TPCE_FS_STCE_PD
#endif

	} /* if (HANDTPL_PARSE_LTUPLE) */

	return (CISTPLF_NOERROR);
}

/*
 * cistpl_pd_parse - read and parse a power description structure
 *
 *	cisdata_t **ddp - pointer to pointer tuple data area
 *	cistpl_cftable_entry_pwr_t *pd - pointer to local power description
 *					structure
 */
static void
cistpl_pd_parse(cistpl_t *tp, cistpl_cftable_entry_pwr_t *pd)
{
	cisdata_t pdesc;

	pdesc = GET_BYTE(tp);	/* power description selector */

	/* nominal supply voltage */
	if (pdesc & CISTPL_CFTABLE_PD_NOMV) {
		pd->nomV = cistpl_expd_parse(tp, &pd->nomV_flags) / 100;
		pd->nomV_flags |= (pdesc | CISTPL_CFTABLE_PD_EXISTS);
	}

	/* minimum supply voltage */
	if (pdesc & CISTPL_CFTABLE_PD_MINV) {
		pd->minV = cistpl_expd_parse(tp, &pd->minV_flags) / 100;
		pd->minV_flags |= (pdesc | CISTPL_CFTABLE_PD_EXISTS);
	}

	/* maximum supply voltage */
	if (pdesc & CISTPL_CFTABLE_PD_MAXV) {
		pd->maxV = cistpl_expd_parse(tp, &pd->maxV_flags) / 100;
		pd->maxV_flags |= (pdesc | CISTPL_CFTABLE_PD_EXISTS);
	}

	/* continuous supply current */
	if (pdesc & CISTPL_CFTABLE_PD_STATICI) {
		pd->staticI_flags |= CISTPL_CFTABLE_PD_MUL10;
		pd->staticI = cistpl_expd_parse(tp, &pd->staticI_flags);
		pd->staticI_flags |= (pdesc | CISTPL_CFTABLE_PD_EXISTS);
	}

	/* maximum current required averaged over 1 second */
	if (pdesc & CISTPL_CFTABLE_PD_AVGI) {
		pd->avgI_flags |= CISTPL_CFTABLE_PD_MUL10;
		pd->avgI = cistpl_expd_parse(tp, &pd->avgI_flags);
		pd->avgI_flags |= (pdesc | CISTPL_CFTABLE_PD_EXISTS);
	}

	/* maximum current required averaged over 10mS */
	if (pdesc & CISTPL_CFTABLE_PD_PEAKI) {
		pd->peakI_flags |= CISTPL_CFTABLE_PD_MUL10;
		pd->peakI = cistpl_expd_parse(tp, &pd->peakI_flags);
		pd->peakI_flags |= (pdesc | CISTPL_CFTABLE_PD_EXISTS);
	}

	/* power down supply curent required */
	if (pdesc & CISTPL_CFTABLE_PD_PDOWNI) {
		pd->pdownI_flags |= CISTPL_CFTABLE_PD_MUL10;
		pd->pdownI = cistpl_expd_parse(tp, &pd->pdownI_flags);
		pd->pdownI_flags |= (pdesc | CISTPL_CFTABLE_PD_EXISTS);
	}
}

/*
 * cistpl_expd_parse - read and parse an extended power description structure
 *
 *	cistpl_t *tp - pointer to pointer tuple data area
 *	int *flags - flags that get for this parameter:
 *			CISTPL_CFTABLE_PD_NC_SLEEP - no connection on
 *							sleep/power down
 *			CISTPL_CFTABLE_PD_ZERO - zero value required
 *			CISTPL_CFTABLE_PD_NC - no connection ever
 *
 * The power consumption is returned in the following units:
 *
 *				voltage - milliVOLTS
 *				current - microAMPS
 */
extern cistpl_pd_struct_t cistpl_pd_struct;

uint32_t
cistpl_expd_parse(cistpl_t *tp, uint32_t *flags)
{
	cisdata_t pdesc;
	uint32_t exponent, mantisa, val, digits = 0;

	/*
	 * Get the power description parameter byte and break it up
	 *	into mantissa and exponent.
	 */
	pdesc = GET_BYTE(tp);
	exponent = pdesc&7;
	mantisa = (pdesc>>3)&0x0f;

	if (pdesc & CISTPL_EXT_BIT) {
		do {
			if (LOOK_BYTE(tp) <= 0x63)
				digits = LOOK_BYTE(tp);
			if (LOOK_BYTE(tp) == CISTPL_CFTABLE_PD_NC_SLEEPM)
				*flags |= CISTPL_CFTABLE_PD_NC_SLEEP;
			if (LOOK_BYTE(tp) == CISTPL_CFTABLE_PD_ZEROM)
				*flags |= CISTPL_CFTABLE_PD_ZERO;
			if (LOOK_BYTE(tp) == CISTPL_CFTABLE_PD_NCM)
				*flags |= CISTPL_CFTABLE_PD_NC;
		} while (GET_BYTE(tp) & CISTPL_EXT_BIT);
	}

	val = CISTPL_PD_MAN(mantisa) * CISTPL_PD_EXP(exponent);

	/*
	 * If we have to multiply the power value by ten, then just
	 *	don't bother dividing.
	 */
	if (! (*flags & CISTPL_CFTABLE_PD_MUL10))
		val = val/10;	/* do this since our mantissa table is X 10 */

	/*
	 * If we need to add some digits to the right of the decimal, do
	 *	that here.
	 */
	if (exponent)
		val = val + (digits * CISTPL_PD_EXP(exponent-1));

	val /= 1000;

	return (val);
}

/*
 * cistpl_devspeed - returns device speed in nS
 *
 *	cistpl_t *tp - tuple pointer.
 *	cisdata_t spindex - device speed table index
 *	int flags - operation flags
 *		CISTPL_DEVSPEED_TABLE:
 *		    Use the spindex argument as an index into a simple
 *			device speed table. ref: PCMCIA Release 2.01
 *			Card Metaformat pg. 5-14 table 5-12.
 *		    When this flag is set, the spindex argument is ignored.
 *		CISTPL_DEVSPEED_EXT:
 *		    Use the tp argument to access the
 *			tuple data area containing an extended speed
 *			code table.  ref: PCMCIA Release 2.01 Card
 *			Metaformat pg. 5-15 table 5-13.
 *		    The tp->read argument must point to the first byte of
 *			an extended speed code table.
 *		    When this flag is set, the spindex argument is
 *			used as a power-of-10 scale factor.  We only allow
 *			a maximum scale factor of 10^16.
 *
 * The device speed is returned in nS for all combinations of flags and
 *	speed table entries.
 *
 * Note if you pass the CISTPL_DEVSPEED_TABLE with a spindex index that
 *	refers to an extended speed table, you will get back an undefined
 *	speed value.
 */
extern cistpl_devspeed_struct_t cistpl_devspeed_struct;

uint32_t
cistpl_devspeed(cistpl_t *tp, cisdata_t spindex, uint32_t flags)
{
	int scale = 1, first;
	cisdata_t exspeed;
	int exponent, mantisa;
	uint32_t speed;

	switch (flags) {
	case CISTPL_DEVSPEED_TABLE:
		speed = CISTPL_DEVSPEED_TBL(spindex);
		break;
	case CISTPL_DEVSPEED_EXT:
		do {
			exspeed = GET_BYTE(tp);
			first = 1;
			if (first) {
				/*
				 * XXX - ugh! we don't understand additional
				 *	exspeed bytes
				 */
				first = 0;
				exponent = (exspeed & 0x07);
				mantisa = (exspeed >> 3) & 0x0f;
				spindex &= 0x0f;	/* only allow 10^16 */
				while (spindex--)
					scale *= 10;
			} /* if (first) */
		} while (exspeed & CISTPL_EXT_BIT);
		speed = scale * CISTPL_DEVSPEED_MAN(mantisa) *
						CISTPL_DEVSPEED_EXP(exponent);
		speed = speed/10;	/* XXX - mantissa table is all X 10 */
		break;
	default:
		break;
	}

	return (speed);
}

/*
 * cistpl_vers_2_handler - handler for the CISTPL_VERS_2 tuple
 *
 *	void *arg - points to a XXX where the information is stuffed into
 */
uint32_t
cistpl_vers_2_handler(cistpl_callout_t *co, cistpl_t *tp,
					uint32_t flags, void *arg)
{
	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		cistpl_vers_2_t *cs = (cistpl_vers_2_t *)arg;

		RESET_TP(tp);

		cs->vers = GET_BYTE(tp);
		cs->comply = GET_BYTE(tp);
		cs->dindex = GET_SHORT(tp);

		cs->reserved = GET_SHORT(tp);

		cs->vspec8 = GET_BYTE(tp);
		cs->vspec9 = GET_BYTE(tp);
		cs->nhdr = GET_BYTE(tp);

		(void) strcpy(cs->oem, cis_getstr(tp));

		if (GET_LEN(tp) > 0)
		    (void) strcpy(cs->info, cis_getstr(tp));
		else
		    (void) strcpy(cs->info, "(no info)");
	}

	return (CISTPLF_NOERROR);
}

/*
 * cistpl_jedec_handler - handler for JEDEC C and JEDEC A tuples
 *
 *	void *arg - points to a XXX where the information is stuffed into
 */
uint32_t
cistpl_jedec_handler(cistpl_callout_t *co, cistpl_t *tp,
					uint32_t flags, void *arg)
{
	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		int nid;
		cistpl_jedec_t *cs = (cistpl_jedec_t *)arg;

		RESET_TP(tp);

		for (nid = 0; GET_LEN(tp) > 0 &&
					nid < CISTPL_JEDEC_MAX_IDENTIFIERS &&
					LOOK_BYTE(tp) != 0xFF; nid++) {
			cs->jid[nid].id = GET_BYTE(tp);
			cs->jid[nid].info = GET_BYTE(tp);
		}
		cs->nid = nid;
	}

	return (CISTPLF_NOERROR);
}

/*
 * cistpl_format_handler - handler for the CISTPL_FORMAT and
 *				CISTPL_FORMAT_A tuples
 */
uint32_t
cistpl_format_handler(cistpl_callout_t *co, cistpl_t *tp,
					uint32_t flags, void *arg)
{
	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		cistpl_format_t *cs = (cistpl_format_t *)arg;

		RESET_TP(tp);

		cs->type = GET_BYTE(tp);
		cs->edc_length = LOOK_BYTE(tp) & EDC_LENGTH_MASK;
		cs->edc_type = ((uint32_t)GET_BYTE(tp) >> EDC_TYPE_SHIFT) &
								EDC_TYPE_MASK;
		cs->offset = GET_LONG(tp);
		cs->nbytes = GET_LONG(tp);

		switch (cs->type) {
		case TPLFMTTYPE_DISK:
			cs->dev.disk.bksize = GET_SHORT(tp);
			cs->dev.disk.nblocks = GET_LONG(tp);
			cs->dev.disk.edcloc = GET_LONG(tp);
			break;

		case TPLFMTTYPE_MEM:
			cs->dev.mem.flags = GET_BYTE(tp);
			cs->dev.mem.reserved = GET_BYTE(tp);
			cs->dev.mem.address = (caddr_t)(uintptr_t)GET_LONG(tp);
			cs->dev.disk.edcloc = GET_LONG(tp);
			break;
		default:
			/* don't know about any other type */
			break;
		}
	}

	return (CISTPLF_NOERROR);
}

/*
 * cistpl_geometry_handler - handler for the CISTPL_GEOMETRY tuple
 *
 *	void *arg - points to a XXX where the information is stuffed into
 */
uint32_t
cistpl_geometry_handler(cistpl_callout_t *co, cistpl_t *tp, uint32_t flags,
								void *arg)
{
	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		cistpl_geometry_t *cs = (cistpl_geometry_t *)arg;

		RESET_TP(tp);
		cs->spt = GET_BYTE(tp);
		cs->tpc = GET_BYTE(tp);
		cs->ncyl = GET_SHORT(tp);
	}
	return (CISTPLF_NOERROR);
}

/*
 * cistpl_byteorder_handler - handler for the CISTPL_BYTEORDER tuple
 *
 *	void *arg - points to a XXX where the information is stuffed into
 */
uint32_t
cistpl_byteorder_handler(cistpl_callout_t *co, cistpl_t *tp, uint32_t flags,
								void *arg)
{
	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		cistpl_byteorder_t *cs = (cistpl_byteorder_t *)arg;

		RESET_TP(tp);
		cs->order = GET_BYTE(tp);
		cs->map = GET_BYTE(tp);
	}
	return (CISTPLF_NOERROR);
}

/*
 * cistpl_date_handler - handler for CISTPL_DATE card format tuple
 *
 *	void *arg - points to a cistpl_date_t * where the
 *			information is stuffed into
 */
uint32_t
cistpl_date_handler(cistpl_callout_t *co, cistpl_t *tp,
					uint32_t flags, void *arg)
{
	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		cistpl_date_t *cs = (cistpl_date_t *)arg;

		RESET_TP(tp);
		cs->time = GET_SHORT(tp);
		cs->day = GET_SHORT(tp);
	}
	return (CISTPLF_NOERROR);
}

/*
 * cistpl_battery_handler - handler for CISTPL_BATTERY battery replacement
 *				date tuple
 *
 *	void *arg - points to a cistpl_battery_t * where the
 *			information is stuffed into
 */
uint32_t
cistpl_battery_handler(cistpl_callout_t *co, cistpl_t *tp,
					uint32_t flags, void *arg)
{
	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		cistpl_battery_t *cs = (cistpl_battery_t *)arg;

		RESET_TP(tp);
		cs->rday = GET_SHORT(tp);
		cs->xday = GET_SHORT(tp);
	}
	return (CISTPLF_NOERROR);
}

/*
 * cistpl_org_handler - handler for CISTPL_ORG data organization tuple
 *
 *	void *arg - points to a cistpl_org_t * where the
 *			information is stuffed into
 */
uint32_t
cistpl_org_handler(cistpl_callout_t *co, cistpl_t *tp,
					uint32_t flags, void *arg)
{
	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		cistpl_org_t *cs = (cistpl_org_t *)arg;

		RESET_TP(tp);
		cs->type = GET_BYTE(tp);

		(void) strcpy(cs->desc, cis_getstr(tp));
	}

	return (CISTPLF_NOERROR);
}


/*
 * cistpl_manfid_handler - handler for CISTPL_MANFID, the manufacturer ID tuple
 *
 *	void *arg - points to a XXX where the information is stuffed into
 */
uint32_t
cistpl_manfid_handler(cistpl_callout_t *co, cistpl_t *tp,
					uint32_t flags, void *arg)
{
	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		cistpl_manfid_t *cs = (cistpl_manfid_t *)arg;

		RESET_TP(tp);
		cs->manf = GET_SHORT(tp);
		cs->card = GET_SHORT(tp);
	}
	return (CISTPLF_NOERROR);
}

/*
 * cistpl_funcid_handler - handler for CISTPL_FUNCID
 *
 *	void *arg - points to a XXX where the information is stuffed into
 */
uint32_t
cistpl_funcid_handler(cistpl_callout_t *co, cistpl_t *tp,
					uint32_t flags, void *arg)
{
	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		cistpl_funcid_t *cs = (cistpl_funcid_t *)arg;

		RESET_TP(tp);

		cs->function = GET_BYTE(tp);
		cs->sysinit = GET_BYTE(tp);
	}
	return (CISTPLF_NOERROR);
}


/*
 * cistpl_funce_serial_handler - handler for the CISTPL_FUNCE/SERIAL tuple
 *
 *	void *arg - points to a XXX where the information is stuffed into
 */
uint32_t
cistpl_funce_serial_handler(cistpl_callout_t *co, cistpl_t *tp,
						uint32_t flags, void *arg)
{
	int subfunction;

	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		cistpl_funce_t *cs = (cistpl_funce_t *)arg;

		RESET_TP(tp);

		cs->function = TPLFUNC_SERIAL;
		cs->subfunction = subfunction = GET_BYTE(tp);
		switch (subfunction & 0xF) {
		case TPLFE_SUB_SERIAL:
		case TPLFE_CAP_SERIAL_DATA:
		case TPLFE_CAP_SERIAL_FAX:
		case TPLFE_CAP_SERIAL_VOICE:
			cs->data.serial.ua = GET_BYTE(tp);
			cs->data.serial.uc = GET_SHORT(tp);
			break;
		case TPLFE_SUB_MODEM_COMMON:
		case TPLFE_CAP_MODEM_DATA:
		case TPLFE_CAP_MODEM_FAX:
		case TPLFE_CAP_MODEM_VOICE:
			cs->data.modem.fc = GET_BYTE(tp);
			cs->data.modem.cb = (GET_BYTE(tp) + 1) * 4;
			cs->data.modem.eb = GET_INT24(tp);
			cs->data.modem.tb = GET_INT24(tp);
			break;
		case TPLFE_SUB_MODEM_DATA:
			cs->data.data_modem.ud = GET_BE_SHORT(tp) * 75;
			cs->data.data_modem.ms = GET_SHORT(tp);
			cs->data.data_modem.em = GET_BYTE(tp);
			cs->data.data_modem.dc = GET_BYTE(tp);
			cs->data.data_modem.cm = GET_BYTE(tp);
			cs->data.data_modem.ex = GET_BYTE(tp);
			cs->data.data_modem.dy = GET_BYTE(tp);
			cs->data.data_modem.ef = GET_BYTE(tp);
			for (cs->data.data_modem.ncd = 0;
				GET_LEN(tp) > 0 && cs->data.data_modem.ncd < 16;
						cs->data.data_modem.ncd++)
				if (LOOK_BYTE(tp) != 255) {
					cs->data.data_modem.cd[
						cs->data.data_modem.ncd] =
								GET_BYTE(tp);
				} else {
					GET_BYTE(tp);
					break;
				}
			break;
		case TPLFE_SUB_MODEM_FAX:
			cs->data.fax.uf = GET_BE_SHORT(tp) * 75;
			cs->data.fax.fm = GET_BYTE(tp);
			cs->data.fax.fy = GET_BYTE(tp);
			cs->data.fax.fs = GET_SHORT(tp);
			for (cs->data.fax.ncf = 0;
				GET_LEN(tp) > 0 && cs->data.fax.ncf < 16;
							cs->data.fax.ncf++)
				if (LOOK_BYTE(tp) != 255) {
					cs->data.fax.cf[cs->data.fax.ncf] =
								GET_BYTE(tp);
				} else {
					GET_BYTE(tp);
					break;
				}
			break;
		case TPLFE_SUB_VOICE:
			cs->data.voice.uv = GET_BE_SHORT(tp) * 75;
			for (cs->data.voice.nsr = 0; LOOK_BYTE(tp) != 0 &&
				GET_LEN(tp) >= 2;
						cs->data.voice.nsr++) {
				cs->data.voice.sr[cs->data.voice.nsr] =
					GET_BYTE(tp) * 1000;
				cs->data.voice.sr[cs->data.voice.nsr] +=
					GET_BYTE(tp) * 100;
			}
			for (cs->data.voice.nss = 0; LOOK_BYTE(tp) != 0 &&
				GET_LEN(tp) >= 2;
						cs->data.voice.nss++) {
				cs->data.voice.ss[cs->data.voice.nss] =
					GET_BYTE(tp) * 10;
				cs->data.voice.ss[cs->data.voice.nss] +=
								GET_BYTE(tp);
			}
			for (cs->data.voice.nsc = 0; LOOK_BYTE(tp) != 0 &&
				GET_LEN(tp) >= 1;
						cs->data.voice.nsc++) {
				cs->data.voice.sc[cs->data.voice.nsc] =
								GET_BYTE(tp);
			}
			break;
		default:
			break;
		}
	}
	return (CISTPLF_NOERROR);
}

/*
 * cistpl_funce_lan_handler - handler for the CISTPL_FUNCE/LAN tuple
 *
 *	void *arg - points to a XXX where the information is stuffed into
 */
uint32_t
cistpl_funce_lan_handler(cistpl_callout_t *co, cistpl_t *tp, uint32_t flags,
								void *arg)
{
	int subfunction;

	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * We don't currently validate this tuple. This call will
	 *	always set tp->flags |= CISTPLF_VALID.
	 */
	if (flags & HANDTPL_COPY_DONE)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	if (flags & HANDTPL_PARSE_LTUPLE) {
		int i;
		cistpl_funce_t *cs = (cistpl_funce_t *)arg;

		RESET_TP(tp);

		cs->function = TPLFUNC_LAN;
		cs->subfunction = subfunction = GET_BYTE(tp);

		switch (subfunction) {
		case TPLFE_NETWORK_INFO:
			cs->data.lan.tech = GET_BYTE(tp);
			cs->data.lan.speed = GET_BYTE(tp);
			i = GET_BYTE(tp);
			if (i < 24) {
				cs->data.lan.speed <<= i;
			} else {
				/*
				 * if speed is too large a value
				 * to hold in a uint32 flag it and
				 * store as [mantissa][exponent]
				 * in least significant 16 bits
				 */
				cs->data.lan.speed = 0x80000000 |
					(cs->data.lan.speed << 8) | i;
			}
			cs->data.lan.media = GET_BYTE(tp);
			cs->data.lan.con = GET_BYTE(tp);
			cs->data.lan.id_sz = GET_BYTE(tp);
			if (cs->data.lan.id_sz <= 16) {
				for (i = 0; i < cs->data.lan.id_sz; i++)
					cs->data.lan.id[i] = GET_BYTE(tp);
			}
			break;
		default:
				/* unknown LAN tuple type */
			return (CISTPLF_UNKNOWN);
		}
	}
	return (CISTPLF_NOERROR);
}

/*
 * cistpl_linktarget_handler - handler for CISTPL_LINKTARGET tuple
 *
 *	void *arg - points to a cistpl_linktarget_t * where the
 *			information is stuffed into
 *
 *	If HANDTPL_COPY_DONE is set, we just validate the tuple but
 *		do not return any values.
 *	If HANDTPL_PARSE_LTUPLE is set, we validate the tuple and
 *		return the parsed tuple data if the tuple is valid.
 *
 *	If the tuple link field is invalid, the CISTPLF_LINK_INVALID flag
 *		will be set in the tp->flags field and HANDTPL_ERROR
 *		will be returned.
 *
 *	If the tuple data body is invalid, the CISTPLF_PARAMS_INVALID flag
 *		will be set in the tp->flags field and HANDTPL_ERROR
 *		will be returned.
 *
 *	The tuple is considered invalid if it's link field is less than
 *		MIN_LINKTARGET_LENGTH or if the data body of the tuple
 *		does not contain the pattern CISTPL_LINKTARGET_MAGIC.
 *
 * XXX At some point we should revisit this to see if we can call
 *	cis_validate_longlink_acm instead of doing the validation
 *	in both places.
 */
uint32_t
cistpl_linktarget_handler(cistpl_callout_t *co, cistpl_t *tp, uint32_t flags,
								void *arg)
{
	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * Validate the tuple for both the HANDTPL_COPY_DONE case and
	 *	the HANDTPL_PARSE_LTUPLE case. Only return data in
	 *	the HANDTPL_PARSE_LTUPLE case.
	 */
	if (flags & (HANDTPL_COPY_DONE | HANDTPL_PARSE_LTUPLE)) {
		uchar_t *cp;
		cisdata_t tl;

		if ((tl = tp->len) >= (cisdata_t)MIN_LINKTARGET_LENGTH) {
			cisdata_t *ltm = (cisdata_t *)CISTPL_LINKTARGET_MAGIC;
			int i;

			RESET_TP(tp);

			/*
			 * Save the start address of this string in case
			 *	the tuple turns out to be OK since we
			 *	need to pass this address to the caller.
			 */
			cp = GET_BYTE_ADDR(tp);

			/*
			 * Check each byte of the tuple body to see if it
			 *	matches what should be in a valid tuple.
			 *	Note that we can't assume that this magic
			 *	pattern is a string and we also only need
			 *	to be sure that MIN_LINKTARGET_LENGTH bytes
			 *	match; all bytes following this magic number
			 *	in this tuple are ignored.
			 */
			for (i = 0; i < MIN_LINKTARGET_LENGTH; i++) {
				if (GET_BYTE(tp) != *ltm++) {
					tp->flags |= CISTPLF_PARAMS_INVALID;
					return (HANDTPL_ERROR);
				}
			} /* MIN_LINKTARGET_LENGTH */

			/*
			 * This tuple is valid.
			 */
			if (flags & HANDTPL_COPY_DONE)
				tp->flags |= CISTPLF_VALID;

			/*
			 * If we're also parsing this tuple, then
			 *	setup the return values.
			 */
			if (flags & HANDTPL_PARSE_LTUPLE) {
				cistpl_linktarget_t *cs =
						(cistpl_linktarget_t *)arg;

				cs->length = tl;
				(void) strncpy(cs->tpltg_tag, (char *)cp,
								cs->length);
				cs->tpltg_tag[cs->length] = '\0';

			} /* HANDTPL_PARSE_LTUPLE */

		} else {

			tp->flags |= CISTPLF_LINK_INVALID;
			return (HANDTPL_ERROR);

		} /* CISTPL_LINKTARGET */

	} /* (HANDTPL_COPY_DONE | HANDTPL_PARSE_LTUPLE) */

	return (CISTPLF_NOERROR);
}

/*
 * cistpl_longlink_ac_handler - handler for CISTPL_LONGLINK_A and
 *				CISTPL_LONGLINK_C tuples
 *
 *	void *arg - points to a cistpl_longlink_ac_t * where the
 *			information is stuffed into
 *
 *	If the passed in tuple is CISTPL_LONGLINK_A the CISTPL_LONGLINK_AC_AM
 *		flag in cistpl_longlink_ac_t->flags is set.
 *	If the passed in tuple is CISTPL_LONGLINK_C the CISTPL_LONGLINK_AC_CM
 *		flag in cistpl_longlink_ac_t->flags is set.
 *
 *	If HANDTPL_COPY_DONE is set, we just validate the tuple but
 *		do not return any values.
 *	If HANDTPL_PARSE_LTUPLE is set, we validate the tuple and
 *		return the parsed tuple data if the tuple is valid.
 *
 *	If the tuple link field is invalid, the CISTPLF_LINK_INVALID flag
 *		will be set in the tp->flags field and HANDTPL_ERROR
 *		will be returned.
 *
 *	The tuple is considered invalid if it's link field is less than
 *		MIN_LONGLINK_AC_LENGTH.
 */
uint32_t
cistpl_longlink_ac_handler(cistpl_callout_t *co, cistpl_t *tp, uint32_t flags,
								void *arg)
{
	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * Validate the tuple for both the HANDTPL_COPY_DONE case and
	 *	the HANDTPL_PARSE_LTUPLE case. Only return data in
	 *	the HANDTPL_PARSE_LTUPLE case.
	 */
	if (flags & (HANDTPL_COPY_DONE | HANDTPL_PARSE_LTUPLE)) {

		if (tp->len >= (cisdata_t)MIN_LONGLINK_AC_LENGTH) {

			/*
			 * This tuple is valid.
			 */
			if (flags & HANDTPL_COPY_DONE)
				tp->flags |= CISTPLF_VALID;

			if (flags & HANDTPL_PARSE_LTUPLE) {
				cistpl_longlink_ac_t *cs =
						(cistpl_longlink_ac_t *)arg;

				switch (tp->type) {
				    case CISTPL_LONGLINK_A:
					cs->flags = CISTPL_LONGLINK_AC_AM;
					break;

				    case CISTPL_LONGLINK_C:
					cs->flags = CISTPL_LONGLINK_AC_CM;
					break;
				    default:
					break;
				} /* switch */

				RESET_TP(tp);

				cs->tpll_addr = GET_LONG(tp);

			} /* HANDTPL_PARSE_LTUPLE */

		} else {
			tp->flags |= CISTPLF_LINK_INVALID;
			return (HANDTPL_ERROR);
		} /* MIN_LONGLINK_AC_LENGTH */

	} /* (HANDTPL_COPY_DONE | HANDTPL_PARSE_LTUPLE) */

	return (CISTPLF_NOERROR);
}

/*
 * cistpl_longlink_mfc_handler - handler for CISTPL_LONGLINK_MFC tuples
 *
 *	void *arg - points to a cistpl_longlink_mfc_t * where the
 *			information is stuffed into
 *
 *	If HANDTPL_COPY_DONE is set, we just validate the tuple but
 *		do not return any values.
 *	If HANDTPL_PARSE_LTUPLE is set, we validate the tuple and
 *		return the parsed tuple data if the tuple is valid.
 *
 *	If the tuple link field is invalid, the CISTPLF_LINK_INVALID flag
 *		will be set in the tp->flags field and HANDTPL_ERROR
 *		will be returned.
 *
 *	If the number of register sets is invalid, the CISTPLF_PARAMS_INVALID
 *		flag be set in the tp->flags field and HANDTPL_ERROR will be
 *		returned.
 *
 *	The tuple is considered invalid if it's link field is less than
 *		MIN_LONGLINK_MFC_LENGTH or if the number of register sets
 *		is not in the range [MIN_LONGLINK_MFC_NREGS..CIS_MAX_FUNCTIONS]
 */
uint32_t
cistpl_longlink_mfc_handler(cistpl_callout_t *co, cistpl_t *tp,
					uint32_t flags, void *arg)
{
	/*
	 * nothing special about our flags, so just call the
	 *	generic handler for this
	 */
	if (flags & HANDTPL_SET_FLAGS)
		return (cis_no_tuple_handler(co, tp, flags, arg));

	/*
	 * Validate the tuple for both the HANDTPL_COPY_DONE case and
	 *	the HANDTPL_PARSE_LTUPLE case. Only return data in
	 *	the HANDTPL_PARSE_LTUPLE case.
	 */
	if (flags & (HANDTPL_COPY_DONE | HANDTPL_PARSE_LTUPLE)) {

		if (tp->len >= (cisdata_t)MIN_LONGLINK_MFC_LENGTH) {

			/*
			 * This tuple is valid.
			 */
			if (flags & HANDTPL_COPY_DONE)
				tp->flags |= CISTPLF_VALID;

			if (flags & HANDTPL_PARSE_LTUPLE) {
				cistpl_longlink_mfc_t *cs =
						(cistpl_longlink_mfc_t *)arg;
				int fn;

				RESET_TP(tp);

				/*
				 * Get the number of register sets described
				 *	by this tuple. The number of register
				 *	sets must be greter than or equal to
				 *	MIN_LONGLINK_MFC_NREGS and less than
				 *	CIS_MAX_FUNCTIONS.
				 * Note that the number of functions is equal
				 *	to the number of register sets.
				 */
				cs->nregs = GET_BYTE(tp);
				cs->nfuncs = cs->nregs;

				if ((cs->nregs < MIN_LONGLINK_MFC_NREGS) ||
					(cs->nregs > CIS_MAX_FUNCTIONS)) {
				    tp->flags |= CISTPLF_PARAMS_INVALID;
				    return (HANDTPL_ERROR);
				}

				/*
				 * Cycle through each function and setup
				 *	the appropriate parameter values.
				 */
				for (fn = 0; fn < cs->nregs; fn++) {
				    cs->function[fn].tas = GET_BYTE(tp);
				    cs->function[fn].addr = GET_LONG(tp);
				} /* for (fn) */

			} /* HANDTPL_PARSE_LTUPLE */

		} else {
			tp->flags |= CISTPLF_LINK_INVALID;
			return (HANDTPL_ERROR);
		} /* MIN_LONGLINK_MFC_LENGTH */

	} /* (HANDTPL_COPY_DONE | HANDTPL_PARSE_LTUPLE) */

	return (CISTPLF_NOERROR);
}

/*
 * cis_validate_longlink_acm - Validates the secondary tuple chain pointed
 *				to by cisptr and specified by a previous
 *				CISTPL_LONGLINK_A, CISTPL_LONGLINK_C or
 *				CISTPL_LONGLINK_MFC tuple.
 *
 *	cisptr->offset must be the offset to the first byte in the secondary
 *		tuple chain to validate
 *	cisptr->flags must be setup to specify the correct address space
 *
 * The cisptr->offset member is not updated after this function returns.
 *
 *	BAD_CIS_ADDR is returned is the raw CIS data cound not be read.
 *	HANDTPL_ERROR is returned if the secondary tuple chain does not
 *		contain a valid CISTPL_LINKTARGET tuple.
 */
uint32_t
cis_validate_longlink_acm(cisptr_t *cisptr)
{
	uchar_t cb[MIN_LINKTARGET_LENGTH + LINKTARGET_AC_HEADER_LENGTH];
	cisptr_t t_cisptr, *cpt;
	int tl;

	/*
	 * Since the NEXT_CIS_ADDR macro increments the cisptr_t->offset
	 *	member, make a local copy of the cisptr and use the local
	 *	copy to read data from the card.
	 */
	cpt = &t_cisptr;
	bcopy((caddr_t)cisptr, (caddr_t)cpt, sizeof (cisptr_t));

	for (tl = 0; tl < MIN_LINKTARGET_LENGTH +
					LINKTARGET_AC_HEADER_LENGTH; tl++) {

		cb[tl] = GET_CIS_DATA(cpt);
		if (!NEXT_CIS_ADDR(cpt))
			return ((uint32_t)BAD_CIS_ADDR);

	} /* for */

	if ((cb[0] == CISTPL_LINKTARGET) && (cb[1] >= MIN_LINKTARGET_LENGTH)) {
		cisdata_t *ltm = (cisdata_t *)CISTPL_LINKTARGET_MAGIC;

		for (tl = 0; tl < MIN_LINKTARGET_LENGTH; tl++, ltm++) {
			if (cb[tl + LINKTARGET_AC_HEADER_LENGTH] != *ltm)
				return (HANDTPL_ERROR);
		}
		return (CISTPLF_NOERROR);

	} /* if */

	return (HANDTPL_ERROR);
}

/*
 * cis_getstr (tp)
 *	we want the address of the first character returned
 *	but need to skip past the string in the cistpl_t structure
 */
char *
cis_getstr(cistpl_t *tp)
{
	uchar_t *cp, *cpp;
	uchar_t x;

	cp = tp->read.byte;
	cpp = cp;

	while ((x = LOOK_BYTE(tp)) != 0 && x != 0xff) {
		x = GET_BYTE(tp);
	}

	(void) GET_BYTE(tp);	/* get past that last byte */

	while ((*cpp != 0) && (*cpp != 0xff))
	    cpp++;

	*cpp = '\0';

	return ((char *)cp);
}

/*
 * cis_return_name - returns name of tuple
 *
 *    calling:	co - pointer to cistpl_callout_t entry that contains
 *			tuple name to return
 *		gtn - pointer to cistpl_get_tuple_name_t to return
 *			name into
 */
static void
cis_return_name(cistpl_callout_t *co, cistpl_get_tuple_name_t *gtn)
{
	(void) strncpy(gtn->name, co->text, CIS_MAX_TUPLE_NAME_LEN);
	gtn->name[CIS_MAX_TUPLE_NAME_LEN - 1] = '\0';
}

/*
 * cis_malloc/cis_free
 *	wrappers around kmem_alloc()/kmem_free() that
 *	provide malloc/free style usage
 */

caddr_t
cis_malloc(size_t len)
{
	caddr_t addr;

	addr = kmem_zalloc(len + sizeof (size_t), KM_SLEEP);
	*(size_t *)addr = len + sizeof (size_t);
	addr += sizeof (size_t);
	return (addr);
}

void
cis_free(caddr_t addr)
{
	size_t len;
	addr -= sizeof (size_t);
	len = *(size_t *)addr;
	kmem_free(addr, len);
}
/*
 * 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 (c) 1995-1999 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#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/ddi_impldefs.h>
#include <sys/kstat.h>
#include <sys/kmem.h>
#include <sys/modctl.h>
#include <sys/kobj.h>

#include <sys/pctypes.h>
#include <pcmcia/sys/cs_types.h>
#include <pcmcia/sys/cis.h>
#include <pcmcia/sys/cis_handlers.h>

/*
 *
 * The following speed tables are used by cistpl_devspeed() to generate
 *	device speeds from tuple data.
 *
 * Define the device speed table.  For a description of this table's contents,
 *	see PCMCIA Release 2.01 Card Metaformat pg. 5-14 table 5-12.
 *
 * All times in this table are in nS.
 */
uint32_t cistpl_devspeed_table[CISTPL_DEVSPEED_MAX_TBL] = {
    0,		/* 0x00 - DSPEED_NULL */
    250,	/* 0x01 - DSPEED_250NS */
    200,	/* 0x02 - DSPEED_200NS */
    150,	/* 0x03 - DSPEED_150NS */
    100,	/* 0x04 - DSPEED_100NS */
    0,		/* 0x05 - reserved */
    0,		/* 0x06 - reserved */
    0		/* 0x07 - use extended speed byte */
};

/*
 * Define the power-of-10 table.
 */
uint32_t cistpl_exspeed_tenfac[] = {
    1,		/* 10^0 */
    10,		/* 10^1 */
    100,	/* 10^2 */
    1000,	/* 10^3 */
    10000,	/* 10^4 */
    100000,	/* 10^5 */
    1000000,	/* 10^6 */
    10000000	/* 10^7	 */
};

/*
 * The extended device speed code mantissa table.
 *
 * This table is described in PCMCIA Release 2.01 Card Metaformat
 *	pg. 5-15 table 5-13.
 *
 * The description of this table uses non-integer values.  We multiply
 *	everything by 10 before it goes into the table, and the code
 *	will divide by 10 after it calculates the device speed.
 */
uint32_t cistpl_devspeed_man[CISTPL_DEVSPEED_MAX_MAN] = {
    0,		/* no units */
    10,		/* no units */
    12,		/* no units */
    13,		/* no units */
    15,		/* no units */
    20,		/* no units */
    25,		/* no units */
    30,		/* no units */
    35,		/* no units */
    40,		/* no units */
    45,		/* no units */
    50,		/* no units */
    55,		/* no units */
    60,		/* no units */
    70,		/* no units */
    80,		/* no units */
};

/*
 * The extended device speed code exponent table.
 *
 * This table is described in PCMCIA Release 2.01 Card Metaformat
 *	pg. 5-15 table 5-13.
 *
 * The description of this table uses various timing units.  This
 *	table contains all times in nS.
 */
uint32_t cistpl_devspeed_exp[CISTPL_DEVSPEED_MAX_EXP] = {
    1,		/* 1 nS */
    10,		/* 10 nS */
    100,	/* 100 nS */
    1000,	/* 1000 nS */
    10000,	/* 10000 nS */
    100000,	/* 100000 nS */
    1000000,	/* 1000000 nS */
    10000000	/* 10000000 nS */
};

/*
 * The power description mantissa table.
 *
 * This table is described in PCMCIA Release 2.01 Card Metaformat
 *	pg. 5-28 table 5-32.
 *
 * The description of this table uses non-integer values.  We multiply
 *	everything by 10 before it goes into the table, and the code
 *	will divide by 10 after it calculates the device power.
 */
uint32_t cistpl_pd_man[] = {
    10,		/* no units */
    12,		/* no units */
    13,		/* no units */
    15,		/* no units */
    20,		/* no units */
    25,		/* no units */
    30,		/* no units */
    35,		/* no units */
    40,		/* no units */
    45,		/* no units */
    50,		/* no units */
    55,		/* no units */
    60,		/* no units */
    70,		/* no units */
    80,		/* no units */
    90,		/* no units */
};

/*
 * The power description exponent table.
 *
 * This table is described in PCMCIA Release 2.01 Card Metaformat
 *	pg. 5-28 table 5-32.
 *
 * The description of this table uses various voltage and current units.
 *	This table contains all currents in nanoAMPS and all voltages
 *	in microVOLTS.
 *
 * Note if you're doing a current table lookup, you need to multiply
 *	the lookup value by ten.
 */
uint32_t cistpl_pd_exp[] = {
    10,		/* 10 microVOLTS, 100 nanoAMPS */
    100,	/* 100 microVOLTS, 1000 nanoAMPS */
    1000,	/* 1000 microVOLTS, 10000 nanoAMPS */
    10000,	/* 10000 microVOLTS, 100000 nanoAMPS */
    100000,	/* 100000 microVOLTS, 1000000 nanoAMPS */
    1000000,	/* 1000000 microVOLTS, 10000000 nanoAMPS */
    10000000,	/* 10000000 microVOLTS, 100000000 nanoAMPS */
    100000000	/* 100000000 microVOLTS, 1000000000 nanoAMPS */
};

/*
 * Fill out the structure pointers.
 */
cistpl_devspeed_struct_t cistpl_devspeed_struct = {
	cistpl_devspeed_table,
	cistpl_exspeed_tenfac,
	cistpl_devspeed_man,
	cistpl_devspeed_exp,
};

cistpl_pd_struct_t cistpl_pd_struct = {
	cistpl_pd_man,
	cistpl_pd_exp,
};

/*
 * Some handy lookup tables that should probably eventually be
 *	done away with.
 *
 * These are used mostly by the CISTPL_CFTABLE_ENTRY tuple handler.
 */
uint32_t cistpl_cftable_io_size_table[] = {
	0,
	1,
	2,
	4,
};

uint32_t cistpl_cftable_shift_table[] = {
	0,
	8,
	16,
	24,
};

/*
 * List of tuples in the global CIS to ignore if they show
 *	up in both the global and function-specific CIS lists.
 * This list MUST end with CISTPL_NULL.
 */
cistpl_ignore_list_t cistpl_ignore_list[] = {
	CISTPL_FUNCID,
	CISTPL_FUNCE,
	CISTPL_CONFIG,
	CISTPL_CFTABLE_ENTRY,
	CISTPL_NULL	/* list must end with CISTPL_NULL */
};
/*
 * 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.
 */

/*
 * 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] = '\0';
	client->driver_name = 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, 0)) {
#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, 0)) != 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, 0,
					(
						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, 0,
						(
							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, 0,
						(
							IO_DEALLOCATE_WINDOW |
							IO_DISABLE_WINDOW));
		    (void) cs_setup_io_win(socket_num,
						client->io_alloc.Window2,
						NULL, NULL, 0,
						(
							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, 0,
						(
							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, 0,
						(
							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 == 0)
	    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 == 0) ? 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 != 0) {
	    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 == 0)
	    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 == 0) ? 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 != 0) {
	    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] = '\0';
	} /* 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;
		}
		/* FALLTHROUGH */
	    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 */
}
/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * This is the PCMCIA Card Services kernel stubs module. It provides
 *	the various PCMCIA kernel framework entry points.
 */

#if defined(DEBUG)
#define	CS_STUBS_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/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>

#ifdef	CS_STUBS_DEBUG
int cs_stubs_debug = 0;
#endif

static csfunction_t *cardservices = NULL;
static int do_cs_call = 0;
static int cs_no_carservices(int32_t, ...);

#define	CardServices	(do_cs_call ? (*cardservices) :		\
			(cs_no_carservices))

#ifdef	USE_CS_STUBS_MODULE

/*
 * Module linkage information for the kernel.
 */
static struct modlmisc modlmisc = {
	&mod_miscops,
	"PCMCIA Card Services stub module"
};

static struct modlinkage modlinkage = {
	MODREV_1,
	(void *)&modlmisc,
	NULL
};

int
_init(void)
{
	return (mod_install(&modlinkage));
}

int
_fini(void)
{
	if (!do_cs_call)
	    return (mod_remove(&modlinkage));
	else
	    return (EBUSY);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}
#endif	/* USE_CS_STUBS_MODULE */

/*
 * csx_register_cardservices - The Card Services loadable module
 *	calls this runction to register it's entry point.
 *
 * Returns:	CS_SUCCESS - if operation sucessful
 *		CS_UNSUPPORTED_FUNCTION - if invalid function code
 *		CS_BAD_HANDLE - if Card Services is not registered
 */
int32_t
csx_register_cardservices(cs_register_cardservices_t *rcs)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 2)
		cmn_err(CE_CONT, "csx_register_cardservices: "
		    "magic: 0x%x function: 0x%x cardservices: 0x%p\n",
		    rcs->magic, rcs->function, (void *)rcs->cardservices);
#endif

	if (rcs->magic != CS_STUBS_MAGIC)
	    return (CS_BAD_ARGS);

	switch (rcs->function) {
	    case CS_ENTRY_REGISTER:
		cardservices = rcs->cardservices;
		do_cs_call = 1;
#ifdef	CS_STUBS_DEBUG
		if (cs_stubs_debug > 2)
			cmn_err(CE_CONT, "csx_register_cardservices: "
			    "CS_ENTRY_REGISTER\n");
#endif

		return (CS_SUCCESS);

	    case CS_ENTRY_DEREGISTER:
		do_cs_call = 0;
		cardservices = cs_no_carservices;
#ifdef	CS_STUBS_DEBUG
		if (cs_stubs_debug > 2)
			cmn_err(CE_CONT, "csx_register_cardservices: "
			    "CS_ENTRY_DEREGISTER\n");
#endif
		return (CS_UNSUPPORTED_FUNCTION);

	    case CS_ENTRY_INQUIRE:
		rcs->cardservices = cardservices;
#ifdef	CS_STUBS_DEBUG
		if (cs_stubs_debug > 2)
			cmn_err(CE_CONT, "csx_register_cardservices: "
			    "CS_ENTRY_INQUIRE\n");
#endif

		if (do_cs_call)
		    return (CS_SUCCESS);
		else
		    return (CS_BAD_HANDLE);

	    default:
#ifdef	CS_STUBS_DEBUG
		if (cs_stubs_debug > 2)
			cmn_err(CE_CONT, "csx_register_cardservices: "
			    "(unknown function)\n");
#endif
		return (CS_UNSUPPORTED_FUNCTION);
	}

}

int32_t
csx_RegisterClient(client_handle_t *ch, client_reg_t *cr)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_RegisterClient: (no handle yet)\n");
#endif
	return (CardServices(RegisterClient, ch, cr));
}

int32_t
csx_DeregisterClient(client_handle_t ch)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_DeregisterClient: handle: 0x%x\n", ch);
#endif
	return (CardServices(DeregisterClient, ch));
}

int32_t
csx_GetStatus(client_handle_t ch, get_status_t *gs)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_GetStatus: handle: 0x%x\n", ch);
#endif
	return (CardServices(GetStatus, ch, gs));
}

int32_t
csx_SetEventMask(client_handle_t ch, sockevent_t *se)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_SetEventMask: handle: 0x%x\n", ch);
#endif
	return (CardServices(SetEventMask, ch, se));
}

int32_t
csx_GetEventMask(client_handle_t ch, sockevent_t *se)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_GetEventMask: handle: 0x%x\n", ch);
#endif
	return (CardServices(GetEventMask, ch, se));
}

int32_t
csx_RequestIO(client_handle_t ch, io_req_t *ior)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_RequestIO: handle: 0x%x\n", ch);
#endif
	return (CardServices(RequestIO, ch, ior));
}

int32_t
csx_ReleaseIO(client_handle_t ch, io_req_t *ior)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_ReleaseIO: handle: 0x%x\n", ch);
#endif
	return (CardServices(ReleaseIO, ch, ior));
}

int32_t
csx_RequestIRQ(client_handle_t ch, irq_req_t *irqr)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_RequestIRQ: handle: 0x%x\n", ch);
#endif
	return (CardServices(RequestIRQ, ch, irqr));
}

int32_t
csx_ReleaseIRQ(client_handle_t ch, irq_req_t *irqr)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_ReleaseIRQ: handle: 0x%x\n", ch);
#endif
	return (CardServices(ReleaseIRQ, ch, irqr));
}

int32_t
csx_RequestWindow(client_handle_t ch, window_handle_t *wh, win_req_t *wr)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_RequestWindow: handle: 0x%x\n", ch);
#endif
	return (CardServices(RequestWindow, ch, wh, wr));
}

int32_t
csx_ReleaseWindow(window_handle_t wh)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_ReleaseWindow: handle: 0x%x\n", wh);
#endif
	return (CardServices(ReleaseWindow, wh));
}

int32_t
csx_ModifyWindow(window_handle_t wh, modify_win_t *mw)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_ModifyWindow: handle: 0x%x\n", wh);
#endif
	return (CardServices(ModifyWindow, wh, mw));
}

int32_t
csx_MapMemPage(window_handle_t wh, map_mem_page_t *mmp)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_MapMemPage: handle: 0x%x\n", wh);
#endif
	return (CardServices(MapMemPage, wh, mmp));
}

int32_t
csx_RequestSocketMask(client_handle_t ch, request_socket_mask_t *sm)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_RequestSocketMask: handle: 0x%x\n", ch);
#endif
	return (CardServices(RequestSocketMask, ch, sm));
}

int32_t
csx_ReleaseSocketMask(client_handle_t ch, release_socket_mask_t *rsm)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_ReleaseSocketMask: handle: 0x%x\n", ch);
#endif
	return (CardServices(ReleaseSocketMask, ch, rsm));
}

int32_t
csx_RequestConfiguration(client_handle_t ch, config_req_t *cr)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_RequestConfiguration: handle: 0x%x\n", ch);
#endif
	return (CardServices(RequestConfiguration, ch, cr));
}

int32_t
csx_ModifyConfiguration(client_handle_t ch, modify_config_t *mc)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_ModifyConfiguration: handle: 0x%x\n", ch);
#endif
	return (CardServices(ModifyConfiguration, ch, mc));
}

int32_t
csx_ReleaseConfiguration(client_handle_t ch, release_config_t *rc)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_ReleaseConfiguration: handle: 0x%x\n", ch);
#endif
	return (CardServices(ReleaseConfiguration, ch, rc));
}

int32_t
csx_AccessConfigurationRegister(client_handle_t ch, access_config_reg_t *acr)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT,
		"csx_AccessConfigurationRegister: handle: 0x%x\n", ch);
#endif
	return (CardServices(AccessConfigurationRegister, ch, acr));
}

int32_t
csx_GetFirstTuple(client_handle_t ch, tuple_t *tp)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_GetFirstTuple: handle: 0x%x\n", ch);
#endif
	return (CardServices(GetFirstTuple, ch, tp));
}

int32_t
csx_GetNextTuple(client_handle_t ch, tuple_t *tp)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_GetNextTuple: handle: 0x%x\n", ch);
#endif
	return (CardServices(GetNextTuple, ch, tp));
}

int32_t
csx_GetTupleData(client_handle_t ch, tuple_t *tp)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_GetTupleData: handle: 0x%x\n", ch);
#endif
	return (CardServices(GetTupleData, ch, tp));
}

int32_t
csx_MapLogSocket(client_handle_t ch, map_log_socket_t *mls)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_MapLogSocket: handle: 0x%x\n", ch);
#endif
	return (CardServices(MapLogSocket, ch, mls));
}

int32_t
csx_ValidateCIS(client_handle_t ch, cisinfo_t *ci)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_ValidateCIS: handle: 0x%x\n", ch);
#endif
	return (CardServices(ValidateCIS, ch, ci));
}

int32_t
csx_MakeDeviceNode(client_handle_t ch, make_device_node_t *mdn)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_MakeDeviceNode: handle: 0x%x\n", ch);
#endif
	return (CardServices(MakeDeviceNode, ch, mdn));
}

int32_t
csx_RemoveDeviceNode(client_handle_t ch, remove_device_node_t *rdn)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_RemoveDeviceNode: handle: 0x%x\n", ch);
#endif
	return (CardServices(RemoveDeviceNode, ch, rdn));
}

int32_t
csx_ConvertSpeed(convert_speed_t *cp)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_ConvertSpeed\n");
#endif
	return (CardServices(ConvertSpeed, cp));
}

int32_t
csx_ConvertSize(convert_size_t *cp)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_ConvertSize\n");
#endif
	return (CardServices(ConvertSize, cp));
}

int32_t
csx_Event2Text(event2text_t *e2t)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Event2Text\n");
#endif
	return (CardServices(Event2Text, e2t));
}

int32_t
csx_Error2Text(error2text_t *e2t)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Error2Text\n");
#endif
	return (CardServices(Error2Text, e2t));
}

int32_t
csx_CS_DDI_Info(cs_ddi_info_t *cp)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_CS_DDI_Info\n");
#endif
	return (CardServices(CS_DDI_Info, cp));
}

int32_t
csx_CS_Sys_Ctl(cs_sys_ctl_t *csc)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_CS_Sys_Ctl\n");
#endif
	return (CardServices(CS_Sys_Ctl, csc));
}

int32_t
csx_GetClientInfo(client_handle_t ch, client_info_t *ci)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_GetClientInfo: handle: 0x%x\n", ch);
#endif

	return (CardServices(GetClientInfo, ch, ci));
}

int32_t
csx_GetFirstClient(get_firstnext_client_t *fnc)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_GetFirstClient\n");
#endif

	return (CardServices(GetFirstClient, fnc));
}

int32_t
csx_GetNextClient(get_firstnext_client_t *fnc)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_GetNextClient\n");
#endif

	return (CardServices(GetNextClient, fnc));
}

int32_t
csx_ResetFunction(client_handle_t ch, reset_function_t *rf)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_ResetFunction: handle: 0x%x\n", ch);
#endif

	return (CardServices(ResetFunction, ch, rf));
}

int32_t
csx_GetCardServicesInfo(client_handle_t ch, get_cardservices_info_t *gcsi)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_GetCardServicesInfo: handle: 0x%x\n", ch);
#endif

	return (CardServices(GetCardServicesInfo, ch, gcsi));
}

int32_t
csx_GetConfigurationInfo(client_handle_t *ch, get_configuration_info_t *gci)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_GetConfigurationInfo: "
		"handle: (no handle yet)\n");
#endif

	return (CardServices(GetConfigurationInfo, ch, gci));
}

int32_t
csx_GetPhysicalAdapterInfo(client_handle_t ch, get_physical_adapter_info_t *gp)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_GetPhysicalAdapterInfo: handle: 0x%x\n", ch);
#endif

	return (CardServices(GetPhysicalAdapterInfo, ch, gp));
}

/*
 * CIS tuple parsing functions - one entrypoint per tuple that we know
 *	how to parse
 */
int32_t
csx_Parse_CISTPL_CONFIG(client_handle_t ch, tuple_t *tp, cistpl_config_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_CONFIG: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_CONFIG;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_DEVICE(client_handle_t ch, tuple_t *tp, cistpl_device_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_DEVICE: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_DEVICE;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_DEVICE_A(client_handle_t ch, tuple_t *tp, cistpl_device_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_DEVICE_A: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_DEVICE_A;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_DEVICE_OA(client_handle_t ch, tuple_t *tp, cistpl_device_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_DEVICE_OA: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_DEVICE_OA;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_DEVICE_OC(client_handle_t ch, tuple_t *tp, cistpl_device_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_DEVICE_OC: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_DEVICE_OC;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_VERS_1(client_handle_t ch, tuple_t *tp, cistpl_vers_1_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_VERS_1: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_VERS_1;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_VERS_2(client_handle_t ch, tuple_t *tp, cistpl_vers_2_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_VERS_2: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_VERS_2;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_JEDEC_A(client_handle_t ch, tuple_t *tp, cistpl_jedec_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_JEDEC_A: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_JEDEC_A;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_JEDEC_C(client_handle_t ch, tuple_t *tp, cistpl_jedec_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_JEDEC_C: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_JEDEC_C;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_FORMAT(client_handle_t ch, tuple_t *tp, cistpl_format_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_FORMAT: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_FORMAT;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_FORMAT_A(client_handle_t ch, tuple_t *tp, cistpl_format_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_FORMAT_A: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_FORMAT_A;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_GEOMETRY(client_handle_t ch, tuple_t *tp,
    cistpl_geometry_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_GEOMETRY: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_GEOMETRY;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_BYTEORDER(client_handle_t ch, tuple_t *tp,
    cistpl_byteorder_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_BYTEORDER: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_BYTEORDER;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_DATE(client_handle_t ch, tuple_t *tp, cistpl_date_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_DATE: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_DATE;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_BATTERY(client_handle_t ch, tuple_t *tp, cistpl_battery_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_BATTERY: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_BATTERY;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_ORG(client_handle_t ch, tuple_t *tp, cistpl_org_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_ORG: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_ORG;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_MANFID(client_handle_t ch, tuple_t *tp, cistpl_manfid_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_MANFID: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_MANFID;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_FUNCID(client_handle_t ch, tuple_t *tp, cistpl_funcid_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_FUNCID: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_FUNCID;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_FUNCE(client_handle_t ch, tuple_t *tp,
    cistpl_funce_t *pt, uint32_t function)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_FUNCE: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_FUNCE;
	return (CardServices(ParseTuple, ch, tp, pt, function));
}

int32_t
csx_Parse_CISTPL_CFTABLE_ENTRY(client_handle_t ch, tuple_t *tp,
    cistpl_cftable_entry_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT,
		"csx_Parse_CISTPL_CFTABLE_ENTRY: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_CFTABLE_ENTRY;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_LINKTARGET(client_handle_t ch, tuple_t *tp,
    cistpl_linktarget_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_LINKTARGET: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_LINKTARGET;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_LONGLINK_A(client_handle_t ch, tuple_t *tp,
    cistpl_longlink_ac_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_LONGLINK_A: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_LONGLINK_A;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_LONGLINK_C(client_handle_t ch, tuple_t *tp,
    cistpl_longlink_ac_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_LONGLINK_C: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_LONGLINK_C;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_LONGLINK_MFC(client_handle_t ch, tuple_t *tp,
    cistpl_longlink_mfc_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_LONGLINK_MFC: "
						"handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_LONGLINK_MFC;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t csx_Parse_CISTPL_LONGLINK_CB(client_handle_t ch, tuple_t *tp,
    cistpl_longlink_cb_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_LONGLINK_CB: "
						"handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_LONGLINK_CB;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_SPCL(client_handle_t ch, tuple_t *tp,
    cistpl_spcl_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_SPCL: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_SPCL;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_SWIL(client_handle_t ch, tuple_t *tp,
    cistpl_swil_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_SWIL: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_SWIL;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t csx_Parse_CISTPL_BAR(client_handle_t ch, tuple_t *tp,
    cistpl_bar_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_BAR: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_BAR;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_DEVICEGEO(client_handle_t ch, tuple_t *tp,
    cistpl_devicegeo_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_DEVICEGEO: handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_DEVICEGEO;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_Parse_CISTPL_DEVICEGEO_A(client_handle_t ch, tuple_t *tp,
    cistpl_devicegeo_t *pt)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_Parse_CISTPL_DEVICEGEO_A: "
						"handle: 0x%x\n", ch);
#endif
	tp->DesiredTuple = CISTPL_DEVICEGEO_A;
	return (CardServices(ParseTuple, ch, tp, pt));
}

int32_t
csx_ParseTuple(client_handle_t ch, tuple_t *tp, cisparse_t *cp, uint32_t ef)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_ParseTuple: handle: 0x%x\n", ch);
#endif
	return (CardServices(ParseTuple, ch, tp, cp, ef));
}

/*
 * The following functions are used to access various datatypes.
 *	These functions are not specific to PCMCIA client drivers
 *	and they don't depend on Card Services being present to
 *	operate.
 */
void
csx_Put8(acc_handle_t handle, uint32_t offset, uint8_t value)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	ddi_put8(handle, (uint8_t *)(hp->ah_addr + offset), value);
}

void
csx_Put16(acc_handle_t handle, uint32_t offset, uint16_t value)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	ddi_put16(handle, (uint16_t *)(hp->ah_addr + offset), value);
}

void
csx_Put32(acc_handle_t handle, uint32_t offset, uint32_t value)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	ddi_put32(handle, (uint32_t *)(hp->ah_addr + offset), value);
}

void
csx_Put64(acc_handle_t handle, uint32_t offset, uint64_t value)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	ddi_put64(handle, (uint64_t *)(hp->ah_addr + offset), value);
}

uint8_t
csx_Get8(acc_handle_t handle, uint32_t offset)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	return (ddi_get8(handle, (uint8_t *)(hp->ah_addr + offset)));
}

uint16_t
csx_Get16(acc_handle_t handle, uint32_t offset)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	return (ddi_get16(handle, (uint16_t *)(hp->ah_addr + offset)));
}

uint32_t
csx_Get32(acc_handle_t handle, uint32_t offset)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	return (ddi_get32(handle, (uint32_t *)(hp->ah_addr + offset)));
}

uint64_t
csx_Get64(acc_handle_t handle, uint32_t offset)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	return (ddi_get64(handle, (uint64_t *)(hp->ah_addr + offset)));
}

void
csx_RepPut8(acc_handle_t handle, uint8_t *hostaddr, uint32_t offset,
						uint32_t rc, uint32_t flags)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	ddi_rep_put8(handle, hostaddr, (uint8_t *)(hp->ah_addr + offset),
		rc, (uint32_t)flags);
}

void
csx_RepPut16(acc_handle_t handle, uint16_t *hostaddr, uint32_t offset,
						uint32_t rc, uint32_t flags)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	ddi_rep_put16(handle, hostaddr, (uint16_t *)(hp->ah_addr + offset),
		rc, (uint32_t)flags);
}

void
csx_RepPut32(acc_handle_t handle, uint32_t *hostaddr, uint32_t offset,
						uint32_t rc, uint32_t flags)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	ddi_rep_put32(handle, hostaddr, (uint32_t *)(hp->ah_addr + offset),
		rc, (uint32_t)flags);
}

void
csx_RepPut64(acc_handle_t handle, uint64_t *hostaddr, uint32_t offset,
						uint32_t rc, uint32_t flags)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	ddi_rep_put64(handle, hostaddr, (uint64_t *)(hp->ah_addr + offset),
		rc, (uint32_t)flags);
}

void
csx_RepGet8(acc_handle_t handle, uint8_t *hostaddr, uint32_t offset,
						uint32_t rc, uint32_t flags)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	ddi_rep_get8(handle, hostaddr, (uint8_t *)(hp->ah_addr + offset),
		rc, (uint32_t)flags);
}

void
csx_RepGet16(acc_handle_t handle, uint16_t *hostaddr, uint32_t offset,
						uint32_t rc, uint32_t flags)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	ddi_rep_get16(handle, hostaddr, (uint16_t *)(hp->ah_addr + offset),
		rc, (uint32_t)flags);
}

void
csx_RepGet32(acc_handle_t handle, uint32_t *hostaddr, uint32_t offset,
						uint32_t rc, uint32_t flags)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	ddi_rep_get32(handle, hostaddr, (uint32_t *)(hp->ah_addr + offset),
		rc, (uint32_t)flags);
}

void
csx_RepGet64(acc_handle_t handle, uint64_t *hostaddr, uint32_t offset,
						uint32_t rc, uint32_t flags)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

	ddi_rep_get64(handle, hostaddr, (uint64_t *)(hp->ah_addr + offset),
		rc, (uint32_t)flags);
}

/*
 * The following two functions return the mapped (virtual) or physical
 *	base address associated with the passed handle if the address
 *	can be directly accessed by the caller. If the object represented
 *	by the handle needs to be accessed through a common access
 *	function, CS_BAD_BASE is returned.
 *
 * XXX - Need to figure out how to determine when to return CS_BAD_BASE
 *	and also we need more generic return codes not tied to CS.
 */
int32_t
csx_GetMappedAddr(acc_handle_t handle, void **addr)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_GetMappedAddr: handle: 0x%p\n", handle);
#endif

	*addr = hp->ah_addr;

	return (CS_SUCCESS);	/* XXX should be generic return code */
}

int32_t
csx_GetPhysAddr(acc_handle_t handle, void **addr)
{
#ifndef	lint
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
#endif	/* lint */

#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_GetPhysAddr: handle: 0x%p\n", handle);
#endif

	*addr = NULL;

	return (CS_BAD_BASE);
}

/*ARGSUSED*/
int32_t
csx_DupHandle(acc_handle_t handle, acc_handle_t *dup, uint32_t flags)
{
#ifndef	lint
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);
#endif	/* lint */

#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_DupHandle: handle: 0x%p\n", handle);
#endif

	return (CS_BAD_HANDLE);

#ifdef	XXX
	*dup = (acc_handle_t)kmem_alloc(sizeof (acc_hdl_t), KM_SLEEP);
	((acc_hdl_t *)*dup)->ddi_handle =
		(ddi_acc_handle_t *)kmem_alloc(sizeof (ddi_acc_impl_t),
		    KM_SLEEP);

	bcopy((caddr_t)hp, (caddr_t)((acc_hdl_t *)*dup)->ddi_handle,
	    sizeof (ddi_acc_impl_t));

	return (CS_SUCCESS);
#endif
}

int32_t
csx_FreeHandle(acc_handle_t *handle)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_FreeHandle: handle: 0x%p\n", *handle);
#endif
	return (CS_BAD_HANDLE);

#ifdef	XXX

	kmem_free((void *)((acc_hdl_t *)*handle)->ddi_handle,
		sizeof (ddi_acc_impl_t));
	kmem_free((void *)(acc_hdl_t *)*handle, sizeof (acc_hdl_t));

	return (CS_SUCCESS);
#endif
}

/*
 * XXX - Probably want to remove these fucntions soon
 */
int32_t
csx_GetHandleOffset(acc_handle_t handle, uint32_t *offset)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_GetHandleOffset: handle: 0x%p\n", handle);
#endif

	*offset = hp->ah_offset;

	return (CS_SUCCESS);
}

int32_t
csx_SetHandleOffset(acc_handle_t handle, uint32_t offset)
{
	ddi_acc_hdl_t *hp = impl_acc_hdl_get(handle);

#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "csx_SetHandleOffset: handle: 0x%p\n", handle);
#endif

	hp->ah_offset = offset;

	return (CS_SUCCESS);
}

static int
cs_no_carservices(int32_t arg __unused, ...)
{
#ifdef	CS_STUBS_DEBUG
	if (cs_stubs_debug > 3)
	    cmn_err(CE_CONT, "cs_no_carservices\n");
#endif
	return (CS_UNSUPPORTED_FUNCTION);
}
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright 2023 Oxide Computer Company
 */

/*
 * PCMCIA NEXUS
 *	The PCMCIA module is a generalized interface for
 *	implementing PCMCIA nexus drivers.  It preserves
 *	the logical socket name space while allowing multiple
 *	instances of the hardware to be properly represented
 *	in the device tree.
 *
 *	The nexus also exports events to an event manager
 *	driver if it has registered.
 */

#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/debug.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/cred.h>
#include <sys/kstat.h>
#include <sys/kmem.h>
#include <sys/modctl.h>
#include <sys/kobj.h>
#include <sys/callb.h>
#include <sys/param.h>
#include <sys/thread.h>
#include <sys/proc.h>

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

#ifdef sparc
#include <sys/ddi_subrdefs.h>

#elif defined(__x86)
#include <sys/mach_intr.h>
#endif

#undef SocketServices

/* some bus specific stuff */

/* need PCI regspec size for worst case at present */
#include <sys/pci.h>

typedef struct pcmcia_logical_socket {
	int			ls_socket; /* adapter's socket number */
	uint32_t		ls_flags;
	struct pcmcia_adapter	*ls_adapter;
	pcmcia_if_t		*ls_if;
	dev_info_t		*ls_sockdrv;
	dev_info_t		*ls_dip[PCMCIA_MAX_FUNCTIONS];
	dev_info_t		*ls_mfintr_dip;
	int			ls_functions;
	uint32_t		ls_cs_events;
	uint32_t		ls_intr_pri;
	uint32_t		ls_intr_vec;
	int			ls_intrrefs;
	struct intrspec		ls_intrspec; /* MFC intrspec */
	inthandler_t		*ls_inthandlers; /* for multifunction cards */
	ddi_iblock_cookie_t	ls_iblk;
	ddi_idevice_cookie_t	ls_idev;
	kmutex_t		ls_ilock;
	int			ls_error; /* error for CS return */
} pcmcia_logical_socket_t;

/*
 * entry points used by the true nexus
 */
int pcmcia_detach(dev_info_t *, ddi_detach_cmd_t);
int pcmcia_ctlops(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *, void *);
int pcmcia_prop_op(dev_t, dev_info_t *, dev_info_t *, ddi_prop_op_t,
			int, char *, caddr_t, int *);
void pcmcia_set_assigned(dev_info_t *, int, ra_return_t *);
int pcmcia_intr_ops(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t intr_op,
    ddi_intr_handle_impl_t *hdlp, void *result);

/*
 * prototypes used internally by the nexus and sometimes Card Services
 */
int SocketServices(int function, ...);


void *CISParser(int function, ...);
extern void *(*cis_parser)(int, ...);

struct regspec *pcmcia_cons_regspec(dev_info_t *, int, uchar_t *,
					ra_return_t *);

static int (*pcmcia_card_services)(int, ...) = NULL;

/*
 * variables used in the logical/physical mappings
 * that the nexus common code maintains.
 */
struct pcmcia_adapter *pcmcia_adapters[PCMCIA_MAX_ADAPTERS];
int    pcmcia_num_adapters;
pcmcia_logical_socket_t *pcmcia_sockets[PCMCIA_MAX_SOCKETS];
int    pcmcia_num_sockets;
pcmcia_logical_window_t *pcmcia_windows[PCMCIA_MAX_WINDOWS];
int    pcmcia_num_windows;
struct power_entry pcmcia_power_table[PCMCIA_MAX_POWER];
int	pcmcia_num_power;

struct pcmcia_mif *pcmcia_mif_handlers = NULL;
pcm_dev_node_t *pcmcia_devnodes = NULL;

kmutex_t pcmcia_global_lock;
kcondvar_t pcmcia_condvar;
kmutex_t pcmcia_enum_lock;

/*
 * Mapping of the device "type" to names acceptable to
 * the DDI
 */
static char *pcmcia_dev_type[] = {
	"multifunction",
	"byte",
	"serial",
	"parallel",
	"block",
	"display",
	"network",
	"block",
	"byte"
};

char *pcmcia_default_pm_mode = "parental-suspend-resume";

/*
 * generic names from the approved list:
 *	disk tape pci sbus scsi token-ring isa keyboard display mouse
 *	audio ethernet timer memory parallel serial rtc nvram scanner
 *	floppy(controller) fddi isdn atm ide pccard video-in video-out
 * in some cases there will need to be device class dependent names.
 * network -> ethernet, token-ring, etc.
 * this list is a first guess and is used when all else fails.
 */

char *pcmcia_generic_names[] = {
	"multifunction",
	"memory",
	"serial",
	"parallel",
	"disk",
	"video",		/* no spec for video-out yet */
	"network",
	"aims",
	"scsi",
	"security"
};

#define	PCM_GENNAME_SIZE	(sizeof (pcmcia_generic_names) / \
					sizeof (char *))
#define	PCMCIA_MAP_IO	0x0
#define	PCMCIA_MAP_MEM	0x1
#define	PPB_SUBTRACTIVE	((PCI_CLASS_BRIDGE << 16) | (PCI_BRIDGE_PCI << 8) | \
		(PCI_BRIDGE_PCI_IF_SUBDECODE))

/*
 * The following should be 2^^n - 1
 */
#define	PCMCIA_SOCKET_BITS	0x7f

#ifdef PCMCIA_DEBUG
int pcmcia_debug = 0x0;
static void pcmcia_dump_minors(dev_info_t *);
#endif

static f_tt *pcmcia_cs_event = NULL;
int pcmcia_timer_id;
dev_info_t	*pcmcia_dip;
/*
 * XXX - See comments in cs.c
 */
static f_tt *pcmcia_cis_parser = NULL;

extern struct pc_socket_services pc_socket_services;

/* some function declarations */
static int pcm_adapter_callback(dev_info_t *, int, int, int);
extern void pcmcia_init_adapter(anp_t *, dev_info_t *);
extern void pcmcia_find_cards(anp_t *);
extern void pcmcia_merge_power(struct power_entry *);
extern void pcmcia_do_resume(int, pcmcia_logical_socket_t *);
extern void pcmcia_resume(int, pcmcia_logical_socket_t *);
extern void pcmcia_do_suspend(int, pcmcia_logical_socket_t *);
extern void pcm_event_manager(int, int, void *);
static void pcmcia_create_dev_info(int);
static int pcmcia_create_device(ss_make_device_node_t *);
static void pcmcia_init_devinfo(dev_info_t *, struct pcm_device_info *);
void pcmcia_fix_string(char *str);
dev_info_t *pcmcia_number_socket(dev_info_t *, int);
static int pcmcia_merge_conf(dev_info_t *);
static uint32_t pcmcia_mfc_intr(caddr_t, caddr_t);
void pcmcia_free_resources(dev_info_t *);
static void pcmcia_ppd_free(struct pcmcia_parent_private *ppd);
int pcmcia_get_intr(dev_info_t *, int);
int pcmcia_return_intr(dev_info_t *, int);
int pcmcia_ra_alloc(dev_info_t *, ndi_ra_request_t *, ra_return_t *, char *,
		dev_info_t **);
int pcmcia_ra_free(dev_info_t *, ra_return_t *, char *);

extern int cs_init(void);
extern int cs_deinit(void);
extern void cisp_init(void);
extern void cis_deinit(void);

/*
 * non-DDI compliant functions are listed here
 * some will be declared while others that have
 * entries in .h files. All will be commented on.
 *
 * with declarations:
 *	ddi_add_child
 *	ddi_binding_name
 *	ddi_bus_prop_op
 *	ddi_ctlops
 *	ddi_find_devinfo
 *	ddi_get_name_addr
 *	ddi_get_parent_data
 *	ddi_hold_installed_driver
 *	ddi_name_to_major
 *	ddi_node_name
 *	ddi_pathname
 *	ddi_rele_driver
 *	ddi_set_name_addr
 *	ddi_set_parent_data
 *	ddi_unorphan_devs
 *	i_ddi_bind_node_to_driver
 *	i_ddi_bind_node_to_driver
 *	i_ddi_bus_map
 *	i_ddi_map_fault
 *	i_ddi_mem_alloc
 *	i_ddi_mem_alloc
 *	i_ddi_mem_free
 *	i_ddi_mem_free
 *	modload
 *	modunload
 */

extern void ddi_unorphan_devs(major_t);

/* Card&Socket Services entry points */
static int GetCookiesAndDip(sservice_t *);
static int SSGetAdapter(get_adapter_t *);
static int SSGetPage(get_page_t *);
static int SSGetSocket(get_socket_t *);
static int SSGetStatus(get_ss_status_t *);
static int SSGetWindow(get_window_t *);
static int SSInquireAdapter(inquire_adapter_t *);
static int SSInquireSocket(inquire_socket_t *);
static int SSInquireWindow(inquire_window_t *);
static int SSResetSocket(int, int);
static int SSSetPage(set_page_t *);
static int SSSetSocket(set_socket_t *);
static int SSSetWindow(set_window_t *);
static int SSSetIRQHandler(set_irq_handler_t *);
static int SSClearIRQHandler(clear_irq_handler_t *);

static struct modldrv modlmisc = {
	&mod_miscops,		/* Type of module. This one is a driver */
	"PCMCIA Nexus Support", /* Name of the module. */
};

static struct modlinkage modlinkage = {
	MODREV_1, (void *)&modlmisc, NULL
};

int
_init()
{
	int	ret;

	cisp_init();

	if (cs_init() != CS_SUCCESS) {
		if (cs_deinit() != CS_SUCCESS)
			cmn_err(CE_CONT, "pcmcia: _init cs_deinit error\n");
		return (-1);
	}

	mutex_init(&pcmcia_global_lock, NULL, MUTEX_DEFAULT, NULL);
	cv_init(&pcmcia_condvar, NULL, CV_DRIVER, NULL);
	mutex_init(&pcmcia_enum_lock, NULL, MUTEX_DEFAULT, NULL);

	if ((ret = mod_install(&modlinkage)) != 0) {
		mutex_destroy(&pcmcia_global_lock);
		cv_destroy(&pcmcia_condvar);
		mutex_destroy(&pcmcia_enum_lock);
	}
	return (ret);
}

int
_fini()
{
	int	ret;

	if ((ret = mod_remove(&modlinkage)) == 0) {
		mutex_destroy(&pcmcia_global_lock);
		cv_destroy(&pcmcia_condvar);
		mutex_destroy(&pcmcia_enum_lock);
		cis_deinit();
		if (cs_deinit() != CS_SUCCESS) {
			cmn_err(CE_CONT, "pcmcia: _fini cs_deinit error\n");
		}
	}
	return (ret);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

extern pri_t minclsyspri;

/*
 * pcmcia_attach()
 *	the attach routine must make sure that everything needed is present
 *	including real hardware.  The sequence of events is:
 *		attempt to load all adapter drivers
 *		attempt to load Card Services
 *		initialize logical sockets
 *		report the nexus exists
 */

int
pcmcia_attach(dev_info_t *dip, anp_t *adapter)
{
	int count, done, i;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT, "pcmcia_attach: dip=0x%p adapter=0x%p\n",
		    (void *)dip, (void *)adapter);
	}
#endif

	pcmcia_dip = dip;

	mutex_enter(&pcmcia_enum_lock);
	mutex_enter(&pcmcia_global_lock);
	if (pcmcia_num_adapters == 0) {
		pcmcia_cis_parser = (f_tt *)(uintptr_t)CISParser;
		cis_parser = (void *(*)(int, ...)) CISParser;
		pcmcia_cs_event = (f_tt *)cs_event;
		cs_socket_services = SocketServices;
		/* tell CS we are up with basic init level */
		(void) cs_event(PCE_SS_INIT_STATE, PCE_SS_STATE_INIT, 0);
	}

	(void) ddi_prop_update_string(DDI_DEV_T_NONE, dip,
	    PCM_DEVICETYPE, "pccard");

	ddi_report_dev(dip);	/* directory/device naming */

	/*
	 * now setup any power management stuff necessary.
	 * we do it here in order to ensure that all PC Card nexi
	 * implement it.
	 */

	if (pm_create_components(dip, 1) != DDI_SUCCESS) {
		cmn_err(CE_WARN, "%s: not power managed\n",
		    ddi_get_name_addr(dip));
	} else {
		pm_set_normal_power(dip, 0, 1);
	}

	/*
	 * setup the info necessary for Card Services/SocketServices
	 * and notify CS when ready.
	 */

	pcmcia_free_resources(dip);
	pcmcia_init_adapter(adapter, dip);
	/* exit mutex so CS can run for any cards found */
	mutex_exit(&pcmcia_global_lock);

	/*
	 * make sure the devices are identified before
	 * returning.  We do this by checking each socket to see if
	 * a card is present.  If there is one, and there isn't a dip,
	 * we can't be done.  We scan the list of sockets doing the
	 * check. if we aren't done, wait for a condition variable to
	 * wakeup.
	 * Because we can miss a wakeup and because things can
	 * take time, we do eventually give up and have a timeout.
	 */

	for (count = 0, done = 0;
	    done == 0 && count < max(pcmcia_num_sockets, 16);
	    count++) {
		done = 1;
		/* block CS while checking so we don't miss anything */
		mutex_enter(&pcmcia_global_lock);
		for (i = 0; i < pcmcia_num_sockets; i++) {
			get_ss_status_t status;
			if (pcmcia_sockets[i] == NULL)
				continue;
			bzero(&status, sizeof (status));
			status.socket = i;
			if (SSGetStatus(&status) == SUCCESS) {
				if (status.CardState & SBM_CD &&
				    pcmcia_sockets[i]->ls_dip[0] == NULL) {
					done = 0;
				}
			}
		}
		/* only wait if we aren't done with this set */
		if (!done) {
			mutex_exit(&pcmcia_global_lock);
			delay(10); /* give up CPU for a time */
			mutex_enter(&pcmcia_global_lock);
		}
		mutex_exit(&pcmcia_global_lock);
	}

	mutex_exit(&pcmcia_enum_lock);
	return (DDI_SUCCESS);
}

/*
 * pcmcia_detach
 *	unload everything and then detach the nexus
 */
/* ARGSUSED */
int
pcmcia_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	switch (cmd) {
	case DDI_DETACH:
		pm_destroy_components(dip);
		return (DDI_SUCCESS);

	/*
	 * resume from a checkpoint
	 * We don't do anything special here since the adapter
	 * driver will generate resume events that we intercept
	 * and convert to insert events.
	 */
	case DDI_SUSPEND:
	case DDI_PM_SUSPEND:
		return (DDI_SUCCESS);

	default:
		return (DDI_FAILURE);
	}
}

/*
 * card_services_error()
 *	used to make 2.4/2.5 drivers get an error when
 *	they try to initialize.
 */
static int
card_services_error()
{
	return (CS_BAD_VERSION);
}
static int (*cs_error_ptr)() = card_services_error;

/*
 * pcmcia_ctlops
 *	handle the nexus control operations for the cases where
 *	a PC Card driver gets called and we need to modify the
 *	devinfo structure or otherwise do bus specific operations
 */
int
pcmcia_ctlops(dev_info_t *dip, dev_info_t *rdip,
    ddi_ctl_enum_t ctlop, void *arg, void *result)
{
	int e;
	char name[64];
	struct pcmcia_parent_private *ppd;
	power_req_t *pm;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT, "pcmcia_ctlops(%p, %p, %d, %p, %p)\n",
		    (void *)dip, (void *)rdip, ctlop, (void *)arg,
		    (void *)result);
		if (rdip != NULL && ddi_get_name(rdip) != NULL)
			cmn_err(CE_CONT, "\t[%s]\n", ddi_get_name(rdip));
	}
#endif

	switch (ctlop) {
	case DDI_CTLOPS_REPORTDEV:
		if (rdip == (dev_info_t *)0)
			return (DDI_FAILURE);

		if (strcmp("pcs", ddi_node_name(rdip)) == 0)
			cmn_err(CE_CONT, "?PCCard socket %d at %s@%s\n",
			    ddi_get_instance(rdip),
			    ddi_driver_name(dip), ddi_get_name_addr(dip));
		else
			cmn_err(CE_CONT, "?%s%d at %s@%s in socket %d\n",
			    ddi_driver_name(rdip),
			    ddi_get_instance(rdip),
			    ddi_driver_name(dip),
			    ddi_get_name_addr(dip),
			    CS_GET_SOCKET_NUMBER(
			    ddi_getprop(DDI_DEV_T_NONE, rdip,
			    DDI_PROP_DONTPASS,
			    PCM_DEV_SOCKET, -1)));

		return (DDI_SUCCESS);

	case DDI_CTLOPS_INITCHILD:
		/*
		 * we get control here before the child is called.
		 * we can change things if necessary.  This is where
		 * the CardServices hook gets planted.
		 */
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug) {
			cmn_err(CE_CONT, "pcmcia: init child: %s(%d) @%p\n",
			    ddi_node_name(arg), ddi_get_instance(arg),
			    (void *)arg);
			if (DEVI(arg)->devi_binding_name != NULL)
				cmn_err(CE_CONT, "\tbinding_name=%s\n",
				    DEVI(arg)->devi_binding_name);
			if (DEVI(arg)->devi_node_name != NULL)
				cmn_err(CE_CONT, "\tnode_name=%s\n",
				    DEVI(arg)->devi_node_name);
		}
#endif

		ppd = (struct pcmcia_parent_private *)
		    ddi_get_parent_data((dev_info_t *)arg);
		if (ppd == NULL)
			return (DDI_FAILURE);

		if (strcmp("pcs", ddi_node_name((dev_info_t *)arg)) == 0) {
			if (ppd == NULL)
				return (DDI_FAILURE);
			(void) sprintf(name, "%x",
			    (int)ppd->ppd_reg[0].phys_hi);
			ddi_set_name_addr((dev_info_t *)arg, name);
			return (DDI_SUCCESS);
		}

		/*
		 * We don't want driver.conf files that stay in
		 * pseudo device form.	It is acceptable to have
		 * .conf files add properties only.
		 */
		if (ndi_dev_is_persistent_node((dev_info_t *)arg) == 0) {
			(void) pcmcia_merge_conf((dev_info_t *)arg);
			cmn_err(CE_WARN, "%s%d: %s.conf invalid",
			    ddi_get_name((dev_info_t *)arg),
			    ddi_get_instance((dev_info_t *)arg),
			    ddi_get_name((dev_info_t *)arg));
			return (DDI_FAILURE);
		}


#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug && ppd != NULL) {
			cmn_err(CE_CONT, "\tnreg=%x, intr=%x, socket=%x,"
			    " function=%x, active=%x, flags=%x\n",
			    ppd->ppd_nreg, ppd->ppd_intr,
			    ppd->ppd_socket, ppd->ppd_function,
			    ppd->ppd_active, ppd->ppd_flags);
		}
#endif

		/*
		 * make sure names are relative to socket number
		 */
		if (ppd->ppd_function > 0) {
			int sock;
			int func;
			sock = ppd->ppd_socket;
			func = ppd->ppd_function;
			(void) sprintf(name, "%x,%x", sock, func);
		} else {
			(void) sprintf(name, "%x", ppd->ppd_socket);
		}
		ddi_set_name_addr((dev_info_t *)arg, name);

#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT, "pcmcia: system init done for %s [%s] "
			    "nodeid: %x @%s\n",
			    ddi_get_name(arg), ddi_get_name_addr(arg),
			    DEVI(arg)->devi_nodeid, name);
		if (pcmcia_debug > 1)
			pcmcia_dump_minors((dev_info_t *)arg);
#endif

		return (DDI_SUCCESS);

	case DDI_CTLOPS_UNINITCHILD:

#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug) {
			cmn_err(CE_CONT, "pcmcia: uninit child: %s(%d) @%p\n",
			    ddi_node_name(arg), ddi_get_instance(arg),
			    (void *)arg);
			if (DEVI(arg)->devi_binding_name != NULL)
				cmn_err(CE_CONT, "\tbinding_name=%s\n",
				    DEVI(arg)->devi_binding_name);
			if (DEVI(arg)->devi_node_name != NULL)
				cmn_err(CE_CONT, "\tnode_name=%s\n",
				    DEVI(arg)->devi_node_name);
		}
#endif

		ddi_set_name_addr((dev_info_t *)arg, NULL);
		ddi_remove_minor_node((dev_info_t *)arg, NULL);
		return (DDI_SUCCESS);

	case DDI_CTLOPS_SLAVEONLY:
		/* PCMCIA devices can't ever be busmaster until CardBus */
		ppd = (struct pcmcia_parent_private *)
		    ddi_get_parent_data(rdip);
		if (ppd != NULL && ppd->ppd_flags & PPD_CB_BUSMASTER)
			return (DDI_FAILURE); /* at most */
		return (DDI_SUCCESS);

	case DDI_CTLOPS_SIDDEV:
		/* in general this is true. */
		return (DDI_SUCCESS);

	case DDI_CTLOPS_NREGS:
		ppd = (struct pcmcia_parent_private *)
		    ddi_get_parent_data(rdip);
		if (ppd != NULL)
			*((uint32_t *)result) = (ppd->ppd_nreg);
		else
			*((uint32_t *)result) = 0;
		return (DDI_SUCCESS);

	case DDI_CTLOPS_REGSIZE:
		ppd = (struct pcmcia_parent_private *)
		    ddi_get_parent_data(rdip);
		if (ppd != NULL && ppd->ppd_nreg > 0)
			*((off_t *)result) =  sizeof (struct pcm_regs);
		else
			*((off_t *)result) = 0;
		return (DDI_SUCCESS);

	case DDI_CTLOPS_POWER:
		ppd = (struct pcmcia_parent_private *)
		    ddi_get_parent_data(rdip);

		if (ppd == NULL)
			return (DDI_FAILURE);
		/*
		 * if this is not present, don't bother (claim success)
		 * since it is already in the right state.  Don't
		 * do any resume either since the card insertion will
		 * happen independently.
		 */
		if (!ppd->ppd_active)
			return (DDI_SUCCESS);
		for (e = 0; e < pcmcia_num_adapters; e++)
			if (pcmcia_adapters[e] ==
			    pcmcia_sockets[ppd->ppd_socket]->ls_adapter)
				break;
		if (e == pcmcia_num_adapters)
			return (DDI_FAILURE);
		pm = (power_req_t *)arg;
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug) {
			cmn_err(CE_WARN, "power: %d: %p, %d, %d [%s]\n",
			    pm->request_type,
			    (void *)pm->req.set_power_req.who,
			    pm->req.set_power_req.cmpt,
			    pm->req.set_power_req.level,
			    ddi_get_name_addr(rdip));
		}
#endif
		e = ppd->ppd_socket;
		switch (pm->request_type) {
		case PMR_SUSPEND:
			if (!(pcmcia_sockets[e]->ls_flags &
			    PCS_SUSPENDED)) {
				pcmcia_do_suspend(ppd->ppd_socket,
				    pcmcia_sockets[e]);
			}
			ppd->ppd_flags |= PPD_SUSPENDED;
			return (DDI_SUCCESS);
		case PMR_RESUME:
			/* for now, we just succeed since the rest is done */
			return (DDI_SUCCESS);
		case PMR_SET_POWER:
			/*
			 * not sure how to handle power control
			 * for now, we let the child handle it itself
			 */
			(void) pcmcia_power(pm->req.set_power_req.who,
			    pm->req.set_power_req.cmpt,
			    pm->req.set_power_req.level);
			break;
		default:
			break;
		}
		return (DDI_FAILURE);
		/* These CTLOPS will need to be implemented for new form */
		/* let CardServices know about this */
	case DDI_CTLOPS_DETACH:
		return (DDI_SUCCESS);
	case DDI_CTLOPS_ATTACH:
		return (DDI_SUCCESS);

	default:
		/* if we don't understand, pass up the tree */
		/* most things default to general ops */
		return (ddi_ctlops(dip, rdip, ctlop, arg, result));
	}
}

struct pcmcia_props {
	char *name;
	int   len;
	int   prop;
} pcmcia_internal_props[] = {
	{ PCM_DEV_ACTIVE, 0, PCMCIA_PROP_ACTIVE },
	{ PCM_DEV_R2TYPE, 0, PCMCIA_PROP_R2TYPE },
	{ PCM_DEV_CARDBUS, 0, PCMCIA_PROP_CARDBUS },
	{ CS_PROP, sizeof (void *), PCMCIA_PROP_OLDCS },
	{ "reg", 0, PCMCIA_PROP_REG },
	{ "interrupts", sizeof (int), PCMCIA_PROP_INTR },
	{ "pm-hardware-state", 0, PCMCIA_PROP_DEFAULT_PM },
};

/*
 * pcmcia_prop_decode(name)
 *	decode the name and determine if this is a property
 *	we construct on the fly, one we have on the prop list
 *	or one that requires calling the CIS code.
 */
static int
pcmcia_prop_decode(char *name)
{
	int i;
	if (strncmp(name, "cistpl_", 7) == 0)
		return (PCMCIA_PROP_CIS);

	for (i = 0; i < (sizeof (pcmcia_internal_props) /
	    sizeof (struct pcmcia_props)); i++) {
		if (strcmp(name, pcmcia_internal_props[i].name) == 0)
			return (i);
	}

	return (PCMCIA_PROP_UNKNOWN);
}

/*
 * pcmcia_prop_op()
 *	we don't have properties in PROM per se so look for them
 *	only in the devinfo node.  Future may allow us to find
 *	certain CIS tuples via this interface if a user asks for
 *	a property of the form "cistpl-<tuplename>" but not yet.
 *
 *	The addition of 1275 properties adds to the necessity.
 */
int
pcmcia_prop_op(dev_t dev, dev_info_t *dip, dev_info_t *ch_dip,
    ddi_prop_op_t prop_op, int mod_flags,
    char *name, caddr_t valuep, int *lengthp)
{
	int len, proplen, which, flags;
	caddr_t buff, propptr;
	struct pcmcia_parent_private *ppd;

	len = *lengthp;
	ppd = (struct pcmcia_parent_private *)ddi_get_parent_data(ch_dip);

	switch (which = pcmcia_prop_decode(name)) {
	default:
		if (ppd == NULL)
			return (DDI_PROP_NOT_FOUND);

		/* note that proplen may get modified */
		proplen = pcmcia_internal_props[which].len;
		switch (pcmcia_internal_props[which].prop) {
		case PCMCIA_PROP_DEFAULT_PM:
			propptr = pcmcia_default_pm_mode;
			proplen = strlen(propptr) + 1;
			break;
		case PCMCIA_PROP_OLDCS:
			propptr = (caddr_t)&cs_error_ptr;
			break;
		case PCMCIA_PROP_REG:
			propptr = (caddr_t)ppd->ppd_reg;
			proplen = ppd->ppd_nreg * sizeof (struct pcm_regs);
			break;
		case PCMCIA_PROP_INTR:
			propptr = (caddr_t)&ppd->ppd_intr;
			break;

		/* the next set are boolean values */
		case PCMCIA_PROP_ACTIVE:
			propptr = NULL;
			if (!ppd->ppd_active) {
				return (DDI_PROP_NOT_FOUND);
			}
			break;
		case PCMCIA_PROP_R2TYPE:
			propptr = NULL;
			if (ppd->ppd_flags & PPD_CARD_CARDBUS)
				return (DDI_PROP_NOT_FOUND);
			break;
		case PCMCIA_PROP_CARDBUS:
			propptr = NULL;
			if ((ppd->ppd_flags & PPD_CARD_CARDBUS) == 0)
				return (DDI_PROP_NOT_FOUND);
			break;
		}

		break;

	case PCMCIA_PROP_CIS:
		/*
		 * once we have the lookup code in place
		 * it is sufficient to break out of the switch
		 * once proplen and propptr are set.
		 * The common prop_op code deals with the rest.
		 */
	case PCMCIA_PROP_UNKNOWN:
		return (ddi_bus_prop_op(dev, dip, ch_dip, prop_op,
		    mod_flags | DDI_PROP_NOTPROM,
		    name, valuep, lengthp));
	}

	if (prop_op == PROP_LEN) {
		/* just the length */
		*lengthp = proplen;
		return (DDI_PROP_SUCCESS);
	}
	switch (prop_op) {
	case PROP_LEN_AND_VAL_ALLOC:
		if (mod_flags & DDI_PROP_CANSLEEP)
			flags = KM_SLEEP;
		else
			flags = KM_NOSLEEP;
		buff = kmem_alloc((size_t)proplen, flags);
		if (buff == NULL)
			return (DDI_PROP_NO_MEMORY);
		*(caddr_t *)valuep = (caddr_t)buff;
		break;
	case PROP_LEN_AND_VAL_BUF:
		buff = (caddr_t)valuep;
		if (len < proplen)
			return (DDI_PROP_BUF_TOO_SMALL);
		break;
	default:
		break;
	}

	if (proplen > 0)
		bcopy(propptr, buff, proplen);
	*lengthp = proplen;
	return (DDI_PROP_SUCCESS);
}


struct regspec *
pcmcia_rnum_to_regspec(dev_info_t *dip, int rnumber)
{
	struct pcmcia_parent_private *ppd;
	ppd = (struct pcmcia_parent_private *)ddi_get_parent_data(dip);
	if (ppd->ppd_nreg < rnumber)
		return (NULL);
	return ((struct regspec *)&ppd->ppd_reg[rnumber]);
}

struct regspec *
pcmcia_rnum_to_mapped(dev_info_t *dip, int rnumber)
{
	struct pcmcia_parent_private *ppd;
	ppd = (struct pcmcia_parent_private *)ddi_get_parent_data(dip);
	if (ppd->ppd_nreg < rnumber)
		return (NULL);
	if (ppd->ppd_assigned == NULL)
		return (NULL);
	if (ppd->ppd_assigned[rnumber].phys_len == 0)
		return (NULL);
	else
		return ((struct regspec *)&ppd->ppd_assigned[rnumber]);
}

int
pcmcia_find_rnum(dev_info_t *dip, struct regspec *reg)
{
	struct pcmcia_parent_private *ppd;
	struct regspec *regp;
	int i;

	ppd = (struct pcmcia_parent_private *)ddi_get_parent_data(dip);
	if (ppd == NULL)
		return (-1);
	for (regp = (struct regspec *)ppd->ppd_reg, i = 0;
	    i < ppd->ppd_nreg; i++, regp++) {
		if (bcmp(reg, regp, sizeof (struct regspec)) == 0)
			return (i);
	}
	for (regp = (struct regspec *)ppd->ppd_assigned, i = 0;
	    i < ppd->ppd_nreg; i++, regp++) {
		if (bcmp(reg, regp, sizeof (struct regspec)) == 0)
			return (i);
	}

	return (-1);
}

int
pcmcia_bus_map(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp,
    off_t offset, off_t len, caddr_t *vaddrp)
{
	struct pcm_regs *regs, *mregs = NULL, tmp_reg;
	ddi_map_req_t mr = *mp;
	ra_return_t ret;
	int check, rnum = -1;
	uint32_t base;
	uchar_t regbuf[sizeof (pci_regspec_t)];

	mp = &mr;		/* a copy of original request */

	/* check for register number */
	switch (mp->map_type) {
	case DDI_MT_REGSPEC:
		regs = (struct pcm_regs *)mp->map_obj.rp;
		mregs = (struct pcm_regs *)mp->map_obj.rp;
		/*
		 * when using regspec, must not be relocatable
		 * and should be from assigned space.
		 */
		if (!PC_REG_RELOC(regs->phys_hi))
			return (DDI_FAILURE);
		rnum = pcmcia_find_rnum(rdip, (struct regspec *)mregs);
		break;
	case DDI_MT_RNUMBER:
		regs = (struct pcm_regs *)
		    pcmcia_rnum_to_regspec(rdip, mp->map_obj.rnumber);
		mregs = (struct pcm_regs *)
		    pcmcia_rnum_to_mapped(rdip, mp->map_obj.rnumber);
		rnum = mp->map_obj.rnumber;
		if (regs == NULL)
			return (DDI_FAILURE);
		mp->map_type = DDI_MT_REGSPEC;
		mp->map_obj.rp = (struct regspec *)mregs;
		break;
	default:
		return (DDI_ME_INVAL);
	}

	/* basic sanity checks */
	switch (mp->map_op) {
	default:
		return (DDI_ME_UNIMPLEMENTED);
	case DDI_MO_UNMAP:
		if (mregs == NULL)
			return (DDI_FAILURE);
		regs = mregs;
		break;
	case DDI_MO_MAP_LOCKED:
	case DDI_MO_MAP_HANDLE:
		panic("unsupported bus operation");
		/*NOTREACHED*/
	}

	/*
	 * we need a private copy for manipulation and
	 * calculation of the correct ranges
	 */
	tmp_reg = *regs;
	mp->map_obj.rp = (struct regspec *)(regs = &tmp_reg);
	base = regs->phys_lo;
	if (base == 0 && offset != 0) {
		/*
		 * for now this is an error.  What does it really mean
		 * to ask for an offset from an address that hasn't
		 * been allocated yet.
		 */
		return (DDI_ME_INVAL);
	}
	regs->phys_lo += (uint32_t)offset;
	if (len != 0) {
		if (len > regs->phys_len) {
			return (DDI_ME_INVAL);
		}
		regs->phys_len = len;
	}

	/*
	 * basic sanity is checked so now make sure
	 * we can actually allocate something for this
	 * request and then convert to a "standard"
	 * regspec for the next layer up (pci/isa/rootnex/etc.)
	 */

	switch (PC_GET_REG_TYPE(regs->phys_hi)) {
	case PC_REG_SPACE_IO:
		check = PCA_RES_NEED_IO;
		break;
	case PC_REG_SPACE_MEMORY:
		check = PCA_RES_NEED_MEM;
		break;
	default:
		/* not a valid register type */
		return (DDI_FAILURE);
	}

	mr.map_type = DDI_MT_REGSPEC;
	ret.ra_addr_hi = 0;
	ret.ra_addr_lo = regs->phys_lo;
	ret.ra_len = regs->phys_len;
	mr.map_obj.rp = pcmcia_cons_regspec(dip,
	    (check == PCA_RES_NEED_IO) ?
	    PCMCIA_MAP_IO : PCMCIA_MAP_MEM,
	    regbuf, &ret);
	switch (mp->map_op) {
	case DDI_MO_UNMAP:
		pcmcia_set_assigned(rdip, rnum, NULL);
		break;
	default:
		break;
	}
	return (ddi_map(dip, &mr, (off_t)0, (off_t)0, vaddrp));
}

/*
 * pcmcia_cons_regspec()
 * based on parent's bus type, construct a regspec that is usable
 * by that parent to map the resource into the system.
 */
#define	PTYPE_PCI	1
#define	PTYPE_ISA	0
struct regspec *
pcmcia_cons_regspec(dev_info_t *dip, int type, uchar_t *buff, ra_return_t *ret)
{
	int ptype = -1, len, bus;
	char device_type[MODMAXNAMELEN];
	dev_info_t *pdip;
	struct regspec *defreg;
	pci_regspec_t *pcireg;

	pdip = ddi_get_parent(dip);
	if (pdip != ddi_root_node()) {
		/* we're not a child of root so find out what */
		len = sizeof (device_type);
		if (ddi_prop_op(DDI_DEV_T_ANY, pdip, PROP_LEN_AND_VAL_BUF, 0,
		    "device_type", (caddr_t)device_type, &len) ==
		    DDI_PROP_SUCCESS) {
			/* check things out */
			if (strcmp(device_type, "pci") == 0)
				ptype = PTYPE_PCI;
			else if (strcmp(device_type, "isa") == 0)
				ptype = PTYPE_ISA;
		}
	}
	switch (ptype) {
	case PTYPE_PCI:
		/* XXX need to look at carefully */
		if (ddi_getlongprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
		    "reg", (caddr_t)&pcireg, &len) == DDI_SUCCESS) {
			bus = PCI_REG_BUS_G(pcireg->pci_phys_hi);
			kmem_free(pcireg, len);
		} else {
			bus = 0;
		}
		pcireg = (pci_regspec_t *)buff;
		pcireg->pci_phys_hi = (type == PCMCIA_MAP_IO ? PCI_ADDR_IO :
		    PCI_ADDR_MEM32) | PCI_RELOCAT_B | (bus << 16);
		pcireg->pci_phys_mid = ret->ra_addr_hi;
		pcireg->pci_phys_low = ret->ra_addr_lo;
		if (type == PCMCIA_MAP_IO)
			pcireg->pci_phys_low &= 0xFFFF;
		pcireg->pci_size_hi = 0;
		pcireg->pci_size_low = ret->ra_len;
		break;
	default:
		/* default case is to use struct regspec */
		defreg = (struct regspec *)buff;
		defreg->regspec_bustype = type == PCMCIA_MAP_IO ? 1 : 0;
		defreg->regspec_addr = ret->ra_addr_lo;
		defreg->regspec_size = ret->ra_len;
		break;
	}
	return ((struct regspec *)buff);
}

/*
 * pcmcia_init_adapter
 *	Initialize the per-adapter structures and check to see if
 *	there are possible other instances coming.
 */
void
pcmcia_init_adapter(anp_t *adapter, dev_info_t *dip)
{
	int i, n;
	pcmcia_if_t *ls_if;

	i = pcmcia_num_adapters++;
	pcmcia_adapters[i] = kmem_zalloc(sizeof (struct pcmcia_adapter),
	    KM_SLEEP);
	pcmcia_adapters[i]->pca_dip = dip;
	/* should this be pca_winshift??? */
	pcmcia_adapters[i]->pca_module = ddi_driver_major(dip);
	pcmcia_adapters[i]->pca_unit = ddi_get_instance(dip);
	pcmcia_adapters[i]->pca_iblock = adapter->an_iblock;
	pcmcia_adapters[i]->pca_idev = adapter->an_idev;
	pcmcia_adapters[i]->pca_if = ls_if = adapter->an_if;
	pcmcia_adapters[i]->pca_number = i;
	(void) strcpy(pcmcia_adapters[i]->pca_name, ddi_get_name(dip));
	pcmcia_adapters[i]->
	    pca_name[sizeof (pcmcia_adapters[i]->pca_name) - 1] = '\0';

	if (ls_if != NULL) {
		inquire_adapter_t conf;
		int sock, win;

		if (ls_if->pcif_inquire_adapter != NULL)
			GET_CONFIG(ls_if, dip, &conf);

		/* resources - assume worst case and fix from there */
		pcmcia_adapters[i]->pca_flags = PCA_RES_NEED_IRQ |
		    PCA_RES_NEED_IO | PCA_RES_NEED_MEM;
		/* indicate first socket not initialized */
		pcmcia_adapters[i]->pca_first_socket = -1;

		if (conf.ResourceFlags & RES_OWN_IRQ)
			pcmcia_adapters[i]->pca_flags &= ~PCA_RES_NEED_IRQ;
		if (conf.ResourceFlags & RES_OWN_IO)
			pcmcia_adapters[i]->pca_flags &= ~PCA_RES_NEED_IO;
		if (conf.ResourceFlags & RES_OWN_MEM)
			pcmcia_adapters[i]->pca_flags &= ~PCA_RES_NEED_MEM;
		if (conf.ResourceFlags & RES_IRQ_SHAREABLE)
			pcmcia_adapters[i]->pca_flags |= PCA_IRQ_SHAREABLE;
		if (conf.ResourceFlags & RES_IRQ_NEXUS)
			pcmcia_adapters[i]->pca_flags |= PCA_IRQ_SMI_SHARE;

		/* need to know interrupt limitations */
		if (conf.ActiveLow) {
			pcmcia_adapters[i]->pca_avail_intr = conf.ActiveLow;
			pcmcia_adapters[i]->pca_flags |= PCA_IRQ_ISA;
		} else
			pcmcia_adapters[i]->pca_avail_intr = conf.ActiveHigh;

		/* power entries for adapter */
		pcmcia_adapters[i]->pca_power = conf.power_entry;
		pcmcia_adapters[i]->pca_numpower = conf.NumPower;

		for (n = 0; n < conf.NumPower; n++)
			pcmcia_merge_power(&conf.power_entry[n]);

		/* now setup the per socket info */
		for (sock = 0; sock < conf.NumSockets;
		    sock++) {
			dev_info_t *sockdrv = NULL;
			sockdrv = pcmcia_number_socket(dip, sock);
			if (sockdrv == NULL)
				n = sock + pcmcia_num_sockets;
			else {
				n = ddi_get_instance(sockdrv);
			}
			/* make sure we know first socket on adapter */
			if (pcmcia_adapters[i]->pca_first_socket == -1)
				pcmcia_adapters[i]->pca_first_socket = n;

			/*
			 * the number of sockets is weird.
			 * we might have only two sockets but
			 * due to persistence of instances we
			 * will need to call them something other
			 * than 0 and 1.  So, we use the largest
			 * instance number as the number and
			 * have some that just don't get used.
			 */
			if (n >= pcmcia_num_sockets)
				pcmcia_num_sockets = n + 1;
#if defined(PCMCIA_DEBUG)
			if (pcmcia_debug) {
				cmn_err(CE_CONT,
				    "pcmcia_init: new socket added %d "
				    "(%d)\n",
				    n, pcmcia_num_sockets);
			}
#endif

			pcmcia_sockets[n] =
			    kmem_zalloc(sizeof (pcmcia_logical_socket_t),
			    KM_SLEEP);
			pcmcia_sockets[n]->ls_socket = sock;
			pcmcia_sockets[n]->ls_if = ls_if;
			pcmcia_sockets[n]->ls_adapter =
			    pcmcia_adapters[i];
			pcmcia_sockets[n]->ls_cs_events = 0L;
			pcmcia_sockets[n]->ls_sockdrv = sockdrv;
			/* Prototype of intrspec */
			pcmcia_sockets[n]->ls_intr_pri = adapter->an_ipl;
#if defined(PCMCIA_DEBUG)
			if (pcmcia_debug)
				cmn_err(CE_CONT,
				    "phys sock %d, log sock %d\n",
				    sock, n);
#endif
			mutex_init(&pcmcia_sockets[n]->ls_ilock, NULL,
			    MUTEX_DRIVER, *adapter->an_iblock);
		}

		pcmcia_adapters[i]->pca_numsockets = conf.NumSockets;
		/* now setup the per window information */
		for (win = 0; win < conf.NumWindows; win++) {
			n = win + pcmcia_num_windows;
			pcmcia_windows[n] =
			    kmem_zalloc(sizeof (pcmcia_logical_window_t),
			    KM_SLEEP);
			pcmcia_windows[n]->lw_window = win;
			pcmcia_windows[n]->lw_if = ls_if;
			pcmcia_windows[n]->lw_adapter =
			    pcmcia_adapters[i];
		}
		pcmcia_num_windows += conf.NumWindows;
		SET_CALLBACK(ls_if, dip,
		    pcm_adapter_callback, i);

		/* now tell CS about each socket */
		for (sock = 0; sock < pcmcia_num_sockets; sock++) {
#if defined(PCMCIA_DEBUG)
			if (pcmcia_debug) {
				cmn_err(CE_CONT,
				    "pcmcia_init: notify CS socket %d "
				    "sockp=%p\n",
				    sock, (void *)pcmcia_sockets[sock]);
			}
#endif
			if (pcmcia_sockets[sock] == NULL ||
			    (pcmcia_sockets[sock]->ls_flags &
			    PCS_SOCKET_ADDED)) {
				/* skip the ones that are done already */
				continue;
			}
			pcmcia_sockets[sock]->ls_flags |= PCS_SOCKET_ADDED;
			if (cs_event(PCE_ADD_SOCKET, sock, 0) !=
			    CS_SUCCESS) {
				/* flag socket as broken */
				pcmcia_sockets[sock]->ls_flags = 0;
			} else {
				pcm_event_manager(PCE_ADD_SOCKET,
				    sock, NULL);
			}
		}

	}
#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT, "logical sockets:\n");
		for (i = 0; i < pcmcia_num_sockets; i++) {
			if (pcmcia_sockets[i] == NULL)
				continue;
			cmn_err(CE_CONT,
			    "\t%d: phys sock=%d, if=%p, adapt=%p\n",
			    i, pcmcia_sockets[i]->ls_socket,
			    (void *)pcmcia_sockets[i]->ls_if,
			    (void *)pcmcia_sockets[i]->ls_adapter);
		}
		cmn_err(CE_CONT, "logical windows:\n");
		for (i = 0; i < pcmcia_num_windows; i++) {
			cmn_err(CE_CONT,
			    "\t%d: phys_window=%d, if=%p, adapt=%p\n",
			    i, pcmcia_windows[i]->lw_window,
			    (void *)pcmcia_windows[i]->lw_if,
			    (void *)pcmcia_windows[i]->lw_adapter);
		}
		cmn_err(CE_CONT, "\tpcmcia_num_power=%d\n", pcmcia_num_power);
		for (n = 0; n < pcmcia_num_power; n++)
			cmn_err(CE_CONT,
			    "\t\tPowerLevel: %d\tValidSignals: %x\n",
			    pcmcia_power_table[n].PowerLevel,
			    pcmcia_power_table[n].ValidSignals);
	}
#endif
}

/*
 * pcmcia_find_cards()
 *	check the adapter to see if there are cards present at
 *	driver attach time.  If there are, generate an artificial
 *	card insertion event to get CS running and the PC Card ultimately
 *	identified.
 */
void
pcmcia_find_cards(anp_t *adapt)
{
	int i;
	get_ss_status_t status;
	for (i = 0; i < pcmcia_num_sockets; i++) {
		if (pcmcia_sockets[i] &&
		    pcmcia_sockets[i]->ls_if == adapt->an_if) {
			/* check the status */
			status.socket = i;
			if (SSGetStatus(&status) == SUCCESS &&
			    status.IFType != IF_CARDBUS &&
			    status.CardState & SBM_CD &&
			    pcmcia_sockets[i]->ls_dip[0] == NULL) {
				(void) cs_event(PCE_CARD_INSERT, i, 0);
				delay(1);
			}
		}
	}
}

/*
 * pcmcia_number_socket(dip, adapt)
 *	we determine socket number by creating a driver for each
 *	socket on the adapter and then forcing it to attach.  This
 *	results in an instance being assigned which becomes the
 *	logical socket number.	If it fails, then we are the first
 *	set of sockets and renumbering occurs later.  We do this
 *	one socket at a time and return the dev_info_t so the
 *	instance number can be used.
 */
dev_info_t *
pcmcia_number_socket(dev_info_t *dip, int localsocket)
{
	dev_info_t *child = NULL;
	struct pcmcia_parent_private *ppd;

	if (ndi_devi_alloc(dip, "pcs", (pnode_t)DEVI_SID_NODEID,
	    &child) == NDI_SUCCESS) {
		ppd = kmem_zalloc(sizeof (struct pcmcia_parent_private),
		    KM_SLEEP);
		ppd->ppd_reg = kmem_zalloc(sizeof (struct pcm_regs), KM_SLEEP);
		ppd->ppd_nreg = 1;
		ppd->ppd_reg[0].phys_hi = localsocket;
		ddi_set_parent_data(child, (caddr_t)ppd);
		if (ndi_devi_online(child, 0) != NDI_SUCCESS) {
			kmem_free(ppd->ppd_reg, sizeof (struct pcm_regs));
			kmem_free(ppd, sizeof (struct pcmcia_parent_private));
			(void) ndi_devi_free(child);
			child = NULL;
		}
	}
	return (child);
}

/*
 * pcm_phys_to_log_socket()
 *	from an adapter and socket number return the logical socket
 */
int
pcm_phys_to_log_socket(struct pcmcia_adapter *adapt, int socket)
{
	register pcmcia_logical_socket_t *sockp;
	int i;

	for (i = 0, sockp = pcmcia_sockets[0];
	    i < pcmcia_num_sockets; i++, sockp = pcmcia_sockets[i]) {
		if (sockp == NULL)
			continue;
		if (sockp->ls_socket == socket && sockp->ls_adapter == adapt)
			break;
	}
	if (i >= pcmcia_num_sockets) {
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT,
			    "\tbad socket/adapter: %x/%p != %x/%x\n",
			    socket, (void *)adapt, pcmcia_num_sockets,
			    pcmcia_num_adapters);
#endif
		return (-1);
	}

	return (i);		/* want logical socket */
}

/*
 * pcm_adapter_callback()
 *	this function is called back by the adapter driver at interrupt time.
 *	It is here that events should get generated for the event manager if it
 *	is present.  It would also be the time where a device information
 *	tree could be constructed for a card that was added in if we
 *	choose to create them dynamically.
 */

#if defined(PCMCIA_DEBUG)
char *cblist[] = {
	"removal",
	"insert",
	"ready",
	"battery-warn",
	"battery-dead",
	"status-change",
	"write-protect", "reset", "unlock", "client-info", "eject-complete",
	"eject-request", "erase-complete", "exclusive-complete",
	"exclusive-request", "insert-complete", "insert-request",
	"reset-complete", "reset-request", "timer-expired",
	"resume", "suspend"
};
#endif

/*ARGSUSED*/
static int
pcm_adapter_callback(dev_info_t *dip, int adapter, int event, int socket)
{
	pcmcia_logical_socket_t *sockp;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT, "pcm_adapter_callback: %p %x %x %x: ",
		    (void *)dip, adapter, event, socket);
		cmn_err(CE_CONT, "[%s]\n", cblist[event]);
	}
#endif

	if (adapter >= pcmcia_num_adapters || adapter < 0) {
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT, "\tbad adapter number: %d : %d\n",
			    adapter, pcmcia_num_adapters);
#endif
		return (1);
	}

	/* get the logical socket since that is what CS knows */
	socket = pcm_phys_to_log_socket(pcmcia_adapters[adapter], socket);
	if (socket == -1) {
		cmn_err(CE_WARN, "pcmcia callback - bad logical socket\n");
		return (0);
	}
	sockp = pcmcia_sockets[socket];
	switch (event) {
	case -1:		/* special case of adapter going away */
	case PCE_CARD_INSERT:
		sockp->ls_cs_events |= PCE_E2M(PCE_CARD_INSERT) |
		    PCE_E2M(PCE_CARD_REMOVAL);
		break;
	case PCE_CARD_REMOVAL:
				/* disable interrupts at this point */
		sockp->ls_cs_events |= PCE_E2M(PCE_CARD_INSERT) |
		    PCE_E2M(PCE_CARD_REMOVAL);
		/* remove children that never attached */

		break;
	case PCE_PM_RESUME:
		pcmcia_do_resume(socket, sockp);
		/* event = PCE_CARD_INSERT; */
		break;
	case PCE_PM_SUSPEND:
		pcmcia_do_suspend(socket, sockp);
		/* event = PCE_CARD_REMOVAL; */
		break;
	default:
		/* nothing to do */
		break;
	}

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT,
		    "\tevent %d, event mask=%x, match=%x (log socket=%d)\n",
		    event,
		    (int)sockp->ls_cs_events,
		    (int)(sockp->ls_cs_events & PCE_E2M(event)), socket);
	}
#endif

	if (pcmcia_cs_event && sockp->ls_cs_events & (1 << event)) {
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT, "\tcalling CS event handler (%p) "
			    "with event=%d\n",
			    (void *)pcmcia_cs_event, event);
#endif
		CS_EVENT(event, socket, 0);
	}

	/* let the event manager(s) know about the event */
	pcm_event_manager(event, socket, NULL);

	return (0);
}

/*
 * pcm_event_manager()
 *	checks for registered management driver callback handlers
 *	if there are any, call them if the event warrants it
 */
void
pcm_event_manager(int event, int socket, void *arg)
{
	struct pcmcia_mif *mif;

	for (mif = pcmcia_mif_handlers; mif != NULL; mif = mif->mif_next) {
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT,
			    "pcm_event_manager: event=%d, mif_events=%x"
			    " (tst:%d)\n",
			    event, (int)*(uint32_t *)mif->mif_events,
			    PR_GET(mif->mif_events, event));
#endif
		if (PR_GET(mif->mif_events, event)) {
			mif->mif_function(mif->mif_id, event, socket, arg);
		}
	}

}

/*
 * pcm_search_devinfo(dev_info_t *, pcm_device_info *, int)
 * search for an immediate child node to the nexus and not siblings of nexus
 * and not grandchildren.  We follow the same sequence that name binding
 * follows so we match same class of device (modem == modem) and don't
 * have to depend on features that might not exist.
 */
dev_info_t *
pcm_search_devinfo(dev_info_t *self, struct pcm_device_info *info, int socket)
{
	char bf[256];
	struct pcmcia_parent_private *ppd;
	dev_info_t *dip;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug)
		cmn_err(CE_CONT,
		    "pcm_search_devinfo: socket=%x [%s|%s|%s] pd_flags=%x\n",
		    socket, info->pd_bind_name, info->pd_generic_name,
		    info->pd_vers1_name, info->pd_flags);
#endif

	ndi_devi_enter(self);
	/* do searches in compatible property order */
	for (dip = (dev_info_t *)DEVI(self)->devi_child;
	    dip != NULL;
	    dip = (dev_info_t *)DEVI(dip)->devi_sibling) {
		int ppd_socket;
		ppd = (struct pcmcia_parent_private *)
		    ddi_get_parent_data(dip);
		if (ppd == NULL) {
#if defined(PCMCIA_DEBUG)
			cmn_err(CE_WARN, "No parent private data\n");
#endif
			continue;
		}
		ppd_socket = CS_MAKE_SOCKET_NUMBER(ppd->ppd_socket,
		    ppd->ppd_function);
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug) {
			cmn_err(CE_CONT, "\tbind=[%s], node=[%s]\n",
			    DEVI(dip)->devi_binding_name,
			    DEVI(dip)->devi_node_name);
		}
#endif
		if (info->pd_flags & PCM_NAME_VERS1) {
			(void) strcpy(bf, info->pd_vers1_name);
			pcmcia_fix_string(bf);
			if (DEVI(dip)->devi_binding_name &&
			    strcmp(DEVI(dip)->devi_binding_name, bf) == 0 &&
			    socket == ppd_socket)
				break;
		}
		if ((info->pd_flags & (PCM_NAME_1275 | PCM_MULTI_FUNCTION)) ==
		    (PCM_NAME_1275 | PCM_MULTI_FUNCTION)) {
			(void) sprintf(bf, "%s,%x", info->pd_bind_name,
			    info->pd_function);
			if (strcmp(bf, DEVI(dip)->devi_binding_name) == 0 &&
			    socket == ppd->ppd_socket)
				break;
		}
		if (info->pd_flags & PCM_NAME_1275) {
			if (DEVI(dip)->devi_binding_name &&
			    strcmp(DEVI(dip)->devi_binding_name,
			    info->pd_bind_name) == 0 &&
			    socket == ppd_socket)
				break;
		}
		if (info->pd_flags & PCM_NAME_GENERIC) {
			(void) sprintf(bf, "%s,%s", PCMDEV_NAMEPREF,
			    info->pd_generic_name);
			if (DEVI(dip)->devi_binding_name &&
			    strcmp(DEVI(dip)->devi_binding_name, bf) == 0 &&
			    socket == ppd_socket)
				break;
		}
		if (info->pd_flags & PCM_NAME_GENERIC) {
			if (DEVI(dip)->devi_binding_name &&
			    strcmp(DEVI(dip)->devi_binding_name,
			    info->pd_generic_name) == 0 &&
			    socket == ppd_socket)
				break;
		}
		if (info->pd_flags & PCM_NO_CONFIG) {
			if (DEVI(dip)->devi_binding_name &&
			    strcmp(DEVI(dip)->devi_binding_name,
			    "pccard,memory") == 0 &&
			    socket == ppd_socket)
				break;
		}
	}
	ndi_devi_exit(self);
	return (dip);
}

/*
 * pcm_find_devinfo()
 *	this is a wrapper around DDI calls to "find" any
 *	devinfo node and then from there find the one associated
 *	with the socket
 */
dev_info_t *
pcm_find_devinfo(dev_info_t *pdip, struct pcm_device_info *info, int socket)
{
	dev_info_t *dip;

	dip = pcm_search_devinfo(pdip, info, socket);
	if (dip == NULL)
		return (NULL);
	/*
	 * we have at least a base level dip
	 * see if there is one (this or a sibling)
	 * that has the correct socket number
	 * if there is, return that one else
	 * NULL so a new one is created
	 */
#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug)
		cmn_err(CE_CONT, "find: initial dip = %p, socket=%d, name=%s "
		    "(instance=%d, socket=%d, name=%s)\n",
		    (void *)dip, socket, info->pd_bind_name,
		    ddi_get_instance(dip),
		    ddi_getprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
		    PCM_DEV_SOCKET, -1),
		    ddi_get_name(dip));
#endif

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug && dip != NULL)
		cmn_err(CE_CONT, "\treturning non-NULL dip (%s)\n",
		    ddi_get_name(dip));
#endif
	return (dip);
}

/*
 * pcm_find_parent_dip(socket)
 *	find the correct parent dip for this logical socket
 */
dev_info_t *
pcm_find_parent_dip(int socket)
{
	if ((socket < 0 || socket >= pcmcia_num_sockets) ||
	    pcmcia_sockets[socket] == NULL)
		return (NULL);
	return (pcmcia_sockets[socket]->ls_adapter->pca_dip);
}

/*
 * pcmcia_set_em_handler()
 *	This is called by the management and event driver to tell
 *	the nexus what to call.	 Multiple drivers are allowed
 *	but normally only one will exist.
 */
int
pcmcia_set_em_handler(int (*handler)(), caddr_t events, int elen,
    uint32_t id, void **cs, void **ss)
{
	struct pcmcia_mif *mif, *tmp;

	if (handler == NULL) {
		/* NULL means remove the handler based on the ID */
		if (pcmcia_mif_handlers == NULL)
			return (0);
		mutex_enter(&pcmcia_global_lock);
		if (pcmcia_mif_handlers->mif_id == id) {
			mif = pcmcia_mif_handlers;
			pcmcia_mif_handlers = mif->mif_next;
			kmem_free(mif, sizeof (struct pcmcia_mif));
		} else {
			for (mif = pcmcia_mif_handlers;
			    mif->mif_next != NULL &&
			    mif->mif_next->mif_id != id;
			    mif = mif->mif_next)
				;
			if (mif->mif_next != NULL &&
			    mif->mif_next->mif_id == id) {
				tmp = mif->mif_next;
				mif->mif_next = tmp->mif_next;
				kmem_free(tmp, sizeof (struct pcmcia_mif));
			}
		}
		mutex_exit(&pcmcia_global_lock);
	} else {

		if (pcmcia_num_adapters == 0) {
			return (ENXIO);
		}
		if (elen > EM_EVENTSIZE)
			return (EINVAL);

		mif = (struct pcmcia_mif *)
		    kmem_zalloc(sizeof (struct pcmcia_mif), KM_NOSLEEP);
		if (mif == NULL)
			return (ENOSPC);

		mif->mif_function = (void (*)())(uintptr_t)handler;
		bcopy(events, mif->mif_events, elen);
		mif->mif_id = id;
		mutex_enter(&pcmcia_global_lock);
		mif->mif_next = pcmcia_mif_handlers;
		pcmcia_mif_handlers = mif;
		if (cs != NULL)
			*cs = (void *)pcmcia_card_services;
		if (ss != NULL) {
			*ss = (void *)SocketServices;
		}

		mutex_exit(&pcmcia_global_lock);
	}
	return (0);
}

/*
 * pcm_fix_bits(uchar_t *data, int num, int dir)
 *	shift socket bits left(0) or right(0)
 *	This is used when mapping logical and physical
 */
void
pcm_fix_bits(socket_enum_t src, socket_enum_t dst, int num, int dir)
{
	int i;

	PR_ZERO(dst);

	if (dir == 0) {
				/* LEFT */
		for (i = 0; i <= PCMCIA_MAX_SOCKETS - num; i++) {
			if (PR_GET(src, i))
				PR_SET(dst, i + num);
		}
	} else {
				/* RIGHT */
		for (i = num; i < PCMCIA_MAX_SOCKETS; i++) {
			if (PR_GET(src, i))
				PR_SET(dst, i - num);
		}
	}
}

uint32_t
genmask(int len)
{
	uint32_t mask;
	for (mask = 0; len > 0; len--) {
		mask |= 1 << (len - 1);
	}
	return (mask);
}

int
genp2(int val)
{
	int i;
	if (val == 0)
		return (0);
	for (i = 0; i < 32; i++)
		if (val > (1 << i))
			return (i);
	return (0);
}

#if defined(PCMCIA_DEBUG)
char *ssfuncs[128] = {
	"GetAdapter", "GetPage", "GetSocket", "GetStatus", "GetWindow",
	"InquireAdapter", "InquireSocket", "InquireWindow", "ResetSocket",
	"SetPage", "SetAdapter", "SetSocket", "SetWindow", "SetIRQHandler",
	"ClearIRQHandler",
	/* 15 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	/* 25 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	/* 35 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	/* 45 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	/* 55 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	/* 65 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	/* 75 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	/* 85 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	/* 95 */ NULL, NULL, NULL,
	"CSIsActiveDip",
	"CSInitDev", "CSRegister", "CSCISInit", "CSUnregister",
	"CISGetAddress", "CISSetAddress", "CSCardRemoved", "CSGetCookiesAndDip"
};
#endif

/*
 * SocketServices
 *	general entrypoint for Card Services to find
 *	Socket Services.  Finding the entry requires
 *	a _depends_on[] relationship.
 *
 *	In some cases, the work is done locally but usually
 *	the parameters are adjusted and the adapter driver
 *	code asked to do the work.
 */
int
SocketServices(int function, ...)
{
	va_list arglist;
	uint32_t args[16];
	csregister_t *reg;
	sservice_t *serv;
	dev_info_t *dip;
	int socket, func;
	int error = SUCCESS;
	pcmcia_logical_socket_t *sockp;

	va_start(arglist, function);

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug > 1)
		cmn_err(CE_CONT, "SocketServices called for function %d [%s]\n",
		    function,
		    ((function < 128) && ssfuncs[function] != NULL) ?
		    ssfuncs[function] : "UNKNOWN");
#endif
	switch (function) {
	case CSRegister:
	case CISGetAddress:
	case CISSetAddress:

		reg = va_arg(arglist, csregister_t *);

		if (reg->cs_magic != PCCS_MAGIC ||
		    reg->cs_version != PCCS_VERSION) {
			cmn_err(CE_WARN,
			    "pcmcia: CSRegister (%x, %x, %p, %p) *ERROR*",
			    reg->cs_magic, reg->cs_version,
			    (void *)reg->cs_card_services,
			    (void *)reg->cs_event);
			error = BAD_FUNCTION;
			break;
		}

		switch (function) {
		case CISGetAddress:
			reg->cs_event = pcmcia_cis_parser;
			break;
		case CISSetAddress:
			pcmcia_cis_parser = reg->cs_event;
			break;
		case CSRegister:
			break;
		}
		break;

	case CSUnregister:
		break;

	case CSCISInit:
		args[0] = va_arg(arglist, int);
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT,
			    "CSCISInit: CIS is initialized on socket %d\n",
			    (int)args[0]);
#endif
		/*
		 * now that the CIS has been parsed (there may not
		 * be one but the work is done) we can create the
		 * device information structures.
		 *
		 * we serialize the node creation to avoid problems
		 * with initial probe/attach of nexi.
		 */

		mutex_enter(&pcmcia_global_lock);
		pcmcia_create_dev_info(args[0]);
		cv_broadcast(&pcmcia_condvar); /* wakeup the nexus attach */
		mutex_exit(&pcmcia_global_lock);
		break;

	case CSInitDev:
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT, "CSInitDev: initialize device\n");
#endif
		/*
		 * this is where we create the /devices entries
		 * that let us out into the world
		 */

		(void) pcmcia_create_device(va_arg(arglist,
		    ss_make_device_node_t *));
		break;

	case CSCardRemoved:
		args[0] = va_arg(arglist, uint32_t);
		socket = CS_GET_SOCKET_NUMBER(args[0]);
		func = CS_GET_FUNCTION_NUMBER(args[0]);
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT,
			    "CSCardRemoved! (socket=%d)\n", (int)args[0]);
#endif
		if (socket >= pcmcia_num_sockets)
			break;

		sockp = pcmcia_sockets[socket];
		if (sockp == NULL) {
			cmn_err(CE_WARN,
			    "pcmcia: bad socket = %x", socket);
			break;
		}

		if (!(sockp->ls_flags & PCS_SUSPENDED)) {
			for (func = 0; func < sockp->ls_functions; func++) {
				/*
				 * break the association of dip and socket
				 * for all functions on that socket
				 */
				dip = sockp->ls_dip[func];
				sockp->ls_dip[func] = NULL;
				if (dip != NULL) {
					struct pcmcia_parent_private *ppd;
					ppd = (struct pcmcia_parent_private *)
					    ddi_get_parent_data(dip);
					ppd->ppd_active = 0;
					(void) ndi_devi_offline(dip,
					    NDI_DEVI_REMOVE);

					pcmcia_ppd_free(ppd);
				}
#if defined(PCMCIA_DEBUG)
				else {
					if (pcmcia_debug)
						cmn_err(CE_CONT,
						    "CardRemoved: no "
						    "dip present "
						    "on socket %d!\n",
						    (int)args[0]);
				}
#endif
			}
		} else {
			mutex_enter(&pcmcia_global_lock);
			sockp->ls_flags &= ~PCS_SUSPENDED;
			cv_broadcast(&pcmcia_condvar);
			mutex_exit(&pcmcia_global_lock);
		}
		break;

	case CSGetCookiesAndDip:
		serv = va_arg(arglist, sservice_t *);
		if (serv != NULL)
			error = GetCookiesAndDip(serv);
		else
			error = BAD_SOCKET;
		break;

	case CSGetActiveDip:
		/*
		 * get the dip associated with the card currently
		 * in the specified socket
		 */
		args[0] = va_arg(arglist, uint32_t);
		socket = CS_GET_SOCKET_NUMBER(args[0]);
		func = CS_GET_FUNCTION_NUMBER(args[0]);
		error = (long)pcmcia_sockets[socket]->ls_dip[func];
		break;

		/*
		 * the remaining entries are SocketServices calls
		 */
	case SS_GetAdapter:
		error = SSGetAdapter(va_arg(arglist, get_adapter_t *));
		break;
	case SS_GetPage:
		error = SSGetPage(va_arg(arglist, get_page_t *));
		break;
	case SS_GetSocket:
		error = SSGetSocket(va_arg(arglist, get_socket_t *));
		break;
	case SS_GetStatus:
		error = SSGetStatus(va_arg(arglist, get_ss_status_t *));
		break;
	case SS_GetWindow:
		error = SSGetWindow(va_arg(arglist, get_window_t *));
		break;
	case SS_InquireAdapter:
		error = SSInquireAdapter(va_arg(arglist, inquire_adapter_t *));
		break;
	case SS_InquireSocket:
		error = SSInquireSocket(va_arg(arglist, inquire_socket_t *));
		break;
	case SS_InquireWindow:
		error = SSInquireWindow(va_arg(arglist, inquire_window_t *));
		break;
	case SS_ResetSocket:
		args[0] = va_arg(arglist, uint32_t);
		args[1] = va_arg(arglist, int);
		error = SSResetSocket(args[0], args[1]);
		break;
	case SS_SetPage:
		error = SSSetPage(va_arg(arglist, set_page_t *));
		break;
	case SS_SetSocket:
		error = SSSetSocket(va_arg(arglist, set_socket_t *));
		break;
	case SS_SetWindow:
		error = SSSetWindow(va_arg(arglist, set_window_t *));
		break;
	case SS_SetIRQHandler:
		error = SSSetIRQHandler(va_arg(arglist, set_irq_handler_t *));
		break;
	case SS_ClearIRQHandler:
		error = SSClearIRQHandler(va_arg(arglist,
		    clear_irq_handler_t *));
		break;
	default:
		error = BAD_FUNCTION;
		break;
	}
	va_end(arglist);
	return (error);
}

/*
 * pcmcia_merge_power()
 *	The adapters may have different power tables so it
 *	is necessary to construct a single power table that
 *	can be used throughout the system.  The result is
 *	a merger of all capabilities.  The nexus adds
 *	power table entries one at a time.
 */
void
pcmcia_merge_power(struct power_entry *power)
{
	int i;
	struct power_entry pwr;

	pwr = *power;

	for (i = 0; i < pcmcia_num_power; i++) {
		if (pwr.PowerLevel == pcmcia_power_table[i].PowerLevel) {
			if (pwr.ValidSignals ==
			    pcmcia_power_table[i].ValidSignals) {
				return;
			} else {
				/* partial match */
				pwr.ValidSignals &=
				    ~pcmcia_power_table[i].ValidSignals;
			}
		}
	}
	/* what's left becomes a new entry */
	if (pcmcia_num_power == PCMCIA_MAX_POWER)
		return;
	pcmcia_power_table[pcmcia_num_power++] = pwr;
}

/*
 * pcmcia_do_suspend()
 *	tell CS that a suspend has happened by passing a
 *	card removal event.  Then cleanup the socket state
 *	to fake the cards being removed so resume works
 */
void
pcmcia_do_suspend(int socket, pcmcia_logical_socket_t *sockp)
{
	get_ss_status_t stat;
	struct pcmcia_adapter *adapt;
	pcmcia_if_t *ls_if;
	dev_info_t *dip;
	int i;

#ifdef	XXX
	if (pcmcia_cs_event == NULL) {
		return;
	}
#endif

	ls_if = sockp->ls_if;
	adapt = sockp->ls_adapter;

	if (ls_if == NULL || ls_if->pcif_get_status == NULL) {
		return;
	}

	stat.socket = socket;
#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT,
		    "pcmcia_do_suspend(%d, %p)\n", socket, (void *)sockp);
	}
#endif

	if (GET_STATUS(ls_if, adapt->pca_dip, &stat) != SUCCESS)
		return;

	/*
	 * If there is a card in the socket, then we need to send
	 *	everyone a PCE_CARD_REMOVAL event, and remove the
	 *	card active property.
	 */

	for (i = 0; i < sockp->ls_functions; i++) {
		struct pcmcia_parent_private *ppd;
		dip = sockp->ls_dip[i];
		if (dip != NULL) {
			ppd = (struct pcmcia_parent_private *)
			    ddi_get_parent_data(dip);
			ppd->ppd_flags |= PPD_SUSPENDED;
		}
#if 0
		sockp->ls_dip[i] = NULL;
#endif
	}
	sockp->ls_flags |= PCS_SUSPENDED;

	if (pcmcia_cs_event &&
	    (sockp->ls_cs_events & (1 << PCE_PM_SUSPEND))) {
		CS_EVENT(PCE_PM_SUSPEND, socket, 0);
	}
	pcm_event_manager(PCE_PM_SUSPEND, socket, NULL);
}

/*
 * pcmcia_do_resume()
 *	tell CS that a suspend has happened by passing a
 *	card removal event.  Then cleanup the socket state
 *	to fake the cards being removed so resume works
 */
void
pcmcia_do_resume(int socket, pcmcia_logical_socket_t *sockp)
{
	get_ss_status_t stat;
	struct pcmcia_adapter *adapt;
	pcmcia_if_t *ls_if;

#ifdef	XXX
	if (pcmcia_cs_event == NULL) {
		return;
	}
#endif

	ls_if = sockp->ls_if;
	adapt = sockp->ls_adapter;

	if (ls_if == NULL || ls_if->pcif_get_status == NULL) {
		return;
	}

	stat.socket = socket;
#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT,
		    "pcmcia_do_resume(%d, %p)\n", socket, (void *)sockp);
	}
#endif
	if (GET_STATUS(ls_if, adapt->pca_dip, &stat) ==
	    SUCCESS) {

#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT, "\tsocket=%x, CardState=%x\n",
			    socket, stat.CardState);
#endif
#if 0
		/* now have socket info -- do we have events? */
		if ((stat.CardState & SBM_CD) == SBM_CD) {
			if (pcmcia_cs_event &&
			    (sockp->ls_cs_events & (1 << PCE_CARD_INSERT))) {
				CS_EVENT(PCE_CARD_INSERT, socket, 0);
			}

			/* we should have card removed from CS soon */
			pcm_event_manager(PCE_CARD_INSERT, socket, NULL);
		}
#else
		if (pcmcia_cs_event &&
		    (sockp->ls_cs_events & (1 << PCE_PM_SUSPEND))) {
			CS_EVENT(PCE_PM_RESUME, socket, 0);
			CS_EVENT(PCE_CARD_REMOVAL, socket, 0);
			if ((stat.CardState & SBM_CD) == SBM_CD)
				CS_EVENT(PCE_CARD_INSERT, socket, 0);
		}
#endif
	}
}

/*
 * pcmcia_map_power_set()
 *	Given a power table entry and level, find it in the
 *	master table and return the index in the adapter table.
 */
static int
pcmcia_map_power_set(struct pcmcia_adapter *adapt, int level, int which)
{
	int plevel, i;
	struct power_entry *pwr = (struct power_entry *)adapt->pca_power;
	plevel = pcmcia_power_table[level].PowerLevel;
	/* mask = pcmcia_power_table[level].ValidSignals; */
	for (i = 0; i < adapt->pca_numpower; i++)
		if (plevel == pwr[i].PowerLevel &&
		    pwr[i].ValidSignals & which)
			return (i);
	return (0);
}

/*
 * pcmcia_map_power_get()
 *	Given an adapter power entry, find the appropriate index
 *	in the master table.
 */
static int
pcmcia_map_power_get(struct pcmcia_adapter *adapt, int level, int which)
{
	int plevel, i;
	struct power_entry *pwr = (struct power_entry *)adapt->pca_power;
	plevel = pwr[level].PowerLevel;
	/* mask = pwr[level].ValidSignals; */
	for (i = 0; i < pcmcia_num_power; i++)
		if (plevel == pcmcia_power_table[i].PowerLevel &&
		    pcmcia_power_table[i].ValidSignals & which)
			return (i);
	return (0);
}

/*
 * XXX - SS really needs a way to allow the caller to express
 *	interest in PCE_CARD_STATUS_CHANGE events.
 */
static uint32_t
pcm_event_map[32] = {
	PCE_E2M(PCE_CARD_WRITE_PROTECT)|PCE_E2M(PCE_CARD_STATUS_CHANGE),
	PCE_E2M(PCE_CARD_UNLOCK)|PCE_E2M(PCE_CARD_STATUS_CHANGE),
	PCE_E2M(PCE_EJECTION_REQUEST)|PCE_E2M(PCE_CARD_STATUS_CHANGE),
	PCE_E2M(PCE_INSERTION_REQUEST)|PCE_E2M(PCE_CARD_STATUS_CHANGE),
	PCE_E2M(PCE_CARD_BATTERY_WARN)|PCE_E2M(PCE_CARD_STATUS_CHANGE),
	PCE_E2M(PCE_CARD_BATTERY_DEAD)|PCE_E2M(PCE_CARD_STATUS_CHANGE),
	PCE_E2M(PCE_CARD_READY)|PCE_E2M(PCE_CARD_STATUS_CHANGE),
	PCE_E2M(PCE_CARD_REMOVAL)|PCE_E2M(PCE_CARD_INSERT)|
					PCE_E2M(PCE_CARD_STATUS_CHANGE),
	PCE_E2M(PCE_PM_SUSPEND)|PCE_E2M(PCE_PM_RESUME),
};

static int
pcm_mapevents(uint32_t eventmask)
{
	uint32_t mask;
	int i;

	for (i = 0, mask = 0; eventmask && i < 32; i++) {
		if (eventmask & (1 << i)) {
			mask |= pcm_event_map[i];
			eventmask &= ~(1 << i);
		}
	}
	return (mask);
}


/*
 * PCMCIA Generic Naming Support
 *
 * With 2.6, PCMCIA naming moves to the 1275 and generic naming model.
 * Consequently, the whole naming mechanism is to be changed.  This is
 * not backward compatible with the current names but that isn't a problem
 * due to so few drivers existing.
 *
 * For cards with a device_id tuple, a generic name will be used.
 * if there is no device_id, then the 1275 name will be used if possible.
 * The 1275 name is of the form pccardNNNN,MMMM from the manfid tuple.
 * if there is not manfid tuple, an attempt will be made to bind the
 * node to the version_1 strings.
 *
 * In all cases, a "compatible" property is created with a number
 * of names.  The most generic name will be last in the list.
 */

/*
 * pcmcia_fix_string()
 * want to avoid special characters in alias strings so convert
 * to something innocuous
 */

void
pcmcia_fix_string(char *str)
{
	for (; str && *str; str++) {
		switch (*str) {
			case ' ':
			case '\t':
				*str = '_';
				break;
		}
	}
}

void
pcmcia_1275_name(int socket, struct pcm_device_info *info,
    client_handle_t handle)
{
	cistpl_manfid_t manfid;
	cistpl_jedec_t jedec;
	tuple_t tuple;
	int i;

	tuple.Socket = socket;

	/* get MANFID if it exists -- this is most important form */
	tuple.DesiredTuple = CISTPL_MANFID;
	tuple.Attributes = 0;
	if ((i = csx_GetFirstTuple(handle, &tuple)) ==
	    SUCCESS) {
		i = csx_Parse_CISTPL_MANFID(handle, &tuple,
		    &manfid);
		if (i == SUCCESS) {
			(void) sprintf(info->pd_bind_name, "%s%x,%x",
			    PCMDEV_NAMEPREF,
			    manfid.manf, manfid.card);
			info->pd_flags |= PCM_NAME_1275;
		}
	} else {
		tuple.Attributes = 0;
		tuple.DesiredTuple = CISTPL_JEDEC_A;
		if ((i = csx_GetFirstTuple(handle, &tuple)) ==
		    SUCCESS) {
			i = csx_Parse_CISTPL_JEDEC_A(handle, &tuple,
			    &jedec);
			if (i == SUCCESS) {
				(void) sprintf(info->pd_bind_name, "%s%x,%x",
				    PCMDEV_NAMEPREF,
				    jedec.jid[0].id, jedec.jid[0].info);
				info->pd_flags |= PCM_NAME_1275;
			}
		}
	}
}

void
pcmcia_vers1_name(int socket, struct pcm_device_info *info,
    client_handle_t handle)
{
	cistpl_vers_1_t vers1;
	tuple_t tuple;
	int which = 0;
	int i, len, space;

	tuple.Socket = socket;
	info->pd_vers1_name[0] = '\0';

	/* Version 1 strings */
	tuple.DesiredTuple = CISTPL_VERS_1;
	tuple.Attributes = 0;
	if (!which &&
	    (i = csx_GetFirstTuple(handle, &tuple)) == SUCCESS) {
		i = csx_Parse_CISTPL_VERS_1(handle, &tuple, &vers1);
		if (i == SUCCESS) {
			/* BEGIN CSTYLED */
			for (i = 0, len = 0, space = 0; i < vers1.ns; i++) {
			    if ((space + len + strlen(info->pd_vers1_name)) >=
				sizeof (info->pd_vers1_name))
				    break;
			    if (space) {
				    info->pd_vers1_name[len++] = ',';
			    }
			    (void) strcpy(info->pd_vers1_name + len,
				(char *)vers1.pi[i]);
			    len += strlen((char *)vers1.pi[i]);
			    /* strip trailing spaces off of string */
			    while (info->pd_vers1_name[len - 1] == ' ' &&
				    len > 0)
				    len--;
			    space = 1;
			}
			/* END CSTYLED */
			info->pd_vers1_name[len] = '\0';
			info->pd_flags |= PCM_NAME_VERS1;
		}
	}
}


int
pcmcia_get_funce(client_handle_t handle, tuple_t *tuple)
{
	int ret = 0;

	tuple->Attributes = 0;
	while (csx_GetNextTuple(handle, tuple) == SUCCESS) {
		if (tuple->TupleCode == CISTPL_FUNCID) {
			break;
		}
		if (tuple->TupleCode == CISTPL_FUNCE) {
			ret = 1;
			break;
		}
		tuple->Attributes = 0;
	}
	return (ret);
}

char *pcmcia_lan_types[] = {
	"arcnet",
	"ethernet",
	"token-ring",
	"localtalk",
	"fddi",
	"atm",
	"wireless",
	"reserved"
};

void
pcmcia_generic_name(int socket, struct pcm_device_info *info,
    client_handle_t handle)
{
	cistpl_funcid_t funcid;
	cistpl_funce_t funce;
	tuple_t tuple;
	int which = 0;
	int i;

	tuple.Socket = socket;

	tuple.DesiredTuple = CISTPL_FUNCID;
	tuple.Attributes = 0;
	if ((i = csx_GetFirstTuple(handle, &tuple)) ==
	    SUCCESS) {
		/*
		 * need to make sure that CISTPL_FUNCID is not
		 * present in both a global and local CIS for MF
		 * cards.  3COM seems to do this erroneously
		 */

		if (info->pd_flags & PCM_MULTI_FUNCTION &&
		    tuple.Flags & CISTPLF_GLOBAL_CIS) {
			tuple_t ltuple;
			ltuple = tuple;
			ltuple.DesiredTuple = CISTPL_FUNCID;
			ltuple.Attributes = 0;
			if ((i = csx_GetNextTuple(handle, &ltuple)) ==
			    SUCCESS) {
				/* this is the per-function funcid */
				tuple = ltuple;
			}
		}

		i = csx_Parse_CISTPL_FUNCID(handle, &tuple, &funcid);
		if (i == SUCCESS) {
			/* in case no function extension */
			if (funcid.function < PCM_GENNAME_SIZE)
				(void) strcpy(info->pd_generic_name,
				    pcmcia_generic_names[funcid.function]);
			else
				(void) sprintf(info->pd_generic_name,
				    "class,%x",
				    funcid.function);
		}
		info->pd_type = funcid.function;
		switch (funcid.function) {
		case TPLFUNC_LAN:
			which = pcmcia_get_funce(handle, &tuple);
			if (which) {
				i = csx_Parse_CISTPL_FUNCE(handle,
				    &tuple,
				    &funce, TPLFUNC_LAN);
				if (i == SUCCESS) {
					i = funce.data.lan.tech;
					if (i >= sizeof (pcmcia_lan_types) /
					    sizeof (char *)) {
						break;
					}
					(void) strcpy(info->pd_generic_name,
					    pcmcia_lan_types[i]);
				}
			}
			break;
		case TPLFUNC_VIDEO:
#ifdef future_pcmcia_spec
			which = pcmcia_get_funce(handle, &tuple);
			if (which) {
				i = csx_Parse_CISTPL_FUNCE(handle,
				    &tuple,
				    &funce, TPLFUNC_VIDEO);
				if (i == SUCCESS) {
					i = funce.video.tech;
					if (i > sizeof (pcmcia_lan_types) /
					    sizeof (char *)) {
						break;
					}
					(void) strcpy(info->pd_generic_names,
					    pcmcia_lan_types[i]);
				}
			}
#endif
			break;
		}
		info->pd_flags |= PCM_NAME_GENERIC;
	} else {
		/* if no FUNCID, do we have CONFIG */
		tuple.DesiredTuple = CISTPL_CONFIG;
		tuple.Attributes = 0;
		if (csx_GetFirstTuple(handle, &tuple) != SUCCESS) {
			info->pd_flags |= PCM_NO_CONFIG | PCM_NAME_GENERIC;
			(void) strcpy(info->pd_generic_name,
			    pcmcia_generic_names[PCM_TYPE_MEMORY]);
			info->pd_type = PCM_TYPE_MEMORY;
		}
	}
}


/*
 * pcmcia_add_compatible()
 * add the cached compatible property list.
 */
void
pcmcia_add_compatible(dev_info_t *dip, struct pcm_device_info *info)
{
	int length = 0, i;
	char buff[MAXNAMELEN];
	char *compat_name[8];
	int ci = 0;

	bzero(compat_name, sizeof (compat_name));

	if (info->pd_flags & PCM_NAME_VERS1) {
		(void) sprintf(buff, "%s,%s", PCMDEV_NAMEPREF,
		    info->pd_vers1_name);
		pcmcia_fix_string(buff); /* don't want spaces */
		length = strlen(buff) + 1;
		compat_name[ci] = kmem_alloc(length, KM_SLEEP);
		(void) strcpy(compat_name[ci++], buff);
	}

	if ((info->pd_flags & (PCM_NAME_1275 | PCM_MULTI_FUNCTION)) ==
	    (PCM_NAME_1275 | PCM_MULTI_FUNCTION)) {
		(void) sprintf(buff, "%s,%x", info->pd_bind_name,
		    info->pd_function);
		length = strlen(buff) + 1;
		compat_name[ci] = kmem_alloc(length, KM_SLEEP);
		(void) strcpy(compat_name[ci++], buff);
	}

	if (info->pd_flags & PCM_NAME_1275) {
		length = strlen(info->pd_bind_name) + 1;
		compat_name[ci] = kmem_alloc(length, KM_SLEEP);
		(void) strcpy(compat_name[ci++], info->pd_bind_name);
	}

	if (info->pd_flags & PCM_NAME_GENERIC) {
		if (strncmp(info->pd_generic_name, "class,", 6) == 0) {
			/* no generic without "pccard" */
			(void) sprintf(buff, "%s%s", PCMDEV_NAMEPREF,
			    info->pd_generic_name);
		} else {
			/* first pccard,generic-name */
			(void) sprintf(buff, "%s,%s", PCMDEV_NAMEPREF,
			    info->pd_generic_name);
		}
		length = strlen(buff) + 1;
		compat_name[ci] = kmem_alloc(length, KM_SLEEP);
		(void) strcpy(compat_name[ci++], buff);

		/* now the simple generic name */
		length = strlen(info->pd_generic_name) + 1;
		compat_name[ci] = kmem_alloc(length, KM_SLEEP);
		(void) strcpy(compat_name[ci++], info->pd_generic_name);
	}

	if (info->pd_flags & PCM_NO_CONFIG) {
		char *mem = "pccard,memory";
		/*
		 * I/O cards are required to have a config tuple.
		 * there are some that violate the spec and don't
		 * but it is most likely that this is a memory card
		 * so tag it as such.  "memory" is more general
		 * than other things so needs to come last.
		 */
		length = strlen(mem) + 1;
		compat_name[ci] = kmem_alloc(length, KM_SLEEP);
		(void) strcpy(compat_name[ci++], mem);
	}

	if (ci == 0)
		return;

	if (ndi_prop_update_string_array(DDI_DEV_T_NONE, dip,
	    "compatible", (char **)compat_name, ci) != DDI_PROP_SUCCESS)
		cmn_err(CE_WARN, "pcmcia: unable to create compatible prop");

	for (i = 0; i < ci; i++)
		kmem_free(compat_name[i], strlen(compat_name[i]) + 1);
}
/*
 * CIS parsing and other PC Card specific code
 */

/*
 * pcmcia_get_mem_regs()
 */
static int
pcmcia_get_mem_regs(struct pcm_regs *regs, struct pcm_device_info *info,
    int type, int pctype)
{
	int num_regs = 0;
	tuple_t tuple;
	cistpl_device_t device;
	uint32_t curr_base;
	int ret, len;
	int space;

	/*
	 * current plan for reg spec:
	 * device_a will be accumulated to determine max size of
	 * attribute memory.  device for common.  Then config
	 * tuples to get a worst case I/O size.
	 */
	bzero(&tuple, sizeof (tuple));
	tuple.Socket = info->pd_socket;

	tuple.DesiredTuple = (cisdata_t)type;

	space = (type == CISTPL_DEVICE_A) ? PC_REG_SPACE_ATTRIBUTE :
	    PC_REG_SPACE_MEMORY;
	if ((ret = csx_GetFirstTuple(info->pd_handle, &tuple)) == CS_SUCCESS) {
		bzero(&device, sizeof (device));

		if (type == CISTPL_DEVICE)
			ret = csx_Parse_CISTPL_DEVICE(info->pd_handle, &tuple,
			    &device);
		else
			ret = csx_Parse_CISTPL_DEVICE_A(info->pd_handle, &tuple,
			    &device);

		if (ret == CS_SUCCESS) {
			curr_base = 0;
			for (ret = 0; ret < device.num_devices; ret++) {
				/* need to order these for real mem first */
				if (device.devnode[ret].type !=
				    CISTPL_DEVICE_DTYPE_NULL) {
					/* how to represent types??? */
					regs[num_regs].phys_hi =
					    PC_REG_PHYS_HI(0, 0,
					    pctype,
					    space,
					    info->pd_socket,
					    info->pd_function,
					    0);
					regs[num_regs].phys_lo = curr_base;
					len = device.devnode[ret].size_in_bytes;
					curr_base += len;
					regs[num_regs].phys_len = len;
					num_regs++;
				} else {
					/*
					 * NULL device is a "hole"
					 */
					curr_base +=
					    device.devnode[ret].size_in_bytes;
				}
			}
		}
	}
	return (num_regs);
}

/*
 *
 */
static int
pcmcia_get_io_regs(struct pcm_regs *regs, struct pcm_device_info *info,
    int pctype)
{
	int num_regs = 0;
	tuple_t tuple;
	uint32_t curr_base;
	int len, curr, i, curr_len;
	cistpl_config_t config;
	cistpl_cftable_entry_t cftable;
	struct pcm_regs tmp[16];
	int found = 0;

	bzero(&tuple, sizeof (tuple));
	tuple.DesiredTuple = CISTPL_CONFIG;
	tuple.Socket = info->pd_socket;
	tuple.Attributes = 0;
	curr_base = 0;
	len = 0;

	if (csx_GetFirstTuple(info->pd_handle, &tuple) == CS_SUCCESS) {
		if (csx_Parse_CISTPL_CONFIG(info->pd_handle,
		    &tuple, &config) != CS_SUCCESS) {
			info->pd_flags |= PCM_NO_CONFIG; /* must be memory */
			return (0);
		}
		curr = 0;

		tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
		tuple.Socket = info->pd_socket;
		tuple.Attributes = 0;
		bzero(tmp, sizeof (tmp));

	while (csx_GetNextTuple(info->pd_handle, &tuple) == CS_SUCCESS) {
		bzero(&cftable, sizeof (cftable));

		if (csx_Parse_CISTPL_CFTABLE_ENTRY(info->pd_handle,
		    &tuple, &cftable) == CS_SUCCESS) {

		/* BEGIN CSTYLED */
		if (cftable.flags & CISTPL_CFTABLE_TPCE_FS_IO) {
		    /* we have an I/O entry */
		    if (cftable.io.flags &
			CISTPL_CFTABLE_TPCE_FS_IO_RANGE) {
			len = cftable.io.addr_lines;
			if (len != 0)
				len = 1 << len;
			for (i = 0; i < cftable.io.ranges && curr < 16; i++) {
			    curr_base = cftable.io.range[i].addr;
			    curr_len = cftable.io.range[i].length;
			    if (curr_len == 0)
				    curr_len = len;
			    if (len != 0 || cftable.io.addr_lines == 0) {
				/* we have potential relocation */
				int mask;
				mask = cftable.io.addr_lines ?
				    cftable.io.addr_lines : genp2(len);
				mask = genmask(mask);
				if ((mask & curr_base) == 0) {
					/* more accurate length */
					regs->phys_len = curr_len;
					regs->phys_lo = 0;
					regs->phys_hi =
					    PC_REG_PHYS_HI(0,
					    0,
					    pctype,
					    PC_REG_SPACE_IO,
					    info->pd_socket,
					    info->pd_function,
					    0);
					num_regs++;
					found = 2;
					break;
				}
			    }
			    tmp[curr].phys_len = curr_len;
			    tmp[curr].phys_lo = curr_base;
			    curr++;
			    found = 1;
			}
			if (found == 2)
				break;
		    } else {
			/* no I/O range so just a mask */
			regs->phys_len = 1 << cftable.io.addr_lines;
			regs->phys_hi =
			    PC_REG_PHYS_HI(0,
			    0,
			    pctype,
			    PC_REG_SPACE_IO,
			    info->pd_socket,
			    info->pd_function,
			    0);
			regs->phys_lo = 0;
			num_regs++;
			regs++;
			/* quit on "good" entry */
			break;
		    }
		    /* was this the last CFTABLE Entry? */
		    if (config.last == cftable.index)
			    break;
		}
		/* END CSTYLE */
		}
	}
	if (found == 1) {
		/*
		 * have some non-relocatable values
		 * so we include them all for now
		 */
		for (i = 0; i < curr && num_regs < 8; i++) {
		    regs->phys_len = tmp[i].phys_len;
		    regs->phys_lo = tmp[i].phys_lo;
		    regs->phys_hi = PC_REG_PHYS_HI(1, 0, pctype,
			    PC_REG_SPACE_IO, info->pd_socket,
			    info->pd_function, 0);
		    regs++;
		    num_regs++;
		}
	    }
	}
	return (num_regs);
}

/*
 * pcmcia_create_regs()
 *	create a valid set of regspecs for the card
 *	The first one is always for CIS access and naming
 */
/*ARGSUSED*/
static void
pcmcia_find_regs(dev_info_t *dip, struct pcm_device_info *info,
			struct pcmcia_parent_private *ppd)
{
	struct pcm_regs regs[32]; /* assume worst case */
	int num_regs = 0;
	int len;
	int bustype;

	if (ppd->ppd_flags & PPD_CARD_CARDBUS) {
		/* always have a CIS map */
		regs[0].phys_hi = PC_REG_PHYS_HI(0, 0, PC_REG_TYPE_CARDBUS,
		    PC_REG_SPACE_CONFIG,
		    info->pd_socket,
		    info->pd_function, 0);
		bustype = PC_REG_TYPE_CARDBUS;
	} else {
		/* always have a CIS map */
		regs[0].phys_hi = PC_REG_PHYS_HI(0, 0, PC_REG_TYPE_16BIT,
		    PC_REG_SPACE_ATTRIBUTE,
		    info->pd_socket,
		    info->pd_function, 0);
		bustype = PC_REG_TYPE_16BIT;
	}
	regs[0].phys_lo = 0;	/* always starts at zero */
	regs[0].phys_len = 0;
	num_regs++;
	/*
	 * need to search CIS for other memory instances
	 */

	if (info->pd_flags & PCM_OTHER_NOCIS) {
		/* special case of memory only card without CIS */
		regs[1].phys_hi = PC_REG_PHYS_HI(0, 0, PC_REG_TYPE_16BIT,
		    PC_REG_SPACE_MEMORY,
		    info->pd_socket,
		    info->pd_function, 0);
		regs[1].phys_lo = 0;
		regs[1].phys_len = PCM_MAX_R2_MEM;
		num_regs++;
	} else {
		/*
		 * want to get any other memory and/or I/O regions
		 * on the card and represent them here.
		 */
		num_regs += pcmcia_get_mem_regs(&regs[num_regs], info,
		    CISTPL_DEVICE_A, bustype);
		num_regs += pcmcia_get_mem_regs(&regs[num_regs], info,
		    CISTPL_DEVICE, bustype);

		/* now look for an I/O space to configure */
		num_regs += pcmcia_get_io_regs(&regs[num_regs], info,
		    bustype);

	}

	len = num_regs * sizeof (uint32_t) * 3;
	ppd->ppd_nreg = num_regs;
	ppd->ppd_reg = kmem_alloc(len, KM_SLEEP);
	bcopy(regs, ppd->ppd_reg, len);
	len = sizeof (struct pcm_regs) * ppd->ppd_nreg;
	ppd->ppd_assigned = kmem_zalloc(len, KM_SLEEP);
}


/*
 * pcmcia_need_intr()
 *	check to see if an interrupt tuple exists.
 *	existence means we need one in the intrspec.
 */
static int
pcmcia_need_intr(int socket, struct pcm_device_info *info)
{
	cistpl_config_t config;
	cistpl_cftable_entry_t cftable;
	tuple_t tuple;
	int i;

	bzero(&tuple, sizeof (tuple));
	tuple.DesiredTuple = CISTPL_CONFIG;
	tuple.Socket = socket;
	tuple.Attributes = 0;
	if (csx_GetFirstTuple(info->pd_handle, &tuple) != CS_SUCCESS) {
		return (0);
	}
#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT, "pcmcia_need_intr: have config tuple\n");
	}
#endif
	bzero(&config, sizeof (config));
	if (csx_Parse_CISTPL_CONFIG(info->pd_handle,
	    &tuple, &config) != CS_SUCCESS) {
		cmn_err(CE_WARN, "pcmcia: config failed to parse\n");
		return (0);
	}

	for (cftable.index = (int)-1, i = -1;
	    i != config.last; i = cftable.index) {
		tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
		tuple.Attributes = 0;
		if (csx_GetNextTuple(info->pd_handle,
		    &tuple) != CS_SUCCESS) {
			cmn_err(CE_WARN, "pcmcia: get cftable failed\n");
			break;
		}
		bzero(&cftable, sizeof (cftable));
		if (csx_Parse_CISTPL_CFTABLE_ENTRY(info->pd_handle,
		    &tuple, &cftable) !=
		    CS_SUCCESS) {
			cmn_err(CE_WARN, "pcmcia: parse cftable failed\n");
			break;
		}
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT, "\t%x: flags=%x (%x)\n",
			    i, cftable.flags,
			    cftable.flags & CISTPL_CFTABLE_TPCE_FS_IRQ);
#endif
		if (cftable.flags & CISTPL_CFTABLE_TPCE_FS_IRQ)
			return (1);
	}
	return (0);

}

/*
 * pcmcia_num_funcs()
 *	look for a CISTPL_LONGLINK_MFC
 *	if there is one, return the number of functions
 *	if there isn't one, then there is one function
 */
static int
pcmcia_num_funcs(int socket, client_handle_t handle)
{
	int count = 1;
	cistpl_longlink_mfc_t mfc;
	tuple_t tuple;

	bzero(&tuple, sizeof (tuple_t));
	tuple.DesiredTuple = CISTPL_LONGLINK_MFC;
	tuple.Socket = socket;
	tuple.Attributes = 0;
	if (csx_GetFirstTuple(handle, &tuple) == CS_SUCCESS) {
		/* this is a multifunction card */
		if (csx_ParseTuple(handle, &tuple, (cisparse_t *)&mfc,
		    CISTPL_LONGLINK_MFC) == CS_SUCCESS) {
			count = mfc.nfuncs;
		}
	}
	return (count);
}

client_handle_t pcmcia_cs_handle;

/*
 * pcmcia_create_dev_info(socket)
 *	either find or create the device information structure
 *	for the card(s) just inserted.	We don't care about removal yet.
 *	In any case, we will only do this at CS request
 */
static void
pcmcia_create_dev_info(int socket)
{
	struct pcm_device_info card_info;
	client_reg_t reg;
	cisinfo_t cisinfo;
	int i;
	dev_info_t *pdip;
	static int handle_def = 0;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug)
		cmn_err(CE_CONT, "create dev_info_t for device in socket %d\n",
		    socket);
#endif

	/*
	 * before we can do anything else, we need the parent
	 * devinfo of the socket.  This gets things in the right
	 * place in the device tree.
	 */

	pdip = pcm_find_parent_dip(socket);
	if (pdip == NULL)
		return;

	/* Card Services calls needed to get CIS info */
	reg.dip = NULL;
	reg.Attributes = INFO_SOCKET_SERVICES;
	reg.EventMask = 0;
	reg.event_handler = NULL;
	reg.Version = CS_VERSION;

	bzero(&card_info, sizeof (card_info));

	if (handle_def == 0) {
		if (csx_RegisterClient(&pcmcia_cs_handle,
		    &reg) != CS_SUCCESS) {
#if defined(PCMCIA_DEBUG)
			if (pcmcia_debug)
				cmn_err(CE_CONT,
				    "pcmcia: RegisterClient failed\n");
#endif
			return;
		}
		handle_def++;
	}
	card_info.pd_handle = pcmcia_cs_handle;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug)
		cmn_err(CE_CONT,
		    "pcmcia_create_dev_info: handle = %x\n",
		    (int)card_info.pd_handle);
#endif
	card_info.pd_type = -1; /* no type to start */
	card_info.pd_socket = socket;
	card_info.pd_function = 0;
	pcmcia_sockets[socket]->ls_functions = 1; /* default */

	cisinfo.Socket = socket;

	if ((i = csx_ValidateCIS(card_info.pd_handle,
	    &cisinfo)) != SUCCESS ||
	    cisinfo.Tuples == 0) {
		/* no CIS means memory */
		(void) strcpy(card_info.pd_generic_name, "memory");
		card_info.pd_flags |= PCM_NAME_GENERIC |
		    PCM_OTHER_NOCIS | PCM_NAME_1275;
		(void) strcpy(card_info.pd_bind_name, "pccard,memory");
		(void) strcpy(card_info.pd_generic_name, "memory");
		card_info.pd_type = PCM_TYPE_MEMORY;
	} else {
		int functions, lsocket;
		card_info.pd_tuples = cisinfo.Tuples;

		/*
		 * how many functions on the card?
		 * we need to know and then we do one
		 * child node for each function using
		 * the function specific tuples.
		 */
		lsocket = CS_MAKE_SOCKET_NUMBER(socket, CS_GLOBAL_CIS);
		functions = pcmcia_num_funcs(lsocket,
		    card_info.pd_handle);
		pcmcia_sockets[socket]->ls_functions = functions;
		if (functions > 1) {
			card_info.pd_flags |= PCM_MULTI_FUNCTION;
		}
		for (i = 0; i < functions; i++) {
			register int flags;
			lsocket = CS_MAKE_SOCKET_NUMBER(socket, i);
			card_info.pd_socket = socket;
			card_info.pd_function = i;
			/*
			 * new name construction
			 */
			if (functions != 1) {
				/* need per function handle */
				card_info.pd_function = i;
				/* get new handle */
			}
			pcmcia_1275_name(lsocket, &card_info,
			card_info.pd_handle);
			pcmcia_vers1_name(lsocket, &card_info,
			card_info.pd_handle);
			pcmcia_generic_name(lsocket, &card_info,
			card_info.pd_handle);
			flags = card_info.pd_flags;
			if (!(flags & PCM_NAME_1275)) {
				if (flags & PCM_NAME_VERS1) {
				    (void) strcpy(card_info.pd_bind_name,
					PCMDEV_NAMEPREF);
				    card_info.pd_bind_name[
				        sizeof (PCMDEV_NAMEPREF)] = ',';
				    (void) strncpy(card_info.pd_bind_name +
					sizeof (PCMDEV_NAMEPREF),
					card_info.pd_vers1_name,
					MODMAXNAMELEN -
					sizeof (PCMDEV_NAMEPREF));
				    pcmcia_fix_string(card_info.pd_bind_name);
				} else {
					/*
					 * have a CIS but not the right info
					 * so treat as generic "pccard"
					 */
					(void) strcpy(card_info.pd_generic_name,
					    "pccard,memory");
					card_info.pd_flags |= PCM_NAME_GENERIC;
					(void) strcpy(card_info.pd_bind_name,
					    "pccard,memory");
				}
			}
			pcmcia_init_devinfo(pdip, &card_info);
		}
		return;
	}

	pcmcia_init_devinfo(pdip, &card_info);
}

/*
 * pcmcia_init_devinfo()
 *	if there isn't a device info structure, create one
 *	if there is, we don't do much.
 *
 *	Note: this will need updating as 1275 finalizes their spec.
 */
static void
pcmcia_init_devinfo(dev_info_t *pdip, struct pcm_device_info *info)
{
	int unit;
	dev_info_t *dip;
	char *name;
	struct pcmcia_parent_private *ppd;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug)
		cmn_err(CE_CONT, "init_devinfo(%s, %d)\n", info->pd_bind_name,
		    info->pd_socket);
#endif

	/*
	 * find out if there is already an instance of this
	 * device.  We don't want to create a new one unnecessarily
	 */
	unit = CS_MAKE_SOCKET_NUMBER(info->pd_socket, info->pd_function);

	dip = pcm_find_devinfo(pdip, info, unit);
	if ((dip != NULL) && (ddi_getprop(DDI_DEV_T_NONE, dip,
	    DDI_PROP_DONTPASS, PCM_DEV_SOCKET, -1) != -1)) {
		/* it already exist but isn't a .conf file */

#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT, "\tfound existing device node (%s)\n",
			    ddi_get_name(dip));
#endif
		if (strlen(info->pd_vers1_name) > 0)
			(void) ndi_prop_update_string(DDI_DEV_T_NONE,
			    dip, PCM_DEV_MODEL, info->pd_vers1_name);

		ppd = (struct pcmcia_parent_private *)
		    ddi_get_parent_data(dip);

		pcmcia_sockets[info->pd_socket]->ls_dip[info->pd_function] =
		    dip;

		ppd->ppd_active = 1;

		if (ndi_devi_online(dip, 0) == NDI_FAILURE) {
			pcmcia_sockets[info->pd_socket]-> \
			    ls_dip[info->pd_function] = NULL;
			ppd->ppd_active = 0;
		}
	} else {

		char *dtype;

#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT, "pcmcia: create child [%s](%d): %s\n",
			    info->pd_bind_name, info->pd_socket,
			    info->pd_generic_name);
#endif

		if (info->pd_flags & PCM_NAME_GENERIC)
			name = info->pd_generic_name;
		else
			name = info->pd_bind_name;

		if (ndi_devi_alloc(pdip, name, (pnode_t)DEVI_SID_NODEID,
		    &dip) !=
		    NDI_SUCCESS) {
			cmn_err(CE_WARN,
			    "pcmcia: unable to create device [%s](%d)\n",
			    name, info->pd_socket);
			return;
		}
		/*
		 * construct the "compatible" property if the device
		 * has a generic name
		 */
		pcmcia_add_compatible(dip, info);

		ppd = kmem_zalloc(sizeof (struct pcmcia_parent_private),
		    KM_SLEEP);

		ppd->ppd_socket = info->pd_socket;
		ppd->ppd_function = info->pd_function;

		/*
		 * add the "socket" property
		 * the value of this property contains the logical PCMCIA
		 * socket number the device has been inserted in, along
		 * with the function # if the device is part of a
		 * multi-function device.
		 */
		(void) ndi_prop_update_int(DDI_DEV_T_NONE, dip,
		    PCM_DEV_SOCKET, unit);

		if (info->pd_flags & PCM_MULTI_FUNCTION)
			ppd->ppd_flags |= PPD_CARD_MULTI;

		/*
		 * determine all the properties we need for PPD
		 * then create the properties
		 */
		/* socket is unique */
		pcmcia_find_regs(dip, info, ppd);

		ppd->ppd_intr = pcmcia_need_intr(unit, info);

		if (ppd->ppd_nreg > 0)
			(void) ddi_prop_update_int_array(DDI_DEV_T_NONE, dip,
			    "reg", (int *)ppd->ppd_reg, ppd->ppd_nreg *
			    sizeof (struct pcm_regs) / sizeof (int));
		if (ppd->ppd_intr) {
			(void) ddi_prop_update_int(DDI_DEV_T_NONE, dip,
			    "interrupts", ppd->ppd_intr);
			ppd->ppd_intrspec =
			    kmem_zalloc(sizeof (struct intrspec), KM_SLEEP);
		}

		/* set parent private - our own format */
		ddi_set_parent_data(dip, (caddr_t)ppd);

		/* init the device type */
		if (info->pd_type >= 0 &&
		    info->pd_type < (sizeof (pcmcia_dev_type) /
		    (sizeof (char *))))
			dtype = pcmcia_dev_type[info->pd_type];
		else
			dtype = "unknown";

		if (strlen(info->pd_vers1_name) > 0)
			(void) ndi_prop_update_string(DDI_DEV_T_NONE,
			    dip, PCM_DEV_MODEL, info->pd_vers1_name);

		(void) ndi_prop_update_string(DDI_DEV_T_NONE, dip,
		    PCM_DEVICETYPE, dtype);

		/* set PC Card as active and present in socket */
		pcmcia_sockets[info->pd_socket]->ls_dip[info->pd_function] =
		    dip;

		ppd->ppd_active = 1;

		/*
		 * We should not call ndi_devi_online here if
		 * pcmcia attach is in progress. This causes a deadlock.
		 */
		if (pcmcia_dip != dip) {
			if (ndi_devi_online_async(dip, 0)
			    != NDI_SUCCESS) {
				pcmcia_sockets[info->pd_socket]->\
				    ls_dip[info->pd_function] = NULL;
				pcmcia_ppd_free(ppd);
				(void) ndi_devi_free(dip);
				return;
			}
		}

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug)
		cmn_err(CE_CONT, "\tjust added \"active\" to %s in %d\n",
		    ddi_get_name(dip), info->pd_socket);
#endif
	}

	/*
	 * inform the event manager that a child was added
	 * to the device tree.
	 */
	pcm_event_manager(PCE_DEV_IDENT, unit, ddi_get_name(dip));

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug > 1) {
		pcmcia_dump_minors(dip);
	}
#endif
}

/*
 * free any allocated parent-private data
 */
static void
pcmcia_ppd_free(struct pcmcia_parent_private *ppd)
{
	size_t len;

	if (ppd->ppd_nreg != 0) {
		len = ppd->ppd_nreg * sizeof (uint32_t) * 3;
		kmem_free(ppd->ppd_reg, len);
		len = sizeof (struct pcm_regs) * ppd->ppd_nreg;
		kmem_free(ppd->ppd_assigned, len);
	}

	/*
	 * pcmcia only allocates 1 intrspec today
	 */
	if (ppd->ppd_intr != 0) {
		len = sizeof (struct intrspec) * ppd->ppd_intr;
		kmem_free(ppd->ppd_intrspec, len);
	}

	kmem_free(ppd, sizeof (*ppd));
}


/*
 * pcmcia_get_devinfo(socket)
 *	entry point to allow finding the device info structure
 *	for a given logical socket.  Used by event manager
 */
dev_info_t *
pcmcia_get_devinfo(int socket)
{
	int func = CS_GET_FUNCTION_NUMBER(socket);
	socket = CS_GET_SOCKET_NUMBER(socket);
	if (pcmcia_sockets[socket])
		return (pcmcia_sockets[socket]->ls_dip[func]);
	return ((dev_info_t *)NULL);
}

/*
 * CSGetCookiesAndDip()
 *	get info needed by CS to setup soft interrupt handler and provide
 *		socket-specific adapter information
 */
static int
GetCookiesAndDip(sservice_t *serv)
{
	pcmcia_logical_socket_t *socket;
	csss_adapter_info_t *ai;
	int sock;

	sock = CS_GET_SOCKET_NUMBER(serv->get_cookies.socket);

	if (sock >= pcmcia_num_sockets ||
	    (int)serv->get_cookies.socket < 0)
		return (BAD_SOCKET);

	socket = pcmcia_sockets[sock];
	ai = &serv->get_cookies.adapter_info;
	serv->get_cookies.dip = socket->ls_adapter->pca_dip;
	serv->get_cookies.iblock = socket->ls_adapter->pca_iblock;
	serv->get_cookies.idevice = socket->ls_adapter->pca_idev;

	/*
	 * Setup the adapter info for Card Services
	 */
	(void) strcpy(ai->name, socket->ls_adapter->pca_name);
	ai->major = socket->ls_adapter->pca_module;
	ai->minor = socket->ls_adapter->pca_unit;
	ai->number = socket->ls_adapter->pca_number;
	ai->num_sockets = socket->ls_adapter->pca_numsockets;
	ai->first_socket = socket->ls_adapter->pca_first_socket;

	return (SUCCESS);
}

/*
 * Note:
 *	The following functions that start with 'SS'
 *	implement SocketServices interfaces.  They
 *	simply map the socket and/or window number to
 *	the adapter specific number based on the general
 *	value that CardServices uses.
 *
 *	See the descriptions in SocketServices for
 *	details.  Also refer to specific adapter drivers
 *	for implementation reference.
 */

static int
SSGetAdapter(get_adapter_t *adapter)
{
	int n;
	get_adapter_t info;

	adapter->state = (unsigned)0xFFFFFFFF;
	adapter->SCRouting = 0xFFFFFFFF;

	for (n = 0; n < pcmcia_num_adapters; n++) {
		GET_ADAPTER(pcmcia_adapters[n]->pca_if,
		    pcmcia_adapters[n]->pca_dip, &info);
		adapter->state &= info.state;
		adapter->SCRouting &= info.SCRouting;
	}

	return (SUCCESS);
}

static int
SSGetPage(get_page_t *page)
{
	pcmcia_logical_window_t *window;
	get_page_t newpage;
	int retval, win;

	if (page->window > pcmcia_num_windows) {
		return (BAD_WINDOW);
	}

	window = pcmcia_windows[page->window];
	newpage = *page;
	win = newpage.window = window->lw_window; /* real window */

	retval = GET_PAGE(window->lw_if, window->lw_adapter->pca_dip,
	    &newpage);
	if (retval == SUCCESS) {
		*page = newpage;
		page->window = win;
	}
	return (retval);
}

static int
SSGetSocket(get_socket_t *socket)
{
	int retval, sock;
	get_socket_t newsocket;
	pcmcia_logical_socket_t *sockp;

	sock = socket->socket;
	if (sock > pcmcia_num_sockets ||
	    (sockp = pcmcia_sockets[sock]) == NULL) {
		return (BAD_SOCKET);
	}

	newsocket = *socket;
	newsocket.socket = sockp->ls_socket;
	retval = GET_SOCKET(sockp->ls_if, sockp->ls_adapter->pca_dip,
	    &newsocket);
	if (retval == SUCCESS) {
		newsocket.VccLevel = pcmcia_map_power_get(sockp->ls_adapter,
		    newsocket.VccLevel,
		    VCC);
		newsocket.Vpp1Level = pcmcia_map_power_get(sockp->ls_adapter,
		    newsocket.Vpp1Level,
		    VPP1);
		newsocket.Vpp2Level = pcmcia_map_power_get(sockp->ls_adapter,
		    newsocket.Vpp2Level,
		    VPP2);
		*socket = newsocket;
		socket->socket = sock;
	}

	return (retval);
}

static int
SSGetStatus(get_ss_status_t *status)
{
	get_ss_status_t newstat;
	int sock, retval;
	pcmcia_logical_socket_t *sockp;

	sock = status->socket;
	if (sock > pcmcia_num_sockets ||
	    (sockp = pcmcia_sockets[sock]) == NULL) {
		return (BAD_SOCKET);
	}

	newstat = *status;
	newstat.socket = sockp->ls_socket;
	retval = GET_STATUS(sockp->ls_if, sockp->ls_adapter->pca_dip,
	    &newstat);
	if (retval == SUCCESS) {
		*status = newstat;
		status->socket = sock;
	}

	return (retval);
}

static int
SSGetWindow(get_window_t *window)
{
	int win, retval;
	get_window_t newwin;
	pcmcia_logical_window_t *winp;

	win = window->window;
	winp = pcmcia_windows[win];
	newwin = *window;
	newwin.window = winp->lw_window;

	retval = GET_WINDOW(winp->lw_if, winp->lw_adapter->pca_dip,
	    &newwin);
	if (retval == SUCCESS) {
		newwin.socket = winp->lw_socket;
		newwin.window = win;
		*window = newwin;
	}
	return (retval);
}

/*
 * SSInquireAdapter()
 *	Get the capabilities of the "generic" adapter
 *	we are exporting to CS.
 */
static int
SSInquireAdapter(inquire_adapter_t *adapter)
{
	adapter->NumSockets = pcmcia_num_sockets;
	adapter->NumWindows = pcmcia_num_windows;
	adapter->NumEDCs = 0;
	/*
	 * notes: Adapter Capabilities are going to be difficult to
	 * determine with reliability.	Fortunately, most of them
	 * don't matter under Solaris or can be handled transparently
	 */
	adapter->AdpCaps = 0;	/* need to fix these */
	/*
	 * interrupts need a little work.  For x86, the valid IRQs will
	 * be restricted to those that the system has exported to the nexus.
	 * for SPARC, it will be the DoRight values.
	 */
	adapter->ActiveHigh = 0;
	adapter->ActiveLow = 0;
	adapter->power_entry = pcmcia_power_table; /* until we resolve this */
	adapter->NumPower = pcmcia_num_power;
	return (SUCCESS);
}

static int
SSInquireSocket(inquire_socket_t *socket)
{
	int retval, sock;
	inquire_socket_t newsocket;
	pcmcia_logical_socket_t *sockp;

	sock = socket->socket;
	if (sock > pcmcia_num_sockets ||
	    (sockp = pcmcia_sockets[sock]) == NULL)
		return (BAD_SOCKET);
	newsocket = *socket;
	newsocket.socket = sockp->ls_socket;
	retval = INQUIRE_SOCKET(sockp->ls_if, sockp->ls_adapter->pca_dip,
	    &newsocket);
	if (retval == SUCCESS) {
		*socket = newsocket;
		socket->socket = sock;
	}
	return (retval);
}

static int
SSInquireWindow(inquire_window_t *window)
{
	int retval, win;
	pcmcia_logical_window_t *winp;
	inquire_window_t newwin;
	int slide;

	win = window->window;
	if (win > pcmcia_num_windows)
		return (BAD_WINDOW);

	winp = pcmcia_windows[win];
	newwin = *window;
	newwin.window = winp->lw_window;
	retval = INQUIRE_WINDOW(winp->lw_if, winp->lw_adapter->pca_dip,
	    &newwin);
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug > 1)
			cmn_err(CE_CONT, "SSInquireWindow: win=%d, pwin=%d\n",
			    win, newwin.window);
#endif
	if (retval == SUCCESS) {
		*window = newwin;
		/* just in case */
		window->iowin_char.IOWndCaps &= ~WC_BASE;
		slide = winp->lw_adapter->pca_first_socket;
		/*
		 * note that sockets are relative to the adapter.
		 * we have to adjust the bits to show a logical
		 * version.
		 */

		pcm_fix_bits(newwin.Sockets, window->Sockets, slide, 0);

#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug > 1) {
			cmn_err(CE_CONT, "iw: orig bits=%x, new bits=%x\n",
			    (int)*(uint32_t *)newwin.Sockets,
			    (int)*(uint32_t *)window->Sockets);
			cmn_err(CE_CONT, "\t%x.%x.%x\n", window->WndCaps,
			    window->mem_win_char.MemWndCaps,
			    window->mem_win_char.MinSize);
		}
#endif
		window->window = win;
	}
	return (retval);
}

static int
SSResetSocket(int socket, int mode)
{
	pcmcia_logical_socket_t *sockp;

	if (socket >= pcmcia_num_sockets ||
	    (sockp = pcmcia_sockets[socket]) == NULL)
		return (BAD_SOCKET);

	return (RESET_SOCKET(sockp->ls_if, sockp->ls_adapter->pca_dip,
	    sockp->ls_socket, mode));
}

static int
SSSetPage(set_page_t *page)
{
	int window, retval;
	set_page_t newpage;
	pcmcia_logical_window_t *winp;

	window = page->window;
	if (window > pcmcia_num_windows) {
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug > 1)
			cmn_err(CE_CONT, "SSSetPage: window=%d (of %d)\n",
			    window, pcmcia_num_windows);
#endif
		return (BAD_WINDOW);
	}

	winp = pcmcia_windows[window];
	newpage = *page;
	newpage.window = winp->lw_window;
	retval = SET_PAGE(winp->lw_if, winp->lw_adapter->pca_dip, &newpage);
	if (retval == SUCCESS) {
		newpage.window = window;
		*page = newpage;
	}
#if defined(PCMCIA_DEBUG)
	if ((pcmcia_debug > 1) && retval != SUCCESS)
		cmn_err(CE_CONT, "\tSetPage: returning error %x\n", retval);
#endif
	return (retval);
}

static int
SSSetWindow(set_window_t *win)
{
	int socket, window, retval, func;
	set_window_t newwin;
	pcmcia_logical_window_t *winp;
	pcmcia_logical_socket_t *sockp;

	window = win->window;
	if (window > pcmcia_num_windows)
		return (BAD_WINDOW);

	socket = CS_GET_SOCKET_NUMBER(win->socket);
	func = CS_GET_FUNCTION_NUMBER(win->socket);

	if (socket > pcmcia_num_sockets ||
	    (sockp = pcmcia_sockets[socket]) == NULL) {
		return (BAD_SOCKET);
	}

	winp = pcmcia_windows[window];
	winp->lw_socket = win->socket; /* reverse map */
	newwin = *win;
	newwin.window = winp->lw_window;
	newwin.socket = sockp->ls_socket;
	newwin.child = sockp->ls_dip[func]; /* so we carry the dip around */

	retval = SET_WINDOW(winp->lw_if, winp->lw_adapter->pca_dip, &newwin);
	if (retval == SUCCESS) {
		newwin.window = window;
		newwin.socket = winp->lw_socket;
		*win = newwin;
	}
	return (retval);
}

static int
SSSetSocket(set_socket_t *socket)
{
	int sock, retval;
	pcmcia_logical_socket_t *sockp;
	set_socket_t newsock;

	sock = socket->socket;
	if (sock > pcmcia_num_sockets ||
	    (sockp = pcmcia_sockets[sock]) == NULL) {
		return (BAD_SOCKET);
	}

	newsock = *socket;
	/* note: we force CS to always get insert/removal events */
	sockp->ls_cs_events = pcm_mapevents(newsock.SCIntMask) |
	    PCE_E2M(PCE_CARD_INSERT) | PCE_E2M(PCE_CARD_REMOVAL) |
	    PCE_E2M(PCE_PM_SUSPEND);
#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug > 1)
		cmn_err(CE_CONT,
		    "SetSocket: SCIntMask = %x\n", newsock.SCIntMask);
#endif
	newsock.socket = sockp->ls_socket;
	newsock.VccLevel = pcmcia_map_power_set(sockp->ls_adapter,
	    newsock.VccLevel, VCC);
	newsock.Vpp1Level = pcmcia_map_power_set(sockp->ls_adapter,
	    newsock.Vpp1Level, VPP1);
	newsock.Vpp2Level = pcmcia_map_power_set(sockp->ls_adapter,
	    newsock.Vpp2Level, VPP2);
	retval = SET_SOCKET(sockp->ls_if, sockp->ls_adapter->pca_dip,
	    &newsock);
	if (retval == SUCCESS) {
		newsock.socket = sock;
		newsock.VccLevel = pcmcia_map_power_get(sockp->ls_adapter,
		    newsock.VccLevel,
		    VCC);
		newsock.Vpp1Level = pcmcia_map_power_get(sockp->ls_adapter,
		    newsock.Vpp1Level,
		    VPP1);
		newsock.Vpp2Level = pcmcia_map_power_get(sockp->ls_adapter,
		    newsock.Vpp2Level,
		    VPP2);
		*socket = newsock;
		if (socket->IREQRouting & IRQ_ENABLE) {
			sockp->ls_flags |= PCS_IRQ_ENABLED;
		} else {
			sockp->ls_flags &= ~PCS_IRQ_ENABLED;
		}
	}
	return (retval);
}

/*
 * SSSetIRQHandler()
 *	arrange for IRQ to be allocated if appropriate and always
 *	arrange that PC Card interrupt handlers get called.
 */
static int
SSSetIRQHandler(set_irq_handler_t *handler)
{
	int sock, retval, func;
	pcmcia_logical_socket_t *sockp;
	struct pcmcia_parent_private *ppd;
	dev_info_t *dip;
	ddi_iblock_cookie_t iblk;
	ddi_idevice_cookie_t idev;

	sock = CS_GET_SOCKET_NUMBER(handler->socket);
	func = CS_GET_FUNCTION_NUMBER(handler->socket);
	if (sock > pcmcia_num_sockets ||
	    (sockp = pcmcia_sockets[sock]) == NULL) {
		return (BAD_SOCKET);
	}
#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {

		cmn_err(CE_CONT, "SSSetIRQHandler: socket=%x, function=%x\n",
		    sock, func);
		cmn_err(CE_CONT, "\thandler(%p): socket=%x, irq=%x, id=%x\n",
		    (void *)handler->handler, handler->socket, handler->irq,
		    handler->handler_id);
	}
#endif
	dip = sockp->ls_dip[func];

	ppd = (struct pcmcia_parent_private *)ddi_get_parent_data(dip);

	handler->iblk_cookie = &iblk;
	handler->idev_cookie = &idev;

	retval = ddi_add_intr(dip, 0, handler->iblk_cookie,
	    handler->idev_cookie,
	    (uint32_t(*)(caddr_t))(uintptr_t) handler->handler,
	    handler->arg1);

	if (retval == DDI_SUCCESS) {
		handler->iblk_cookie = &sockp->ls_iblk;
		handler->idev_cookie = &sockp->ls_idev;
		handler->irq = ppd->ppd_intrspec->intrspec_vec;
		retval = SUCCESS;
	} else {
		retval = sockp->ls_error;
	}
	return (retval);
}

/*
 * SSClearIRQHandler()
 *	Arrange to have the interrupt handler specified removed
 *	from the interrupt list.
 */
static int
SSClearIRQHandler(clear_irq_handler_t *handler)
{
	int sock, func;
	pcmcia_logical_socket_t *sockp;
	dev_info_t *dip;

	sock = CS_GET_SOCKET_NUMBER(handler->socket);
	func = CS_GET_FUNCTION_NUMBER(handler->socket);

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {

		cmn_err(CE_CONT,
		    "SSClearIRQHandler: socket=%x, function=%x\n",
		    sock, func);
		cmn_err(CE_CONT,
		    "\thandler(%p): socket=%x, id=%x\n",
		    (void *)handler, handler->socket,
		    handler->handler_id);
	}
#endif

	if (sock > pcmcia_num_sockets ||
	    (sockp = pcmcia_sockets[sock]) == NULL) {
		return (BAD_SOCKET);
	}
	dip = sockp->ls_dip[func];
	if (dip) {
		ddi_remove_intr(dip, 0, NULL);
		return (SUCCESS);
	}
	return (BAD_SOCKET);
}


/*
 * pcm_pathname()
 *	make a partial path from dip.
 *	used to mknods relative to /devices/pcmcia/
 *
 * XXX - we now use ddi_get_name_addr to get the "address" portion
 *	of the name; that way, we only have to modify the name creation
 *	algorithm in one place
 */
static void
pcm_pathname(dev_info_t *dip, char *name, char *path)
{
	(void) sprintf(path, "%s@%s:%s", ddi_node_name(dip),
	    ddi_get_name_addr(dip), name);
}

/*
 * pcmcia_create_device()
 *	create the /devices entries for the driver
 *	it is assumed that the PC Card driver will do a
 *	RegisterClient for each subdevice.
 *	The device type string is encoded here to match
 *	the standardized names when possible.
 * XXX - note that we may need to provide a way for the
 *	caller to specify the complete name string that
 *	we pass to ddi_set_name_addr
 */
static int
pcmcia_create_device(ss_make_device_node_t *init)
{
	int err = SUCCESS;
	struct pcm_make_dev device;
	struct dev_ops *ops;
	major_t major;

	/*
	 * Now that we have the name, create it.
	 */

	bzero(&device, sizeof (device));
	if (init->flags & SS_CSINITDEV_CREATE_DEVICE) {
		if ((err = ddi_create_minor_node(init->dip,
		    init->name,
		    init->spec_type,
		    init->minor_num,
		    init->node_type,
		    0)) != DDI_SUCCESS) {
#if defined(PCMCIA_DEBUG)
			if (pcmcia_debug)
				cmn_err(CE_CONT,
				    "pcmcia_create_device: failed "
				    "create\n");
#endif
			return (BAD_ATTRIBUTE);
		}

		major = ddi_driver_major(init->dip);
		ops = ddi_get_driver(init->dip);
		LOCK_DEV_OPS(&devnamesp[major].dn_lock);
		INCR_DEV_OPS_REF(ops);
		(void) ddi_pathname(init->dip, device.path);
		DECR_DEV_OPS_REF(ops);
		UNLOCK_DEV_OPS(&devnamesp[major].dn_lock);
		(void) sprintf(device.path + strlen(device.path), ":%s",
		    init->name);

		(void) strcpy(device.driver, ddi_binding_name(init->dip));
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT,
			    "pcmcia_create_device: created %s "
			    "from %s [%s]\n",
			    device.path, init->name, device.driver);
#endif
		device.dev =
		    makedevice(ddi_driver_major(init->dip), init->minor_num);
		device.flags |= (init->flags & SS_CSINITDEV_MORE_DEVICES) ?
		    PCM_EVENT_MORE : 0;
		device.type = init->spec_type;
		device.op = SS_CSINITDEV_CREATE_DEVICE;
		device.socket = ddi_getprop(DDI_DEV_T_ANY, init->dip,
		    DDI_PROP_CANSLEEP, PCM_DEV_SOCKET,
		    -1);
	} else if (init->flags & SS_CSINITDEV_REMOVE_DEVICE) {
		device.op = SS_CSINITDEV_REMOVE_DEVICE;
		device.socket = ddi_getprop(DDI_DEV_T_ANY, init->dip,
		    DDI_PROP_CANSLEEP, PCM_DEV_SOCKET,
		    -1);
		if (init->name != NULL)
			(void) strcpy(device.path, init->name);
		device.dev = makedevice(ddi_driver_major(init->dip), 0);
		ddi_remove_minor_node(init->dip, init->name);
	}

	/*
	 *	we send an event for ALL devices created.
	 *	To do otherwise ties us to using drvconfig
	 *	forever.  There are relatively few devices
	 *	ever created so no need to do otherwise.
	 *	The existence of the event manager must never
	 *	be visible to a PCMCIA device driver.
	 */
	pcm_event_manager(PCE_INIT_DEV, device.socket, &device);

	return (err);
}

/*
 * pcmcia_get_minors()
 *	We need to traverse the minor node list of the
 *	dip if there are any.  This takes two passes;
 *	one to get the count and buffer size and the
 *	other to actually copy the data into the buffer.
 *	The framework requires that the dip be locked
 *	during this time to avoid breakage as well as the
 *	driver being locked.
 */
int
pcmcia_get_minors(dev_info_t *dip, struct pcm_make_dev **minors)
{
	int count = 0;
	struct ddi_minor_data *dp;
	struct pcm_make_dev *md;
	int socket;
	major_t major;
	struct dev_ops *ops;

	socket = ddi_getprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
	    PCM_DEV_SOCKET, -1);
	ndi_devi_enter(dip);
	if (DEVI(dip)->devi_minor != (struct ddi_minor_data *)NULL) {
		for (dp = DEVI(dip)->devi_minor;
		    dp != (struct ddi_minor_data *)NULL;
		    dp = dp->next) {
			count++; /* have one more */
		}
		/* we now know how many nodes to allocate */
		md = kmem_zalloc(count * sizeof (struct pcm_make_dev),
		    KM_NOSLEEP);
		if (md != NULL) {
			*minors = md;
			for (dp = DEVI(dip)->devi_minor;
			    dp != (struct ddi_minor_data *)NULL;
			    dp = dp->next, md++) {
#if defined(PCMCIA_DEBUG)
				if (pcmcia_debug > 1) {
					cmn_err(CE_CONT,
					    "pcmcia_get_minors: name=%s,"
					    "socket=%d, stype=%x, "
					    "ntype=%s, dev_t=%x",
					    dp->ddm_name,
					    socket,
					    dp->ddm_spec_type,
					    dp->ddm_node_type,
					    (int)dp->ddm_dev);
					cmn_err(CE_CONT,
					    "\tbind name = %s\n",
					    ddi_binding_name(dip));
				}
#endif
				md->socket = socket;
				md->op = SS_CSINITDEV_CREATE_DEVICE;
				md->dev = dp->ddm_dev;
				md->type = dp->ddm_spec_type;
				(void) strcpy(md->driver,
				    ddi_binding_name(dip));
				major = ddi_driver_major(dip);
				ops = ddi_get_driver(dip);
				LOCK_DEV_OPS(&devnamesp[major].dn_lock);
				pcm_pathname(dip, dp->ddm_name, md->path);
				INCR_DEV_OPS_REF(ops);
				(void) ddi_pathname(dip, md->path);
				DECR_DEV_OPS_REF(ops);
				UNLOCK_DEV_OPS(&devnamesp[major].dn_lock);
				(void) sprintf(md->path + strlen(md->path),
				    ":%s", dp->ddm_name);
				if (dp->next == NULL)
					/* no more */
					md->flags |= PCM_EVENT_MORE;
			}
		} else {
			count = 0;
		}
	}
	ndi_devi_exit(dip);
	return (count);
}

#if defined(PCMCIA_DEBUG)
static char *ddmtypes[] = { "minor", "alias", "default", "internal" };

static void
pcmcia_dump_minors(dev_info_t *dip)
{
	int count = 0;
	struct ddi_minor_data *dp;
	int unit, major;
	dev_info_t *np;

	unit = ddi_getprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
	    PCM_DEV_SOCKET, -1);
	cmn_err(CE_CONT,
	    "pcmcia_dump_minors: dip=%p, socket=%d\n", (void *)dip, unit);

	major = ddi_driver_major(dip);
	if (major != -1) {
		for (np = devnamesp[major].dn_head; np != NULL;
		    np = (dev_info_t *)DEVI(np)->devi_next) {
			char *cf2 = "";
			char *cur = "";
			if (i_ddi_node_state(np) == DS_READY)
				cf2 = "DS_READY";
			if (np == dip)
				cur = "CUR";
			cmn_err(CE_CONT, "\tsibs: %s %s %s\n",
			    ddi_binding_name(np), cf2, cur);

			ndi_devi_enter(np);
			if (DEVI(np)->devi_minor !=
			    (struct ddi_minor_data *)NULL) {
				for (dp = DEVI(np)->devi_minor;
				    dp != (struct ddi_minor_data *)NULL;
				    dp = dp->next) {
					count++; /* have one more */
				}
				for (dp = DEVI(dip)->devi_minor;
				    dp != (struct ddi_minor_data *)NULL;
				    dp = dp->next) {
					cmn_err(CE_CONT, "\ttype=%s, name=%s,"
					    "socket=%d, stype=%x, "
					    "ntype=%s, dev_t=%x",
					    ddmtypes[dp->type],
					    dp->ddm_name,
					    unit,
					    dp->ddm_spec_type,
					    dp->ddm_node_type,
					    (int)dp->ddm_dev);
					cmn_err(CE_CONT, "\tbind name = %s\n",
					    ddi_binding_name(np));
				}
			}
			ndi_devi_exit(np);
		}
	}
}
#endif

/*
 * experimental merging code
 * what are the things that we should merge on?
 *	match something by name in the "compatible" property
 *	restrict to a specific "socket"
 *	restrict to a specific "instance"
 */
/*ARGSUSED*/
static int
pcmcia_merge_conf(dev_info_t *dip)
{
	return (0);		/* merge failed */
}

/*
 * pcmcia_mfc_intr()
 *	Multifunction Card interrupt handler
 *	While some adapters share interrupts at the lowest
 *	level, some can't.  In order to be consistent, we
 *	split multifunction cards out with this intercept and
 *	allow the low level to do what is best for it.
 *	the arg is a pcmcia_socket structure and all interrupts
 *	are per-socket in this case.  We also have the option
 *	to optimize if the cards support it.  It also means
 *	that we can use the INTRACK mode if it proves desirable
 */
/*ARGSUSED*/
static uint32_t
pcmcia_mfc_intr(caddr_t arg1, caddr_t arg2)
{
	pcmcia_logical_socket_t *sockp;
	inthandler_t *intr, *first;
	int done, result;

	sockp = (pcmcia_logical_socket_t *)arg1;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug > 1) {
		cmn_err(CE_CONT, "pcmcia_mfc_intr sockp=%p"
		    " ls_inthandlers=%p\n"
		    "\t ls_flags=0x%x PCS_IRQ_ENABLED=0x%x \n",
		    (void *) sockp, (void *) sockp->ls_inthandlers,
		    sockp->ls_flags, PCS_IRQ_ENABLED);
	}
#endif

	if (sockp == NULL || sockp->ls_inthandlers == NULL ||
	    !(sockp->ls_flags & PCS_IRQ_ENABLED))
		return (DDI_INTR_UNCLAIMED);

	mutex_enter(&sockp->ls_ilock);
	for (done = 0, result = 0, first = intr = sockp->ls_inthandlers;
	    intr != NULL && !done; intr = intr->next) {
		result |= intr->intr(intr->arg1, intr->arg2);
		if (intr->next == first)
			done++;
	}
	if (intr == NULL) {
		cmn_err(CE_WARN, "pcmcia_mfc_intr: bad MFC handler list");
	}
	if (sockp->ls_inthandlers)
		sockp->ls_inthandlers = sockp->ls_inthandlers->next;

	mutex_exit(&sockp->ls_ilock);
	return (result ? DDI_INTR_CLAIMED : DDI_INTR_UNCLAIMED);
}

/*
 * pcmcia_power(dip)
 *	control power for nexus and children
 */
int
pcmcia_power(dev_info_t *dip, int component, int level)
{
#if 0
	anp_t *anp = (anp_t *)ddi_get_driver_private(dip);
	int i;
	/*
	 * for now, we only have one component.  Should there be one per-socket?
	 * the level is only one (power on or off)
	 */
	if (component != 0 || level > 1)
		return (DDI_FAILURE);

	for (i = 0; i < pcic->pc_numsockets; i++) {
		if (pcic->pc_callback)
			PC_CALLBACK(dip, pcic->pc_cb_arg,
			    (level == 0) ? PCE_PM_SUSPEND :
			    PCE_PM_RESUME,
			    i);
	}
#else
	cmn_err(CE_WARN, "pcmcia_power: component=%d, level=%d for %s",
	    component, level, ddi_get_name_addr(dip));
	return (DDI_FAILURE);
#endif
}

void
pcmcia_begin_resume(dev_info_t *dip)
{
	int i;
	struct pcmcia_adapter *adapt = NULL;
	for (i = 0; i < pcmcia_num_adapters; i++) {
		if (pcmcia_adapters[i]->pca_dip == dip) {
			adapt = pcmcia_adapters[i];
			break;
		}
	}
	if (adapt == NULL)
		return;

	for (i = 0; i < adapt->pca_numsockets; i++) {
		int s;
		s = adapt->pca_first_socket + i;
		if (pcmcia_sockets[s]->ls_flags & PCS_SUSPENDED) {
			if (pcmcia_sockets[s]->ls_flags &
			    (1 << PCE_PM_RESUME)) {
				(void) cs_event(PCE_PM_RESUME, s, 0);
				pcm_event_manager(PCE_PM_RESUME, s, NULL);
			}
			(void) cs_event(PCE_CARD_REMOVAL, s, 0);
			pcm_event_manager(PCE_CARD_REMOVAL, s, NULL);
		}
	}
}

/*
 * mark a cardbus card as "suspended" in the pcmcia module
 */
void
pcmcia_cb_suspended(int socket)
{
	mutex_enter(&pcmcia_global_lock);
	pcmcia_sockets[socket]->ls_flags |= PCS_SUSPENDED;
	mutex_exit(&pcmcia_global_lock);

}

/*
 * mark a cardbus card as "resumed" in the pcmcia module
 */
void
pcmcia_cb_resumed(int socket)
{
	if (pcmcia_sockets[socket]->ls_flags & PCS_SUSPENDED) {
		mutex_enter(&pcmcia_global_lock);
		pcmcia_sockets[socket]->ls_flags &= ~PCS_SUSPENDED;
		cv_broadcast(&pcmcia_condvar);
		mutex_exit(&pcmcia_global_lock);
#ifdef PCMCIA_DEBUG
		if (pcmcia_debug) {
			cmn_err(CE_NOTE, "pcmcia_cb_resume RESUMED");
		}
#endif
	}

}

void
pcmcia_wait_insert(dev_info_t *dip)
{
	int i, f, tries, done;
	struct pcmcia_adapter *adapt = NULL;
	anp_t *nexus;

	for (i = 0; i < pcmcia_num_adapters; i++) {
		if (pcmcia_adapters[i]->pca_dip == dip) {
			adapt = pcmcia_adapters[i];
			break;
		}
	}
	if (adapt == NULL)
		return;

	for (tries = adapt->pca_numsockets * 10; tries > 0; tries--) {
		done = 1;
		mutex_enter(&pcmcia_global_lock);
		for (i = 0; i < adapt->pca_numsockets; i++) {
			int s;
			s = adapt->pca_first_socket + i;
			for (f = 0; f < PCMCIA_MAX_FUNCTIONS; f++)
				if (pcmcia_sockets[s] &&
				    pcmcia_sockets[s]->ls_flags &
				    PCS_SUSPENDED) {

#ifdef PCMCIA_DEBUG
					if (pcmcia_debug) {
						cmn_err(CE_NOTE,
						    "pcmcia_wait_insert: "
						    "socket in SUSPENDED "
						    "state");
					}
#endif
					done = 0;
					break;
				}
		}
		if (!done) {
			(void) cv_reltimedwait(&pcmcia_condvar,
			    &pcmcia_global_lock, drv_usectohz(100000),
			    TR_CLOCK_TICK);
		} else {
			tries = 0;
		}
		mutex_exit(&pcmcia_global_lock);
	}

	if (tries == 0) {
		cmn_err(CE_NOTE, "pcmcia_wait_insert timed out");
	}

	nexus = (anp_t *)ddi_get_driver_private(dip);
	pcmcia_find_cards(nexus);
}

int
pcmcia_map_reg(dev_info_t *pdip, dev_info_t *dip, ra_return_t *ra,
		uint32_t state, caddr_t *base,
		ddi_acc_handle_t *handle, ddi_device_acc_attr_t *attrib,
		uint32_t req_base)
{
	struct pcmcia_parent_private *ppd;
	int rnum = 0, type = PCMCIA_MAP_MEM;
	ddi_map_req_t mr;
	ddi_acc_hdl_t *hp;
	int result;
	struct regspec *reg;
	ddi_device_acc_attr_t attr;

	if (dip != NULL) {
		ppd = (struct pcmcia_parent_private *)ddi_get_parent_data(dip);
		if (ppd == NULL)
			return (DDI_FAILURE);
		for (rnum = 1; rnum < ppd->ppd_nreg; rnum++) {
			struct pcm_regs *p;
			p = &ppd->ppd_reg[rnum];
			if (state & WS_IO) {
				/* need I/O */
				type = PCMCIA_MAP_IO;
				/*
				 * We want to find an IO regspec. When we
				 *	find one, it either has to match
				 *	the caller's requested base address
				 *	or it has to be relocatable.
				 * We match on the requested base address
				 *	rather than the allocated base
				 *	address so that we handle the case
				 *	of adapters that have IO window base
				 *	relocation registers.
				 */
				if ((p->phys_hi &
				    PC_REG_SPACE(PC_REG_SPACE_IO)) &&
				    ((req_base == p->phys_lo) ||
				    !(p->phys_hi & PC_REG_RELOC(1))))
					break;
			} else {
				/* need memory */
				type = PCMCIA_MAP_MEM;
				if (p->phys_hi &
				    PC_REG_SPACE(PC_REG_SPACE_MEMORY|
				    PC_REG_SPACE_ATTRIBUTE))
					break;
			}
		}
		if (rnum >= ppd->ppd_nreg)
			return (DDI_FAILURE);
	} else if (state & WS_IO) {
		return (DDI_FAILURE);
	}

	reg = kmem_zalloc(sizeof (pci_regspec_t), KM_SLEEP);
	reg = pcmcia_cons_regspec(pdip, type, (uchar_t *)reg, ra);

	if (attrib == NULL ||
	    attrib->devacc_attr_version != DDI_DEVICE_ATTR_V0) {
		attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
		attr.devacc_attr_endian_flags = DDI_NEVERSWAP_ACC;
		attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;
	} else {
		attr = *attrib;
	}
	/*
	 * Allocate and initialize the common elements of data access handle.
	 */
	*handle = impl_acc_hdl_alloc(KM_SLEEP, NULL);
	hp = impl_acc_hdl_get(*handle);
	hp->ah_vers = VERS_ACCHDL;
	hp->ah_dip = dip != NULL ? dip : pdip;
	hp->ah_rnumber = rnum;
	hp->ah_offset = 0;
	hp->ah_len = ra->ra_len;
	hp->ah_acc = attr;

	/*
	 * Set up the mapping request and call to parent.
	 */
	mr.map_op = DDI_MO_MAP_LOCKED;
	mr.map_type = DDI_MT_REGSPEC;
	mr.map_obj.rp = reg;
	mr.map_prot = PROT_READ | PROT_WRITE;
	mr.map_flags = DDI_MF_KERNEL_MAPPING;
	mr.map_handlep = hp;
	mr.map_vers = DDI_MAP_VERSION;

	result = ddi_map(pdip, &mr, 0, ra->ra_len, base);
	if (result != DDI_SUCCESS) {
		impl_acc_hdl_free(*handle);
		*handle = (ddi_acc_handle_t)NULL;
	} else {
		hp->ah_addr = *base;
		if (mr.map_op == DDI_MO_UNMAP)
			ra = NULL;
		if (dip != NULL)
			pcmcia_set_assigned(dip, rnum, ra);
	}

	kmem_free(reg, sizeof (pci_regspec_t));

	return (result);
}

struct pcmcia_adapter *
pcmcia_get_adapter(dev_info_t *dip)
{
	int i;

	for (i = 0; i < pcmcia_num_adapters; i++) {
		if (pcmcia_adapters[i] &&
		    pcmcia_adapters[i]->pca_dip == dip) {
			return (pcmcia_adapters[i]);
		}
	}
	return (NULL);
}


void
pcmcia_set_assigned(dev_info_t *dip, int rnum, ra_return_t *ret)
{
	struct pcmcia_parent_private *ppd;
	struct pcm_regs *reg, *assign;

	ppd = (struct pcmcia_parent_private *)ddi_get_parent_data(dip);
	if (ppd) {
		reg = &ppd->ppd_reg[rnum];
		assign = &ppd->ppd_assigned[rnum];
		if (ret) {
			if (assign->phys_hi == 0) {
				assign->phys_hi = reg->phys_hi;
				assign->phys_lo = ret->ra_addr_lo;
				assign->phys_len = ret->ra_len;
			} else if (assign->phys_lo != ret->ra_addr_lo) {
#ifdef PCMCIA_DEBUG
				cmn_err(CE_WARN, "pcmcia: bad address:"
				    "%s=<%x,%x>",
				    ddi_get_name_addr(dip),
				    ret->ra_addr_lo, assign->phys_lo);
#else
				cmn_err(CE_WARN, "!pcmcia: bad address:"
				    "%s=<%x,%x>",
				    ddi_get_name_addr(dip),
				    ret->ra_addr_lo, (int)assign->phys_lo);
#endif
			}
			assign->phys_hi = PC_INCR_REFCNT(assign->phys_hi);
		} else {
			int i;
			assign->phys_hi = PC_DECR_REFCNT(assign->phys_hi);
			i = PC_GET_REG_REFCNT(assign->phys_hi);
			if (i == 0) {
				assign->phys_hi = 0;
				assign->phys_lo = 0;
				assign->phys_len = 0;
			}
		}
	}
}

int
pcmcia_alloc_mem(dev_info_t *dip, ndi_ra_request_t *req, ra_return_t *ret,
		dev_info_t **res_dip)
{
	return (pcmcia_ra_alloc(dip, req, ret, NDI_RA_TYPE_MEM, res_dip));
}

int
pcmcia_alloc_io(dev_info_t *dip, ndi_ra_request_t *req, ra_return_t *ret,
		dev_info_t **res_dip)
{
	return (pcmcia_ra_alloc(dip, req, ret, NDI_RA_TYPE_IO, res_dip));
}

static boolean_t
is_subtractv(dev_info_t *dip)
{
	uint_t  class;

	if (dip == NULL)
		return (B_FALSE);
	class = ddi_getprop(DDI_DEV_T_ANY, dip,
	    DDI_PROP_CANSLEEP|DDI_PROP_DONTPASS,
	    "class-code", 0xff);
	if (class == PPB_SUBTRACTIVE) {
		return (B_TRUE);
	}
	return (B_FALSE);
}

/*
 * pcmcia_pci_alloc()
 *	allocate mem or I/O resource from the ancestor of the cardbus bridge.
 *	First start from the parent node. If the parent is a subtractive
 *	decode bridge and it does not have the requested resource, go up the
 *	device tree to find the resource.
 *
 *	dip		the parent node of the cardbus bridge
 *
 *	res_dip		returns a pointer to the node from which the
 *			resource is obtained. *res_dip could point to
 *			the parent or a higher level ancestor. *res_dip
 *			should be saved by the caller and later passed
 *			to pcmcia_ra_free();
 */
int
pcmcia_pci_alloc(dev_info_t *dip, ndi_ra_request_t *req, ra_return_t *ret,
		char *type, dev_info_t **res_dip)
{
	uint64_t base = 0;
	uint64_t len = 0;

	if ((ndi_ra_alloc(dip, req, &base, &len, type, NDI_RA_PASS)
	    == NDI_FAILURE) ||
	    ((base >> 32) != 0)) {
		if (is_subtractv(dip)) {
			return (pcmcia_pci_alloc(ddi_get_parent(dip),
			    req, ret, type, res_dip));

		} else {
			ret->ra_addr_hi = 0;
			ret->ra_addr_lo = 0;
			ret->ra_len = 0;
			return (DDI_FAILURE);
		}
	}
	ret->ra_addr_lo =  base & 0xffffffff;
	ret->ra_addr_hi = 0;
	ret->ra_len = len;
	*res_dip = dip;
	return (DDI_SUCCESS);
}

int
pcmcia_ra_alloc(dev_info_t *dip, ndi_ra_request_t *req, ra_return_t *ret,
		char *type, dev_info_t **res_dip)
{
	uint64_t base = 0;
	uint64_t len = 0;

	/*
	 * Allocate space from busra resource list
	 * should not return an address > 32 bits
	 */

	if ((ndi_ra_alloc(dip, req, &base, &len, type, NDI_RA_PASS)
	    == NDI_FAILURE) ||
	    ((base >> 32) != 0)) {
		return (pcmcia_pci_alloc(ddi_get_parent(dip), req, ret,
		    type, res_dip));
	} else {
		ret->ra_addr_lo =  base & 0xffffffff;
		ret->ra_addr_hi = 0;
		ret->ra_len = len;
		*res_dip = dip;
		return (DDI_SUCCESS);
	}
}

int
pcmcia_free_mem(dev_info_t *dip, ra_return_t *ret)
{
	return (pcmcia_ra_free(dip, ret, NDI_RA_TYPE_MEM));
}

int
pcmcia_free_io(dev_info_t *dip, ra_return_t *ret)
{
	return (pcmcia_ra_free(dip, ret, NDI_RA_TYPE_IO));
}

int
pcmcia_ra_free(dev_info_t *dip, ra_return_t *ret, char *type)
{
	if (dip == (dev_info_t *)-1)
		return (DDI_FAILURE);
	if (ndi_ra_free(dip, (uint64_t)ret->ra_addr_lo, (uint64_t)ret->ra_len,
	    type, NDI_RA_PASS) == NDI_SUCCESS) {
		return (DDI_SUCCESS);
	} else {
		return (DDI_FAILURE);
	}
}


/*
 * when the low level device configuration does resource assignment
 * (devconf) then free the allocated resources so we can reassign them
 * later.  Walk the child list to get them.
 */
void
pcmcia_free_resources(dev_info_t *self)
{
	struct regspec *assigned;
	int len;
	dev_info_t *dip;

	ndi_devi_enter(self);
	/* do searches in compatible property order */
	for (dip = (dev_info_t *)DEVI(self)->devi_child;
	    dip != NULL;
	    dip = (dev_info_t *)DEVI(dip)->devi_sibling) {
		len = 0;
		if (ddi_getlongprop(DDI_DEV_T_ANY, dip,
		    DDI_PROP_DONTPASS|DDI_PROP_CANSLEEP,
		    "assigned-addresses",
		    (caddr_t)&assigned,
		    &len) == DDI_PROP_SUCCESS) {
			/*
			 * if there are assigned resources at this point,
			 * then the OBP or devconf have assigned them and
			 * they need to be freed.
			 */
			kmem_free(assigned, len);
		}
	}
	ndi_devi_exit(self);
}

/*
 * this is the equivalent of pcm_get_intr using ra_allocs.
 * returns -1 if failed, otherwise returns the allocated irq.
 * The input request, if less than zero it means not a specific
 * irq requested. If larger then 0 then we are requesting that specific
 * irq
 */
int
pcmcia_get_intr(dev_info_t *dip, int request)
{
	ndi_ra_request_t req;
	uint64_t base;
	uint64_t len;
	int err;

	bzero(&req, sizeof (req));
	base = 0;
	len = 1;
	if (request >= 0) {
		req.ra_flags = NDI_RA_ALLOC_SPECIFIED;
		req.ra_len = 1;
		req.ra_addr = (uint64_t)request;
	}

	req.ra_boundbase = 0;
	req.ra_boundlen = 0xffffffffUL;
	req.ra_flags |= NDI_RA_ALLOC_BOUNDED;

	err = ndi_ra_alloc(dip, &req, &base, &len, NDI_RA_TYPE_INTR,
	    NDI_RA_PASS);

	if (err == NDI_FAILURE) {
		return (-1);
	} else {
		return ((int)base);
	}
}


int
pcmcia_return_intr(dev_info_t *dip, int request)
{
	if ((ndi_ra_free(dip, (uint64_t)request, 1, NDI_RA_TYPE_INTR,
	    NDI_RA_PASS)) == NDI_SUCCESS) {
		return (0);
	} else
		return (-1);

}

#ifdef sparc

int
pcmcia_add_intr_impl(dev_info_t *dip, dev_info_t *rdip,
    ddi_intr_handle_impl_t *hdlp)
{

	struct pcmcia_parent_private *ppd;
	pcmcia_logical_socket_t *sockp;
	int socket, ret;
	struct pcmcia_adapter *adapt;
	set_irq_handler_t handler;
	struct intrspec *pispec;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT,
		    "pcmcia_add_intr_impl() entered "
		    "dip=%p rdip=%p hdlp=%p \n",
		    (void *)dip, (void *)rdip, (void *)hdlp);
	}
#endif

	ppd = (struct pcmcia_parent_private *)ddi_get_parent_data(rdip);
	socket = ppd->ppd_socket;
	sockp = pcmcia_sockets[socket];
	adapt = sockp->ls_adapter;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT, "pcmcia_add_intr_impl()"
		    " ppd_flags=0X%x PPD_CARD_MULTI=0X%x\n"
		    " ppd_intrspec=%p ls_inthandlers=%p\n",
		    ppd->ppd_flags, PPD_CARD_MULTI,
		    (void *) ppd->ppd_intrspec,
		    (void *)sockp->ls_inthandlers);
	}
#endif

	/*
	 * calculate IPL level when we support multiple levels
	 */
	pispec = ppd->ppd_intrspec;
	if (pispec == NULL) {
		sockp->ls_error = BAD_IRQ;
		return (DDI_FAILURE);
	}

	handler.socket = sockp->ls_socket;
	handler.irq = 0;	/* default case */
	handler.handler = (f_tt *)hdlp->ih_cb_func;
	handler.arg1 = hdlp->ih_cb_arg1;
	handler.arg2 = hdlp->ih_cb_arg2;
	handler.handler_id = (uint32_t)(uintptr_t)rdip;

	/*
	 * check if multifunction and do the right thing
	 * we put an intercept in between the mfc handler and
	 * us so we can catch and process.  We might be able
	 * to optimize this depending on the card features
	 * (a future option).
	 */
	if (ppd->ppd_flags & PPD_CARD_MULTI) {
		inthandler_t *intr;
		/*
		 * note that the first function is a special
		 * case since it sets things up.  We fall through
		 * to the lower code and get the hardware set up.
		 * subsequent times we just lock the list and insert
		 * the handler and all is well.
		 */
		intr = kmem_zalloc(sizeof (inthandler_t), KM_NOSLEEP);
		if (intr == NULL) {
			sockp->ls_error = BAD_IRQ;
			return (DDI_FAILURE);
		}
		intr->intr = hdlp->ih_cb_func;
		intr->handler_id = (uint_t)(uintptr_t)rdip;
		intr->arg1 = hdlp->ih_cb_arg1;
		intr->arg2 = hdlp->ih_cb_arg2;
		intr->socket = socket;

		mutex_enter(&sockp->ls_ilock);
		if (sockp->ls_inthandlers == NULL) {
			intr->next = intr->prev = intr;
			sockp->ls_inthandlers = intr;
			sockp->ls_mfintr_dip = rdip;
			mutex_exit(&sockp->ls_ilock);

			/*
			 * replace first function handler with
			 * the mfc handler
			 */
			handler.handler =  (f_tt *)pcmcia_mfc_intr;
			handler.arg1 = (caddr_t)sockp;
			handler.arg2 = NULL;
		} else {
			insque(intr, sockp->ls_inthandlers);
			mutex_exit(&sockp->ls_ilock);

			pispec->intrspec_vec = sockp->ls_intr_vec;
			pispec->intrspec_pri = sockp->ls_intr_pri;
			hdlp->ih_pri = sockp->ls_intr_pri;

			return (DDI_SUCCESS);
		}
	}

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT, "pcmcia_add_intr_impl() let adapter do it\n");
	}
#endif
	pispec->intrspec_func = (uint32_t (*)())handler.handler;

	/* set default IPL then check for override */

	pispec->intrspec_pri = sockp->ls_intr_pri;
	hdlp->ih_pri = pispec->intrspec_pri;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT, "pcmcia_add_intr_impl() socket=%d irq=%d"
		    " handler_id=0X%x handler=%p arg1=%p arg2=%p\n",
		    handler.socket, handler.irq,
		    handler.handler_id, (void *)handler.handler, handler.arg1,
		    handler.arg2);
	}
#endif

	if ((ret = SET_IRQ(sockp->ls_if, adapt->pca_dip, &handler)) !=
	    SUCCESS) {
		sockp->ls_error = ret;
		return (DDI_FAILURE);
	}

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT, "pcmcia_add_intr_impl()"
		    " iblk_cookie=%p idev_cookie=%p\n"
		    " ls_flags=0X%x PCS_COOKIES_VALID=0X%x\n",
		    (void *)handler.iblk_cookie,
		    (void *)handler.idev_cookie,
		    sockp->ls_flags, PCS_COOKIES_VALID);
	}
#endif

	if (!(sockp->ls_flags & PCS_COOKIES_VALID)) {
		hdlp->ih_pri = (uint_t)(uintptr_t)*handler.iblk_cookie;
		sockp->ls_iblk = *handler.iblk_cookie;
		sockp->ls_idev = *handler.idev_cookie;
		sockp->ls_flags |= PCS_COOKIES_VALID;
	}

	return (DDI_SUCCESS);
}

void
pcmcia_remove_intr_impl(dev_info_t *dip, dev_info_t *rdip,
    ddi_intr_handle_impl_t *hdlp)
{

	struct pcmcia_parent_private *ppd;
	pcmcia_logical_socket_t *sockp;
	clear_irq_handler_t handler;
	struct intrspec *pispec;
	int socket;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT, "pcmcia_remove_intr_impl() entered"
		    " dip=%p rdip=%p hdlp=%p\n",
		    (void *)dip, (void *)rdip, (void *)hdlp);
	}
#endif

	ppd = (struct pcmcia_parent_private *)ddi_get_parent_data(rdip);
	socket = ppd->ppd_socket;
	sockp = pcmcia_sockets[socket];
	pispec = ppd->ppd_intrspec;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT, "pcmcia_remove_intr_impl()"
		    " ls_inthandlers=%p ls_intrspec=%p\n",
		    (void *)sockp->ls_inthandlers,
		    (void *)&sockp->ls_intrspec);
	}
#endif

	/* first handle the multifunction case since it is simple */
	mutex_enter(&sockp->ls_ilock);
	if (sockp->ls_inthandlers != NULL) {
		/* we must be MFC */
		inthandler_t *intr;
		int remhandler = 0;
		intr = sockp->ls_inthandlers;

		/* Check if there is only one handler left */
		if ((intr->next == intr) && (intr->prev == intr)) {
			if (intr->handler_id == (unsigned)(uintptr_t)rdip) {
				sockp->ls_inthandlers = NULL;
				remhandler++;
				kmem_free(intr, sizeof (inthandler_t));
			}
		} else {
			inthandler_t *first;
			int done;

			for (done = 0, first = intr; !done; intr = intr->next) {
				if (intr->next == first)
					done++;
				if (intr->handler_id ==
				    (unsigned)(uintptr_t)rdip) {
					done++;

					/*
					 * If we're about to remove the
					 *	handler at the head of
					 *	the list, make the next
					 *	handler in line the head.
					 */
					if (sockp->ls_inthandlers == intr)
						sockp->ls_inthandlers =
						    intr->next;

					remque(intr);
					kmem_free(intr, sizeof (inthandler_t));
					break;
				} /* handler_id */
			} /* for */
		} /* intr->next */

		if (!remhandler) {
			mutex_exit(&sockp->ls_ilock);
			return;
		}

		/* need to get the dip that was used to add the handler */
		rdip = sockp->ls_mfintr_dip;
	}

	mutex_exit(&sockp->ls_ilock);

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT, "pcmcia_remove_intr_impl()"
		    " pispec=%p rdip=%p\n",
		    (void *)pispec, (void *)rdip);
	}
#endif

	handler.socket = sockp->ls_socket;
	handler.handler_id = (uint32_t)(uintptr_t)rdip;
	handler.handler = (f_tt *)pispec->intrspec_func;
	CLEAR_IRQ(sockp->ls_if, dip, &handler);
}


/* Consolidated interrupt processing interface */
/*ARGSUSED*/
int
pcmcia_intr_ops(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t intr_op,
    ddi_intr_handle_impl_t *hdlp, void *result)
{
	int	ret = DDI_SUCCESS;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug) {
		cmn_err(CE_CONT, "pcmcia_intr_ops() intr_op=%d\n",
		    (int)intr_op);
	}
#endif

	switch (intr_op) {
	case DDI_INTROP_GETCAP:
		*(int *)result = DDI_INTR_FLAG_LEVEL;
		break;
	case DDI_INTROP_SETCAP:
		ret = DDI_ENOTSUP;
		break;
	case DDI_INTROP_ALLOC:
		*(int *)result = hdlp->ih_scratch1;
		break;
	case DDI_INTROP_FREE:
		break;
	case DDI_INTROP_GETPRI:
		if (pcmcia_add_intr_impl(dip, rdip, hdlp) != DDI_SUCCESS)
			return (DDI_FAILURE);
		*(int *)result = hdlp->ih_pri;
		pcmcia_remove_intr_impl(dip, rdip, hdlp);
		break;
	case DDI_INTROP_SETPRI:
		break;
	case DDI_INTROP_ADDISR:
		ret = pcmcia_add_intr_impl(dip, rdip, hdlp);
		break;
	case DDI_INTROP_REMISR:
		pcmcia_remove_intr_impl(dip, rdip, hdlp);
		break;
	case DDI_INTROP_ENABLE:
	case DDI_INTROP_DISABLE:
		break;
	case DDI_INTROP_NINTRS:
	case DDI_INTROP_NAVAIL:
		*(int *)result = i_ddi_get_intx_nintrs(rdip);
		break;
	case DDI_INTROP_SUPPORTED_TYPES:
		/* PCI nexus driver supports only fixed interrupts */
		*(int *)result = i_ddi_get_intx_nintrs(rdip) ?
		    DDI_INTR_TYPE_FIXED : 0;
		break;
	default:
		ret = DDI_ENOTSUP;
		break;
	}

	return (ret);
}

#elif defined(__x86)

static struct intrspec	*pcmcia_intr_get_ispec(dev_info_t *, int,
			    pcmcia_logical_socket_t **);
static struct intrspec	*pcmcia_intr_add_isr(dev_info_t *, dev_info_t *,
			    ddi_intr_handle_impl_t *);
static int		pcmcia_intr_enable_isr(dev_info_t *, dev_info_t *,
			    ddi_intr_handle_impl_t *);
static void		pcmcia_intr_remove_isr(dev_info_t *, dev_info_t *,
			    ddi_intr_handle_impl_t *);
static void		pcmcia_intr_disable_isr(dev_info_t *, dev_info_t *,
			    ddi_intr_handle_impl_t *);

/*
 * pcmcia_intr_get_ispec:
 *	This is mostly copied from older 'pcmcia_get_intrspec' function
 */
static struct intrspec *
pcmcia_intr_get_ispec(dev_info_t *rdip, int inum,
    pcmcia_logical_socket_t **sockp)
{
	int				socket;
	struct intrspec			*intrspec;
	struct pcmcia_parent_private	*ppd;

	if ((int)inum > 0 || (ddi_getprop(DDI_DEV_T_ANY, rdip,
	    DDI_PROP_DONTPASS, "interrupts", -1) < 0))
		return (NULL);

	ppd = (struct pcmcia_parent_private *)ddi_get_parent_data(rdip);
	if (ppd == NULL || ppd->ppd_intrspec == NULL)
		return (NULL);

	if ((socket = ppd->ppd_socket) < 0)
		return (NULL);

	if ((*sockp = pcmcia_sockets[socket]) == NULL)
		return (NULL);

	intrspec = ppd->ppd_intrspec;
	if (intrspec->intrspec_vec == 0 && (*sockp)->ls_intr_vec != 0)
		intrspec->intrspec_vec = (*sockp)->ls_intr_vec;

	return (intrspec);
}

static struct intrspec *
pcmcia_intr_add_isr(dev_info_t *dip, dev_info_t *rdip,
    ddi_intr_handle_impl_t *hdlp)
{
	int				socket;
	struct intrspec			*ispecp;
	struct pcmcia_adapter		*adapt;
	pcmcia_logical_socket_t		*sockp;
	struct pcmcia_parent_private	*ppd;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug)
		cmn_err(CE_CONT, "pcmcia_intr_add_isr: "
		    "dip=0x%p rdip=0x%p hdlp=0x%p\n",
		    (void *)dip, (void *)rdip, (void *)hdlp);
#endif	/* PCMCIA_DEBUG */

	ppd = (struct pcmcia_parent_private *)ddi_get_parent_data(rdip);
	socket = ppd->ppd_socket;
	sockp = pcmcia_sockets[socket];
	adapt = sockp->ls_adapter;

	ispecp = ppd->ppd_intrspec;
	if (ispecp == NULL) {
		sockp->ls_error = BAD_IRQ;
		return (ispecp);
	}

	/*
	 * check if multifunction and do the right thing
	 * we put an intercept in between the mfc handler and us so we can
	 * catch and process. We might be able to optimize this depending
	 * on the card features (a future option).
	 */
	if (ppd->ppd_flags & PPD_CARD_MULTI &&
	    hdlp->ih_cb_func != pcmcia_mfc_intr) {
		inthandler_t *intr;

		/*
		 * note that the first function is a special case since it
		 * sets things up.  We fall through to the lower code and
		 * get the hardware set up. Subsequent times we just lock
		 * the list and insert the handler and all is well.
		 */
		intr = kmem_zalloc(sizeof (inthandler_t), KM_NOSLEEP);
		if (intr == NULL) {
			sockp->ls_error = BAD_IRQ;
			return (NULL);
		}

		intr->intr = (uint32_t (*)())hdlp->ih_cb_func;
		intr->handler_id = (uint32_t)(uintptr_t)rdip;
		intr->arg1 = hdlp->ih_cb_arg1;
		intr->arg2 = hdlp->ih_cb_arg2;
		intr->socket = socket;
		mutex_enter(&sockp->ls_ilock);
		if (sockp->ls_inthandlers == NULL) {
			intr->next = intr->prev = intr;
			sockp->ls_inthandlers = intr;
			sockp->ls_mfintr_dip = rdip;
		} else {
			insque(intr, sockp->ls_inthandlers);
		}
		mutex_exit(&sockp->ls_ilock);
		return (ispecp);
	}

	/*
	 * Do we need to allocate an IRQ at this point or not?
	 */
	if (adapt->pca_flags & PCA_RES_NEED_IRQ) {
		int i, irq;

		/*
		 * this adapter needs IRQ allocations
		 * this is only necessary if it is the first function on the
		 * card being setup. The socket will keep the allocation info
		 */
		/* all functions use same intrspec except mfc handler */
		if (hdlp->ih_cb_func == pcmcia_mfc_intr) {
			/*
			 * We treat this special in order to allow things to
			 * work properly for MFC cards. The intrspec for the
			 * mfc dispatcher is intercepted and taken from the
			 * logical socket in order to not be trying to
			 * multiplex the meaning when ENABLE is called.
			 */
			ispecp = &sockp->ls_intrspec;
			((ihdl_plat_t *)hdlp->ih_private)->ip_ispecp = ispecp;
		}

		if (adapt->pca_flags & PCA_IRQ_ISA) {
			for (irq = -1, i = 1; irq == -1 && i < 16; i++) {
				/* find available and usable IRQ level */
				if (adapt->pca_avail_intr & (1 << i))
					irq = pcmcia_get_intr(dip, i);
			}
		}
		if (irq < 0) {
			sockp->ls_error = NO_RESOURCE;
			return (NULL);
		}
		hdlp->ih_vector = sockp->ls_intr_vec = irq;


#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT, "allocated irq=%x\n", irq);
#endif	/* PCMCIA_DEBUG */

		ispecp->intrspec_vec = sockp->ls_intr_vec;
		ispecp->intrspec_pri = sockp->ls_intr_pri;
		return (ispecp);
	}

	if (ispecp->intrspec_func != NULL)
		ispecp->intrspec_func = hdlp->ih_cb_func;

	/* set default IPL then check for override */
	ispecp->intrspec_pri = sockp->ls_intr_pri;
	return (ispecp);
}


static int
pcmcia_intr_enable_isr(dev_info_t *dip, dev_info_t *rdip,
    ddi_intr_handle_impl_t *hdlp)
{
	int				socket, ret;
	int				irq = 0;	/* default case */
	dev_info_t			*parent = ddi_root_node();
	struct intrspec			*ispecp;
	set_irq_handler_t		handler;
	struct pcmcia_adapter		*adapt;
	pcmcia_logical_socket_t		*sockp;
	struct pcmcia_parent_private	*ppd;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug)
		cmn_err(CE_CONT, "pcmcia_intr_enable_isr: "
		    "dip=0x%p rdip=0x%p hdlp=0x%p\n",
		    (void *)dip, (void *)rdip, (void *)hdlp);
#endif	/* PCMCIA_DEBUG */

	ppd = (struct pcmcia_parent_private *)ddi_get_parent_data(rdip);
	socket = ppd->ppd_socket;
	sockp = pcmcia_sockets[socket];
	adapt = sockp->ls_adapter;

	ispecp = ppd->ppd_intrspec;
	ASSERT(ispecp);

	mutex_enter(&sockp->ls_ilock);
	if ((sockp->ls_inthandlers != NULL) &&
	    ((ihdl_plat_t *)hdlp->ih_private)->ip_ispecp !=
	    &sockp->ls_intrspec) {
		inthandler_t *intr = sockp->ls_inthandlers;

		ASSERT(ppd->ppd_flags & PPD_CARD_MULTI);

		/* Only one handler. So, call ddi_add_intr on it */
		if ((intr->next == intr) && (intr->prev == intr)) {
			hdlp->ih_cb_func = pcmcia_mfc_intr;
			hdlp->ih_cb_arg1 = (caddr_t)sockp;
			hdlp->ih_cb_arg2 = NULL;

			ret = (*(DEVI(parent)->devi_ops->devo_bus_ops->
			    bus_intr_op))(parent, rdip, DDI_INTROP_ENABLE,
			    hdlp, NULL);

			if (ret == DDI_FAILURE) {
				sockp->ls_inthandlers = NULL;
				kmem_free(intr, sizeof (inthandler_t));
				sockp->ls_error = BAD_IRQ;
				mutex_exit(&sockp->ls_ilock);
				return (ret);
			}
		}
		mutex_exit(&sockp->ls_ilock);
		hdlp->ih_vector = ispecp->intrspec_vec = sockp->ls_intr_vec;
		hdlp->ih_pri = sockp->ls_intr_pri;
		sockp->ls_iblk = (ddi_iblock_cookie_t)(uintptr_t)
		    sockp->ls_intr_pri;
		sockp->ls_idev.idev_vector = (ushort_t)hdlp->ih_vector;
		sockp->ls_idev.idev_priority = (ushort_t)sockp->ls_intr_pri;
		return (DDI_SUCCESS);
	}
	mutex_exit(&sockp->ls_ilock);

	if (adapt->pca_flags & PCA_RES_NEED_IRQ) {
		if (hdlp->ih_cb_func == pcmcia_mfc_intr)
			ispecp = (struct intrspec *)&sockp->ls_intrspec;

		/* XXX: remove it later as this is done in _add_isr as well */
		ispecp->intrspec_vec = sockp->ls_intr_vec;
		ispecp->intrspec_pri = sockp->ls_intr_pri;

		/* Enable interrupts */
		ret = (*(DEVI(parent)->devi_ops->devo_bus_ops->bus_intr_op))(
		    parent, rdip, DDI_INTROP_ENABLE, hdlp, NULL);

		sockp->ls_iblk = (ddi_iblock_cookie_t)(uintptr_t)
		    sockp->ls_intr_pri;
		sockp->ls_idev.idev_vector = (ushort_t)sockp->ls_intr_vec;
		sockp->ls_idev.idev_priority = (ushort_t)sockp->ls_intr_pri;

		if (ret != DDI_SUCCESS)
			sockp->ls_error = BAD_IRQ;
		return (ret);
	}

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug)
		cmn_err(CE_CONT, "pcmcia_intr_enable_isr; let adapter do it\n");
#endif	/* PCMCIA_DEBUG */

	handler.socket = sockp->ls_socket;
	handler.irq = irq;
	handler.handler = (f_tt *)(uintptr_t)hdlp->ih_cb_func;
	handler.arg1 = hdlp->ih_cb_arg1;
	handler.arg2 = hdlp->ih_cb_arg2;
	handler.handler_id = (uint32_t)(uintptr_t)rdip;
	if (ispecp->intrspec_func != NULL)
		ispecp->intrspec_func = hdlp->ih_cb_func;

	/* set default IPL then check for override */
	ispecp->intrspec_pri = sockp->ls_intr_pri;

	if ((ret = SET_IRQ(sockp->ls_if, adapt->pca_dip, &handler)) !=
	    SUCCESS) {
		sockp->ls_error = ret;
		return (DDI_FAILURE);
	}
	ispecp->intrspec_func = hdlp->ih_cb_func;
	if (!(sockp->ls_flags & PCS_COOKIES_VALID)) {
		sockp->ls_iblk = *handler.iblk_cookie;
		sockp->ls_idev = *handler.idev_cookie;
		sockp->ls_flags |= PCS_COOKIES_VALID;
	}
	return (DDI_SUCCESS);
}

/* ARGSUSED */
static void
pcmcia_intr_remove_isr(dev_info_t *dip, dev_info_t *rdip,
    ddi_intr_handle_impl_t *hdlp)
{
	int				done, remhandler = 0;
	inthandler_t			*intr, *first;
	struct intrspec			*ispecp;
	pcmcia_logical_socket_t		*sockp;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug)
		cmn_err(CE_CONT, "pcmcia_intr_remove_isr: "
		    "dip=0x%p rdip=0x%p hdlp=0x%p\n",
		    (void *)dip, (void *)rdip, (void *)hdlp);
#endif	/* PCMCIA_DEBUG */

	ispecp = pcmcia_intr_get_ispec(rdip, hdlp->ih_inum, &sockp);
	ASSERT(ispecp);

	/* first handle the multifunction case since it is simple */
	mutex_enter(&sockp->ls_ilock);
	if (sockp->ls_inthandlers != NULL &&
	    ((ihdl_plat_t *)hdlp->ih_private)->ip_ispecp !=
	    &sockp->ls_intrspec) {

		intr = sockp->ls_inthandlers;

		/* Check if there is only one handler left */
		if ((intr->next == intr) && (intr->prev == intr)) {
			if (intr->handler_id == (uint32_t)(uintptr_t)rdip) {
				sockp->ls_inthandlers = NULL;
				remhandler++;
				kmem_free(intr, sizeof (inthandler_t));
			}

		} else {
			for (done = 0, first = intr; !done; intr = intr->next) {
				if (intr->next == first)
					done++;
				if (intr->handler_id ==
				    (uint32_t)(uintptr_t)rdip) {
					done++;

					/*
					 * If we're about to remove the handler
					 * at the head of the list, make the
					 * next handler in line the head.
					 */
					if (sockp->ls_inthandlers == intr)
						sockp->ls_inthandlers =
						    intr->next;

					remque(intr);
					kmem_free(intr, sizeof (inthandler_t));
					break;
				} /* handler_id */
			} /* end of for */
		} /* end of if intr->next */

		if (!remhandler) {
			mutex_exit(&sockp->ls_ilock);
			return;
		}
	}
	mutex_exit(&sockp->ls_ilock);

	if (sockp->ls_adapter->pca_flags & PCA_RES_NEED_IRQ) {
		sockp->ls_intr_vec = 0;
		ispecp->intrspec_vec = 0;
	}
}


static void
pcmcia_intr_disable_isr(dev_info_t *dip, dev_info_t *rdip,
    ddi_intr_handle_impl_t *hdlp)
{
	int				socket, ret;
	dev_info_t			*parent;
	struct intrspec			*ispecp;
	clear_irq_handler_t		handler;
	struct pcmcia_adapter		*adapt;
	pcmcia_logical_socket_t		*sockp;
	struct pcmcia_parent_private	*ppd;
	ihdl_plat_t			*ihdl_plat_datap =
	    (ihdl_plat_t *)hdlp->ih_private;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug)
		cmn_err(CE_CONT, "pcmcia_intr_disable_isr: "
		    "dip=0x%p rdip=0x%p hdlp=0x%p\n",
		    (void *)dip, (void *)rdip, (void *)hdlp);
#endif	/* PCMCIA_DEBUG */

	ppd = (struct pcmcia_parent_private *)ddi_get_parent_data(rdip);
	socket = ppd->ppd_socket;
	sockp = pcmcia_sockets[socket];
	adapt = sockp->ls_adapter;
	ispecp = ppd->ppd_intrspec;
	ASSERT(ispecp);

	mutex_enter(&sockp->ls_ilock);
	if (sockp->ls_inthandlers != NULL &&
	    ihdl_plat_datap->ip_ispecp != &sockp->ls_intrspec) {
		inthandler_t	*intr = sockp->ls_inthandlers;

		/* Check if there is only one handler left */
		if ((intr->next == intr) && (intr->prev == intr)) {
			if (intr->handler_id != (uint32_t)(uintptr_t)rdip) {
				/*
				 * need to get the dip that was
				 * used to add the handler
				 */
				rdip = sockp->ls_mfintr_dip;
			}
			ispecp = (struct intrspec *)&sockp->ls_intrspec;
		} else {
			/* Don't call cleanup if list still has members */
			mutex_exit(&sockp->ls_ilock);
			return;
		}
	}
	mutex_exit(&sockp->ls_ilock);

	if (ihdl_plat_datap->ip_ispecp ==
	    (struct intrspec *)&sockp->ls_intrspec)
		ispecp = ihdl_plat_datap->ip_ispecp;

	if (adapt->pca_flags & PCA_RES_NEED_IRQ) {
		ret = ispecp->intrspec_vec;
		parent = ddi_root_node();
		ret = (*(DEVI(parent)->devi_ops->devo_bus_ops->bus_intr_op))(
		    parent, rdip, DDI_INTROP_DISABLE, hdlp, NULL);
		(void) pcmcia_return_intr(dip, hdlp->ih_vector);
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT, "pcmcia_intr_disable_isr: "
			    "INTROP_DISABLE returned %x\n", ret);
#endif	/* PCMCIA_DEBUG */
	} else {
		handler.socket = sockp->ls_socket;
		handler.handler_id = (uint32_t)(uintptr_t)rdip;
		handler.handler = (f_tt *)ispecp->intrspec_func;
		ret = CLEAR_IRQ(sockp->ls_if, dip, &handler);
#if defined(PCMCIA_DEBUG)
		if (pcmcia_debug)
			cmn_err(CE_CONT, "pcmcia_intr_disable_isr: "
			    "CLEAR_IRQ returned %x\n", ret);
#endif	/* PCMCIA_DEBUG */
	}
}

/* Consolidated interrupt processing interface */
int
pcmcia_intr_ops(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t intr_op,
    ddi_intr_handle_impl_t *hdlp, void *result)
{
	struct intrspec		*ispecp;
	pcmcia_logical_socket_t	*sockp;

#if defined(PCMCIA_DEBUG)
	if (pcmcia_debug)
		cmn_err(CE_CONT, "pcmcia_intr_ops: "
		    "dip=0x%p rdip=0x%p op=0x%x hdlp=0x%p\n",
		    (void *)dip, (void *)rdip, intr_op, (void *)hdlp);
#endif	/* PCMCIA_DEBUG */

	switch (intr_op) {
	case DDI_INTROP_SUPPORTED_TYPES:
		if (ddi_get_parent_data(rdip) == NULL) {
			*(int *)result = 0;
			return (DDI_FAILURE);
		}
		*(int *)result = DDI_INTR_TYPE_FIXED;
		break;
	case DDI_INTROP_GETCAP:
		*(int *)result = DDI_INTR_FLAG_LEVEL;
		break;
	case DDI_INTROP_NINTRS:
	case DDI_INTROP_NAVAIL:
		if (i_ddi_get_intx_nintrs(rdip) == 0) {
			*(int *)result = 0;
			return (DDI_FAILURE);
		}
		*(int *)result = 1;	/* for PCMCIA there is only one intr */
		break;
	case DDI_INTROP_ALLOC:
		if ((ispecp = pcmcia_intr_get_ispec(rdip, hdlp->ih_inum,
		    &sockp)) == NULL)
			return (DDI_FAILURE);
		*(int *)result = hdlp->ih_scratch1;
		break;
	case DDI_INTROP_FREE:
		break;
	case DDI_INTROP_GETPRI:
		ispecp = pcmcia_intr_get_ispec(rdip, hdlp->ih_inum, &sockp);
		if (ispecp == NULL) {
			*(int *)result = 0;
			return (DDI_FAILURE);
		}

		*(int *)result = ispecp->intrspec_pri = sockp->ls_intr_pri;
		break;
	case DDI_INTROP_SETPRI:
		if (*(int *)result > LOCK_LEVEL)
			return (DDI_FAILURE);
		ispecp = pcmcia_intr_get_ispec(rdip, hdlp->ih_inum, &sockp);
		ASSERT(ispecp);
		ispecp->intrspec_pri = sockp->ls_intr_pri = *(int *)result;
		break;
	case DDI_INTROP_ADDISR:
		if ((ispecp = pcmcia_intr_add_isr(dip, rdip, hdlp)) == NULL)
			return (DDI_FAILURE);
		((ihdl_plat_t *)hdlp->ih_private)->ip_ispecp = ispecp;
		break;
	case DDI_INTROP_REMISR:
		pcmcia_intr_remove_isr(dip, rdip, hdlp);
		break;
	case DDI_INTROP_ENABLE:
		if (pcmcia_intr_enable_isr(dip, rdip, hdlp) != DDI_SUCCESS)
			return (DDI_FAILURE);
		break;
	case DDI_INTROP_DISABLE:
		pcmcia_intr_disable_isr(dip, rdip, hdlp);
		break;
	default:
		return (DDI_ENOTSUP);
	}

	return (DDI_SUCCESS);
}
#endif
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


#include <sys/types.h>
#include <sys/byteorder.h>
#include <sys/systm.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>

int pcs_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
int pcs_attach(dev_info_t *, ddi_attach_cmd_t);
int pcs_detach(dev_info_t *, ddi_detach_cmd_t);
dev_info_t *pcs_dip;

static struct dev_ops pcs_devops = {
	DEVO_REV,
	0,
	pcs_getinfo,
	nulldev,
	nulldev,
	pcs_attach,
	pcs_detach,
	nulldev,
	NULL,
	NULL,
	NULL,
	ddi_quiesce_not_needed,		/* quiesce */
};
/*
 * This is the loadable module wrapper.
 */
#include <sys/modctl.h>

extern struct mod_ops mod_driverops;

static struct modldrv modldrv = {
	&mod_driverops,		/* Type of module. This one is a driver */
	"PCMCIA Socket Driver",	/* Name of the module. */
	&pcs_devops,		/* driver ops */
};

static struct modlinkage modlinkage = {
	MODREV_1, (void *)&modldrv, NULL
};

struct pcs_inst {
	dev_info_t *dip;
} *pcs_instances;

int
_init()
{
	int ret;
	if ((ret = ddi_soft_state_init((void **)&pcs_instances,
	    sizeof (struct pcs_inst), 1)) != 0)
		return (ret);
	if ((ret = mod_install(&modlinkage)) != 0) {
		ddi_soft_state_fini((void **)&pcs_instances);
	}
	return (ret);
}

int
_fini()
{
	int ret;
	ret = mod_remove(&modlinkage);
	if (ret == 0) {
		ddi_soft_state_fini((void **)&pcs_instances);
	}
	return (ret);
}

int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}

int
pcs_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
{
	int error = DDI_SUCCESS;
	int inum;
	struct pcs_inst *inst;
#ifdef lint
	dip = dip;
#endif

	switch (cmd) {
	case DDI_INFO_DEVT2DEVINFO:
		inum = getminor((dev_t)arg);
		inst = (struct pcs_inst *)ddi_get_soft_state(pcs_instances,
		    inum);
		if (inst == NULL)
			error = DDI_FAILURE;
		else
			*result = inst->dip;
		break;
	case DDI_INFO_DEVT2INSTANCE:
		inum = getminor((dev_t)arg);
		inst = (struct pcs_inst *)ddi_get_soft_state(pcs_instances,
		    inum);
		if (inst == NULL)
			error = DDI_FAILURE;
		else
			*result = (void *)(uintptr_t)inum;
		break;
	default:
		error = DDI_FAILURE;
	}
	return (error);
}

int
pcs_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	int ret = DDI_SUCCESS;
	int inum;
	struct pcs_inst *inst;

	switch (cmd) {
	case DDI_RESUME:
		return (DDI_SUCCESS);
	case DDI_ATTACH:
		break;
	default:
		return (DDI_FAILURE);
	}

	inum = ddi_get_instance(dip);

	if (ddi_soft_state_zalloc(pcs_instances, inum) == DDI_SUCCESS) {
		inst = (struct pcs_inst *)ddi_get_soft_state(pcs_instances,
		    inum);
		if (inst == NULL)
			ret = DDI_FAILURE;
		else
			inst->dip = dip;
	}

	return (ret);
}

int
pcs_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	switch (cmd) {
	case DDI_DETACH:
		ddi_soft_state_free(pcs_instances, ddi_get_instance(dip));
		return (DDI_SUCCESS);

	case DDI_SUSPEND:
	case DDI_PM_SUSPEND:
		return (DDI_SUCCESS);
	default:
		break;
	}
	return (DDI_FAILURE);
}
#
# 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
#
#
#ident	"%W%	%E% SMI"
#
# Copyright (c) 1995-1996 by Sun Microsystems, Inc.
# All rights reserved.
#
# uts/common/pcmcia/sys/Makefile
#
# include global definitions
include ../../../../Makefile.master

HDRS=	cis.h			\
	cis_handlers.h		\
	cis_protos.h		\
	cs.h			\
	cs_priv.h		\
	cs_strings.h		\
	cs_types.h		\
	cs_stubs.h

ROOTDIR=	$(ROOT)/usr/include/sys
ROOTHDRS=	$(HDRS:%=$(ROOTDIR)/%)

# install rules

$(ROOTDIR)/%: %
	$(INS.file)

CHECKHDRS= $(HDRS:%.h=%.check)

.KEEP_STATE:

.PARALLEL: $(CHECKHDRS)

install_h: $(ROOTDIR) .WAIT $(ROOTHDRS)

$(ROOTDIR):
	$(INS.dir)

check:	$(CHECKHDRS)
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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.
 */

#ifndef _CIS_H
#define	_CIS_H

/*
 * This is the Card Services Card Information Structure (CIS) interpreter
 *	header file.  CIS information in this file is based on the
 *	Release 2.01 PCMCIA standard.
 */


#ifdef	__cplusplus
extern "C" {
#endif


#if defined(DEBUG)
#define	CIS_DEBUG
#endif


/*
 * The CIS interpreter has a single entry point with a bunch of function
 *	id numbers.
 */
#define	CISP_CIS_SETUP		0x01	/* setup CS address in CIS */
#define	CISP_CIS_LIST_CREATE	0x02	/* create the CIS linked list */
#define	CISP_CIS_LIST_DESTROY	0x03	/* destroy the CIS linked list */
#define	CISP_CIS_GET_LTUPLE	0x04	/* get a tuple */
#define	CISP_CIS_PARSE_TUPLE	0x05	/* parse a tuple */
#define	CISP_CIS_CONV_DEVSPEED	0x06	/* convert devspeed to nS and back */
#define	CISP_CIS_CONV_DEVSIZE	0x07	/* convert device size */

/*
 * Make the  calls to CardServices look like function calls.
 */
#define	CIS_CARD_SERVICES	(*cis_card_services)

/*
 * define the tuples that we recognize
 *
 * Layer 1 - Basic Compatability TUples
 */
#define	CISTPL_NULL		0x000	/* null tuple - ignore */
#define	CISTPL_DEVICE		0x001	/* device information */
#define	CISTPL_LONGLINK_CB	0x002	/* longlink to next tuple chain */
#define	CISTPL_CONFIG_CB	0x004	/* configuration tuple */
#define	CISTPL_CFTABLE_ENTRY_CB	0x005	/* configuration table entry */
#define	CISTPL_LONGLINK_MFC	0x006	/* multi-function tuple */
#define	CISTPL_BAR		0x007	/* Base Address Register definition */
#define	CISTPL_CHECKSUM		0x010	/* checksum control */
#define	CISTPL_LONGLINK_A	0x011	/* long-link to AM */
#define	CISTPL_LONGLINK_C	0x012	/* long-link to CM */
#define	CISTPL_LINKTARGET	0x013	/* link-target control */
#define	CISTPL_NO_LINK		0x014	/* no-link control */
#define	CISTPL_VERS_1		0x015	/* level 1 version information */
#define	CISTPL_ALTSTR		0x016	/* alternate language string */
#define	CISTPL_DEVICE_A		0x017	/* AM device information */
#define	CISTPL_JEDEC_C		0x018	/* JEDEC programming info for CM */
#define	CISTPL_JEDEC_A		0x019	/* JEDEC programming info for AM */
#define	CISTPL_CONFIG		0x01a	/* configuration */
#define	CISTPL_CFTABLE_ENTRY	0x01b	/* configuration-table-entry */
#define	CISTPL_DEVICE_OC	0x01c	/* other op conditions CM device info */
#define	CISTPL_DEVICE_OA	0x01d	/* other op conditions AM device info */
#define	CISTPL_DEVICEGEO	0x01e	/* Common Memory device geometry */
#define	CISTPL_DEVICEGEO_A	0x01f	/* Attribute Memory device geometry */
#define	CISTPL_MANFID		0x020	/* manufacturer identification */
#define	CISTPL_FUNCID		0x021	/* function identification */
#define	CISTPL_FUNCE		0x022	/* function extension */

/*
 * Layer 2 - Data Recording Format Tuples
 */
#define	CISTPL_SWIL		0x023	/* software interleave */
#define	CISTPL_VERS_2		0x040	/* level 2 version information */
#define	CISTPL_FORMAT		0x041	/* Common Memory recording format */
#define	CISTPL_GEOMETRY		0x042	/* geometry */
#define	CISTPL_BYTEORDER	0x043	/* byte order */
#define	CISTPL_DATE		0x044	/* card initialization date */
#define	CISTPL_BATTERY		0x045	/* battery replacement date */
#define	CISTPL_FORMAT_A		0x047	/* Attribute Memory recording format */

/*
 * Layer 3 - Data Organization Tuples
 */
#define	CISTPL_ORG		0x046	/* organization */

/*
 * Layer 4 - System Specific Standard Tuples
 */
#define	CISTPL_VEND_SPEC_80	0x080	/* vendor-specific 0x80 */
#define	CISTPL_VEND_SPEC_81	0x081	/* vendor-specific 0x81 */
#define	CISTPL_VEND_SPEC_82	0x082	/* vendor-specific 0x82 */
#define	CISTPL_VEND_SPEC_83	0x083	/* vendor-specific 0x83 */
#define	CISTPL_VEND_SPEC_84	0x084	/* vendor-specific 0x84 */
#define	CISTPL_VEND_SPEC_85	0x085	/* vendor-specific 0x85 */
#define	CISTPL_VEND_SPEC_86	0x086	/* vendor-specific 0x86 */
#define	CISTPL_VEND_SPEC_87	0x087	/* vendor-specific 0x87 */
#define	CISTPL_VEND_SPEC_88	0x088	/* vendor-specific 0x88 */
#define	CISTPL_VEND_SPEC_89	0x089	/* vendor-specific 0x89 */
#define	CISTPL_VEND_SPEC_8a	0x08a	/* vendor-specific 0x8a */
#define	CISTPL_VEND_SPEC_8b	0x08b	/* vendor-specific 0x8b */
#define	CISTPL_VEND_SPEC_8c	0x08c	/* vendor-specific 0x8c */
#define	CISTPL_VEND_SPEC_8d	0x08d	/* vendor-specific 0x8d */
#define	CISTPL_VEND_SPEC_8e	0x08e	/* vendor-specific 0x8e */
#define	CISTPL_VEND_SPEC_8f	0x08f	/* vendor-specific 0x8f */
#define	CISTPL_SPCL		0x090	/* special-purpose tuple */
#define	CISTPL_END		0x0ff	/* end-of-list tuple */

/*
 * Macro to check if tuple is a vendor-specific tuple.
 */
#define	CISTPL_VENDSPEC_START	CISTPL_VEND_SPEC_80
#define	CISTPL_VENDSPEC_END	CISTPL_VEND_SPEC_8f
#define	CISTPL_IS_VENDOR_SPECIFIC(td)	(((td) >= CISTPL_VENDSPEC_START) &&   \
						((td) <= CISTPL_VENDSPEC_END))

/*
 * The GetFirstTuple and GetNextTuple Card Services function calls use
 *	the DesiredTuple member of the tuple_t structure to determine
 *	while tuple type to return; since the CIS parser doesn't ever
 *	return CISTPL_END tuples, we can never ask for those tuples,
 *	so we overload this tuple code to mean that we want the
 *	first (or next) tuple in the chain.
 * XXX - If we ever do return CISTPL_END tuples, we'll have to
 *	re-think this.
 */
#define	RETURN_FIRST_TUPLE	0x0ff	/* return first/next tuple */
#define	RETURN_NEXT_TUPLE	0x0ff	/* return first/next tuple */

/*
 * types for data in CIS and pointers into PC card's CIS space
 *
 * The "size" member is used by the NEXT_CIS_ADDR macro so that
 *	we don't run past the end of the mapped CIS address space.
 */
typedef uchar_t cisdata_t;

typedef struct cisptr_t {
    acc_handle_t	handle;	/* access handle of CIS space */
    uint32_t		size;	/* size of mapped area */
    uint32_t		offset;	/* byte offset into CIS space */
	/* see flag definitions for cistpl_t structure */
    uint32_t		flags;
} cisptr_t;

/*
 * This is the maximum length that the data portion of a tuple can be.
 *	We have to use this since the brain-damaged 2.01 PCMCIA spec
 *	specifies that you can end a CIS chain by putting a CISTPL_END
 *	in the link field of the last VALID tuple.
 */
#define	CIS_MAX_TUPLE_DATA_LEN	254

/*
 * This is the maximum size of the string used to describe the name
 *	of the tuple.
 */
#define	CIS_MAX_TUPLE_NAME_LEN	40

/*
 * CIS_MAX_FUNCTIONS defines the maximum number of functions that can
 *	exist on a card.
 */
#define	CIS_MAX_FUNCTIONS	8	/* max number of functions per card */

/*
 * Macros to manipulate addresses and data in various CIS spaces
 *
 * NEXT_CIS_ADDR(cisptr_t *) increments the offset to point to the
 *	next data element in the CIS, based on what space the CIS
 *	we are reading resides in.  If the resulting address would
 *	be past the end of the mapped-in area, we return NULL,
 *	otherwise the adjusted offset value is returned. Note that
 *	this only works if the "size" member specifies the maximum
 *	mapped in window size and an "offset" member value of zero
 *	refers to the first byte of the window.
 *
 * GET_CIS_DATA(ptr) returns the data byte at the current CIS location.
 *
 * GET_CIS_ADDR(tp,ptr) returns the virtual address that was saved by a
 *	call to STORE_CIS_ADDR.
 *
 * BAD_CIS_ADDR is a flag that should be returned by callers of NEXT_CIS_ADDR
 *	if that macro returns NULL.  Note that this flag shares the same bit
 *	field definitions as the tuple handler flags defined in cis_handlers.h
 *	so check that file if you make any changes to these flags.
 * XXX - not the best distribution of flags, I'm afraid
 */
#define	NEXT_CIS_ADDR(ptr)	\
			(((ptr->flags&CISTPLF_AM_SPACE)?(ptr->offset += 2): \
				(ptr->offset++)),	\
				((ptr->offset > ptr->size)?(0):ptr->offset))
#define	GET_CIS_DATA(ptr)	csx_Get8(ptr->handle, ptr->offset)
#define	GET_CIS_ADDR(tp)	((cisdata_t *)(uintptr_t)(tp)->offset)
#define	BAD_CIS_ADDR	0x080000000 /* read past end of mapped CIS error */

/*
 * CIS_MEM_ALLOC(len) is used to allocate memory for our local linked
 *	CIS list; we use a macro so that the same code can be used in
 *	the kernel as well as in user space
 *
 * CIS_MEM_FREE(ptr) - same comment as CIS_MEM_ALLOC
 */
#if !defined(_KERNEL)
#ifdef	CISMALLOC_DEBUG
#define	CIS_MEM_ALLOC(len)		cis_malloc((uint32_t)len)
#define	CIS_MEM_FREE(ptr)		cis_free(ptr)
#else
#define	CIS_MEM_ALLOC(len)		malloc((uint32_t)len)
#define	CIS_MEM_FREE(ptr)		free(ptr)
#endif	/* CISMALLOC_DEBUG */
#else
#define	CIS_MEM_ALLOC(len)		cis_malloc((uint32_t)len)
#define	CIS_MEM_FREE(ptr)		cis_free(ptr)
#endif

typedef struct cis_u_malloc_tag_t {
	caddr_t		addr;
	uint32_t	len;
} cis_u_malloc_tag_t;

/*
 * We keep the tuples in a locally-maintained linked list.  This allows
 *	us to return the tuple information at any time to a client for
 *	those cards that make their CIS inaccessible once the card is
 *	configured.
 */
typedef struct cistpl_t {
	cisdata_t	type;	/* type of tuple */
	cisdata_t	len;	/* length of tuple data */
	cisdata_t	*data;	/* data in tuple */
	union {
		cisdata_t	*byte;	/* read pointer for GET_BYTE macros */
		uint16_t	*sword;
	}		read;
	uint32_t	flags;	/* misc flags */
	uint32_t	offset;	/* CIS address offset of start of tuple */
	struct cistpl_t	*prev;	/* back pointer */
	struct cistpl_t	*next;	/* forward pointer */
} cistpl_t;

/*
 * Flags that are used in the cistpl_t and cisptr_t linked lists
 */
#define	CISTPLF_NOERROR		0x000000000 /* no error return from handler */
#define	CISTPLF_UNKNOWN		0x000000001 /* unknown tuple */
#define	CISTPLF_REGS		0x000000002 /* tuple contains registers */
#define	CISTPLF_COPYOK		0x000000004 /* OK to copy tuple data */
#define	CISTPLF_VALID		0x000000008 /* tuple is valid */
#define	CISTPLF_GLOBAL_CIS	0x000000010 /* tuple from global CIS */
#define	CISTPLF_MF_CIS		0x000000020 /* tuple from MF CIS chain */
#define	CISTPLF_FROM_AM		0x000000040 /* tuple read from AM space */
#define	CISTPLF_FROM_CM		0x000000080 /* tuple read from CM space */
#define	CISTPLF_IGNORE_TUPLE	0x000000100 /* ignore this tuple */
#define	CISTPLF_VENDOR_SPECIFIC	0x000000200 /* vnedor-specific tuple */
#define	CISTPLF_LINK_INVALID	0x001000000 /* tuple link is invalid */
#define	CISTPLF_PARAMS_INVALID	0x002000000 /* tuple body is invalid */
#define	CISTPLF_AM_SPACE	0x010000000 /* this tuple is in AM space */
#define	CISTPLF_CM_SPACE	0x020000000 /* this tuple is in CM space */
#define	CISTPLF_LM_SPACE	0x040000000 /* this tuple is in local memory */
#define	CISTPLF_MEM_ERR		0x080000000 /* GET_BYTE macros memory error */

/*
 * Some convienience macros
 */
#define	CISTPLF_SPACE_MASK	(CISTPLF_AM_SPACE | CISTPLF_CM_SPACE |	\
							CISTPLF_LM_SPACE)
#define	CISTPLF_FROM_MASK	(CISTPLF_FROM_AM | CISTPLF_FROM_CM)

/*
 * Values used internally on calls to cis_get_ltuple.
 *
 * The GET_XXX_LTUPLEF and FIND_XXX_XXX values are mutually exclusive,
 *	i.e. cis_get_ltuple can only do one of these operations per call.
 *
 * The other flags are bit flags and they share the flags parameter.
 *
 *    CIS_GET_LTUPLE_IGNORE - return tuples with CISTPLF_IGNORE_TUPLE
 *				set in cistpl_t->flags
 */
#define	GET_FIRST_LTUPLEF	0x000000001 /* return first tuple in list */
#define	GET_LAST_LTUPLEF	0x000000002 /* return last tuple in list */
#define	FIND_LTUPLE_FWDF	0x000000003 /* find tuple, fwd search from tp */
#define	FIND_LTUPLE_BACKF	0x000000004 /* find tuple, backward from tp */
#define	FIND_NEXT_LTUPLEF	0x000000005 /* find tuple, fwd from tp+1 */
#define	FIND_PREV_LTUPLEF	0x000000006 /* find tuple, backward from tp-1 */
#define	GET_NEXT_LTUPLEF	0x000000007 /* return next tuple in list */
#define	GET_PREV_LTUPLEF	0x000000008 /* return prev tuple in list */
#define	CIS_GET_LTUPLE_OPMASK	0x00000ffff /* mask for operation values */
#define	CIS_GET_LTUPLE_IGNORE	0x000010000 /* return ignored tuples */

/*
 * macros for getting various data types out of a tuple
 * Note that due to the modem tuple using a few big-endian values,
 * we have to support both big and little endian macros
 *
 * Common Memory Specific macros - these will also work for tuples in
 *	local memory
 */
#define	GET_CM_BYTE(tp)	(((size_t)(tp)->len >= \
				((uintptr_t)(tp)->read.byte - \
					(uintptr_t)(tp)->data)) ? \
			 *(tp)->read.byte++ : ((tp)->flags |= CISTPLF_MEM_ERR))
#define	GET_CM_LEN(tp)	((size_t)(tp)->len - \
				((uintptr_t)(tp)->read.byte - \
				(uintptr_t)(tp)->data))

/* Attribute Memory Specific macros */
#define	GET_AM_BYTE(tp)	(((size_t)(tp)->len >= \
				(((uintptr_t)(tp)->read.byte - \
					(uintptr_t)(tp)->data))>>1) ? \
			 *(cisdata_t *)(tp)->read.sword++ : \
				((tp)->flags |= CISTPLF_MEM_ERR))
#define	GET_AM_LEN(tp)	((size_t)(tp)->len - (((uintptr_t)(tp)->read.byte - \
				(uintptr_t)(tp)->data) >> 1))

/* generic macros */
#define	RESET_TP(tp)	(tp)->read.byte = (tp)->data
#define	LOOK_BYTE(tp)	*(tp)->read.byte
#define	GET_BYTE_ADDR(tp) (tp)->read.byte

#define	GET_BYTE(tp)	(((tp)->flags & CISTPLF_AM_SPACE) ? \
				GET_AM_BYTE(tp) : GET_CM_BYTE(tp))
#define	GET_SHORT(tp)		cis_get_short(tp)
#define	GET_BE_SHORT(tp)	cis_get_be_short(tp)
#define	GET_INT24(tp)		cis_get_int24(tp)
#define	GET_LONG(tp)		cis_get_long(tp)
#define	GET_LEN(tp)	(((tp)->flags & CISTPLF_AM_SPACE) ? \
				GET_AM_LEN(tp) : GET_CM_LEN(tp))

/*
 * cistpl_ignore_list_t - this structure describes tuples in the global
 *				CIS list that we want to ignore if they
 *				also show up in a function-specific CIS.
 */
typedef struct cistpl_ignore_list_t {
	cisdata_t	type;
} cistpl_ignore_list_t;

#ifdef	__cplusplus
}
#endif

#endif	/* _CIS_H */
/*
 * 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 (c) 1995-2001 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#ifndef _CIS_HANDLERS_H
#define	_CIS_HANDLERS_H

#ifdef	__cplusplus
extern "C" {
#endif

/*
 * This is the CIS tuple handler header file.
 *
 * Each tuple that we recognize and are prepared to handle is assigned a
 *	cistpl_callout_t structure.  This lets us specify a handler for
 *	this tuple, as well as flags that describe this tuple and which
 *	are used by the CIS interpreter and tuple parser.
 */
typedef struct cistpl_callout_t {
    cisdata_t	type;		/* type of tuple */
    cisdata_t	subtype;	/* only used for CISTPL_FUNCE */
    uint32_t	flags;		/* misc flags */
    uint32_t	(*handler)();	/* tuple handler */
    char	*text;		/* name of tuple */
} cistpl_callout_t;

/*
 * Flags that are used by a tuple handler to specify what action it
 *	should perform.
 */
#define	HANDTPL_NOERROR		0x000000000 /* no error */
#define	HANDTPL_SET_FLAGS	0x000000001 /* set tuple flags */
#define	HANDTPL_COPY_DONE	0x000000002 /* tuple data copy is done */
#define	HANDTPL_PARSE_LTUPLE	0x000000004 /* parse tuple, return opt data */
#define	HANDTPL_RETURN_NAME	0x000000008 /* return tuple name string */

/*
 * This flag is returned by tuple handlers if they encounter an error. It
 *	is returned by cis_list_lcreate if any of the tuple handlers have
 *	return an error while processing the CIS.
 *
 * Note that the following bit is reserved:
 *		#define	BAD_CIS_ADDR	0x080000000
 *	It appears in cis.h and is used to indicate that cis_list_create
 *	tried to read past the end of the mapped in CIS space.
 */
#define	HANDTPL_ERROR		0x001000000 /* handler returned an error */

/*
 * General-use constants and macros that aren't specific to a tuple.
 */
#define	CISTPL_EXT_BIT	0x080		/* additional extension bytes follow */

/*
 * Constants, macros and structures used by cistpl_devspeed and
 *	cis_convert_devspeed functions.
 */
#define	CISTPL_DEVSPEED_TABLE	0x000000001 /* use the device speed table */
#define	CISTPL_DEVSPEED_EXT	0x000000002 /* use the extended speed table */
#define	CISTPL_DEVSPEED_MAX_TBL	8 		/* max devspeed table entries */
#define	CISTPL_DEVSPEED_MAX_EXP	8		/* max exponent entries */
#define	CISTPL_DEVSPEED_MAX_MAN	16		/* max mantissa entries */
#define	CISTPL_DEVSPEED_TBL(t)	cistpl_devspeed_struct.table[(t) &	\
						(CISTPL_DEVSPEED_MAX_TBL - 1)]
#define	CISTPL_DEVSPEED_MAN(m)	cistpl_devspeed_struct.mantissa[(m) &	\
						(CISTPL_DEVSPEED_MAX_MAN - 1)]
#define	CISTPL_DEVSPEED_EXP(e)	cistpl_devspeed_struct.exponent[(e) &	\
						(CISTPL_DEVSPEED_MAX_EXP - 1)]
typedef struct cistpl_devspeed_struct_t {
	uint32_t	*table;
	uint32_t	*tenfac;
	uint32_t	*mantissa;
	uint32_t	*exponent;
} cistpl_devspeed_struct_t;

/*
 * Constants, flags and structure typedefs that are used by specific tuples.
 *
 * CISTPL_DEVICE, CISTPL_DEVICE_A, CISTPL_DEVICE_OC and CISTPL_DEVICE_OA
 */
#define	CISTPL_DEVICE_DTYPE_NULL	0x00	/* a NULL device (hole) */
#define	CISTPL_DEVICE_DTYPE_ROM		0x01	/* device is of type ROM */
#define	CISTPL_DEVICE_DTYPE_OTPROM	0x02	/* device is of type OTPROM */
#define	CISTPL_DEVICE_DTYPE_EPROM	0x03	/* device is of type EPROM */
#define	CISTPL_DEVICE_DTYPE_EEPROM	0x04	/* device is of type EEPROM */
#define	CISTPL_DEVICE_DTYPE_FLASH	0x05	/* device is of type FLASH */
#define	CISTPL_DEVICE_DTYPE_SRAM	0x06	/* device is of type SRAM */
#define	CISTPL_DEVICE_DTYPE_DRAM	0x07	/* device is of type DRAM */
#define	CISTPL_DEVICE_DTYPE_RSVD_8	0x08	/* reserved */
#define	CISTPL_DEVICE_DTYPE_RSVD_9	0x09	/* reserved */
#define	CISTPL_DEVICE_DTYPE_RSVD_a	0x0a	/* reserved */
#define	CISTPL_DEVICE_DTYPE_RSVD_b	0x0b	/* reserved */
#define	CISTPL_DEVICE_DTYPE_RSVD_c	0x0c	/* reserved */
#define	CISTPL_DEVICE_DTYPE_FUNCSPEC	0x0d	/* device is of type FUNCSPEC */
#define	CISTPL_DEVICE_DTYPE_EXTEND	0x0e	/* device is of type extended */
#define	CISTPL_DEVICE_DTYPE_RSVD_f	0x0f	/* reserved */

/*
 * Flags for cistpl_device_node_t->flags member for CISTPL_DEVICE
 *	and CISTPL_DEVICE_A tuples
 */
#define	CISTPL_DEVICE_WPS		0x00000001	/* WPS bit is set */
/*
 * Flags and values for cistpl_device_node_t->flags member for
 *	CISTPL_DEVICE_OC and CISTPL_DEVICE_OA tuples
 */
#define	CISTPL_DEVICE_OC_MWAIT		0x00010000	/* use MWAIT */
#define	CISTPL_DEVICE_OC_Vcc_MASK	0x00060000	/* mask for Vcc value */
#define	CISTPL_DEVICE_OC_Vcc5		0x00000000	/* 5.0 volt operation */
#define	CISTPL_DEVICE_OC_Vcc33		0x00020000	/* 3.3 volt operation */
#define	CISTPL_DEVICE_OC_VccXX		0x00040000	/* X.X volt operation */
#define	CISTPL_DEVICE_OC_VccYY		0x00060000	/* Y.Y volt operation */
/*
 * CISTPL_DEVICE_MAX_DEVICES defines the maximum number of devices that
 *	we can parse in a CISTPL_DEVICE{...} tuple
 */
#define	CISTPL_DEVICE_MAX_DEVICES	10

/*
 * CISTPL_DEVICE_SPEED_SIZE_IGNORE if the device speed is set to this, then
 *	ignore the speed and size values
 */
#define	CISTPL_DEVICE_SPEED_SIZE_IGNORE	0x0ff	/* ignore size and speed info */

typedef struct cistpl_device_node_t {
	uint32_t	flags;	/* flags specific to this device */
	uint32_t	speed;	/* device speed in device speed code format */
	uint32_t	nS_speed; /* device speed in nS */
	uint32_t	type;	/* device type */
	uint32_t	size;	/* device size */
	uint32_t	size_in_bytes; /* device size in bytes */
} cistpl_device_node_t;

typedef struct cistpl_device_t {
	uint32_t		num_devices; /* number of devices found */
	cistpl_device_node_t	devnode[CISTPL_DEVICE_MAX_DEVICES];
} cistpl_device_t;

/*
 * CISTPL_CONFIG
 */
#define	MAKE_CONFIG_REG_ADDR(base, reg)	(base + (reg * 2))
#define	CISTPL_CONFIG_MAX_CONFIG_REGS	128 /* max num config regs */
typedef struct cistpl_config_t {
    uint32_t	present;	/* register present flags */
    uint32_t	nr;		/* number of config registers found */
    uint32_t	hr;		/* highest config register index found */
    uint32_t	regs[CISTPL_CONFIG_MAX_CONFIG_REGS];	/* reg offsets */
    uint32_t	base;		/* base offset of config registers */
    uint32_t	last;		/* last config index */
} cistpl_config_t;

/*
 * CISTPL_VERS_1
 */
#define	CISTPL_VERS_1_MAX_PROD_STRINGS	4 /* max number product strings */
typedef struct cistpl_vers_1_t {
    uint32_t	major;		/* major version number */
    uint32_t	minor;		/* minor version number */
    uint32_t	ns;		/* number of information strings */
				/* pointers to product information strings */
    char	pi[CISTPL_VERS_1_MAX_PROD_STRINGS][CIS_MAX_TUPLE_DATA_LEN];
} cistpl_vers_1_t;

/*
 * CISTPL_VERS_2
 */
typedef struct cistpl_vers_2_t {
    uint32_t	vers;		/* version number */
    uint32_t	comply;		/* level of compliance */
    uint32_t	dindex;		/* byte address of first data byte in card */
    uint32_t	reserved;	/* two reserved bytes */
    uint32_t	vspec8;		/* vendor specific (byte 8) */
    uint32_t	vspec9;		/* vendor specific (byte 9) */
    uint32_t	nhdr;		/* number of copies of CIS present on device */
    char	oem[CIS_MAX_TUPLE_DATA_LEN];	/* Vendor of software that */
							/* formatted card */
    char	info[CIS_MAX_TUPLE_DATA_LEN];	/* Informational message */
							/* about card */
} cistpl_vers_2_t;

/*
 * CISTPL_JEDEC_A and CISTPL_JEDEC_C
 */
#define	CISTPL_JEDEC_MAX_IDENTIFIERS	4
typedef struct jedec_ident_t {
	uint32_t	id;	/* manufacturer id */
	uint32_t	info;	/* manufacturer specific info */
} jedec_ident_t;

typedef struct cistpl_jedec_t {
	uint32_t	nid;		/* # of JEDEC identifiers present */
	jedec_ident_t	jid[CISTPL_JEDEC_MAX_IDENTIFIERS];
} cistpl_jedec_t;

/*
 * CISTPL_FORMAT and CISTPL_FORMAT_A
 *
 * These tuples describe the data recording format for a region.
 */
typedef struct cistpl_format_t {
	uint32_t	type;	/* format type code */
	uint32_t	edc_length; /* error detection code length */
	uint32_t	edc_type; /* error detection code type */
	uint32_t	offset;	/* offset of first byte of data in this part */
	uint32_t	nbytes;	/* number of bytes of data in this partition */
	union {
		struct disk {
		    uint32_t	bksize; /* block size */
		    uint32_t	nblocks; /* nblocks data for disk-like device */
		    uint32_t	edcloc; /* location of error detection code */
		} disk;
		struct mem {
		    uint32_t	flags; /* various flags */
		    uint32_t	reserved; /* reserved byte */
		    caddr_t	address; /* physical addr for mem-like device */
		    uint32_t	edcloc; /* location of error detection code */
		} mem;
	} dev;
} cistpl_format_t;

/*
 * device format types
 */
#define	TPLFMTTYPE_DISK	0x00	/* disk-like format */
#define	TPLFMTTYPE_MEM	0x01	/* memory-like format */
#define	TPLFMTTYPE_VS	0x80	/* vendor specific format */

/*
 * error detection code types
 */
#define	TPLFMTEDC_NONE	0x00	/* no error detection code */
#define	TPLFMTEDC_CKSUM	0x01	/* arithmetic checksum is used */
#define	TPLFMTEDC_CRC	0x02	/* 16-bit CRC */
#define	TPLFMTEDC_PCC	0x03	/* whole-partition arithmetic checksum */
#define	TPLFMTEDC_VS	0x80	/* vendor specific error checking */

#define	EDC_LENGTH_MASK	0x07
#define	EDC_TYPE_MASK   0x0f
#define	EDC_TYPE_SHIFT	3

/*
 * flags for memory-like devices
 */
#define	TPLFMTFLAGS_ADDR	0x01	/* address is valid */
#define	TPLFMTFLAGS_AUTO	0x02	/* automatically map memory region */

/*
 * CISTPL_GEOMETRY
 */
typedef struct cistpl_geometry_t {
	uint32_t	spt;
	uint32_t	tpc;
	uint32_t	ncyl;
} cistpl_geometry_t;

/*
 * CISTPL_BYTEORDER
 */
typedef struct cistpl_byteorder_t {
	uint32_t	order;		/* byte order code */
	uint32_t	map;		/* byte mapping code */
} cistpl_byteorder_t;

/*
 * byte order and mapping codes
 */
#define	TPLBYTEORD_LOW	0x00	/* specifies little endian order */
#define	TPLBYTEORD_HIGH	0x01	/* specifies big endian order */
#define	TPLBYTEORD_VS	0x80	/* vendor specific order 0x80-0xFF */

#define	TPLBYTEMAP_LOW	0x00	/* byte zero is least significant byte */
#define	TPLBYTEMAP_HIGH	0x01	/* byte zero is most significant byte */
#define	TPLBYTEMAP_VS	0x80	/* vendor specific mapping */

/*
 * CISTPL_DATE
 */
typedef struct cistpl_date_t {
	uint32_t	time;
	uint32_t	day;
} cistpl_date_t;

/*
 * CISTPL_BATTERY
 */
typedef struct cistpl_battery_t {
	uint32_t	rday;		/* replacement date */
	uint32_t	xday;		/* expiration date */
} cistpl_battery_t;

/*
 * CISTPL_ORG
 */
typedef struct cistpl_org_t {
	uint32_t	type;		/* data organization code */
	char	desc[CIS_MAX_TUPLE_DATA_LEN];	/* text description of */
						/* this organization */
} cistpl_org_t;

/*
 * CISTPL_MANFID
 */
typedef struct cistpl_manfid_t {
	uint32_t	manf;		/* PCMCIA PC Card manufacturer code */
	uint32_t	card;		/* manufacturer information */
} cistpl_manfid_t;

/*
 * CISTPL_FUNCID
 */
typedef struct cistpl_funcid_t {
	uint32_t	function;		/* PC Card function code */
	uint32_t	sysinit;		/* system initialization mask */
} cistpl_funcid_t;

/*
 * Function types for CISTPL_FUNCID; note that the TPLFUNC_UNKNOWN is
 *	not defined by the PCMCIA standard.
 *
 * Definitions for cistpl_funcid_t->function
 */
#define	TPLFUNC_MULTI		0x000	/* vendor-specific multifunction card */
#define	TPLFUNC_MEMORY		0x001	/* memory card */
#define	TPLFUNC_SERIAL		0x002	/* serial I/O port */
#define	TPLFUNC_PARALLEL	0x003	/* parallel printer port */
#define	TPLFUNC_FIXED		0x004	/* fixed disk, silicon or removeable */
#define	TPLFUNC_VIDEO		0x005	/* video interface */
#define	TPLFUNC_LAN		0x006	/* Local Area Network adapter */
#define	TPLFUNC_AIMS		0x007	/* Auto Incrementing Mass Storage */
#define	TPLFUNC_SCSI		0x008	/* SCSI bridge */
#define	TPLFUNC_SECURITY	0x009	/* Security Cards */
#define	TPLFUNC_VENDOR_SPECIFIC	0x0fe	/* Vendor Specific */
#define	TPLFUNC_UNKNOWN		0x0ff	/* unknown function(s) */
/*
 * Definitions for cistpl_funcid_t->sysinit
 */
#define	TPLINIT_POST		0x01	/* POST should attempt configure */
#define	TPLINIT_ROM		0x02	/* map ROM during sys init */

/*
 * CISTPL_FUNCE
 */
typedef struct cistpl_funce_t {
	uint32_t	function;		/* type of extended data */
	uint32_t	subfunction;
	union {
		struct serial {
			uint32_t ua;	/* UART in use */
			uint32_t uc;	/* UART capabilities */
		} serial;
		struct modem {
			uint32_t fc;	/* supported flow control methods */
			uint32_t cb;	/* size of DCE command buffer */
			uint32_t eb;	/* size of DCE to DCE buffer */
			uint32_t tb;	/* size of DTE to DCE buffer */
		} modem;
		struct data_modem {
			uint32_t ud;	/* highest data rate */
			uint32_t ms;	/* modulation standards */
			/* err correct proto and non-CCITT modulation */
			uint32_t em;
			uint32_t dc;	/* data compression protocols */
			uint32_t cm;	/* command protocols */
			uint32_t ex;	/* escape mechanisms */
			uint32_t dy;	/* standardized data encryption */
			uint32_t ef;	/* misc. end user features */
			uint32_t ncd;	/* number of country codes */
			uchar_t cd[16];	/* CCITT country code */
		} data_modem;
		struct fax {
			uint32_t uf;	/* highest data rate in DTE/UART */
			uint32_t fm;	/* CCITT modulation standards */
			uint32_t fy;	/* standardized data encryption */
			uint32_t fs;	/* feature selection */
			uint32_t ncf; /* number of country codes */
			uchar_t cf[16];	/* CCITT country codes */
		} fax;
		struct voice {
			uint32_t uv;	/* highest data rate */
			uint32_t nsr;
			uint32_t sr[16]; /* voice sampling rates (*100) */
			uint32_t nss;
			uint32_t ss[16]; /* voice sample sizes (*10) */
			uint32_t nsc;
			uint32_t sc[16]; /* voice compression methods */
		} voice;
		struct lan {
			uint32_t tech; /* network technology */
			uint32_t speed; /* media bit or baud rate */
			uint32_t media; /* network media supported */
			uint32_t con; /* open/closed connector standard */
			uint32_t id_sz; /* length of lan station id */
			uchar_t id[16]; /* station ID */
		} lan;
	}   data;
} cistpl_funce_t;

/* serial port subfunctions */
#define	TPLFE_SUB_SERIAL	0 /* serial port */
#define	TPLFE_SUB_MODEM_COMMON	1 /* common modem interface */
#define	TPLFE_SUB_MODEM_DATA	2 /* data modem services */
#define	TPLFE_SUB_MODEM_FAX	3 /* fax modem services */
#define	TPLFE_SUB_VOICE		4 /* voice services */
/* modem subfunctions for description of capabilities */
#define	TPLFE_CAP_MODEM_DATA	5 /* data modem capabilities */
#define	TPLFE_CAP_MODEM_FAX	6 /* fax modem capabilities */
#define	TPLFE_CAP_MODEM_VOICE	7 /* voice modem capabilities */
/* serial port subfunctions for description of capabilities */
#define	TPLFE_CAP_SERIAL_DATA	8 /* serial port capabilities - data modem */
#define	TPLFE_CAP_SERIAL_FAX	9 /* serial port capabilities - fax modem */
#define	TPLFE_CAP_SERIAL_VOICE 10 /* serial port capabilities - voice */

/* serial port UART definitions */
#define	TPLFE_UA_8250		0 /* Intel 8250 */
#define	TPLFE_UA_16450		1 /* NS 16450 */
#define	TPLFE_UA_16550		2 /* NS 16550 */

/* serial port capabilities definitions */
#define	TPLFE_UC_PARITY_SPACE	0x0001 /* space parity supported */
#define	TPLFE_UC_PARITY_MARK	0x0002 /* mark parity supported */
#define	TPLFE_UC_PARITY_ODD	0x0004 /* odd parity supported */
#define	TPLFE_UC_PARITY_EVEN	0x0008 /* even parity supported */
#define	TPLFE_UC_CS5		0x0100 /* 5 bit characters supported */
#define	TPLFE_UC_CS6		0x0200 /* 6 bit characters supported */
#define	TPLFE_UC_CS7		0x0400 /* 7 bit characters supported */
#define	TPLFE_UC_CS8		0x0800 /* 8 bit characters supported */
#define	TPLFE_UC_STOP_1		0x1000 /* 1 stop bit supported */
#define	TPLFE_UC_STOP_15	0x2000 /* 1.5 stop bits supported */
#define	TPLFE_UC_STOP_2		0x4000 /* 2 stop bits supported */

/* modem flow control methods */
#define	TPLFE_FC_TX_XONOFF	0x01 /* transmit XON/XOFF */
#define	TPLFE_FC_RX_XONOFF	0x02 /* receiver XON/XOFF */
#define	TPLFE_FC_TX_HW		0x04 /* transmit hardware flow control (CTS) */
#define	TPLFE_FC_RX_HW		0x08 /* receiver hardware flow control (RTS) */
#define	TPLFE_FC_TRANS		0x10 /* tranparent flow control */

/* modem modulation standards */
#define	TPLFE_MS_BELL103	0x0001 /* 300bps */
#define	TPLFE_MS_V21		0x0002 /* 300bps (V.21) */
#define	TPLFE_MS_V23		0x0004 /* 600/1200bps (V.23) */
#define	TPLFE_MS_V22AB		0x0008 /* 1200bps (V.22A V.22B) */
#define	TPLFE_MS_BELL212	0x0010 /* 2400bsp (US Bell 212) */
#define	TPLFE_MS_V22BIS		0x0020 /* 2400bps (V.22bis) */
#define	TPLFE_MS_V26		0x0040 /* 2400bps leased line (V.26) */
#define	TPLFE_MS_V26BIS		0x0080 /* 2400bps (V.26bis) */
#define	TPLFE_MS_V27BIS		0x0100 /* 4800/2400bps leased line (V.27bis) */
#define	TPLFE_MS_V29		0x0200 /* 9600/7200/4800 leased line (V.29) */
#define	TPLFE_MS_V32		0x0400 /* up to 9600bps (V.32) */
#define	TPLFE_MS_V32BIS		0x0800 /* up to 14400bps (V.32bis) */
#define	TPLFE_MS_VFAST		0x1000 /* up to 28800 V.FAST */

/* modem error correction/detection protocols */
#define	TPLFE_EM_MNP		0x01 /* MNP levels 2-4 */
#define	TPLFE_EM_V42		0x02 /* CCITT LAPM (V.42) */

/* modem data compression protocols */
#define	TPLFE_DC_V42BIS		0x01 /* CCITT compression V.42 */
#define	TPLFE_DC_MNP5		0x02 /* MNP compression (uses MNP 2, 3 or 4) */

/* modem command protocols */
#define	TPLFE_CM_AT1	0x01 /* ANSI/EIA/TIA 602 "Action" commands */
#define	TPLFE_CM_AT2	0x02 /* ANSI/EIA/TIA 602 "ACE/DCE IF Params" */
#define	TPLFE_CM_AT3	0x04 /* ANSI/EIA/TIA 602 "Ace Parameters" */
#define	TPLFE_CM_MNP_AT	0x08 /* MNP specificat AT commands */
#define	TPLFE_CM_V25BIS	0x10 /* V.25bis calling commands */
#define	TPLFE_CM_V25A	0x20 /* V.25bis test procedures */
#define	TPLFE_CM_DMCL	0x40 /* DMCL command mode */

/* modem escape mechanism */
#define	TPLFE_EX_BREAK		0x01 /* BREAK support standardized */
#define	TPLFE_EX_PLUS		0x02 /* +++ returns to command mode */
#define	TPLFE_EX_UD		0x04 /* user defined escape character */

/* modem miscellaneous features */
#define	TPLFE_EF_CALLERID	0x01 /* Caller ID is supported */

/* fax modulation standards */
#define	TPLFE_FM_V21C2	0x01 /* 300bps (V.21-C2) */
#define	TPLFE_FM_V27TER	0x02 /* 4800/2400bps (V.27ter) */
#define	TPLFE_FM_V29	0x04 /* 9600/7200/4800 leased line (V.29) */
#define	TPLFE_FM_V17	0x08 /* 14.4K/12K/9600/7200bps (V.17) */
#define	TPLFE_FM_V33	0x10 /* 14.4K/12K/9600/7200 lease line (V.33) */

/* fax feature selection */
#define	TPLFE_FS_T3		0x01 /* Group 2 (T.3) service class */
#define	TPLFE_FS_T4		0x02 /* Group 3 (T.4) service class */
#define	TPLFE_FS_T6		0x04 /* Group 4 (T.6) service class */
#define	TPLFE_FS_ECM		0x08 /* Error Correction Modeer */
#define	TPLFE_FS_VOICEREQ	0x10 /* voice requests allowed */
#define	TPLFE_FS_POLLING	0x20 /* polling support */
#define	TPLFE_FS_FTP		0x40 /* file transfer support */
#define	TPLFE_FS_PASSWORD	0x80 /* password support */

/* LAN tuple definitions */
#define	TPLFE_NETWORK_INFO	0x00

/* LAN technology types */
#define	TPLFE_LAN_TECH_ARCNET		1
#define	TPLFE_LAN_TECH_ETHERNET		2
#define	TPLFE_LAN_TECH_TOKENRING	3
#define	TPLFE_LAN_TECH_LOCALTALK	4
#define	TPLFE_LAN_TECH_FDDI		5
#define	TPLFE_LAN_TECH_ATM		6
#define	TPLFE_LAN_TECH_WIRELESS		7

/* LAN media types */
#define	TPLFE_LAN_MEDIA_INHERENT	0
#define	TPLFE_LAN_MEDIA_UTP		1
#define	TPLFE_LAN_MEDIA_STP		2
#define	TPLFE_LAN_MEDIA_THIN_COAX	3
#define	TPLFE_LAN_MEDIA_THICK_COAX	4
#define	TPLFE_LAN_MEDIA_FIBER		5
#define	TPLFE_LAN_MEDIA_SSR_902		6
#define	TPLFE_LAN_MEDIA_SSR_2_4		7
#define	TPLFE_LAN_MEDIA_SSR_5_4		8
#define	TPLFE_LAN_MEDIA_DIFFUSE_IR	9
#define	TPLFE_LAN_MEDIA_PTP_IR		10

/*
 * CISTPL_CFTABLE_ENTRY
 *
 * These flags and macros are used internally to the handler.
 */
	/* mask to get the config entry number from TPCE_INDX */
#define	CISTPL_CFTABLE_TPCE_CFGENTRYM		0x03f
		/* default config bit in TPCE_INDX */
#define	CISTPL_CFTABLE_TPCE_DEFAULTM		0x040
		/* interface config byte follows */
#define	CISTPL_CFTABLE_TPCE_IFM			0x080

		/* power bit mask for tpce_fs */
#define	CISTPL_CFTABLE_TPCE_FS_PWRM		0x003
		/* Vcc, Vpp1 and Vpp2 descriptions */
#define	CISTPL_CFTABLE_TPCE_FS_PWR_VPP2M	0x003
		/* Vcc and Vpp1=Vpp2 descriptions */
#define	CISTPL_CFTABLE_TPCE_FS_PWR_VPP1M	0x002
		/* Vcc description only */
#define	CISTPL_CFTABLE_TPCE_FS_PWR_VCCM		0x001
		/* no connection on sleep/power down */
#define	CISTPL_CFTABLE_PD_NC_SLEEPM		0x07d
		/* zero value required */
#define	CISTPL_CFTABLE_PD_ZEROM			0x07e
		/* no connection ever */
#define	CISTPL_CFTABLE_PD_NCM			0x07f

		/* timing data exists */
#define	CISTPL_CFTABLE_TPCE_FS_TDM		0x004
		/* WAIT scale mask */
#define	CISTPL_CFTABLE_TPCE_FS_TD_WAITM		0x003
#define	GET_TPCE_FS_TD_WAITS(sf)	((sf)& \
					    CISTPL_CFTABLE_TPCE_FS_TD_WAITM)
		/* RDY/BSY scale mask */
#define	CISTPL_CFTABLE_TPCE_FS_TD_RDYM		0x01c
#define	GET_TPCE_FS_TD_RDYS(sf)	(((sf)>>2)& \
					CISTPL_CFTABLE_TPCE_FS_TD_RDYM)
		/* RSVD scale mask */
#define	CISTPL_CFTABLE_TPCE_FS_TD_RSVDM		0x0e0
#define	GET_TPCE_FS_TD_RSVDS(sf)	(((sf)>>5)& \
					    CISTPL_CFTABLE_TPCE_FS_TD_RSVDM)

#define	CISTPL_CFTABLE_TPCE_FS_IOM		0x008	/* I/O data exists */
		/* I/O addr lines mask */
#define	CISTPL_CFTABLE_TPCE_FS_IO_ALM		0x01f
		/* RANGE bit in TPCE_IO */
#define	CISTPL_CFTABLE_TPCE_FS_IO_RANGEM	0x080
		/* max of 16 I/O ranges */
#define	CISTPL_CFTABLE_ENTRY_MAX_IO_RANGES	16

#define	CISTPL_CFTABLE_TPCE_FS_IRQM		0x010	/* IRQ data exists */
		/* extended IRQ mask exists */
#define	CISTPL_CFTABLE_TPCE_FS_IRQ_MASKM	0x010

#define	CISTPL_CFTABLE_TPCE_FS_MEMM		0x060	/* mem space mask */
		/* space selection byte ... */
#define	CISTPL_CFTABLE_TPCE_FS_MEM3M		0x060
		/* length (2 bytes) and card address (2 bytes) */
#define	CISTPL_CFTABLE_TPCE_FS_MEM2M		0x040
		/* single 2-byte length */
#define	CISTPL_CFTABLE_TPCE_FS_MEM1M		0x020
		/* max of 8 mem space descriptors */
#define	CISTPL_CFTABLE_ENTRY_MAX_MEM_WINDOWS	8
		/* number of bytes/page description */
#define	CISTPL_CFTABLE_TPCE_FS_MEM_PGSIZE	256
		/* host addr info present */
#define	CISTPL_CFTABLE_TPCE_FS_MEM_HOSTM	0x080

#define	CISTPL_CFTABLE_TPCE_FS_MISCM		0x080	/* misc fields mask */

/*
 * Constants, macros, structures and flags used by cistpl_pd_parse()
 *	cistpl_expd_parse() and the CISTPL_CFTABLE_ENTRY tuple handler.
 */
#define	CISTPL_PD_MAN(m)	cistpl_pd_struct.mantissa[m&15]
#define	CISTPL_PD_EXP(e)	cistpl_pd_struct.exponent[e&7]
typedef struct cistpl_pd_struct_t {
    uint32_t	*mantissa;
    uint32_t	*exponent;
} cistpl_pd_struct_t;

/*
 * These flags are passed to the caller in the cistpl_cftable_entry_t->flags
 *	field and indicate what interface information is available.  The low
 *	order byte of this field is reserved and no flags should be defined
 *	to exist there.
 */
#define	CISTPL_CFTABLE_TPCE_DEFAULT	0x000000100 /* this is a default conf */

/* interface config description present flags */
#define	CISTPL_CFTABLE_TPCE_IF		0x000000200 /* if config byte exists */
/*
 * When the CISTPL_CFTABLE_TPCE_IF flag is set, the following flags
 *	are available in the ifc member of the cistpl_cftable_entry_t
 *	structure.
 */
#define	CISTPL_CFTABLE_TPCE_IF_MEMORY	0x00	/* memory interface */
#define	CISTPL_CFTABLE_TPCE_IF_IO_MEM	0x01	/* IO and memory */
#define	CISTPL_CFTABLE_TPCE_IF_RSVD_2	0x02	/* reserved */
#define	CISTPL_CFTABLE_TPCE_IF_RSVD_3	0x03	/* reserved */
#define	CISTPL_CFTABLE_TPCE_IF_CUSTOM_0	0x04	/* custom interface 0 */
#define	CISTPL_CFTABLE_TPCE_IF_CUSTOM_1	0x05	/* custom interface 1 */
#define	CISTPL_CFTABLE_TPCE_IF_CUSTOM_2	0x06	/* custom interface 2 */
#define	CISTPL_CFTABLE_TPCE_IF_CUSTOM_3	0x07	/* custom interface 3 */
#define	CISTPL_CFTABLE_TPCE_IF_RSVD_8	0x08	/* reserved */
#define	CISTPL_CFTABLE_TPCE_IF_RSVD_9	0x09	/* reserved */
#define	CISTPL_CFTABLE_TPCE_IF_RSVD_a	0x0a	/* reserved */
#define	CISTPL_CFTABLE_TPCE_IF_RSVD_b	0x0b	/* reserved */
#define	CISTPL_CFTABLE_TPCE_IF_RSVD_c	0x0c	/* reserved */
#define	CISTPL_CFTABLE_TPCE_IF_RSVD_d	0x0d	/* reserved */
#define	CISTPL_CFTABLE_TPCE_IF_RSVD_e	0x0e	/* reserved */
#define	CISTPL_CFTABLE_TPCE_IF_RSVD_f	0x0f	/* reserved */
#define	CISTPL_CFTABLE_TPCE_IF_MASK	0x0f	/* interface type mask */
#define	CISTPL_CFTABLE_TPCE_IF_BVD	0x10	/* BVD active in PRR */
#define	CISTPL_CFTABLE_TPCE_IF_WP	0x20	/* WP active in PRR */
#define	CISTPL_CFTABLE_TPCE_IF_RDY	0x40	/* RDY active in PRR */
#define	CISTPL_CFTABLE_TPCE_IF_MWAIT	0x80	/* WAIT - mem cycles */

/* power description present flags */
#define	CISTPL_CFTABLE_TPCE_FS_PWR	0x000001000 /* power info exists */

/* timing description present flags */
#define	CISTPL_CFTABLE_TPCE_FS_TD	0x000010000 /* timing info exists */

/* I/O description present flags */
#define	CISTPL_CFTABLE_TPCE_FS_IO	0x000100000 /* I/O information exists */

/* IRQ description present flags */
#define	CISTPL_CFTABLE_TPCE_FS_IRQ	0x000200000 /* IRQ information exists */

/* memory space description present flags */
#define	CISTPL_CFTABLE_TPCE_FS_MEM	0x001000000 /* MEM space info exists */

/* misc description present flags */
#define	CISTPL_CFTABLE_TPCE_FS_MISC	0x002000000 /* MISC info exists */

/* additional information tuples present flags */
#define	CISTPL_CFTABLE_TPCE_FS_STCE_EV	0x004000000 /* STCE_EV exists */
#define	CISTPL_CFTABLE_TPCE_FS_STCE_PD	0x008000000 /* STCE_PD exists */

/*
 * Power description flags and structures.
 *
 * The following eight values represent what the power description structure
 *	parameter selection byte tells us is present.  A copy of this byte
 *	is in the low order byte of each parameter's flag field.
 */
#define	CISTPL_CFTABLE_PD_NOMV		0x001	/* nominal supply voltage */
#define	CISTPL_CFTABLE_PD_MINV		0x002	/* minimum supply voltage */
#define	CISTPL_CFTABLE_PD_MAXV		0x004	/* maximum supply voltage */
#define	CISTPL_CFTABLE_PD_STATICI	0x008	/* continuous supply current */
		/* max current required averaged over 1 second */
#define	CISTPL_CFTABLE_PD_AVGI		0x010
		/* maximum current required averaged over 10mS */
#define	CISTPL_CFTABLE_PD_PEAKI		0x020
		/* power down supply curent required */
#define	CISTPL_CFTABLE_PD_PDOWNI	0x040
		/* power supply is about to blow up */
#define	CISTPL_CFTABLE_PD_RFU		0x080

/*
 * For each voltage/current parameter, there is an associated flags field.
 *	The following flags are in this field.  The low order byte of each
 *	of these flags fields also contains a copy of the power description
 *	structure parameter selection byte as read from the tuple, that's why
 *	we start the flag values at 0x0100 and go up from there.
 */
		/* this parameter exists */
#define	CISTPL_CFTABLE_PD_EXISTS	0x000000100
		/* multiply return value by 10 */
#define	CISTPL_CFTABLE_PD_MUL10		0x000000200
		/* no connection on sleep/power down */
#define	CISTPL_CFTABLE_PD_NC_SLEEP	0x000001000
		/* zero value required */
#define	CISTPL_CFTABLE_PD_ZERO		0x000002000
		/* no connection ever */
#define	CISTPL_CFTABLE_PD_NC		0x000004000

typedef struct cistpl_cftable_entry_pwr_t {
	uint32_t	nomV;		/* nominal supply voltage */
	uint32_t	nomV_flags;
	uint32_t	minV;		/* minimum supply voltage */
	uint32_t	minV_flags;
	uint32_t	maxV;		/* maximum supply voltage */
	uint32_t	maxV_flags;
	uint32_t	staticI;	/* continuous supply current */
	uint32_t	staticI_flags;
	uint32_t	avgI;		/* max current required */
					/* averaged over 1 sec. */
	uint32_t	avgI_flags;
	uint32_t	peakI;		/* max current required */
					/* averaged over 10mS */
	uint32_t	peakI_flags;
	uint32_t	pdownI;		/* power down supply curent required */
	uint32_t	pdownI_flags;
} cistpl_cftable_entry_pwr_t;

/*
 * Flags for the global power description structure.  These show up in
 *	the flags field of the structure.
 */
#define	CISTPL_CFTABLE_TPCE_FS_PWR_VCC	0x000000001 /* Vcc description valid  */
#define	CISTPL_CFTABLE_TPCE_FS_PWR_VPP1	0x000000002 /* vpp1 description valid */
#define	CISTPL_CFTABLE_TPCE_FS_PWR_VPP2	0x000000004 /* Vpp2 description valid */

typedef struct cistpl_cftable_entry_pd_t {
	uint32_t	flags; /* which descriptions are valid */
	struct cistpl_cftable_entry_pwr_t pd_vcc; /* VCC power description */
	struct cistpl_cftable_entry_pwr_t pd_vpp1; /* Vpp1 power description */
	struct cistpl_cftable_entry_pwr_t pd_vpp2; /* Vpp2 power description */
} cistpl_cftable_entry_pd_t;

/*
 * Device speed structure.  Each field is only valid if the
 *	CISTPL_CFTABLE_TPCE_FS_TD flag is set.
 *
 * The following flags describe which timing information is available.
 *	They appear in the flags field of the device speed structure.
 */
		/* WAIT timing exists */
#define	CISTPL_CFTABLE_TPCE_FS_TD_WAIT	0x000000001
		/* RDY/BSY timing exists */
#define	CISTPL_CFTABLE_TPCE_FS_TD_RDY	0x000000002
		/* RSVD timing exists */
#define	CISTPL_CFTABLE_TPCE_FS_TD_RSVD	0x000000004

typedef struct cistpl_cftable_entry_speed_t {
    uint32_t	flags;		/* which timing information is present */
    uint32_t	wait;		/* max WAIT time in device speed format */
    uint32_t	nS_wait;	/* max WAIT time in nS */
    uint32_t	rdybsy;		/* max RDY/BSY time in device speed format */
    uint32_t	nS_rdybsy;	/* max RDY/BSY time in nS */
    uint32_t	rsvd;		/* max RSVD time in device speed format */
    uint32_t	nS_rsvd;	/* max RSVD time in nS */
} cistpl_cftable_entry_speed_t;

/*
 * Device I/O range description structures.  Only valid if the
 *	CISTPL_CFTABLE_TPCE_FS_IO flag is set.
 *
 * The following flags describe the IO description information. They
 *	appear in the flags field of the IO space description structure.
 */
#define	CISTPL_CFTABLE_TPCE_FS_IO_BUS	0x060	/* bus width mask */
#define	CISTPL_CFTABLE_TPCE_FS_IO_BUS8	0x020	/* 8-bit flag */
#define	CISTPL_CFTABLE_TPCE_FS_IO_BUS16	0x040	/* 16-bit flag */
#define	CISTPL_CFTABLE_TPCE_FS_IO_RANGE	0x080	/* IO address ranges exist */

typedef struct cistpl_cftable_entry_io_range_t {
    uint32_t	addr;		/* I/O start address */
    uint32_t	length;		/* I/O register length */
} cistpl_cftable_entry_io_range_t;
typedef struct cistpl_cftable_entry_io_t {
    uint32_t	flags;		/* direct copy of TPCE_IO byte in tuple */
    uint32_t	addr_lines;	/* number of decoded I/O address lines */
    uint32_t	ranges;		/* number of I/O ranges */
    struct cistpl_cftable_entry_io_range_t
	    range[CISTPL_CFTABLE_ENTRY_MAX_IO_RANGES];
} cistpl_cftable_entry_io_t;

/*
 * Device IRQ description structure.  Only valid if the
 *	CISTPL_CFTABLE_TPCE_FS_IRQ flag is set.
 */
typedef struct cistpl_cftable_entry_irq_t {
    uint32_t	flags;		/* direct copy of TPCE_IR byte in tuple */
    uint32_t	irqs;		/* bit mask for each allowed IRQ */
} cistpl_cftable_entry_irq_t;

/*
 * Device memory space description structure.  Only valid if the
 *	CISTPL_CFTABLE_TPCE_FS_MEM flag is set.
 *
 * The following flags describe the memory description information.  They
 *	appear in the flags field of the memory space description structure.
 */
		/* space descriptors */
#define	CISTPL_CFTABLE_TPCE_FS_MEM3	0x000000001
		/* host_addr=card_addr */
#define	CISTPL_CFTABLE_TPCE_FS_MEM2	0x000000002
		/* card address=0, any host address */
#define	CISTPL_CFTABLE_TPCE_FS_MEM1	0x000000004
		/* if host address is present in MEM3 */
#define	CISTPL_CFTABLE_TPCE_FS_MEM_HOST	0x000000008

typedef struct cistpl_cftable_entry_mem_window_t {
    uint32_t	length;		/* length of this window */
    uint32_t	card_addr;	/* card address */
    uint32_t	host_addr;	/* host address */
} cistpl_cftable_entry_mem_window_t;
typedef struct cistpl_cftable_entry_mem_t {
    uint32_t	flags;		/* memory desc type and host addr info */
    uint32_t	windows;	/* number of memory space descriptors */
    cistpl_cftable_entry_mem_window_t
	    window[CISTPL_CFTABLE_ENTRY_MAX_MEM_WINDOWS];
} cistpl_cftable_entry_mem_t;

/*
 * Devices misc description structure.  Only valid if the
 *	CISTPL_CFTABLE_TPCE_FS_MISC flag is set.
 */
#define	CISTPL_CFTABLE_TPCE_FS_MISC_MAX	2	   /* # bytes we understand */
#define	CISTPL_CFTABLE_TPCE_MI_MTC_MASK	0x00000007 /* max twin cards mask */
#define	CISTPL_CFTABLE_TPCE_MI_AUDIO	0x00000008 /* audio on BVD2 */
#define	CISTPL_CFTABLE_TPCE_MI_READONLY	0x00000010 /* R/O storage */
#define	CISTPL_CFTABLE_TPCE_MI_PWRDOWN	0x00000020 /* powerdown capable */
#define	CISTPL_CFTABLE_TPCE_MI_DRQ_MASK	0x00000c00 /* DMAREQ mask */
#define	CISTPL_CFTABLE_TPCE_MI_DRQ_SPK	0x00000400 /* DMAREQ on SPKR */
#define	CISTPL_CFTABLE_TPCE_MI_DRQ_IOIS	0x00000800 /* DMAREQ on IOIS16 */
#define	CISTPL_CFTABLE_TPCE_MI_DRQ_INP	0x00000c00 /* DMAREQ on INPACK */
#define	CISTPL_CFTABLE_TPCE_MI_DMA_8	0x00000000 /* DMA width 8 bits */
#define	CISTPL_CFTABLE_TPCE_MI_DMA_16	0x00001000 /* DMA width 16 bits */

typedef struct cistpl_cftable_entry_misc_t {
    uint32_t	flags;		/* misc features flags */
} cistpl_cftable_entry_misc_t;

/*
 * Additional information sub-tuples defines and structure
 */
#define	STCE_EV		0x0c0	/* Environment Descriptor Subtuple */
#define	STCE_PD		0x0c1	/* Physical Device Name Subtuple */
typedef struct cistpl_cftable_entry_stce_ev_t {
	char	stev_strs[CIS_MAX_TUPLE_DATA_LEN];
} cistpl_cftable_entry_stce_ev_t;

typedef struct cistpl_cftable_entry_stce_pd_t {
	char	stpd_strs[CIS_MAX_TUPLE_DATA_LEN];
} cistpl_cftable_entry_stce_pd_t;

/*
 * cistpl_cftable_entry_t - this is the struct that the caller passes
 *				to the CISTPL_CFTABLE_ENTRY handler
 */
typedef struct cistpl_cftable_entry_t {
    uint32_t	flags;		/* which descriptions are valid */
    uint32_t	ifc;		/* interface description info */
    uint32_t	pin;		/* values for PRR */
    uint32_t	index;		/* configuration index number */
    struct cistpl_cftable_entry_pd_t	pd; /* power requirements description */
    struct cistpl_cftable_entry_speed_t	speed; /* device speed description */
    struct cistpl_cftable_entry_io_t	io; /* device I/O map */
    struct cistpl_cftable_entry_irq_t	irq; /* device IRQ utilization */
    struct cistpl_cftable_entry_mem_t	mem; /* device memory space */
    struct cistpl_cftable_entry_misc_t	misc; /* misc device features */
} cistpl_cftable_entry_t;

/*
 * CISTPL_LINKTARGET
 *
 * This tuple is used to verify that tuple chains other than the primary
 *	chain which starts at offset 0 in Attribute Memory are valid. All
 *	secondary tuple chains are required to contain this tuple as the
 *	first tuple of the chain.
 * This tuple must have a link field of at least MIN_LINKTARGET_LENGTH and
 *	must contain the byte pattern CISTPL_LINKTARGET_MAGIC.
 * LINKTARGET_AC_HEADER_LENGTH is the number of bytes contained in a
 *	valid CISTPL_LINKTARGET tuple header.
 */
#define	MIN_LINKTARGET_LENGTH		3
#define	CISTPL_LINKTARGET_MAGIC		"CIS"
#define	LINKTARGET_AC_HEADER_LENGTH	2

typedef struct cistpl_linktarget_t {
	uint32_t	length;		/* number of bytes in tpltg_tag */
	char	tpltg_tag[CIS_MAX_TUPLE_DATA_LEN];
} cistpl_linktarget_t;

/*
 * CISTPL_LONGLINK_A and CISTPL_LONGLINK_C
 *
 * Both of these tuples are processed the same way. The target address is
 *	really an offset from the beginning of the specified address space
 *	and is not a virtual address.
 * This tuple must have a link field of at least MIN_LONGLINK_AC_LENGTH.
 */
#define	MIN_LONGLINK_AC_LENGTH		4

typedef struct cistpl_longlink_ac_t {
	uint32_t		flags;		/* space flags */
	uint32_t		tpll_addr;	/* target address, normalized */
} cistpl_longlink_ac_t;
/*
 * Flags for cistpl_longlink_ac_t->flags
 */
#define	CISTPL_LONGLINK_AC_AM	0x0001	/* longlink to AM */
#define	CISTPL_LONGLINK_AC_CM	0x0002	/* longlink to CM */

/*
 * CISTPL_LONGLINK_MFC
 *
 * This tuple describes the start of the function-specific CIS for each
 *	function on a multi-function card.
 *
 * This tuple must have a link field of at least MIN_LONGLINK_AC_LENGTH.
 */
#define	MIN_LONGLINK_MFC_LENGTH		6
#define	MIN_LONGLINK_MFC_NREGS		1

typedef struct cis_function_t {
	uint32_t	tas;    /* target address space of function */
	uint32_t	addr;   /* target address offset */
} cis_function_t;

typedef struct cistpl_longlink_mfc_t {
	uint32_t	nfuncs;		/* number of functions */
	uint32_t	nregs;		/* number of config register sets */
	cis_function_t	function[CIS_MAX_FUNCTIONS];
} cistpl_longlink_mfc_t;
/*
 * Flags for cistpl_longlink_mfc_t->function[n]->tas
 */
#define	CISTPL_LONGLINK_MFC_TAS_AM	0x00	/* CIS in attribute memory */
#define	CISTPL_LONGLINK_MFC_TAS_CM	0x01	/* CIS in common memory */

/*
 * CISTPL_LONGLINK_CB
 *
 * This tuple describes the start of a function's CIS chain
 *	for CardBus cards
 */
typedef struct cistpl_longlink_cb_t {
	uint32_t	flags;		/* address space flags */
	uint32_t	addr;		/* raw (unproessed) address value */
	union {
	    /* device-dependant config space info */
	    struct {
		uint32_t	offset;	/* offset within config space */
	    } cfg;
	    /* memory space info */
	    struct {
		uint32_t	asi;	/* BAR */
		uint32_t	offset;	/* offset within BAR space */
	    } mem;
	    /* expansion ROM space info */
	    struct {
		uint32_t	image;	/* image number */
		uint32_t	offset;	/* offset from iamge base */
	    } rom;
	} space;
} cistpl_longlink_cb_t;
/*
 * Flags for cistpl_longlink_cb_t->flags
 */
#define	CISTPL_LONGLINK_CB_CFG	0x0001	/* config space info valid */
#define	CISTPL_LONGLINK_CB_MEM	0x0002	/* memory space info valid */
#define	CISTPL_LONGLINK_CB_ROM	0x0004	/* expansion ROM space info valid */

/*
 * CISTPL_SPCL
 *
 * This tuple is the Special Purpose tuple and it's contents are dependant
 *	on the meaning of the header information in this tuple.
 */
typedef struct cistpl_spcl_t {
	uint32_t	id;		/* tuple contents identification */
	uint32_t	seq;		/* data sequence number */
	uint32_t	bytes;		/* number of bytes following */
	uchar_t		data[CIS_MAX_TUPLE_DATA_LEN];
} cistpl_spcl_t;
/*
 * Flags for cistpl_spcl_t->seq
 */
#define	CISTPL_SPCL_SEQ_END	0x080	/* last tuple in sequence */

/*
 * CISTPL_SWIL
 *
 * This tuple describes the software interleaving of data within a
 *	partition on the card.
 */
typedef struct cistpl_swil_t {
	uint32_t	intrlv;		/* interleave */
} cistpl_swil_t;

/*
 * CISTPL_BAR
 *
 * This tuple describes the CardBus Base Address Registers
 */
typedef struct cistpl_bar_t {
	uint32_t	attributes;	/* attributes */
	uint32_t	size;		/* BAR size */
} cistpl_bar_t;
/*
 * Flags for cistpl_bar_t->attributes
 */
#define	CISTPL_BAR_ASI_MASK	0x007	/* Base Address Register mask */
#define	CISTPL_BAR_ASI_BAR_1	0x001	/* Base Address Register 1 */
#define	CISTPL_BAR_ASI_BAR_2	0x002	/* Base Address Register 2 */
#define	CISTPL_BAR_ASI_BAR_3	0x003	/* Base Address Register 3 */
#define	CISTPL_BAR_ASI_BAR_4	0x004	/* Base Address Register 4 */
#define	CISTPL_BAR_ASI_BAR_5	0x005	/* Base Address Register 5 */
#define	CISTPL_BAR_ASI_BAR_6	0x006	/* Base Address Register 6 */
#define	CISTPL_BAR_ASI_BAR_7	0x007	/* Base Address Register 7 */
#define	CISTPL_BAR_ASI_EXP_ROM	0x007	/* Expansion ROM BAR */

#define	CISTPL_BAR_AS_MEM	0x000	/* BAR is of type memory */
#define	CISTPL_BAR_AS_IO	0x008	/* BAR is of type IO */

#define	CISTPL_BAR_PREFETCH_CACHE_MASK	0x060	/* prefetch/cache mask */
#define	CISTPL_BAR_PREFETCH		0x020	/* prefetchable not cacheable */
#define	CISTPL_BAR_PREFETCH_CACHE	0x040	/* prefetchable and cacheable */

#define	CISTPL_BAR_BELOW_1MB	0x080	/* must locate within first MB */

/*
 * CISTPL_DEVICEGEO and CISTPL_DEVICEGEO_A
 *
 * These tuples describe the device geometry of memory partitions.
 */
#define	CISTPL_DEVICEGEO_MAX_PARTITIONS	42
typedef struct cistpl_devicegeo_info_t {
	uint32_t	bus;		/* card interface width in bytes */
	uint32_t	ebs;		/* minimum erase block size */
	uint32_t	rbs;		/* minimum read block size */
	uint32_t	wbs;		/* minimum write bock size */
	uint32_t	part;		/* segment partition subdivisions */
	uint32_t	hwil;		/* hardware interleave */
} cistpl_devicegeo_info_t;
typedef struct cistpl_devicegeo_t {
	cistpl_devicegeo_info_t	info[CISTPL_DEVICEGEO_MAX_PARTITIONS];
} cistpl_devicegeo_t;

/*
 * The cistpl_get_tuple_name_t used to support the HANDTPL_RETURN_NAME
 *	operation of the CIS parser.
 */
typedef struct cistpl_get_tuple_name_t {
	char	name[CIS_MAX_TUPLE_NAME_LEN];
} cistpl_get_tuple_name_t;

/*
 * cisparse_t - the structure that unifies all tuple parsing structures
 */
typedef union cisparse_t {
	cistpl_config_t		cistpl_config;
	cistpl_device_t		cistpl_device;
	cistpl_vers_1_t		cistpl_vers_1;
	cistpl_vers_2_t		cistpl_vers_2;
	cistpl_jedec_t		cistpl_jedec;
	cistpl_format_t		cistpl_format;
	cistpl_geometry_t	cistpl_geometry;
	cistpl_byteorder_t	cistpl_byteorder;
	cistpl_date_t		cistpl_date;
	cistpl_battery_t	cistpl_battery;
	cistpl_org_t		cistpl_org;
	cistpl_manfid_t		cistpl_manfid;
	cistpl_funcid_t		cistpl_funcid;
	cistpl_funce_t		cistpl_funce;
	cistpl_cftable_entry_t	cistpl_cftable_entry;
	cistpl_linktarget_t	cistpl_linktarget;
	cistpl_longlink_ac_t	cistpl_longlink_ac;
	cistpl_longlink_mfc_t	cistpl_longlink_mfc;
	cistpl_spcl_t		cistpl_spcl;
	cistpl_swil_t		cistpl_swil;
	cistpl_bar_t		cistpl_bar;
	cistpl_devicegeo_t	cistpl_devicegeo;
	cistpl_longlink_cb_t	cistpl_longlink_cb;
	cistpl_get_tuple_name_t	cistpl_get_tuple_name;
	/* members below are for legacy support - REMOVE THEM BEFORE FCS!! */
	cistpl_config_t		config;
	cistpl_device_t		device;
	cistpl_vers_1_t		version_1;
	cistpl_vers_2_t		version_2;
	cistpl_jedec_t		jedec;
	cistpl_format_t		format;
	cistpl_geometry_t	geometry;
	cistpl_byteorder_t	byteorder;
	cistpl_date_t		date;
	cistpl_battery_t	battery;
	cistpl_org_t		org;
	cistpl_manfid_t		manfid;
	cistpl_funcid_t		funcid;
	cistpl_funce_t		funce;
	cistpl_cftable_entry_t	cftable;
	cistpl_linktarget_t	linktarget;
	cistpl_longlink_ac_t	longlink_ac;
	cistpl_longlink_mfc_t	longlink_mfc;
	cistpl_spcl_t		spcl;
	cistpl_swil_t		swil;
	cistpl_bar_t		bar;
	cistpl_devicegeo_t	devgeo;
	cistpl_longlink_cb_t	longlink_cb;
	cistpl_get_tuple_name_t	tuple_name;
} cisparse_t;

#ifdef	__cplusplus
}
#endif

#endif	/* _CIS_HANDLERS_H */
/*
 * 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 (c) 1999,2001 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#ifndef _CIS_PROTOS_H
#define	_CIS_PROTOS_H

#ifdef	__cplusplus
extern "C" {
#endif

/*
 * This file contains all of the function prototypes for functions
 *	used by the CIS interpreter.
 *
 * Prototypes for general functions
 */
uint32_t	cis_list_create(cistpl_callout_t *, cs_socket_t *);
uint32_t	cis_list_destroy(cs_socket_t *);
uint32_t	cis_list_lcreate(cistpl_callout_t *, cisptr_t *,
			cis_info_t *, cisparse_t *, cs_socket_t *);
uint32_t	cis_list_ldestroy(cistpl_t **);
cistpl_t	*cis_get_ltuple(cistpl_t *, cisdata_t, uint32_t);
uint32_t	cistpl_devspeed(cistpl_t *, cisdata_t, uint32_t);
uint32_t	cistpl_expd_parse(cistpl_t *, uint32_t *);
uint32_t	cis_convert_devspeed(convert_speed_t *);
uint32_t	cis_convert_devsize(convert_size_t *);
uint32_t	cis_validate_longlink_acm(cisptr_t *);

/*
 * Prototypes for the tuple handlers
 */
uint32_t	cis_tuple_handler(cistpl_callout_t *, cistpl_t *, uint32_t,
					void *, cisdata_t);
uint32_t	cis_no_tuple_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cis_unknown_tuple_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cistpl_vers_1_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cistpl_config_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cistpl_device_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cistpl_cftable_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cistpl_jedec_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cistpl_vers_2_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cistpl_format_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cistpl_geometry_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cistpl_byteorder_handler(cistpl_callout_t *,
					cistpl_t *, uint32_t, void *);
uint32_t	cistpl_date_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cistpl_battery_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cistpl_org_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cistpl_funcid_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cistpl_funce_serial_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cistpl_funce_lan_handler(cistpl_callout_t *,
					cistpl_t *, uint32_t, void *);
uint32_t	cistpl_manfid_handler(cistpl_callout_t *, cistpl_t *,
					uint32_t, void *);
uint32_t	cistpl_linktarget_handler(cistpl_callout_t *,
					cistpl_t *, uint32_t, void *);
uint32_t	cistpl_longlink_ac_handler(cistpl_callout_t *,
					cistpl_t *, uint32_t, void *);
uint32_t	cistpl_longlink_mfc_handler(cistpl_callout_t *,
					cistpl_t *, uint32_t, void *);

char	*cis_getstr(cistpl_t *);

#ifdef	_KERNEL
caddr_t	cis_malloc(size_t);
void	cis_free(caddr_t);
#endif	/* _KERNEL */

#ifdef	__cplusplus
}
#endif

#endif	/* _CIS_PROTOS_H */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _CS_H
#define	_CS_H

#ifdef	__cplusplus
extern "C" {
#endif

/*
 * PCMCIA Card Services header file
 */

/*
 * XXX - This define really should be in a global header file
 *	somewhere; we do this stunt here since a lot of
 *	people include this header file but not necessarily
 *	the header file in which this is defined.
 */
#ifndef	_VERSION
#define	_VERSION(major, minor)	((major)<<16|(minor))
#endif

/*
 * Define this version of CS - this should correspond to the PCMCIA
 *	version number specified in the PCMCIA standard.
 */
#define	CS_VERSION	_VERSION(5, 2)

/*
 * CS_INTERNAL_REVISION_LEVEL is our internal revision level value returned
 *	via GetCardServicesInfo in get_cardservices_info_t->Revision
 */
#define	CS_INTERNAL_REVISION_LEVEL	_VERSION(2, 0)

#define	CS_GET_CARDSERVICES_INFO_VENDOR_STRING	"Solaris UNIX Card Services\n" \
	"Copyright 2008 Sun Microsystems, Inc.  All rights reserved.\n" \
	"Use is subject to license terms.\n" \
	"@(#)cs.h	1.69 08/10/17 SMI\n" \
	"Based on the PC Card Standard, February 1995\n"

/*
 * typedef for function pointers to quiet lint and cc -v
 */
typedef	int32_t (csfunction_t)(int32_t, ...);	/* for lint - cc -v quieting */

/*
 * CS_SUN_VENDOR_DESCRIPTION - can be returned by clients handling
 *				the CS_EVENT_CLIENT_INFO event in the
 *				client_info_t->VendorName member.
 */
#define	CS_SUN_VENDOR_DESCRIPTION	"Sun Microsystems, Inc. (c) 1996"

/*
 * Return codes from Card Services - these correspond to the PCMCIA
 *	standard and also include some implementation-specific return
 *	codes.
 */
#define	CS_SUCCESS		0x00	/* Request succeeded */
#define	CS_BAD_ADAPTER		0x01	/* Specified adapter is invalid */
#define	CS_BAD_ATTRIBUTE	0x02	/* Bad attribute value */
#define	CS_BAD_BASE		0x03	/* System base address invalid */
#define	CS_BAD_EDC		0x04	/* EDC generator is invalid */
	/* RESERVED - 0x05 */
#define	CS_BAD_IRQ		0x06	/* Invalid IRQ */
#define	CS_BAD_OFFSET		0x07	/* Card offset invalid */
#define	CS_BAD_PAGE		0x08	/* Card page invalid */
#define	CS_READ_FAILURE		0x09	/* Unable to complete read request */
#define	CS_BAD_SIZE		0x0a	/* Size is invalid */
#define	CS_BAD_SOCKET		0x0b	/* Specified socket is invalid */
	/* RESERVED - 0x0c */
#define	CS_BAD_TYPE		0x0d	/* Window/interface type invalid */
#define	CS_BAD_VCC		0x0e	/* Vcc value/index invalid */
#define	CS_BAD_VPP		0x0f	/* Vpp value/index invalid */
#define	CS_BAD_WINDOW		0x11	/* Specified window is invalid */
#define	CS_WRITE_FAILURE	0x12	/* Unable to complete write request */
	/* RESERVED - 0x13 */
#define	CS_NO_CARD		0x14	/* No PC card in socket */
#define	CS_UNSUPPORTED_FUNCTION	0x15	/* Unsupported function */
#define	CS_UNSUPPORTED_MODE	0x16	/* Unsupported processor mode */
#define	CS_BAD_SPEED		0x17	/* Specified speed is unavailable */
#define	CS_BUSY			0x18	/* CS is busy - try again later */
#define	CS_GENERAL_FAILURE	0x19	/* Undefined error */
#define	CS_WRITE_PROTECTED	0x1a	/* Media is write protected */
#define	CS_BAD_ARG_LENGTH	0x1b	/* Arg length invalid */
#define	CS_BAD_ARGS		0x1c	/* Arg values invalid */
#define	CS_CONFIGURATION_LOCKED	0x1d	/* This configuration is locked */
#define	CS_IN_USE		0x1e	/* Requested resource in use */
#define	CS_NO_MORE_ITEMS	0x1f	/* No more of requested item */
#define	CS_OUT_OF_RESOURCE	0x20	/* Internal CS resources exhausted */
#define	CS_BAD_HANDLE		0x21	/* client or window handle invalid */

/*
 * The following are Solaris-specific extended return codes
 */
#define	CS_NO_CIS		0x80	/* No CIS on card */
#define	CS_BAD_CIS		0x81	/* Bad CIS on card */
#define	CS_UNKNOWN_TUPLE	0x82	/* unknown tuple */
#define	CS_BAD_VERSION		0x83	/* bad CS version */
#define	CS_UNSUPPORTED_EVENT	0x84	/* Unsupported event in client */
#define	CS_CSI_ERROR		0x85	/* error in csi driver protocol */
#define	CS_CSI_NOT_INIT		0x86	/* csi library/driver not initialized */
#define	CS_NO_TUPLE_PARSER	0x87	/* no tuple parser for this tuple */
#define	CS_CARD_NOT_READY	0x88	/* card not ready */
#define	CS_ERRORLIST_END	0x8000	/* end of error list */

/*
 * Card Services event codes - these do NOT correspond to the PCMCIA
 *	standard event codes for CS since these events are encoded as
 *	bit flags, while the PCMCIA standard event codes are encoded
 *	as numerical values.  In practice, this shouldn't be a problem
 *	since no one should be looking at the absolute value of the
 *	event codes; these defines should be used.
 *
 * The numerical value of an event code determines in what order a client
 *	will receive the event if other events are also pending for that
 *	client. XXX - need to make event_t a 64-bit field.
 *
 * Card Services receives these events from Socket Services or by reading
 *	the card's Pin Replacement Register.  In either case, the client
 *	always gets the same type of notification.
 */
#define	CS_EVENT_REGISTRATION_COMPLETE	0x00000001 /* 0x82 */
#define	CS_EVENT_PM_RESUME		0x00000002 /* 0x05 */
#define	CS_EVENT_CARD_INSERTION		0x00000004 /* 0x0c */
#define	CS_EVENT_CARD_READY		0x00000008 /* 0x01 */
#define	CS_EVENT_BATTERY_LOW		0x00000010 /* 0x02 is also BVD2 */
#define	CS_EVENT_BATTERY_DEAD		0x00000020 /* 0x40 is also BVD1 */
#define	CS_EVENT_CARD_LOCK		0x00000040 /* 0x03 */
#define	CS_EVENT_PM_SUSPEND		0x00000080 /* 0x04 */
#define	CS_EVENT_CARD_RESET		0x00000100 /* 0x11 */
#define	CS_EVENT_CARD_UNLOCK		0x00000200 /* 0x06 */
#define	CS_EVENT_EJECTION_COMPLETE	0x00000400 /* 0x07 */
#define	CS_EVENT_EJECTION_REQUEST	0x00000800 /* 0x08 */
#define	CS_EVENT_ERASE_COMPLETE		0x00001000 /* 0x81 */
#define	CS_EVENT_EXCLUSIVE_COMPLETE	0x00002000 /* 0x0d */
#define	CS_EVENT_EXCLUSIVE_REQUEST	0x00004000 /* 0x0e */
#define	CS_EVENT_INSERTION_COMPLETE	0x00008000 /* 0x09 */
#define	CS_EVENT_INSERTION_REQUEST	0x00010000 /* 0x0a */
#define	CS_EVENT_RESET_COMPLETE		0x00020000 /* 0x80 */
#define	CS_EVENT_RESET_PHYSICAL		0x00040000 /* 0x0f */
#define	CS_EVENT_RESET_REQUEST		0x00080000 /* 0x10 */
#define	CS_EVENT_MTD_REQUEST		0x00100000 /* 0x12 */
#define	CS_EVENT_CLIENT_INFO		0x00200000 /* 0x14 */
#define	CS_EVENT_TIMER_EXPIRED		0x00400000 /* 0x15 */
#define	CS_EVENT_WRITE_PROTECT		0x01000000 /* 0x17 */

/*
 * The CS_EVENT_SS_UPDATED event is generated when Socket Services
 *	has completed parsing the CIS and has done any necessary
 *	work to get the client driver loaded and attached.
 */
#define	CS_EVENT_SS_UPDATED		0x00800000 /* 0x16 */

/*
 * The CS_EVENT_STATUS_CHANGE event is generated by a Socket Services
 *	PCE_CARD_STATUS_CHANGE event; this event gets converted to
 *	the appropriate Card Services events when Card Services
 *	reads the PRR.
 */
#define	CS_EVENT_STATUS_CHANGE		0x02000000 /* ?? */

/*
 * The CS_EVENT_CARD_REMOVAL is the last "real" CS event and must
 *	have the highest value of all "real" CS events so that this
 *	event is handed to the client after all other queued events
 *	have been processed.
 * If the client has set the CS_EVENT_CARD_REMOVAL_LOWP flag in
 *	either of their event masks, then they will also receive
 *	a CS_EVENT_CARD_REMOVAL at low (cs_event_thread) priority;
 *	in this low priority removal event, the client can call
 *	many CS functions that they can't call when they recieve
 *	the high priority removal event.
 */
#define	CS_EVENT_CARD_REMOVAL		0x10000000 /* 0x0b */
#define	CS_EVENT_CARD_REMOVAL_LOWP	0x20000000 /* ?? */
/*
 * The following are not events but they share the event flags field
 *	and are used internally by CS.  These bit patterns will never
 *	be seen by clients.
 * CS_EVENT_ALL_CLIENTS can only be set by the super-client and by
 *	the CSI clients; setting this bit causes the driver to
 *	receive any events specified in their event masks whenever
 *	any such events occur on the socket.
 * CS_EVENT_READY_TIMEOUT is a CS-private flag and should never be
 *	set by clients.
 */
#define	CS_EVENT_ALL_CLIENTS		0x40000000 /* ?? */
#define	CS_EVENT_READY_TIMEOUT		0x80000000 /* ?? */

/*
 * CS_EVENT_CLIENT_EVENTS_MASK is a msk of events that only the framework
 *	is allowed to manipulate.
 */
#define	CS_EVENT_CLIENT_EVENTS_MASK	~(CS_EVENT_SS_UPDATED |		\
						CS_EVENT_ALL_CLIENTS |	\
						CS_EVENT_CARD_REMOVAL_LOWP)

/*
 * client_info_t structure used by clients for a CS_EVENT_CLIENT_INFO
 *	event and for the GetClientInfo function.
 */
#define	CS_CLIENT_INFO_MAX_NAME_LEN	80
typedef struct client_info_t {
	uint32_t	Attributes;
	uint32_t	Revision;	/* BCD value of client revision */
	uint32_t	CSLevel;	/* BCD value of CS release */
	uint32_t	RevDate;	/* revision date */
	char		ClientName[CS_CLIENT_INFO_MAX_NAME_LEN];
	char		VendorName[CS_CLIENT_INFO_MAX_NAME_LEN];
	char		DriverName[MODMAXNAMELEN];
} client_info_t;

/*
 * Flags for client_info_t->Attributes
 *
 * The low order byte bit values are used to return the data passed
 *	in to RegisterClient in the client_reg_t->Attributes member.
 */
#define	CS_CLIENT_INFO_SOCKET_SERVICES	INFO_SOCKET_SERVICES
#define	CS_CLIENT_INFO_IO_CLIENT	INFO_IO_CLIENT
#define	CS_CLIENT_INFO_MTD_CLIENT	INFO_MTD_CLIENT
#define	CS_CLIENT_INFO_MEM_CLIENT	INFO_MEM_CLIENT
#define	CS_CLIENT_INFO_CSI_CLIENT	INFO_CSI_CLIENT
#define	CS_CLIENT_INFO_CARD_SHARE	INFO_CARD_SHARE
#define	CS_CLIENT_INFO_CARD_EXCL	INFO_CARD_EXCL
#define	CS_CLIENT_INFO_CLIENT_MASK	0x000000ff
/*
 * Control and status flags.
 */
#define	CS_CLIENT_INFO_VALID		0x00010000	/* client info valid */
#define	CS_CLIENT_INFO_CLIENT_ACTIVE	0x00020000	/* client is for card */
#define	CS_CLIENT_INFO_FLAGS_MASK	0xffff0000
/*
 * Client Info subservice flags and types.
 */
#define	CS_CLIENT_INFO_SUBSVC_CS	0x00000000	/* CS client data */
#define	CS_CLIENT_INFO_SUBSVC_MASK	0x0000ff00	/* sub-service mask */
#define	GET_CLIENT_INFO_SUBSVC(s)	(((s) & CS_CLIENT_INFO_SUBSVC_MASK)>>8)
#define	SET_CLIENT_INFO_SUBSVC(s)	(((s)<<8) & CS_CLIENT_INFO_SUBSVC_MASK)

/*
 * CS_CLIENT_INFO_MAKE_DATE - Macro to make constructing the
 *	client_info_t->RevDate member easier. Parameters are:
 *
 *	day - from 1 to 31
 *	month - from 1 to 12
 *	year - year relative to 1980
 *			00 - 1980
 *			06 - 1986
 *			12 = 1992
 *			16 - 1996, etc...
 */
#define	CS_CLIENT_INFO_MAKE_DATE(d, m, y)	(((d) & 0x01f) |	\
						(((m) & 0x0f) << 5) |	\
						(((y) & 0x7f) << 9))
#define	CS_CLIENT_INFO_GET_DAY(d)		((d) & 0x1f)
#define	CS_CLIENT_INFO_GET_MONTH(m)		(((m) >> 5) & 0x0f)
#define	CS_CLIENT_INFO_GET_YEAR(y)		((((y) >> 9) & 0x7f) + 1980)
#define	CS_CLIENT_INFO_GET_YEAR_OFFSET(y)	(((y) >> 9) & 0x7f)

/*
 * get_firstnext_client_t_t structure used for GetFirstClient and GetNextClient
 */
typedef struct get_firstnext_client_t {
	uint32_t	Socket;
	uint32_t	Attributes;
	client_handle_t	client_handle;		/* returned client handle */
	uint32_t	num_clients;
} get_firstnext_client_t;

/*
 * Flags for get_firstnext_client_t->Attributes
 */
#define	CS_GET_FIRSTNEXT_CLIENT_ALL_CLIENTS	0x00000001
#define	CS_GET_FIRSTNEXT_CLIENT_SOCKET_ONLY	0x00000002

/*
 * The client event callback argument structure - this is passed in to
 *	the client event handler.  Most of these arguments are identical
 *	to the PCMCIA-specified arguments.
 */
typedef struct event_callback_args_t {
	client_handle_t	client_handle;
	void		*info;
	void		*mtdrequest;
	void		*buffer;
	void		*misc;
	void		*client_data;
	client_info_t	client_info;
} event_callback_args_t;

/*
 * Event priority flag passed to the client's event handler; the client
 *	uses this priority to determine which mutex to use.
 */
#define	CS_EVENT_PRI_LOW	0x0001
#define	CS_EVENT_PRI_HIGH	0x0002
#define	CS_EVENT_PRI_NONE	0x0004

/*
 * Event-specific event_callback_args_t->info values
 *
 * CS_EVENT_WRITE_PROTECT
 *	CS_EVENT_WRITE_PROTECT_WPOFF - card is not write protected
 *	CS_EVENT_WRITE_PROTECT_WPON - card is write protected
 */
#define	CS_EVENT_WRITE_PROTECT_WPOFF	0x0000
#define	CS_EVENT_WRITE_PROTECT_WPON	0xffff

/*
 * Endinanness and data ordering Attribute bits common to both R2 and
 *	CardBus windows and common to RequestIO, RequestWindow and
 *	DupHandle.
 */
#define	WIN_ACC_ENDIAN_MASK	0x00300000	/* endian mask */
#define	WIN_ACC_NEVER_SWAP	0x00000000	/* i/o access: no swap */
#define	WIN_ACC_BIG_ENDIAN	0x00100000	/* big endian */
#define	WIN_ACC_LITTLE_ENDIAN	0x00200000	/* little endian */

#define	WIN_ACC_ORDER_MASK	0x00700000	/* order mask */
#define	WIN_ACC_STRICT_ORDER	0x00000000	/* strict order */
#define	WIN_ACC_UNORDERED_OK	0x00100000	/* may be re-ordered */
#define	WIN_ACC_MERGING_OK	0x00200000	/* may merge i/o */
#define	WIN_ACC_LOADCACHING_OK	0x00300000	/* may cache reads */
#define	WIN_ACC_STORECACHING_OK	0x00400000	/* may cache all i/o */

/*
 * io_req_t structure used for RequestIO and ReleaseIO
 */
typedef struct io_req_t {
	uint32_t	Socket;
	baseaddru_t	BasePort1;
	uint32_t	NumPorts1;	/* 1st IO range no. contiguous ports */
	uint32_t	Attributes1;	/* 1st IO range attributes */
	baseaddru_t	BasePort2;
	uint32_t	NumPorts2;	/* 2nd IO range no. contiguous ports */
	uint32_t	Attributes2;	/* 2nd IO range attributes */
	uint32_t	IOAddrLines;	/* number of IO address lines decoded */
} io_req_t;

/*
 * Flags for RequestIO and ReleaseIO
 */
#define	IO_DATA_WIDTH_MASK	0x00000001	/* data path width mask */
#define	IO_DATA_WIDTH_8		0x00000000	/* 8 bit data path */
#define	IO_DATA_WIDTH_16	0x00000001	/* 16 bit data path */

/*
 * The following flags are included for compatability with other versions of
 *	Card Services, but they are not implemented in this version.  They
 *	are assigned values as placeholders only.  If any of these flags
 *	are set on a call to RequestIO, CS_BAD_ATTRIBUTE is returned.
 */
#define	IO_SHARED		0x00010000	/* for compatability only */
#define	IO_FIRST_SHARED		0x00020000	/* for compatability only */
#define	IO_FORCE_ALIAS_ACCESS	0x00040000	/* for compatability only */

/*
 * The following flags are private to Card Services and should never be set
 *	by a client.  Doing so will cause the system to take a supervisor
 *	trap at level twenty-nine.
 */
#define	IO_DEALLOCATE_WINDOW	0x10000000	/* CS private */
#define	IO_DISABLE_WINDOW	0x20000000	/* CS private */

/*
 * win_req_t structure used for RequestWindow
 *
 * Note that the ReqOffset member is not defined in the current PCMCIA
 *	spec but is included here to aid clients in determining the
 *	optimum offset to give to MapMemPage.
 */
typedef struct win_req_t {
	uint32_t	Socket;
	uint32_t	Attributes;	/* window flags */
	union {
	    uint32_t		base;	/* requested window base address */
	    acc_handle_t	handle;	/* access handle for base of window */
	} Base;
	uint32_t	Size;		/* window size requested/granted */
	union {
	    uint32_t		AccessSpeed;	/* window access speed */
	    uint32_t		IOAddrLines;	/* for I/O windows only */
	} win_params;
	uint32_t	ReqOffset;	/* required window offest */
} win_req_t;

/*
 * modify_win_t structure used for ModifyWindow
 */
typedef struct modify_win_t {
	uint32_t	Attributes;	/* window flags */
	uint32_t	AccessSpeed;	/* window access speed */
} modify_win_t;

/*
 * Flags for RequestWindow and ModifyWindow
 */
#define	WIN_MEMORY_TYPE_MASK	0x00000021	/* window type mask */
#define	WIN_MEMORY_TYPE_CM	0x00000000	/* window points to CM */
#define	WIN_MEMORY_TYPE_AM	0x00000001	/* window points to AM */
#define	WIN_MEMORY_TYPE_IO	0x00000020	/* window points to IO */

#define	WIN_DATA_WIDTH_MASK	0x00000042	/* data path width mask */
#define	WIN_DATA_WIDTH_8	0x00000000	/* 8-bit data path */
#define	WIN_DATA_WIDTH_16	0x00000002	/* 16-bit data path */
#define	WIN_DATA_WIDTH_32	0x00000040	/* 32-bit data path */

#define	WIN_ENABLE		0x00000004	/* enable/disable window */
#define	WIN_OFFSET_SIZE		0x00000008	/* card offsets window sized */
#define	WIN_ACCESS_SPEED_VALID	0x00000010	/* speed valid (ModifyWindow) */

#define	WIN_PREFETCH_CACHE_MASK	0x00000300	/* prefetch/cache mask */
#define	WIN_PREFETCH		0x00000100	/* prefetchable not cacheable */
#define	WIN_PREFETCH_CACHE	0x00000200	/* prefetchable and cacheable */

#define	WIN_BAR_MASK		0x00007000	/* Base Address Register mask */
#define	WIN_BAR_1		0x00001000	/* Base Address Register 1 */
#define	WIN_BAR_2		0x00002000	/* Base Address Register 2 */
#define	WIN_BAR_3		0x00003000	/* Base Address Register 3 */
#define	WIN_BAR_4		0x00004000	/* Base Address Register 4 */
#define	WIN_BAR_5		0x00005000	/* Base Address Register 5 */
#define	WIN_BAR_6		0x00006000	/* Base Address Register 6 */
#define	WIN_BAR_7		0x00007000	/* Base Address Register 7 */

/*
 * The following flag is used internally by Card Services and should never
 *	be set by the caller.
 */
#define	WIN_DATA_WIDTH_VALID	0x00008000	/* CS internal */

/*
 * The following flags are included for compatability with other versions of
 *	Card Services, but they are not implemented in this version.  They
 *	are assigned values as placeholders only.  If any of these flags
 *	are set on a call to RequestWindow, CS_BAD_ATTRIBUTE is returned.
 */
#define	WIN_PAGED		0x00010000	/* for compatability only */
#define	WIN_SHARED		0x00020000	/* for compatability only */
#define	WIN_FIRST_SHARED	0x00040000	/* for compatability only */
#define	WIN_BINDING_SPECIFIC	0x00080000	/* for compatability only */

/*
 * The following flag is actually part of the AccessSpeed member
 */
#define	WIN_USE_WAIT		0x80	/* use window that supports WAIT */

/*
 * client_reg_t structure for RegisterClient
 */
typedef struct client_reg_t {
	uint32_t		Attributes;
	uint32_t		EventMask;
	event_callback_args_t	event_callback_args;
	uint32_t		Version;	/* CS version to expect */
	csfunction_t		*event_handler;
	/* DDI support */
	ddi_iblock_cookie_t	*iblk_cookie;	/* event iblk cookie */
	ddi_idevice_cookie_t	*idev_cookie;	/* event idev cookie */
	dev_info_t		*dip;		/* client's dip */
	char			driver_name[MODMAXNAMELEN];
	/* CS private */
	void			*priv;		/* CS private data */
} client_reg_t;

/*
 * Flags for RegisterClient - some of these flags are also used internally
 *	by CS to sequence the order of event callbacks and to allow Socket
 *	Services to register as a "super" client.
 *
 * The client_reg_t->Attributes structure member uses these flags.
 *
 * The client_info_t->Attributes, client_types_t->type and client_t->flags
 *	tructure members use these flags as well.
 *
 * Client types - mutually exclusive.
 */
#define	INFO_SOCKET_SERVICES	0x00000001
#define	INFO_IO_CLIENT		0x00000002
#define	INFO_MTD_CLIENT		0x00000004
#define	INFO_MEM_CLIENT		0x00000008
#define	INFO_CSI_CLIENT		0x00000010
#define	INFO_CLIENT_TYPE_MASK	(INFO_SOCKET_SERVICES |		\
					INFO_IO_CLIENT |	\
					INFO_MTD_CLIENT	|	\
					INFO_MEM_CLIENT |	\
					INFO_CSI_CLIENT)
#define	MAX_CLIENT_TYPES	3	/* doesn't include SS or CSI clients */

/*
 * The following two are for backwards-compatability with the PCMCIA spec.
 *	We will give the client CARD_INSERTION and REGISTRATION_COMPLETE
 *	if either of these two bits are set.  Normally, all IO and MEM
 *	clients should set both of these bits.
 */
#define	INFO_CARD_SHARE		0x00000020
#define	INFO_CARD_EXCL		0x00000040
#define	INFO_CARD_FLAGS_MASK	(INFO_CARD_SHARE | INFO_CARD_EXCL)

/*
 * tuple_t struct used for GetFirstTuple, GetNextTuple, GetTupleData
 *	and ParseTuple
 *
 * Note that the values for DesiredTuple are defined in the cis.h header
 *	file.
 */
typedef struct tuple_t {
	uint32_t	Socket;		/* socket number to get tuple from */
	uint32_t	Attributes;	/* tuple return attributes */
	cisdata_t	DesiredTuple;	/* tuple to search for or flags */
	cisdata_t	TupleOffset;	/* offset in tuple data body */
	uint32_t	Flags;		/* CS private */
	cistpl_t	*LinkOffset;	/* CS private */
	cistpl_t	*CISOffset;	/* CS private */
	cisdata_t	TupleDataMax;	/* max size of tuple data area */
	cisdata_t	TupleDataLen;	/* actual size of tuple data area */
					/* tuple body data buffer */
	cisdata_t	TupleData[CIS_MAX_TUPLE_DATA_LEN];
	cisdata_t	TupleCode;	/* tuple type code */
	cisdata_t	TupleLink;	/* tuple data body size */
} tuple_t;

/*
 * Attribute flags definitions for CS tuple functions.
 *
 */
#define	TUPLE_RETURN_LINK		0x00000002 /* return link tuples */
#define	TUPLE_RETURN_IGNORED_TUPLES	0x00010000 /* return ignored tuples */
#define	TUPLE_RETURN_NAME		0x00020000 /* return tuple name */

/*
 * cisinfo_t structure used for ValidateCIS
 */
typedef struct cisinfo_t {
	uint32_t	Socket;		/* socket number to validate CIS on */
	uint32_t	Chains;		/* number of tuple chains in CIS */
	uint32_t	Tuples;		/* total number of tuples in CIS */
} cisinfo_t;

/*
 * map_mem_page_t structure used for MapMemPage
 */
typedef struct map_mem_page_t {
	uint32_t	CardOffset;	/* card offset */
	uint32_t	Page;		/* page number */
} map_mem_page_t;

/*
 * sockevent_t structure used for GetEventMask and SetEventMask
 */
typedef struct sockevent_t {
	uint32_t	Attributes;	/* attribute flags for call */
	uint32_t	EventMask;	/* event mask to set or return */
	uint32_t	Socket;		/* socket number if necessary */
} sockevent_t;

/*
 * request_socket_mask_t structure used for RequestSocketMask
 */
typedef struct request_socket_mask_t {
	uint32_t	Socket;		/* socket number if necessary */
	uint32_t	EventMask;	/* event mask to set or return */
} request_socket_mask_t;

/*
 * release_socket_mask_t structure used for ReleaseSocketMask
 */
typedef struct release_socket_mask_t {
	uint32_t	Socket;
} release_socket_mask_t;

/*
 * Flags for GetEventMask and SetEventMask
 */
#define	CONF_EVENT_MASK_GLOBAL	0x00000000	/* global event mask */
#define	CONF_EVENT_MASK_CLIENT	0x00000001	/* client event mask */
#define	CONF_EVENT_MASK_VALID	0x00000001	/* client event mask */

/*
 * convert_speed_t structure used for ConvertSpeed
 */
typedef struct convert_speed_t {
	uint32_t	Attributes;
	uint32_t	nS;
	uint32_t	devspeed;
} convert_speed_t;

/*
 * Flags for ConvertSpeed
 */
#define	CONVERT_NS_TO_DEVSPEED	0x00000001
#define	CONVERT_DEVSPEED_TO_NS	0x00000002

/*
 * convert_size_t structure used for ConvertSize
 */
typedef struct convert_size_t {
	uint32_t	Attributes;
	uint32_t	bytes;
	uint32_t	devsize;
} convert_size_t;

/*
 * Flags for ConvertSize
 */
#define	CONVERT_BYTES_TO_DEVSIZE	0x00000001
#define	CONVERT_DEVSIZE_TO_BYTES	0x00000002

#define	MAX_CS_EVENT_BUFSIZE		64	/* single event */
#define	MAX_MULTI_EVENT_BUFSIZE		512	/* all events */

#define	CS_EVENT_MAX_BUFSIZE	MAX_MULTI_EVENT_BUFSIZE
#define	CS_ERROR_MAX_BUFSIZE	MAX_CS_EVENT_BUFSIZE

/*
 * event2text_t structure used for Event2Text
 */
typedef struct event2text_t {
	event_t		event;		/* events */
					/* buffer to return text strings */
	char		text[CS_EVENT_MAX_BUFSIZE];
} event2text_t;

/*
 * error2text_t structure used for Error2Text
 */
typedef struct error2text_t {
	uint32_t	item;
	char		text[CS_ERROR_MAX_BUFSIZE];
} error2text_t;

/*
 * get_status_t structure used for GetStatus
 *
 * The values in the status members are the same as the CS_EVENT_XXX values.
 */
typedef struct get_status_t {
	uint32_t	Socket;
	uint32_t	CardState;	/* "live" card status for this client */
	uint32_t	SocketState;	/* latched socket values */
	uint32_t	raw_CardState;	/* raw live card status */
} get_status_t;

/*
 * GetStatus returns card state using the same bit definitions
 *	as the CS_EVENT_XXX bits. Some of the CS_EVENT_XXX bits
 *	are not meaningful for GetStatus and are reused here for
 *	status definitions.
 *
 * get_status_t->CardState and get_status_t->raw_CardState bits
 */
#define	CS_STATUS_WRITE_PROTECTED	CS_EVENT_WRITE_PROTECT
#define	CS_STATUS_CARD_LOCKED		CS_EVENT_CARD_LOCK
#define	CS_STATUS_EJECTION_REQUEST	CS_EVENT_EJECTION_REQUEST
#define	CS_STATUS_INSERTION_REQUEST	CS_EVENT_INSERTION_REQUEST
#define	CS_STATUS_BATTERY_DEAD		CS_EVENT_BATTERY_DEAD
#define	CS_STATUS_BATTERY_LOW		CS_EVENT_BATTERY_LOW
#define	CS_STATUS_CARD_READY		CS_EVENT_CARD_READY
#define	CS_STATUS_CARD_INSERTED		CS_EVENT_CARD_INSERTION
#define	CS_STATUS_RES_EVT1		0x00100000
#define	CS_STATUS_RES_EVT2		0x00200000
#define	CS_STATUS_RES_EVT3		0x00400000
#define	CS_STATUS_VCC_50		0x10000000
#define	CS_STATUS_VCC_33		0x20000000
#define	CS_STATUS_VCC_XX		0x40000000
#define	CS_STATUS_REQ_ATTN		0x80000000
/*
 * get_status_t->SocketState bits
 */
#define	CS_SOCK_STATUS_WRITE_PROTECT_CHANGE	CS_EVENT_WRITE_PROTECT
#define	CS_SOCK_STATUS_CARD_LOCK_CHNAGE		CS_EVENT_CARD_LOCK
#define	CS_SOCK_STATUS_EJECTION_PENDING		CS_EVENT_EJECTION_REQUEST
#define	CS_SOCK_STATUS_INSERTION_PENDING	CS_EVENT_INSERTION_REQUEST
#define	CS_SOCK_STATUS_BATTERY_DEAD_CHNAGE	CS_EVENT_BATTERY_DEAD
#define	CS_SOCK_STATUS_BATTERY_LOW_CHNAGE	CS_EVENT_BATTERY_LOW
#define	CS_SOCK_STATUS_CARD_READY_CHANGE	CS_EVENT_CARD_READY
#define	CS_SOCK_STATUS_CARD_DETECT_CHNAGE	CS_EVENT_CARD_INSERTION

/*
 * map_log_socket_t structure used for MapLogSocket
 */
typedef struct map_log_socket_t {
	uint32_t	LogSocket;	/* logical socket */
	uint32_t	PhyAdapter;	/* physical adapter */
	uint32_t	PhySocket;	/* physical socket */
} map_log_socket_t;

/*
 * get_physical_adapter_info_t structure used for GetPhysicalAdapterInfo
 */
typedef struct get_physical_adapter_info_t {
	uint32_t	LogSocket;	/* logical socket */
	uint32_t	PhySocket;	/* physical socket */
	uint32_t	flags;		/* adapter flags */
	char		name[MODMAXNAMELEN]; /* adapter module name */
	uint32_t	major;		/* adapter major number */
	uint32_t	minor;		/* adapter minor number */
	uint32_t	instance;	/* instance number of this adapter */
	uint32_t	number;		/* canonical adapter number */
	uint32_t	num_sockets;	/* # sockets on this adapter */
	uint32_t	first_socket;	/* first socket # on this adapter */
} get_physical_adapter_info_t;

/*
 * irq_req_t structure used for RequestIRQ and ReleaseIRQ
 */
typedef struct irq_req_t {
	uint32_t		Socket;
	uint32_t		Attributes;	/* IRQ attribute flags */
	csfunction_t		*irq_handler;
	void			*irq_handler_arg;
	ddi_iblock_cookie_t	*iblk_cookie;	/* IRQ iblk cookie */
	ddi_idevice_cookie_t	*idev_cookie;	/* IRQ idev cookie */
} irq_req_t;

/*
 * Flags for RequestIRQ and ReleaseIRQ
 */
#define	IRQ_TYPE_EXCLUSIVE		0x00000002
/*
 * The following flags are included for compatability with other versions of
 *	Card Services, but they are not implemented in this version.  They
 *	are assigned values as placeholders only.  If any of these flags
 *	are set on a call to RequestIRQ, CS_BAD_ATTRIBUTE is returned.
 */
#define	IRQ_FORCED_PULSE		0x00010000
#define	IRQ_TYPE_TIME			0x00020000
#define	IRQ_TYPE_DYNAMIC_SHARING	0x00040000
#define	IRQ_FIRST_SHARED		0x00080000
#define	IRQ_PULSE_ALLOCATED		0x00100000

/*
 * release_config_t structure used for ReleaseConfiguration
 */
typedef struct release_config_t {
	uint32_t	Socket;
} release_config_t;

/*
 * config_req_t structure used for RequestConfiguration
 */
typedef struct config_req_t {
	uint32_t	Socket;
	uint32_t	Attributes;	/* configuration attributes */
	uint32_t	Vcc;		/* Vcc value */
	uint32_t	Vpp1;		/* Vpp1 value */
	uint32_t	Vpp2;		/* Vpp2 value */
	uint32_t	IntType;	/* socket interface type - mem or IO */
	uint32_t	ConfigBase;	/* offset from start of AM space */
	uint32_t	Status;		/* value to write to STATUS register */
	uint32_t	Pin;		/* value to write to PRR */
	uint32_t	Copy;		/* value to write to COPY register */
	uint32_t	ConfigIndex;	/* value to write to COR */
	uint32_t	Present;	/* which config registers present */
	uint32_t	ExtendedStatus;	/* value to write to EXSTAT register */
} config_req_t;

/*
 * Flags for RequestConfiguration - note that the CONF_ENABLE_IRQ_STEERING
 *	flag shares the same bit field as the Attributes flags for
 *	ModifyConfiguration.
 */
#define	CONF_ENABLE_IRQ_STEERING	0x00010000
/*
 * The following flags are used for the IntType member to specify which
 *	type of socket interface the client wants.
 */
#define	SOCKET_INTERFACE_MEMORY		0x00000001
#define	SOCKET_INTERFACE_MEMORY_AND_IO	0x00000002
/*
 * The following flags are used for the Present member to specify which
 *	configuration registers are present.  They may also be used by
 *	clients for their internal state.
 */
#define	CONFIG_OPTION_REG_PRESENT	0x00000001 /* COR present */
#define	CONFIG_STATUS_REG_PRESENT	0x00000002 /* STAT reg present */
#define	CONFIG_PINREPL_REG_PRESENT	0x00000004 /* PRR present */
#define	CONFIG_COPY_REG_PRESENT		0x00000008 /* COPY reg present */
#define	CONFIG_EXSTAT_REG_PRESENT	0x00000010 /* EXSTAT reg present */
#define	CONFIG_IOBASE0_REG_PRESENT	0x00000020 /* IOBASE0 reg present */
#define	CONFIG_IOBASE1_REG_PRESENT	0x00000040 /* IOBASE1 reg present */
#define	CONFIG_IOBASE2_REG_PRESENT	0x00000080 /* IOBASE2 reg present */
#define	CONFIG_IOBASE3_REG_PRESENT	0x00000100 /* IOBASE3 reg present */
#define	CONFIG_IOLIMIT_REG_PRESENT	0x00000200 /* IOLIMIT reg present */

/*
 * CONFIG_IOBASE_REG_MASK - mask of IO Base Port register present bits
 * CONFIG_IOBASE_REG_SHIFT - shifts IO Base Port register present bits
 */
#define	CONFIG_IOBASE_REG_MASK		0x000001e0 /* IOBASEn present mask */
#define	CONFIG_IOBASE_REG_SHIFT		5

/*
 * Bit definitions for configuration registers.
 *
 * Pin Replacement Register (PRR) bits - these are used for calls to
 *	RequestConfiguration, AccessConfigurationRegister and
 *	GetConfigurationInfo, as well as internally by clients
 *	and Card Services.
 * To inform Card Services that a particular bit in the PRR is valid on
 *	a call to RequestConfiguration, both the XXX_STATUS and the
 *	XXX_EVENT bits must be set.
 */
#define	PRR_WP_STATUS		0x01	/* R-WP state W-write WP Cbit */
#define	PRR_READY_STATUS	0x02	/* R-READY state W-write READY Cbit */
#define	PRR_BVD2_STATUS		0x04	/* R-BVD2 state W-write BVD2 Cbit */
#define	PRR_BVD1_STATUS		0x08	/* R-BVD1 state W-write BVD1 Cbit */
#define	PRR_WP_EVENT		0x10	/* WP changed */
#define	PRR_READY_EVENT		0x20	/* READY changed */
#define	PRR_BVD2_EVENT		0x40	/* BVD2 changed */
#define	PRR_BVD1_EVENT		0x80	/* BVD1 changed */
/*
 * Configuration Option Register (COR) bits
 */
#define	COR_ENABLE_FUNCTION	0x01	/* enable function */
#define	COR_ENABLE_BASE_LIMIT	0x02	/* enable base and limit registers */
#define	COR_ENABLE_IREQ_ROUTING	0x04	/* enable IREQ routing */
#define	COR_STATUS_CHANGE_MODE	0x08	/* status change mode */
#define	COR_LEVEL_IRQ		0x40	/* set to enable level interrupts */
#define	COR_SOFT_RESET		0x80	/* soft reset bit */
/*
 * Card Configuration Status Register (CCSR)
 */
#define	CCSR_INTR_ACK		0x01	/* interrupt acknowledge */
#define	CCSR_INTR		0x02	/* interrupt pending */
#define	CCSR_POWER_DOWN		0x04	/* power down card */
#define	CCSR_AUDIO		0x08	/* enable Audio signal */
#define	CCSR_IO_IS_8		0x20	/* only 8-bit IO data path */
#define	CCSR_SIG_CHG		0x40	/* enable status changes */
#define	CCSR_CHANGED		0x80	/* one of the PRR bits has changed */
/*
 * Macros to manipulate the Socket and Copy Register (SCR) values
 */
#define	SCR_GET_SOCKET(r)		((r)&0x0f)
#define	SCR_GET_COPY(r)			(((r)>>4)&7)
#define	SCR_SET_SOCKET(s)		((s)&0x0f)
#define	SCR_SET_COPY(c)			(((c)&7)<<4)
#define	SCR_SET_SOCKET_COPY(s, c)	(((s)&0x0f) | (((c)&7)<<4))

/*
 * modify_config_t structure used for ModifyConfiguration
 */
typedef struct modify_config_t {
	uint32_t	Socket;
	uint32_t	Attributes;	/* attributes to modify */
	uint32_t	Vpp1;		/* Vpp1 value */
	uint32_t	Vpp2;		/* Vpp2 value */
} modify_config_t;

/*
 * Flags for ModifyConfiguration - note that the CONF_ENABLE_IRQ_STEERING
 *	flag used with RequestConfiguration shares this bit field.
 */
#define	CONF_VPP1_CHANGE_VALID		0x00000002	/* Vpp1 is valid */
#define	CONF_VPP2_CHANGE_VALID		0x00000004	/* Vpp2 is valid */
#define	CONF_IRQ_CHANGE_VALID		0x00000008	/* IRQ is valid */

/*
 * access_config_reg_t structure used for AccessConfigurationRegister
 */
typedef struct access_config_reg_t {
	uint32_t	Socket;
	uint32_t	Action;		/* register access operation */
	uint32_t	Offset;		/* config register offset */
	uint32_t	Value;		/* value read or written */
} access_config_reg_t;
/*
 * Flags for AccessConfigurationRegister
 */
#define	CONFIG_REG_READ		0x00000001	/* read config register */
#define	CONFIG_REG_WRITE	0x00000002	/* write config register */
/*
 * The following offsets are used to specify the configuration register
 *	offset to AccessConfigurationRegister
 */
#define	CONFIG_OPTION_REG_OFFSET	0x00	/* COR offset */
#define	CONFIG_STATUS_REG_OFFSET	0x02	/* STAT reg offset */
#define	CONFIG_PINREPL_REG_OFFSET	0x04	/* PRR offset */
#define	CONFIG_COPY_REG_OFFSET		0x06	/* COPY reg offset */
#define	CONFIG_EXSTAT_REG_OFFSET	0x08	/* EXSTAT reg offset */
#define	CONFIG_IOBASE0_REG_OFFSET	0x0a	/* IOBASE0 reg offset */
#define	CONFIG_IOBASE1_REG_OFFSET	0x0c	/* IOBASE1 reg offset */
#define	CONFIG_IOBASE2_REG_OFFSET	0x0e	/* IOBASE2 reg offset */
#define	CONFIG_IOBASE3_REG_OFFSET	0x10	/* IOBASE3 reg offset */
#define	CONFIG_IOLIMIT_REG_OFFSET	0x12	/* IOLIMIT reg offset */

/*
 * reset_function_t structure used for ResetFunction
 */
typedef struct reset_function_t {
	uint32_t	Socket;
	uint32_t	Attributes;
} reset_function_t;

/*
 * get_cardservices_info_t structure used for GetCardServicesInfo
 */
#define	CS_GET_CARDSERVICES_INFO_MAX_VS_LEN	512
typedef struct get_cardservices_info_t {
	char		Signature[2];	/* CS signature bytes */
	uint32_t	NumSockets;	/* number of sockets */
	uint32_t	Revision;	/* BCD value of CS revision */
	uint32_t	CSLevel;	/* BCD value of CS release */
	uint32_t	FuncsPerSocket;	/* max number of functions per socket */
	char		VendorString[CS_GET_CARDSERVICES_INFO_MAX_VS_LEN];
} get_cardservices_info_t;

/*
 * get_configuration_info_t structure used by GetConfigurationInfo
 */
typedef struct get_configuration_info_t {
	uint32_t	Socket;		/* Socket/function to get info for */
	uint32_t	Attributes;	/* configuration attributes */
	uint32_t	Vcc;		/* Vcc value */
	uint32_t	Vpp1;		/* Vpp1 value */
	uint32_t	Vpp2;		/* Vpp2 value */
	uint32_t	IntType;	/* memory only or memory and IO ifc */
	uint32_t	ConfigBase;	/* offset from start of AM space */
	uint32_t	Status;		/* value written to STATUS register */
	uint32_t	Pin;		/* value written to PRR */
	uint32_t	Copy;		/* value to written COPY register */
	uint32_t	Option;		/* which written to COR */
	uint32_t	Present;	/* which config registers present */
	uint32_t	FirstDevType;	/* from CISTPL_DEVICE */
	uint32_t	FuncCode;	/* from CISTPL_FUNCID */
	uint32_t	SysInitMask;	/* from CISTPL_FUNCID */
	uint32_t	ManufCode;	/* from CISTPL_MANFID */
	uint32_t	ManufInfo;	/* from CISTPL_MANFID */
	uint32_t	CardValues;	/* which config registers written */
	uint32_t	AssignedIRQ;	/* IRQ assigned to card */
	uint32_t	IRQ_Attributes;	/* IRQ attributes */
	uint32_t	BasePort1;	/* address of 1st IO range */
	uint32_t	NumPorts1;	/* 1st IO range no. contiguous ports */
	uint32_t	Attributes1;	/* 1st IO range attributes */
	uint32_t	BasePort2;	/* address of 2nd IO range */
	uint32_t	NumPorts2;	/* 2nd IO range no. contiguous ports */
	uint32_t	Attributes2;	/* 2nd IO range attributes */
	uint32_t	IOAddrLines;	/* number of IO address lines decoded */
	uint32_t	ExStat;		/* value written to EXSTAT register */
	uint32_t	DMA_Attributes;	/* signals used for DMA */
	uint32_t	DMA_Assign_Chan;	/* assigned DMA channel */
	uint32_t	NumIOWindows;	/* number of IO windows in use */
	uint32_t	NumMemWindows;	/* number of memory windows in use */
} get_configuration_info_t;

/*
 * devnode_desc_t structure used in make_device_node_t and remove_device_node_t
 *	for MakeDeviceNode and RemoveDeviceNode
 */
typedef struct devnode_desc_t {
	char	*name;		/* device node path and name */
	int32_t	spec_type;	/* dev special type (block or char) */
	int32_t	minor_num;	/* device node minor number */
	char	*node_type;	/* device node type */
} devnode_desc_t;

/*
 * make_device_node_t structure used for MakeDeviceNode
 */
typedef struct make_device_node_t {
	uint32_t	Action;		/* device operation */
	uint32_t	NumDevNodes;	/* number of nodes to create */
	devnode_desc_t	*devnode_desc;	/* description of device nodes */
} make_device_node_t;
/*
 * Action values for MakeDeviceNode
 */
#define	CREATE_DEVICE_NODE		0x01	/* create device node */

/*
 * remove_device_node_t structure used for RemoveDeviceNode
 */
typedef struct remove_device_node_t {
	uint32_t	Action;		/* device operation */
	uint32_t	NumDevNodes;	/* number of nodes to remove */
	devnode_desc_t	*devnode_desc;	/* description of device nodes */
} remove_device_node_t;
/*
 * Action values for RemoveDeviceNode
 *
 * Note: The "Action" member for make_device_node_t and remove_device_node_t
 *		share the same set of values.
 */
#define	REMOVE_DEVICE_NODE		0x02	/* remove device node */
#define	REMOVE_ALL_DEVICE_NODES		0x03	/* remove all device nodes */

/*
 * cs_ddi_info_t for CS_DDI_Info
 */
typedef struct cs_ddi_info_t {
	uint32_t	Socket;		/* socket number */
	char		*driver_name;	/* unique driver name */
	dev_info_t	*dip;		/* dip */
	int32_t		instance;	/* instance */
} cs_ddi_info_t;

/*
 * cs_sys_ctl_t for CS_Sys_Ctl
 */
typedef struct cs_sys_ctl_t {
	uint32_t	Socket;
	uint32_t	Action;
	uint32_t	Flags;
	uint32_t	Events;
	client_handle_t	client_handle;
} cs_sys_ctl_t;
/*
 * cs_sys_ctl_t->Action defines
 *
 * CS_SYS_CTL_SEND_EVENT - send events in cs_sys_ctl_t->Events to clients
 */
#define	CS_SYS_CTL_SEND_EVENT	0x0001	/* simulate events */
/*
 * cs_sys_ctl_t->Flags defines
 *
 * CS_SYS_CTL_WAIT_SYNC - wait for operation to complete, otherwise
 *	return immediately
 * CS_SYS_CTL_EVENT_SOCKET - send events to all clients on specified
 *	socket
 * CS_SYS_CTL_EVENT_CLIENT - send events to client specified by
 *	cs_sys_ctl_t->client_handle
 */
#define	CS_SYS_CTL_WAIT_SYNC	0x00000001	/* synchornize with thread */
#define	CS_SYS_CTL_EVENT_SOCKET	0x00000002	/* to all clients on socket */
#define	CS_SYS_CTL_EVENT_CLIENT	0x00000004	/* to client specified */

/*
 * Autoincrement control flags for RepPut8, RepPut16, RepPut32, RepPut32,
 *	RepGet8, RepGet16, RepGet32, RepGet64
 */
#define	CS_DEV_AUTOINCR		DDI_DEV_AUTOINCR
#define	CS_DEV_NO_AUTOINCR	DDI_DEV_NO_AUTOINCR

/*
 * Card Services function prototypes
 */
int32_t csx_RegisterClient(client_handle_t *, client_reg_t *);
int32_t csx_DeregisterClient(client_handle_t);
int32_t csx_GetStatus(client_handle_t, get_status_t *);
int32_t csx_SetEventMask(client_handle_t, sockevent_t *);
int32_t csx_GetEventMask(client_handle_t, sockevent_t *);
int32_t csx_RequestIO(client_handle_t, io_req_t *);
int32_t csx_ReleaseIO(client_handle_t, io_req_t *);
int32_t csx_RequestIRQ(client_handle_t, irq_req_t *);
int32_t csx_ReleaseIRQ(client_handle_t, irq_req_t *);
int32_t csx_RequestWindow(client_handle_t, window_handle_t *, win_req_t *);
int32_t csx_ReleaseWindow(window_handle_t);
int32_t csx_ModifyWindow(window_handle_t, modify_win_t *);
int32_t csx_MapMemPage(window_handle_t, map_mem_page_t *);
int32_t csx_RequestSocketMask(client_handle_t, request_socket_mask_t *);
int32_t csx_ReleaseSocketMask(client_handle_t, release_socket_mask_t *);
int32_t csx_RequestConfiguration(client_handle_t, config_req_t *);
int32_t csx_ModifyConfiguration(client_handle_t, modify_config_t *);
int32_t csx_ReleaseConfiguration(client_handle_t, release_config_t *);
int32_t csx_AccessConfigurationRegister(client_handle_t, access_config_reg_t *);
int32_t csx_GetFirstTuple(client_handle_t, tuple_t *);
int32_t csx_GetNextTuple(client_handle_t, tuple_t *);
int32_t csx_GetTupleData(client_handle_t, tuple_t *);
int32_t csx_MapLogSocket(client_handle_t, map_log_socket_t *);
int32_t csx_ValidateCIS(client_handle_t, cisinfo_t *);
int32_t csx_MakeDeviceNode(client_handle_t, make_device_node_t *);
int32_t csx_RemoveDeviceNode(client_handle_t, remove_device_node_t *);
int32_t csx_ConvertSpeed(convert_speed_t *);
int32_t csx_ConvertSize(convert_size_t *);
int32_t csx_Event2Text(event2text_t *);
int32_t csx_Error2Text(error2text_t *);
int32_t csx_CS_DDI_Info(cs_ddi_info_t *);
int32_t csx_CS_Sys_Ctl(cs_sys_ctl_t *);
int32_t csx_ResetFunction(client_handle_t, reset_function_t *);
int32_t csx_GetFirstClient(get_firstnext_client_t *);
int32_t csx_GetNextClient(get_firstnext_client_t *);
int32_t csx_GetClientInfo(client_handle_t, client_info_t *);
int32_t csx_GetCardServicesInfo(client_handle_t, get_cardservices_info_t *);
int32_t csx_GetConfigurationInfo(client_handle_t *, get_configuration_info_t *);
int32_t csx_GetPhysicalAdapterInfo(client_handle_t,
					get_physical_adapter_info_t *);

/*
 * CIS tuple parsing functions
 */
int32_t csx_Parse_CISTPL_CONFIG(client_handle_t, tuple_t *, cistpl_config_t *);
int32_t csx_Parse_CISTPL_DEVICE(client_handle_t, tuple_t *, cistpl_device_t *);
int32_t csx_Parse_CISTPL_DEVICE_A(client_handle_t, tuple_t *,
					cistpl_device_t *);
int32_t csx_Parse_CISTPL_DEVICE_OA(client_handle_t, tuple_t *,
					cistpl_device_t *);
int32_t csx_Parse_CISTPL_DEVICE_OC(client_handle_t, tuple_t *,
					cistpl_device_t *);
int32_t csx_Parse_CISTPL_VERS_1(client_handle_t, tuple_t *, cistpl_vers_1_t *);
int32_t csx_Parse_CISTPL_VERS_2(client_handle_t, tuple_t *, cistpl_vers_2_t *);
int32_t csx_Parse_CISTPL_JEDEC_A(client_handle_t, tuple_t *, cistpl_jedec_t *);
int32_t csx_Parse_CISTPL_JEDEC_C(client_handle_t, tuple_t *, cistpl_jedec_t *);
int32_t csx_Parse_CISTPL_FORMAT(client_handle_t, tuple_t *, cistpl_format_t *);
int32_t csx_Parse_CISTPL_FORMAT_A(client_handle_t, tuple_t *,
					cistpl_format_t *);
int32_t csx_Parse_CISTPL_GEOMETRY(client_handle_t, tuple_t *,
					cistpl_geometry_t *);
int32_t csx_Parse_CISTPL_BYTEORDER(client_handle_t, tuple_t *,
					cistpl_byteorder_t *);
int32_t csx_Parse_CISTPL_DATE(client_handle_t, tuple_t *, cistpl_date_t *);
int32_t csx_Parse_CISTPL_BATTERY(client_handle_t, tuple_t *,
					cistpl_battery_t *);
int32_t csx_Parse_CISTPL_ORG(client_handle_t, tuple_t *, cistpl_org_t *);
int32_t csx_Parse_CISTPL_MANFID(client_handle_t, tuple_t *, cistpl_manfid_t *);
int32_t csx_Parse_CISTPL_FUNCID(client_handle_t, tuple_t *, cistpl_funcid_t *);
int32_t csx_Parse_CISTPL_FUNCE(client_handle_t, tuple_t *, cistpl_funce_t *,
					uint32_t);
int32_t csx_Parse_CISTPL_CFTABLE_ENTRY(client_handle_t, tuple_t *,
					cistpl_cftable_entry_t *);
int32_t csx_Parse_CISTPL_LINKTARGET(client_handle_t, tuple_t *,
					cistpl_linktarget_t *);
int32_t csx_Parse_CISTPL_LONGLINK_A(client_handle_t, tuple_t *,
					cistpl_longlink_ac_t *);
int32_t csx_Parse_CISTPL_LONGLINK_C(client_handle_t, tuple_t *,
					cistpl_longlink_ac_t *);
int32_t csx_Parse_CISTPL_LONGLINK_MFC(client_handle_t, tuple_t *,
					cistpl_longlink_mfc_t *);
int32_t csx_Parse_CISTPL_SPCL(client_handle_t, tuple_t *,
					cistpl_spcl_t *);
int32_t csx_Parse_CISTPL_SWIL(client_handle_t, tuple_t *,
					cistpl_swil_t *);
int32_t csx_Parse_CISTPL_BAR(client_handle_t, tuple_t *,
					cistpl_bar_t *);
int32_t csx_Parse_CISTPL_DEVICEGEO(client_handle_t, tuple_t *,
					cistpl_devicegeo_t *);
int32_t csx_Parse_CISTPL_DEVICEGEO_A(client_handle_t, tuple_t *,
					cistpl_devicegeo_t *);
int32_t csx_Parse_CISTPL_LONGLINK_CB(client_handle_t, tuple_t *,
					cistpl_longlink_cb_t *);
int32_t csx_ParseTuple(client_handle_t, tuple_t *, cisparse_t *, uint32_t);

/*
 * Data access functions
 */
void csx_Put8(acc_handle_t, uint32_t, uint8_t);
void csx_Put16(acc_handle_t, uint32_t, uint16_t);
void csx_Put32(acc_handle_t, uint32_t, uint32_t);
void csx_Put64(acc_handle_t, uint32_t, uint64_t);
uint8_t csx_Get8(acc_handle_t, uint32_t);
uint16_t csx_Get16(acc_handle_t, uint32_t);
uint32_t csx_Get32(acc_handle_t, uint32_t);
uint64_t csx_Get64(acc_handle_t, uint32_t);
void csx_RepPut8(acc_handle_t, uint8_t *, uint32_t, uint32_t, uint32_t);
void csx_RepPut16(acc_handle_t, uint16_t *, uint32_t, uint32_t, uint32_t);
void csx_RepPut32(acc_handle_t, uint32_t *, uint32_t, uint32_t, uint32_t);
void csx_RepPut64(acc_handle_t, uint64_t *, uint32_t, uint32_t, uint32_t);
void csx_RepGet8(acc_handle_t, uint8_t *, uint32_t, uint32_t, uint32_t);
void csx_RepGet16(acc_handle_t, uint16_t *, uint32_t, uint32_t, uint32_t);
void csx_RepGet32(acc_handle_t, uint32_t *, uint32_t, uint32_t, uint32_t);
void csx_RepGet64(acc_handle_t, uint64_t *, uint32_t, uint32_t, uint32_t);

/*
 * Data access handle manipulation functions
 */
int32_t csx_GetMappedAddr(acc_handle_t, void **);
int32_t csx_GetPhysAddr(acc_handle_t, void **);
int32_t csx_DupHandle(acc_handle_t, acc_handle_t *, uint32_t);
int32_t csx_FreeHandle(acc_handle_t *);
int32_t csx_GetHandleOffset(acc_handle_t, uint32_t *);
int32_t csx_SetHandleOffset(acc_handle_t, uint32_t);

/*
 * XXX - PCMCIA Shady Meadows Retirement Community
 *
 * The defines in this section should be retired once the PS drivers
 *	get updated.
 *
 * XXX This is an old version of WIN_DATA_WIDTH_MASK and should be
 *	retired soon. RETIRE
 */
#define	WIN_DATA_WIDTH		0x00000002	/* 16-bit data path */
/*
 * XXX The following are old versions of the IO_DATA_WIDTH_XXX names and
 *	should be retured soon. RETIRE
 */
#define	IO_DATA_PATH_WIDTH	0x00000001	/* 16 bit data path */
#define	IO_DATA_PATH_WIDTH_8	0x00000000	/* 8 bit data path */
#define	IO_DATA_PATH_WIDTH_16	0x00000001	/* 16 bit data path */
/*
 * XXX - REMOVAL_ALL_DEVICE_NODES typo, remove soon. RETIRE
 */
#define	REMOVAL_ALL_DEVICE_NODES	0x03	/* remove all device nodes */

/*
 * The old name of the csx_RequestSocketMask structure was
 *	sockmask_t for some bizzare reason. This typedef
 *	keeps that old name around until we can fix
 *	the drivers.
 */
typedef struct request_socket_mask_t sockmask_t;	/* RETIRE */

/* XXX - RETIRE and change to a typedef XXX */
struct devnode_desc {
    char	*name;		/* device node path and name */
    int32_t	spec_type;	/* dev special type (block or char) */
    int32_t	minor_num;	/* device node minor number */
    char	*node_type;	/* device node type */
};

#ifdef	__cplusplus
}
#endif

#endif	/* _CS_H */
/*
 * 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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _CS_PRIV_H
#define	_CS_PRIV_H

#ifdef	__cplusplus
extern "C" {
#endif

/*
 * PCMCIA Card Services private header file
 */

/*
 * typedef for function pointers to quiet lint and cc -v
 */
typedef	int32_t (f_t)(int32_t, ...);	/* for lint - cc -v quieting */

/*
 * Magic number we use when talking with Socket Services
 */
#define	CS_MAGIC	PCCS_MAGIC

/*
 * Make the calls to SocketServices and the CIS Parser look like
 *	function calls.
 */
#define	SocketServices	(*cs_socket_services)
#define	CIS_PARSER	(*cis_parser)

/*
 * CIS_DEFAULT_SPEED is the default speed to use to read the CIS
 *	in AM space.  It is expressed in nS.
 */
#define	CIS_DEFAULT_SPEED	250

/*
 * This is the IO window speed.
 */
#define	IO_WIN_SPEED		250

/*
 * Flags to support various internal first/next functions. All of
 *	these must be within CIS_GET_LTUPLE_OPMASK which is defined
 *	in the cis.h file. Values outside this mask range are used
 *	internally by the CIS parser.
 */
#define	CS_GET_FIRST_FLAG	0x0001
#define	CS_GET_NEXT_FLAG	0x0002

/*
 * Macros to manipulate bits - only does up to uint32_t size
 */
#define	CS_BIT_WORDSIZE		(sizeof (uint32_t))

#define	CS_BIT_GET(val, bit)	\
			((uint32_t)(val) & (uint32_t)(1<<(uint32_t)(bit)))

#define	CS_BIT_CLEAR(val, bit)	((val) &= (uint32_t)~(1<<(uint32_t)(bit)))

#define	CS_BIT_SET(val, bit)	\
			((uint32_t)(val) |= (uint32_t)(1<<(uint32_t)(bit)))

/*
 * Minimum time to wait after socket reset before we are allowed to
 *	access the card.  The PCMCIA specification says at least 20mS
 *	must elapse from the time that the card is reset until the
 *	first access of any kind can be made to the card. This time
 *	value is expressed in mS.
 */
#define	RESET_TIMEOUT_TIME	180

/*
 * Maximum time to wait for card ready after resetting the socket.
 *	We wait for card ready a maximum of 20 seconds after card
 *	reset before considering that we have an error condition.
 * XXX - what does PCMCIA specify as the max time here??
 */
#define	READY_TIMEOUT_TIME	(drv_usectohz(20000000))

/*
 * Time between periodically kicking the soft interrupt handler.
 */
#define	SOFTINT_TIMEOUT_TIME	(drv_usectohz(2000000))

/*
 * Various delays are necessary when switching the card and socket
 *	between IO and memory modes. All delays are in mS.
 *
 *  cs_request_configuration parameters:
 *    CS_RC1_DELAY - delay between writing COR and switching socket
 *			to IO mode
 *    CS_RC2_DELAY - delay after switching socket to IO mode
 *
 *  cs_release_configuration parameters:
 *	CS_RQ_DELAY - amount of time that the RESET bit in the COR is
 *			held asserted
 */
#define	CS_RC1_DELAY		20	/* COR->IO delay in mS */
#define	CS_RC2_DELAY		300	/* post-COR delay in mS */
#define	CS_RQ_DELAY		100	/* COR(RESET) delay in mS */

/*
 * Handy macro to do untimeout.
 */
#define	UNTIMEOUT(id)		\
	if ((id)) {		\
	    (void) untimeout((id));	\
	    (id) = 0;		\
	}

/*
 * Macros to enter/exit event thread mutex
 */
#define	EVENT_THREAD_MUTEX_ENTER(acq, sp)		\
	acq = !MUTEX_HELD(&sp->client_lock);		\
	if (acq)					\
	    mutex_enter(&sp->client_lock);
#define	EVENT_THREAD_MUTEX_EXIT(acq, sp)		\
	if (acq)					\
	    mutex_exit(&sp->client_lock);

/*
 * cisregister_t structure is used to support the CISRegister
 *	and the CISUnregister function calls
 */
typedef struct cisregister_t {
	uint32_t		cis_magic;
	uint32_t		cis_version;
	void *			(*cis_parser)(int32_t function, ...);
	cistpl_callout_t	*cistpl_std_callout; /* standard callout list */
} cisregister_t;

/*
 * These two defines are to support CISRegister and CISUnregister
 */
#define	CIS_MAGIC	0x20434953
#define	CIS_VERSION	_VERSION(0, 1)

/*
 * CS_MAX_CIS defines the number of CIS chains that we hang off the per-socket
 *	structure.
 *
 * CS_GLOBAL_CIS defines the index where the CIS parser puts the first CIS list
 *	for a single-function card or the global CIS list for a multi-function
 *	card.
 *
 * CS_MAX_CIS is one greater than CIS_MAX_FUNCTIONS since the CIS parser
 *	puts the global CIS chain on the CS_GLOBAL_CIS function index as
 * 	follows:
 *
 *	For single-function cards:
 *	    sp->cis[0] - CIS chain
 *	    sp->cis[1..(CIS_MAX_FUNCTIONS - 1)] - not used
 *	    sp->cis[CS_GLOBAL_CIS] - not used
 *
 *	For multi-function cards:
 *	    sp->cis[0..(CIS_MAX_FUNCTIONS - 1)] - global CIS chain followed
 *					by per-function CIS chain
 *	    sp->cis[CS_GLOBAL_CIS] - global CIS chain
 */
#define	CS_MAX_CIS	(CIS_MAX_FUNCTIONS + 1)
#define	CS_GLOBAL_CIS	CIS_MAX_FUNCTIONS

/*
 * CS_SS_CLIENT_HANDLE is a special client handle that Socket Services gets
 *	when it registers with RegisterClient.
 */
#define	CS_SS_CLIENT_HANDLE	0x00000000

/*
 * Client handle, socket number, function number and socket pointer
 *	macros. The client handle encoding is private to Card Services,
 *	and external modules should not use these macros to manipulate
 *	client handles.
 *
 *	The encoding of the client handle is:
 *
 *		xxxxxfff | xsssssss | cccccccc | cccccccc
 *
 *	f - function number bit
 *	s - socket number bit
 *	c - client number bit
 *	x - don't care bits
 */
#define	CLIENT_HANDLE_IS_SS(ch)		(!GET_CLIENT_MINOR((ch)))
#define	CS_MAX_SOCKETS_MASK		(PCMCIA_MAX_SOCKETS - 1)
#define	CS_MAX_FUNCTIONS_MASK		(CIS_MAX_FUNCTIONS - 1)
#define	CS_MAX_CLIENTS_MASK		0x0ffff
#define	CS_MAX_CLIENTS			(CS_MAX_CLIENTS_MASK - 2)
#define	MAKE_CLIENT_HANDLE(s, f, c)	((((f)&CS_MAX_FUNCTIONS_MASK)<<24) | \
					    (((s)&CS_MAX_SOCKETS_MASK)<<16) | \
					    ((c)&CS_MAX_CLIENTS_MASK))
#define	GET_CLIENT_SOCKET(ch)		(((ch)>>16)&CS_MAX_SOCKETS_MASK)
#define	GET_CLIENT_FUNCTION(ch)		(((ch)>>24)&CS_MAX_FUNCTIONS_MASK)
#define	GET_CLIENT_MINOR(ch)		((ch)&CS_MAX_CLIENTS_MASK)

/*
 * Socket number macros. These are used by Socket Services, CSI
 *	drivers and the "super-client" driver to specify which
 *	socket and function number on that socket they wish to
 *	manipulate. This socket number encoding is typically passed
 *	to various Card Services functions by these drivers.
 *
 *	The encoding of the socket number is:
 *
 *		xxxxxxxx | xxxxgfff | xxxxxxxx | xsssssss
 *
 *	g - global CIS bit
 *	f - function number bit
 *	s - socket number bit
 *	x - don't care bits
 */
#define	CS_GET_SOCKET_NUMBER(s)		((s)&CS_MAX_SOCKETS_MASK)
#define	CS_GET_FUNCTION_NUMBER(s)	(((s)>>16)&(CS_MAX_FUNCTIONS_MASK | \
							CIS_MAX_FUNCTIONS))
#define	CS_SET_SOCKET_NUMBER(s)		((s)&CS_MAX_SOCKETS_MASK)
#define	CS_SET_FUNCTION_NUMBER(f)	(((f)&(CS_MAX_FUNCTIONS_MASK | \
						CIS_MAX_FUNCTIONS))<<16)
#define	CS_MAKE_SOCKET_NUMBER(s, f)	(CS_SET_SOCKET_NUMBER(s) | \
						CS_SET_FUNCTION_NUMBER(f))

/*
 * DIP2SOCKET_NUM(dip) - this macro gets the PCM_DEV_SOCKET property from
 *	the passed dip.  If the property can't be found, then the default
 *	value of cs_globals.max_socket_num is returned.
 */
#define	DIP2SOCKET_NUM(dip)		ddi_getprop(DDI_DEV_T_NONE, dip,\
						(DDI_PROP_CANSLEEP |	\
							DDI_PROP_NOTPROM), \
						PCM_DEV_SOCKET,		\
						cs_globals.max_socket_num)

/*
 * Range checking macros
 *
 * CHECK_SOCKET_NUM(socket_number, max_sockets) returns 1 if
 *	socket_number is in range
 */
#define	CHECK_SOCKET_NUM(sn, ms)	(((sn) >= (ms))?0:1)

/*
 * window macros
 *
 * These all expect that the window has been validated as a valid
 *	window (i.e. CW_WINDOW_VALID is set in window state)
 *
 * Note that WINDOW_FOR_SOCKET expects a socket mask for the wsm
 *	parameter (this is a socket_enum_t type, and NOT just a
 *	plain old uint32_t)
 */
#define	WINDOW_FOR_SOCKET(wsm, sn)	((wsm)[sn/PR_WORDSIZE] & \
						(1 << ((sn) & PR_MASK)))
#define	WINDOW_AVAILABLE_FOR_MEM(cwp)	(!(cwp->state & CW_WIN_IN_USE))
#define	WINDOW_AVAILABLE_FOR_IO(cwp)	\
		(!(cwp->state & (CW_CIS | CW_MEM | CW_ALLOCATED)))

/*
 * IO Base and NumPorts address frobnitz macros
 */
#define	IOADDR_FROBNITZ(Base, IOAddrLines)	(Base&((1<<IOAddrLines)-1))
#define	IONUMPORTS_FROBNITZ(np)			(((np)&1)?((np)+1):(np))

/*
 * Structure that contains offsets to the card's configuration registers
 *	as well as copies of the data written to them in RequestConfiguration.
 *	We use an offset per register approach since not all cards have
 *	all registers implemented, and by specifying a NULL register offset,
 *	we know not to try to access that register.
 */
typedef struct config_regs_t {
	cfg_regs_t	cor;		/* Configuration Option Register */
	uint32_t	cor_p;
	cfg_regs_t	ccsr;		/* Configuration and Status Register */
	uint32_t	ccsr_p;
	cfg_regs_t	prr;		/* Pin Replacement Register */
	uint32_t	prr_p;
	cfg_regs_t	scr;		/* Socket and Copy Register */
	uint32_t	scr_p;
	cfg_regs_t	exstat;		/* Extended Status Register */
	uint32_t	exstat_p;
	cfg_regs_t	iobase0;	/* IO Base 0 Register */
	uint32_t	iobase0_p;
	cfg_regs_t	iobase1;	/* IO Base 1 Register */
	uint32_t	iobase1_p;
	cfg_regs_t	iobase2;	/* IO Base 2 Register */
	uint32_t	iobase2_p;
	cfg_regs_t	iobase3;	/* IO Base 3 Register */
	uint32_t	iobase3_p;
	cfg_regs_t	iolimit;	/* IO Limit Register */
	uint32_t	iolimit_p;
} config_regs_t;

/*
 * Macro to make calling the client's event handler look like a function.
 */
#define	CLIENT_EVENT_CALLBACK(cp, event, pri)		\
	    (cp)->event_callback_handler(event, pri,	\
			&(cp)->event_callback_args)

/*
 * Macro to return event in PRR - this also clears the changed bit if
 *	the event occured.
 */
#define	PRR_EVENT(prrx, pe, ps, ce, re)	\
	if (prrx & pe) {		\
	    if (prrx & ps)		\
		(re) |= ce;		\
	    prrx &= ~pe;		\
	    prrx |= ps;			\
	}

/*
 * io_alloc_t struct used to keep track of a client's IO window allocation
 */
typedef struct io_alloc_t {
	uint32_t	Window1;	/* allocated IO window no. for set #1 */
	baseaddru_t	BasePort1;	/* 1st IO range base address or port */
	uint32_t	NumPorts1;	/* 1st IO range no. contiguous ports */
	uint32_t	Attributes1;	/* 1st IO range attributes */
	uint32_t	Window2;	/* allocated IO window no. for set #2 */
	baseaddru_t	BasePort2;	/* s2nd IO range base address or port */
	uint32_t	NumPorts2;	/* 2nd IO range no. contiguous ports */
	uint32_t	Attributes2;	/* second IO range attributes */
	uint32_t	IOAddrLines;	/* number of IO address lines decoded */
} io_alloc_t;

/*
 * irq_alloc_t structure used to keep track of a client's IRQ allocation
 */
typedef struct irq_alloc_t {
	uint32_t	Attributes;	/* IRQ attribute flags */
	uint32_t	irq;		/* assigned IRQ number */
	uint32_t	handler_id;	/* IRQ handler ID for this IRQ */
	f_t		*irq_handler;
	void		*irq_handler_arg1;
	void		*irq_handler_arg2;
} irq_alloc_t;

/*
 * The client data structure
 */
typedef struct client_t {
	client_handle_t	client_handle;	/* this client's client handle */
	unsigned	flags;		/* client flags */
	/* resource control */
	uint32_t	memwin_count;	/* number of mem windows allocated */
	io_alloc_t	io_alloc;	/* IO resource allocations */
	irq_alloc_t	irq_alloc;	/* IRQ resource allocations */
	/* event support */
	uint32_t	event_mask;	/* client event mask */
	uint32_t	global_mask;	/* client global event mask */
	uint32_t	events;		/* current events pending */
	uint32_t	pending_events;	/* events pending in RegisterClient */
	csfunction_t	*event_callback_handler;
	event_callback_args_t	event_callback_args;
	/* config registers support */
	config_regs_t	config_regs;	/* pointers to config registers */
	uint32_t	config_regs_offset; /* offset from start of AM */
	unsigned	pin;		/* valid bits in PRR */
	uint32_t	present;	/* which config registers present */
	/* DDI support */
	dev_info_t	*dip;		/* this client's dip */
	char		*driver_name;	/* client's driver name */
	int32_t		instance;	/* client's driver instance */
	/* list control */
	struct client_t	*next;		/* next client pointer */
	struct client_t	*prev;		/* previous client pointer */
} client_t;

/*
 * Flags for client structure - note that we share the client_t->flags
 *	member with the definitions in cs.h that are used by the
 *	RegisterClient function.
 *
 * We can start our flags from 0x00001000 and on up.
 */
#define	REQ_CONFIGURATION_DONE	0x00001000	/* RequestConfiguration done */
#define	REQ_SOCKET_MASK_DONE	0x00002000	/* RequestSocketMask done */
#define	REQ_IO_DONE		0x00004000	/* RequestIO done */
#define	REQ_IRQ_DONE		0x00008000	/* RequestIRQ done */
#define	CLIENT_SUPER_CLIENT	0x00010000	/* "super-client" client */
#define	CLIENT_CSI_CLIENT	0x00020000	/* CSI client */
#define	CLIENT_CARD_INSERTED	0x00100000	/* current card for client */
#define	CLIENT_SENT_INSERTION	0x00200000	/* send CARD_INSERTION */
#define	CLIENT_MTD_IN_PROGRESS	0x01000000	/* MTD op in progress */
#define	CLIENT_IO_ALLOCATED	0x02000000	/* IO resources allocated */
#define	CLIENT_IRQ_ALLOCATED	0x04000000	/* IRQ resources allocated */
#define	CLIENT_WIN_ALLOCATED	0x08000000	/* window resources allocated */

#ifdef	USE_IOMMAP_WINDOW
/*
 * io_mmap_window_t structure that describes the memory-mapped IO
 *	window on this socket
 */
typedef struct io_mmap_window_t {
	uint32_t		flags;	/* window flags */
	uint32_t		number;	/* IO window number */
	uint32_t		size;	/* size of mapped IO window */
	ddi_acc_handle_t	handle;	/* window mapped base address */
	uint32_t		count;	/* referance count */
} io_mmap_window_t;
#endif	/* USE_IOMMAP_WINDOW */

/*
 * cis_info_t structure used to hold per-socket CIS information
 */
typedef struct cis_info_t {
	uint32_t	flags;		/* CIS-specific flags */
	cistpl_t	*cis;		/* CIS linked lists */
	uint32_t	nchains;	/* number of tuple chains in CIS */
	uint32_t	ntuples;	/* number of tuples in CIS */
} cis_info_t;

/*
 * cs_adapter_t structure used to hold per-socket
 *	adapter-specific info
 */
typedef struct cs_adapter_t {
	uint32_t	flags;		/* adapter flags */
	char		name[MODMAXNAMELEN]; /* adapter module name */
	uint32_t	major;		/* adapter major number */
	uint32_t	minor;		/* adapter minor number */
	uint32_t	instance;	/* instance number of this adapter */
	uint32_t	number;		/* canonical adapter number */
	uint32_t	num_sockets;	/* # sockets on this adapter */
	uint32_t	first_socket;	/* first socket # on this adapter */
} cs_adapter_t;

/*
 * The per-socket structure.
 */
typedef struct cs_socket_t {
	unsigned	socket_num;	/* socket number */
	uint32_t	flags;		/* socket flags */
	uint32_t	init_state;	/* cs_init state */
	cs_adapter_t	adapter;	/* adapter info */
	/* socket thread control and status */
	kthread_t	*event_thread;	/* per-socket work thread */
	uint32_t	thread_state;	/* socket thread state flags */
	kmutex_t	lock;		/* protects events and clients */
	kcondvar_t	thread_cv;	/* event handling synchronization */
	kcondvar_t	caller_cv;	/* event handling synchronization */
	kcondvar_t	reset_cv;	/* for use after card RESET */
	uint32_t	events;		/* socket events */
	uint32_t	event_mask;	/* socket event mask */
	ddi_softintr_t	softint_id;	/* soft interrupt handler ID */
	timeout_id_t	rdybsy_tmo_id;	/* timer ID for READY/BUSY timer */
	ddi_iblock_cookie_t	*iblk;	/* event iblk cookie */
	ddi_idevice_cookie_t	*idev;	/* event idev cookie */
	callb_cpr_t	cprinfo_cs;	/* CPR cookie for cs_event_thread */
	callb_cpr_t	cprinfo_ss;	/* CPR cookie for cs_ss_thread */
	/* client management */
	client_t	*client_list;	/* clients on this socket */
	unsigned	next_cl_minor;	/* next available client minor num */
	kmutex_t	client_lock;	/* protects client list */
	uint32_t	num_clients;	/* number of clients on this socket */
	/* CIS support */
	uint32_t	cis_win_num;	/* CIS window number */
	unsigned	cis_win_size;	/* CIS window size */
	uint32_t	cis_flags;
	uint32_t	nfuncs;		/* number of functions */
	cis_info_t	cis[CS_MAX_CIS]; /* CIS information */
	kmutex_t	cis_lock;	/* protects CIS */
#ifdef	USE_IOMMAP_WINDOW
	/* memory mapped IO window support */
	io_mmap_window_t *io_mmap_window;
#endif	/* USE_IOMMAP_WINDOW */
	/* Socket Services work thread control and status */
	kthread_t	*ss_thread;	/* SS work thread */
	uint32_t	ss_thread_state; /* SS work thread state */
	kcondvar_t	ss_thread_cv;	/* SS work thread synchronization */
	kcondvar_t	ss_caller_cv;	/* SS work thread synchronization */
	kmutex_t	ss_thread_lock;	/* protects SS work thread state */
	struct cs_socket_t	*next;	/* next socket in list */
} cs_socket_t;

/*
 * cs_socket_t->flags flags
 */
#define	SOCKET_CARD_INSERTED		0x00000001	/* card is inserted */
#define	SOCKET_IS_IO			0x00000002	/* socket in IO mode */
#define	SOCKET_UNLOAD_MODULE		0x00000004	/* want to unload CS */
#define	SOCKET_NEEDS_THREAD		0x00000008	/* wake event thread */
#define	SOCKET_IS_VALID			0x00000020	/* socket OK to use */

/*
 * cs_socket_t->thread_state and cs_socket_t->ss_thread_state flags
 */

/* generic for all threads */
#define	SOCKET_THREAD_EXIT		0x00000001	/* exit event thread */

/* only used for per-socket event thread */
#define	SOCKET_WAIT_FOR_READY		0x00001000	/* waiting for READY */
#define	SOCKET_RESET_TIMER		0x00002000	/* RESET timer */
#define	SOCKET_WAIT_SYNC		0x00004000	/* SYNC */

/* only used for Socket Services work thread */
#define	SOCKET_THREAD_CSCISInit		0x00100000	/* call CSCISInit */

/*
 * cs_socket_t->cis_flags and cs_socket_t->cis_info_t->flags flags
 */
#define	CW_VALID_CIS			0x00000001	/* valid CIS */
#define	CW_MULTI_FUNCTION_CIS		0x00000002	/* multifunction card */
#define	CW_LONGLINK_A_FOUND		0x00000004	/* CISTPL_LONGLINK_A */
#define	CW_LONGLINK_C_FOUND		0x00000008	/* CISTP_LONGLINK_C */
#define	CW_LONGLINK_MFC_FOUND		0x00000010	/* LONGLINK_MFC */
#define	CW_CHECK_LINKTARGET		0x00000020	/* check linktarget */
#define	CW_RET_ON_LINKTARGET_ERROR	0x00000040	/* linktarget invalid */
#define	CW_CHECK_PRIMARY_CHAIN		0x00000080	/* check for primary */
							/* chain tuples */

/*
 * CW_LONGLINK_FOUND - a combination of the various CW_LONGLINK_XXX_FOUND
 *			flags used to make the code less dense.
 */
#define	CW_LONGLINK_FOUND		(CW_LONGLINK_A_FOUND |	\
					CW_LONGLINK_C_FOUND |	\
					CW_LONGLINK_MFC_FOUND)

/*
 * macro to test for a valid CIS window on a socket
 */
#define	SOCKET_HAS_CIS_WINDOW(sp)	(sp->cis_win_num != PCMCIA_MAX_WINDOWS)

/*
 * cs_socket_t->init_state flags - these flags are used to keep track of what
 *	was allocated in cs_init so that things can be deallocated properly
 *	in cs_deinit.
 */
#define	SOCKET_INIT_STATE_MUTEX		0x00000001	/* mutexii are OK */
#define	SOCKET_INIT_STATE_CV		0x00000002	/* cvii are OK */
#define	SOCKET_INIT_STATE_THREAD	0x00000004	/* thread OK */
#define	SOCKET_INIT_STATE_READY		0x00000008	/* socket OK */
#define	SOCKET_INIT_STATE_SS_THREAD	0x00000010	/* SS thread OK */
/*
 * 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.
 *	The value of this flag should follow the previous SOCKET_INIT
 *	flag values.
 */
#define	SOCKET_INIT_STATE_SOFTINTR	0x00000020	/* softintr handler */

/*
 * Macro to create a socket event thread.
 */
#define	CS_THREAD_PRIORITY		(v.v_maxsyspri - 4)
#define	CREATE_SOCKET_EVENT_THREAD(eh, csp)			\
	thread_create(NULL, 0, eh, (void *)csp,			\
	0, &p0, TS_RUN, CS_THREAD_PRIORITY)

/*
 * The per-window structure.
 */
typedef struct cs_window_t {
	uint32_t	window_num;	/* window number */
	window_handle_t	window_handle;	/* unique window handle */
	client_handle_t	client_handle;	/* owner of this window */
	unsigned	socket_num;	/* socket number */
	unsigned	state;		/* window state flags */
	struct cs_window_t	*next;	/* next window in list */
} cs_window_t;

/*
 * Window structure state flags - if none of the bits in the
 *	CW_WIN_IN_USE mask are set AND if CW_WINDOW_VALID is set,
 *	it means that this window is available and not being used
 *	by anyone.
 * Setting the CW_ALLOCATED will prevent the window from being found
 *	as an available window for memory or IO; since memory windows
 *	are not shared between clients, RequestWindow will always set
 *	the CW_ALLOCATED flag when it has assigned a memory window to
 *	a client.  Since we can sometimes share IO windows, RequestIO
 *	will only set the CW_ALLOCATED flag if it doesn't want the IO
 *	window to be used by other calls to RequestIO.
 * When CW_WINDOW_VALID is set, it means that this is a valid window
 *	that has been added by the framework and can be used. If this
 *	bit is not set, this window can not be used at all.
 */
#define	CW_ALLOCATED	0x00000001	/* window is allocated  */
#define	CW_CIS		0x00000002	/* window being used as CIS window */
#define	CW_MEM		0x00000004	/* window being used as mem window */
#define	CW_IO		0x00000008	/* window being used as IO window */
#define	CW_WIN_IN_USE	0x0000ffff	/* window in use mask */
#define	CW_WINDOW_VALID	0x00010000	/* window is valid */

/*
 * window handle defines - the WINDOW_HANDLE_MASK implies the maximum number
 *	of windows allowed
 */
#define	WINDOW_HANDLE_MAGIC	0x574d0000
#define	WINDOW_HANDLE_MASK	0x0000ffff
#define	GET_WINDOW_NUMBER(wh)	((wh) & WINDOW_HANDLE_MASK)
#define	GET_WINDOW_MAGIC(wh)	((wh) & ~WINDOW_HANDLE_MASK)

/*
 * The client type structures, used to sequence events to clients on a
 *	socket. The "type" flags are the same as are used for the
 *	RegisterClient function.
 */
typedef struct client_types_t {
	uint32_t		type;
	uint32_t		order;
	struct client_types_t	*next;
} client_types_t;

/*
 * Flags that specify the order of client event notifications for the
 *	client_types_t structure.
 */
#define	CLIENT_EVENTS_LIFO	0x00000001
#define	CLIENT_EVENTS_FIFO	0x00000002

/*
 * This is a structure that CS uses to keep track of items that are global
 *	to all functions in the module.
 */
typedef struct cs_globals_t {
	cs_socket_t	*sp;		/* head of socket list */
	cs_window_t	*cw;		/* head of window list */
	kmutex_t	global_lock;	/* protects this struct */
	kmutex_t	window_lock;	/* protects cs_windows */
	ddi_softintr_t	softint_id;	/* soft interrupt handler id */
	timeout_id_t	sotfint_tmo;	/* soft interrupt handler timeout id */
	uint32_t	init_state;	/* flags set in cs_init */
	uint32_t	flags;		/* general global flags */
	uint32_t	max_socket_num;	/* highest socket number plus one */
	uint32_t	num_sockets;	/* total number of sockets */
	uint32_t	num_windows;	/* total number of windows */
	struct sclient_list_t	*sclient_list;
} cs_globals_t;

/*
 * Flags for cs_globals_t->init_state
 */
#define	GLOBAL_INIT_STATE_SOFTINTR	0x00010000	/* softintr handler */
#define	GLOBAL_INIT_STATE_MUTEX		0x00020000	/* global mutex init */
#define	GLOBAL_INIT_STATE_NO_CLIENTS	0x00040000	/* no new clients */
#define	GLOBAL_INIT_STATE_UNLOADING	0x00080000	/* cs_deinit running */
#define	GLOBAL_INIT_STATE_SS_READY	0x00100000	/* SS ready for */
							/* callbacks */
/*
 * Flags for cs_globals_t->flags
 */
#define	GLOBAL_SUPER_CLIENT_REGISTERED	0x00000001	/* "super-client" reg */
#define	GLOBAL_IN_SOFTINTR		0x00000002	/* in soft int code */

/*
 * sclient_reg_t struct for RegisterClient when a "super-client" is
 *	registering.
 * This structure is actually hung off of the client_reg_t.private
 *	structure member.  Since we don't make public how to write
 *	a "super-client", the actual structure that the client uses
 *	is defined in this private header file.
 */
typedef struct sclient_reg_t {
	uint32_t		max_socket_num;
	uint32_t		num_sockets;
	uint32_t		num_windows;
	uint32_t		num_clients;
	struct sclient_list_t {
		client_handle_t	client_handle;
		uint32_t	error;
	} **sclient_list;
} sclient_reg_t;

/*
 * structure for event text used for cs_ss_event_text
 */
typedef struct cs_ss_event_text_t {
	event_t		ss_event;	/* SS event code */
	event_t		cs_event;	/* CS event code */
	char		*text;
} cs_ss_event_text_t;

/*
 * Flags for cs_read_event_status
 */
#define	CS_RES_IGNORE_NO_CARD		0x0001	/* don't check for card */

/*
 * cs_csfunc2text_strings_t structure used internally in Error2Text
 */
typedef struct cs_csfunc2text_strings_t {
	uint32_t	item;
	char		*text;
} cs_csfunc2text_strings_t;

/*
 * Flags for Error2Text - not used by clients; the struct is defined
 *	in the cs.h header file.
 */
#define	CSFUN2TEXT_FUNCTION	0x0001	/* return text of CS function code */
#define	CSFUN2TEXT_RETURN	0x0002	/* return text of CS return code */

/*
 * Macros to walk the local linked CIS list.
 *
 * These macros can take any valid local list tuple pointer.  They return
 *	another tuple pointer or NULL if they fail.
 */
#define	GET_NEXT_TUPLE(tp, f)		CIS_PARSER(CISP_CIS_GET_LTUPLE, tp,  \
						NULL, GET_NEXT_LTUPLEF |     \
						(f & ~CIS_GET_LTUPLE_OPMASK))
#define	GET_PREV_TUPLE(tp, f)		CIS_PARSER(CISP_CIS_GET_LTUPLE, tp,  \
						NULL, GET_PREV_LTUPLEF |     \
						(f & ~CIS_GET_LTUPLE_OPMASK))
#define	GET_FIRST_LTUPLE(tp, f)		CIS_PARSER(CISP_CIS_GET_LTUPLE, tp,   \
						NULL, GET_FIRST_LTUPLEF |     \
						(f & ~CIS_GET_LTUPLE_OPMASK))
#define	GET_LAST_LTUPLE(tp, f)		CIS_PARSER(CISP_CIS_GET_LTUPLE, tp,   \
						NULL, GET_LAST_LTUPLEF |      \
						(f & ~CIS_GET_LTUPLE_OPMASK))
#define	FIND_LTUPLE_FWD(tp, tu, f)	CIS_PARSER(CISP_CIS_GET_LTUPLE, tp,   \
						tu, FIND_LTUPLE_FWDF |        \
						(f & ~CIS_GET_LTUPLE_OPMASK))
#define	FIND_LTUPLE_BACK(tp, tu, f)	CIS_PARSER(CISP_CIS_GET_LTUPLE, tp,   \
						tu, FIND_LTUPLE_BACKF |       \
						(f & ~CIS_GET_LTUPLE_OPMASK))
#define	FIND_NEXT_LTUPLE(tp, tu, f)	CIS_PARSER(CISP_CIS_GET_LTUPLE, tp,   \
						tu, FIND_NEXT_LTUPLEF |       \
						(f & ~CIS_GET_LTUPLE_OPMASK))
#define	FIND_PREV_LTUPLE(tp, tu, f)	CIS_PARSER(CISP_CIS_GET_LTUPLE, tp,   \
						tu, FIND_PREV_LTUPLEF |       \
						(f & ~CIS_GET_LTUPLE_OPMASK))
#define	FIND_FIRST_LTUPLE(tp, tu, f)	FIND_LTUPLE_FWD(GET_FIRST_LTUPLE(tp,  \
								f), tu, f)


/*
 * Card Services hooks and general nexus prototypes
 */
int	 cs_init(void);
uint32_t cs_event(event_t, uint32_t, uint32_t);
int	 pcmcia_set_em_handler(int (*handler)(), caddr_t events,
	    int elen, uint32_t id, void **cs, void **ss);

extern csfunction_t	*cs_socket_services;


#ifdef	__cplusplus
}
#endif

#endif	/* _CS_PRIV_H */
/*
 * 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 (c) 1995-1996 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#ifndef _CS_STRINGS_H
#define	_CS_STRINGS_H

#ifdef	__cplusplus
extern "C" {
#endif

/*
 * These values depend on the size of the cs_ss_event_text_t array
 *	and on the number of CS events that we want the client to
 *	be able to display.
 * XXX - this should be determined automatically
 */
#define	MAX_SS_EVENTS	9	/* maximum SS events */
#define	MAX_CS_EVENTS	28	/* maximum CS events */

/*
 * The cs_ss_event_text_t structure is used to support the Event2Text
 *	and cs_event2text function.  MAX_SS_EVENTS and MAX_CS_EVENTS
 *	are defined in the cs_priv.h header file.  If the size of this
 *	array or strctures changes, the MAX_CS_EVENT_BUFSIZE define
 *	which is in cs.h might need to be changed as well.
 */
cs_ss_event_text_t cs_ss_event_text[MAX_CS_EVENTS+1] = {
	{ PCE_CARD_REMOVAL, CS_EVENT_CARD_REMOVAL, "CARD_REMOVAL" },
	{ PCE_CARD_INSERT, CS_EVENT_CARD_INSERTION, "CARD_INSERTION" },
	{ PCE_CARD_READY, CS_EVENT_CARD_READY, "CARD_READY" },
	{ PCE_CARD_BATTERY_WARN, CS_EVENT_BATTERY_LOW, "BATTERY_WARN" },
	{ PCE_CARD_BATTERY_DEAD, CS_EVENT_BATTERY_DEAD, "BATTERY_DEAD" },
	{ PCE_CARD_STATUS_CHANGE, 0, "STATUS_CHANGE" },
	{ PCE_CARD_WRITE_PROTECT, CS_EVENT_WRITE_PROTECT, "WRITE_PROTECT" },
	{ PCE_PM_RESUME, CS_EVENT_PM_RESUME, "PM_RESUME" },
	{ PCE_PM_SUSPEND, CS_EVENT_PM_SUSPEND, "PM_SUSPEND" },
	{ 0, CS_EVENT_REGISTRATION_COMPLETE, "REGISTRATION_COMPLETE" },
	{ 0, CS_EVENT_CARD_LOCK, "CARD_LOCK" },
	{ 0, CS_EVENT_CARD_RESET, "CARD_RESET" },
	{ 0, CS_EVENT_CARD_UNLOCK, "CARD_UNLOCK" },
	{ 0, CS_EVENT_EJECTION_COMPLETE, "EJECTION_COMPLETE" },
	{ 0, CS_EVENT_EJECTION_REQUEST, "EJECTION_REQUEST" },
	{ 0, CS_EVENT_ERASE_COMPLETE, "ERASE_COMPLETE" },
	{ 0, CS_EVENT_EXCLUSIVE_COMPLETE, "EXCLUSIVE_COMPLETE" },
	{ 0, CS_EVENT_EXCLUSIVE_REQUEST, "EXCLUSIVE_REQUEST" },
	{ 0, CS_EVENT_INSERTION_COMPLETE, "INSERTION_COMPLETE" },
	{ 0, CS_EVENT_INSERTION_REQUEST, "INSERTION_REQUEST" },
	{ 0, CS_EVENT_RESET_COMPLETE, "RESET_COMPLETE" },
	{ 0, CS_EVENT_RESET_PHYSICAL, "RESET_PHYSICAL" },
	{ 0, CS_EVENT_RESET_REQUEST, "RESET_REQUEST" },
	{ 0, CS_EVENT_MTD_REQUEST, "MTD_REQUEST" },
	{ 0, CS_EVENT_CLIENT_INFO, "CLIENT_INFO" },
	{ 0, CS_EVENT_TIMER_EXPIRED, "TIMER_EXPIRED" },
	{ 0, CS_EVENT_SS_UPDATED, "SS_UPDATED" },
	{ 0, CS_EVENT_CARD_REMOVAL_LOWP, "CARD_REMOVAL_LOWP" },
	{ MAX_SS_EVENTS, 0, "{undefined}" },
};

cs_csfunc2text_strings_t cs_csfunc2text_funcstrings[] = {
	{ CISRegister, "CISRegister" },
	{ CISUnregister, "CISUnregister" },
	{ InitCISWindow, "InitCISWindow" },
	{ GetCardServicesInfo, "GetCardServicesInfo" },
	{ RegisterClient, "RegisterClient" },
	{ DeregisterClient, "DeregisterClient" },
	{ GetStatus, "GetStatus" },
	{ ResetFunction, "ResetFunction" },
	{ SetEventMask, "SetEventMask" },
	{ GetEventMask, "GetEventMask" },
	{ RequestIO, "RequestIO" },
	{ ReleaseIO, "ReleaseIO" },
	{ RequestIRQ, "RequestIRQ" },
	{ ReleaseIRQ, "ReleaseIRQ" },
	{ RequestWindow, "RequestWindow" },
	{ ReleaseWindow, "ReleaseWindow" },
	{ ModifyWindow, "ModifyWindow" },
	{ MapMemPage, "MapMemPage" },
	{ RequestSocketMask, "RequestSocketMask" },
	{ ReleaseSocketMask, "ReleaseSocketMask" },
	{ RequestConfiguration, "RequestConfiguration" },
	{ GetConfigurationInfo, "GetConfigurationInfo" },
	{ ModifyConfiguration, "ModifyConfiguration" },
	{ ReleaseConfiguration, "ReleaseConfiguration" },
	{ OpenMemory, "OpenMemory" },
	{ ReadMemory, "ReadMemory" },
	{ WriteMemory, "WriteMemory" },
	{ CopyMemory, "CopyMemory" },
	{ RegisterEraseQueue, "RegisterEraseQueue" },
	{ CheckEraseQueue, "CheckEraseQueue" },
	{ DeregisterEraseQueue, "DeregisterEraseQueue" },
	{ CloseMemory, "CloseMemory" },
	{ GetFirstRegion, "GetFirstRegion" },
	{ GetNextRegion, "GetNextRegion" },
	{ GetFirstPartition, "GetFirstPartition" },
	{ GetNextPartition, "GetNextPartition" },
	{ ReturnSSEntry, "ReturnSSEntry" },
	{ MapLogSocket, "MapLogSocket" },
	{ MapPhySocket, "MapPhySocket" },
	{ MapLogWindow, "MapLogWindow" },
	{ MapPhyWindow, "MapPhyWindow" },
	{ RegisterMTD, "RegisterMTD" },
	{ RegisterTimer, "RegisterTimer" },
	{ SetRegion, "SetRegion" },
	{ RequestExclusive, "RequestExclusive" },
	{ ReleaseExclusive, "ReleaseExclusive" },
	{ GetFirstClient, "GetFirstClient" },
	{ GetNextClient, "GetNextClient" },
	{ GetClientInfo, "GetClientInfo" },
	{ AddSocketServices, "AddSocketServices" },
	{ ReplaceSocketServices, "ReplaceSocketServices" },
	{ VendorSpecific, "VendorSpecific" },
	{ AdjustResourceInfo, "AdjustResourceInfo" },
	{ ValidateCIS, "ValidateCIS" },
	{ GetFirstTuple, "GetFirstTuple" },
	{ GetNextTuple, "GetNextTuple" },
	{ GetTupleData, "GetTupleData" },
	{ ParseTuple, "ParseTuple" },
	{ MakeDeviceNode, "MakeDeviceNode" },
	{ RemoveDeviceNode, "RemoveDeviceNode" },
	{ ConvertSpeed, "ConvertSpeed" },
	{ ConvertSize, "ConvertSize" },
	{ Event2Text, "Event2Text" },
	{ Error2Text, "Error2Text" },
	{ AccessConfigurationRegister, "AccessConfigurationRegister" },
	{ CS_DDI_Info, "CS_DDI_Info" },
	{ CS_Sys_Ctl, "CS_Sys_Ctl" },
	{ CSFuncListEnd, "{unknown Card Services function}" },
};

cs_csfunc2text_strings_t cs_csfunc2text_returnstrings[] = {
	{ CS_SUCCESS, "CS_SUCCESS" },
	{ CS_BAD_ADAPTER, "CS_BAD_ADAPTER" },
	{ CS_BAD_ATTRIBUTE, "CS_BAD_ATTRIBUTE" },
	{ CS_BAD_BASE, "CS_BAD_BASE" },
	{ CS_BAD_EDC, "CS_BAD_EDC" },
	{ CS_BAD_IRQ, "CS_BAD_IRQ" },
	{ CS_BAD_OFFSET, "CS_BAD_OFFSET" },
	{ CS_BAD_PAGE, "CS_BAD_PAGE" },
	{ CS_READ_FAILURE, "CS_READ_FAILURE" },
	{ CS_BAD_SIZE, "CS_BAD_SIZE" },
	{ CS_BAD_SOCKET, "CS_BAD_SOCKET" },
	{ CS_BAD_TYPE, "CS_BAD_TYPE" },
	{ CS_BAD_VCC, "CS_BAD_VCC" },
	{ CS_BAD_VPP, "CS_BAD_VPP" },
	{ CS_BAD_WINDOW, "CS_BAD_WINDOW" },
	{ CS_WRITE_FAILURE, "CS_WRITE_FAILURE" },
	{ CS_NO_CARD, "CS_NO_CARD" },
	{ CS_UNSUPPORTED_FUNCTION, "CS_UNSUPPORTED_FUNCTION" },
	{ CS_UNSUPPORTED_MODE, "CS_UNSUPPORTED_MODE" },
	{ CS_BAD_SPEED, "CS_BAD_SPEED" },
	{ CS_BUSY, "CS_BUSY" },
	{ CS_GENERAL_FAILURE, "CS_GENERAL_FAILURE" },
	{ CS_WRITE_PROTECTED, "CS_WRITE_PROTECTED" },
	{ CS_BAD_ARG_LENGTH, "CS_BAD_ARG_LENGTH" },
	{ CS_BAD_ARGS, "CS_BAD_ARGS" },
	{ CS_CONFIGURATION_LOCKED, "CS_CONFIGURATION_LOCKED" },
	{ CS_IN_USE, "CS_IN_USE" },
	{ CS_NO_MORE_ITEMS, "CS_NO_MORE_ITEMS" },
	{ CS_OUT_OF_RESOURCE, "CS_OUT_OF_RESOURCE" },
	{ CS_BAD_HANDLE, "CS_BAD_HANDLE" },
	{ CS_NO_CIS, "CS_NO_CIS" },
	{ CS_BAD_CIS, "CS_BAD_CIS" },
	{ CS_UNKNOWN_TUPLE, "CS_UNKNOWN_TUPLE" },
	{ CS_BAD_VERSION, "CS_BAD_VERSION" },
	{ CS_UNSUPPORTED_EVENT, "CS_UNSUPPORTED_EVENT" },
	{ CS_CSI_ERROR, "CS_CSI_ERROR" },
	{ CS_CSI_NOT_INIT, "CS_CSI_NOT_INIT" },
	{ CS_NO_TUPLE_PARSER, "CS_NO_TUPLE_PARSER" },
	{ CS_ERRORLIST_END, "{unknown Card Services return code}" },
};

#ifdef	__cplusplus
}
#endif

#endif /* _CS_STRINGS_H */
/*
 * 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 (c) 1996 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#ifndef _CS_STUBS_H
#define	_CS_STUBS_H

#ifdef	__cplusplus
extern "C" {
#endif


/*
 * Magic number for Card Services to use when registering it's entry
 *	point with the Card Services stubs module.
 */
#define	CS_STUBS_MAGIC	0x19960300

/*
 * Card Services function identifiers - these correspond to the PCMCIA
 *	standard function codes for CS with the exception of a few
 *	private and implementation-specific function identifiers.
 *
 * client services functions
 */
#define	GetCardServicesInfo		0x000b
#define	RegisterClient			0x0010
#define	DeregisterClient		0x0002
#define	GetStatus			0x000c
#define	ResetFunction			0x0011
#define	SetEventMask			0x0031
#define	GetEventMask			0x002e
/*
 * reource management functions
 */
#define	RequestIO			0x001f
#define	ReleaseIO			0x001b
#define	RequestIRQ			0x0020
#define	ReleaseIRQ			0x001c
#define	RequestWindow			0x0021
#define	ReleaseWindow			0x001d
#define	ModifyWindow			0x0017
#define	MapMemPage			0x0014
#define	RequestSocketMask		0x0022
#define	ReleaseSocketMask		0x002f
#define	RequestConfiguration		0x0030
#define	GetConfigurationInfo		0x0004
#define	ModifyConfiguration		0x0027
#define	ReleaseConfiguration		0x001e
#define	AccessConfigurationRegister	0x0036
/*
 * bulk memory service functions
 */
#define	OpenMemory			0x0018
#define	ReadMemory			0x0019
#define	WriteMemory			0x0024
#define	CopyMemory			0x0001
#define	RegisterEraseQueue		0x000f
#define	CheckEraseQueue			0x0026
#define	DeregisterEraseQueue		0x0025
#define	CloseMemory			0x0000
/*
 * client utility functions
 */
#define	GetFirstTuple			0x0007
#define	GetNextTuple			0x000a
#define	GetTupleData			0x000d
#define	GetFirstRegion			0x0006
#define	GetNextRegion			0x0009
#define	GetFirstPartition		0x0005
#define	GetNextPartition		0x0008
/*
 * advanced client services functions
 */
#define	ReturnSSEntry			0x0023
#define	MapLogSocket			0x0012
#define	MapPhySocket			0x0015
#define	MapLogWindow			0x0013
#define	MapPhyWindow			0x0016
#define	RegisterMTD			0x001a
#define	RegisterTimer			0x0028
#define	SetRegion			0x0029
#define	ValidateCIS			0x002b
#define	RequestExclusive		0x002c
#define	ReleaseExclusive		0x002d
#define	GetFirstClient			0x000e
#define	GetNextClient			0x002a
#define	GetClientInfo			0x0003
#define	AddSocketServices		0x0032
#define	ReplaceSocketServices		0x0033
#define	VendorSpecific			0x0034
#define	AdjustResourceInfo		0x0035
/*
 * private functions - clients should never call these; if they do,
 *	the system will esplode.
 */
#define	CISRegister			0x1000
#define	CISUnregister			0x1001
#define	InitCISWindow			0x1002
/*
 * Card Services functions specific to this implementation
 */
#define	ParseTuple		0x2000	/* parses contents of tuples */
#define	MakeDeviceNode		0x2001	/* makes device nodes in fs */
#define	ConvertSpeed		0x2002	/* converts device speeds */
#define	ConvertSize		0x2003	/* converts device sizes */
#define	Event2Text		0x2004	/* return string of event type */
#define	Error2Text		0x2005	/* function or ret code string */
#define	CS_DDI_Info		0x2006	/* set/get DDI info */
#define	CS_Sys_Ctl		0x2007  /* CS system control */
#define	RemoveDeviceNode	0x2008	/* removes device nodes in fs */
#define	GetPhysicalAdapterInfo	0x2009	/* returns physical adapter info */
#define	CSFuncListEnd		0x8000	/* end of CS function list */

/*
 * Structure used when Card Services registers it's entry point with
 *	the Card Services stubs module
 */
typedef struct cs_register_cardservices_t {
	uint32_t	function;
	uint32_t	magic;
	csfunction_t	*cardservices;
	csfunction_t	*socketservices;
} cs_register_cardservices_t;

/*
 * Functions for cs_register_cardservices_t
 */
#define	CS_ENTRY_REGISTER	0x0001
#define	CS_ENTRY_DEREGISTER	0x0002
#define	CS_ENTRY_INQUIRE	0x0003

/*
 * Function prototypes
 */
int32_t csx_register_cardservices(cs_register_cardservices_t *);

#ifdef	__cplusplus
}
#endif

#endif	/* _CS_STUBS_H */
/*
 * 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 (c) 1995-1996 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#ifndef _CS_TYPES_H
#define	_CS_TYPES_H

#ifdef	__cplusplus
extern "C" {
#endif

/*
 * PCMCIA Card Services types header file
 */

typedef uint32_t client_handle_t;
typedef	uint32_t window_handle_t;
typedef uint32_t event_t;
typedef uint8_t	cfg_regs_t;

typedef struct baseaddru_t {
	uint32_t		base;
	ddi_acc_handle_t	handle;
} baseaddru_t;

#ifdef	__cplusplus
}
#endif

#endif	/* _CS_TYPES_H */