--- old/usr/src/uts/common/pcmcia/cis/cis.c	Sat Aug  9 23:41:52 2014
+++ /dev/null	Sat Aug  9 23:38:59 2014
@@ -1,1380 +0,0 @@
-/*
- * 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.
- */
-
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
-/*
- * 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, NULL) &
-							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))) == NULL) {
-		if ((cs->nS = cd->table[exponent]) == NULL)
-		    return (CS_BAD_SPEED);
-		return (CS_SUCCESS);
-	    } else {
-		if ((cs->nS = ((cd->mantissa[mantissa] *
-					cd->exponent[exponent]) / 10)) == NULL)
-		    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, NULL, 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, NULL,
-							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, NULL,
-							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;
-}
