/*
* 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;
}