p80211meta.c

对于无线网卡采用prism芯片的linux的开源驱动.

	int		grp;
	int		size;

	result = P80211DID_INVALID;

	if ( (result = p80211_isvalid_catdid( catlist, did )) == P80211DID_VALID ) {
		cat = P80211DID_SECTION(did);
		grp = P80211DID_GROUP(did);
		size = GETMETASIZE(catlist[cat].grplist);
		if ( (grp > 0UL) && (grp < size) ) {
			result = P80211DID_VALID; 
		}
	}

	return result;
}


/*----------------------------------------------------------------
* p80211_isvalid_itemdid
*
* Verifies whether the item portion of a did is valid.
*
* Arguments:
*	catlist		ptr to a category metadata list
*	did		data id
*
* Returns: 
*	P80211DID_INVALID	if DID is an invalid DID
*	!P80211DID_INVALID	if DID is a valid DID
----------------------------------------------------------------*/
UINT32 p80211_isvalid_itemdid( catlistitem_t *catlist, UINT32 did )
{
	int		result;
	int		cat;
	int		grp;
	int		item;
	int		size;

	result = P80211DID_INVALID;

	if ( (result = p80211_isvalid_catdid( catlist, did )) == P80211DID_VALID ) {
		if ( (result = p80211_isvalid_grpdid( catlist, did )) == P80211DID_VALID ) {
			cat = P80211DID_SECTION(did);
			grp = P80211DID_GROUP(did);
			size = GETMETASIZE(catlist[cat].grplist[grp].itemlist);
			item = P80211DID_ITEM(did);

			if ( (item > 0UL) && (item < size) ) {
				result = P80211DID_VALID; 
			}
		}
	}

	return result;
}


/*----------------------------------------------------------------
* p80211_did2cat
*
* Returns address of a category in the category metadata list
*
* Arguments:
*	catlist		ptr to a category metadata list
*	did		data id
*
* Returns: 
*	NULL				if DID is an invalid DID
*	ptr to a category list item	if DID is a valid DID
----------------------------------------------------------------*/
catlistitem_t *p80211_did2cat( catlistitem_t *catlist, UINT32 did )
{
	catlistitem_t	*category;
	int		result;

	category = NULL;
	result = P80211DID_INVALID;

	if ( (result = p80211_isvalid_catdid( catlist, did )) == P80211DID_VALID ) {
		category = &(catlist[P80211DID_SECTION(did)]);
	}

	return category;
}	


/*----------------------------------------------------------------
* p80211_did2grp
*
* Returns address of a group in the group metadata list
*
* Arguments:
*	catlist		ptr to a category metadata list
*	did		data id
*
* Returns: 
*	NULL				if DID is an invalid DID
*	ptr to group list item		if DID is a valid DID
----------------------------------------------------------------*/
grplistitem_t *p80211_did2grp( catlistitem_t *catlist, UINT32 did )
{
	grplistitem_t	*group;
	int		result;

	group = NULL;
	result = P80211DID_INVALID;

	if ( (result = p80211_isvalid_catdid( catlist, did )) == P80211DID_VALID ) {
		if ( (result = p80211_isvalid_grpdid( catlist, did )) == P80211DID_VALID ) {
			group = &(catlist[P80211DID_SECTION(did)].
				grplist[P80211DID_GROUP(did)]);
		}
	}

	return group;
}


/*----------------------------------------------------------------
* p80211_did2item
*
* Returns address of an item in the item metadata list
*
* Arguments:
*	catlist		ptr to a category metadata list
*	did		data id
*
* Returns: 
*	NULL				if DID is an invalid DID
*	ptr to item list item		if DID is a valid DID
----------------------------------------------------------------*/
p80211meta_t *p80211_did2item( catlistitem_t *catlist, UINT32 did )
{
	p80211meta_t	*item;
	int		result;

	item = NULL;
	result = P80211DID_INVALID;

	if ( (result = p80211_isvalid_catdid( catlist, did )) == P80211DID_VALID ) {
		if ( (result = p80211_isvalid_grpdid( catlist, did )) == P80211DID_VALID ) {
			if ( (result = p80211_isvalid_itemdid( catlist, did )) == P80211DID_VALID ) {
				item = &(catlist[P80211DID_SECTION(did)].
					grplist[P80211DID_GROUP(did)].
					itemlist[P80211DID_ITEM(did)]);
			}
		}
	}

	return item;
}


/*----------------------------------------------------------------
* p80211item_getoffset
*
*   Returns the offset of the data item identified by a given DID.
*   This function assumes a valid did is passed to the function.  
*
* Arguments:
*	did	a valid, complete DID
*
* Returns: 
*	0xffffffff	if the type from the did doesn't match a 
*			known type
*	offset		on success
----------------------------------------------------------------*/
UINT32 p80211item_getoffset( catlistitem_t *metalist, UINT32 did )
{
	UINT32			catgrp;
	UINT32			offset, len;
	UINT32			tmpdid;
	UINT32			item;
	INT			i;
	p80211meta_t 		*alist=NULL;

	offset = 0UL;

	if ( (p80211_isvalid_did(metalist, did )) != P80211DID_INVALID ) {
		alist = metalist[P80211DID_SECTION(did)].
			grplist[P80211DID_GROUP(did)].itemlist;
		item = P80211DID_ITEM(did);

		catgrp = P80211DID_MKSECTION(P80211DID_SECTION(did)) |
			P80211DID_MKGROUP(P80211DID_GROUP(did));

		for ( i = 1; i < item; i++ ) {
			tmpdid = catgrp | P80211DID_MKITEM(i) | alist[i].did;
			len = p80211item_maxdatalen(metalist, tmpdid);
			if (len == 0xffffffffUL) {
				printf("Undefined data type for %s\n",
					alist[i].name );
				offset = 0xffffffff;
				return offset;
			}
			offset += len + sizeof(p80211item_t);
		} /* for each arg meta data item up to current item */
	} else {
		offset = 0xffffffff;
	}

	return offset;
}


/*----------------------------------------------------------------
* p80211item_gettype
*
* Returns the type of the item identified by a given DID.
*
* Arguments:
*	meta	pointer to a metadata item
*
* Returns: 
*	0		Unrecognized type in metadata.
*	anything else	Success, return value is item type.
----------------------------------------------------------------*/

int p80211item_gettype(p80211meta_t *meta)
{
	int  type;

	if (meta->totextptr == p80211_totext_octetstr)
		type = P80211_TYPE_OCTETSTR;
	else if (meta->totextptr == p80211_totext_displaystr)
		type = P80211_TYPE_DISPLAYSTR;
	else if (meta->totextptr == p80211_totext_int)
		type = P80211_TYPE_INT;
	else if (meta->totextptr == p80211_totext_enumint)
		type = P80211_TYPE_ENUMINT;
	else if (meta->totextptr == NULL ||
		 meta->totextptr == p80211_totext_getmibattribute ||
		 meta->totextptr == p80211_totext_setmibattribute)
		type = P80211_TYPE_UNKDATA;
	else if (meta->totextptr == p80211_totext_intarray)
		type = P80211_TYPE_INTARRAY;
	else if (meta->totextptr == p80211_totext_bitarray)
		type = P80211_TYPE_BITARRAY;
	else if (meta->totextptr == p80211_totext_macarray)
		type = P80211_TYPE_MACARRAY;
	else
		type = 0;

    return type;
}


/*----------------------------------------------------------------
* p80211item_getaccess
*
* Returns the access type (read, write or read-write) of the item
* identified by a given DID.
*
* Arguments:
*	meta	pointer to a metadata item
*
* Returns: 
*	0		Unrecognized access type in metadata.
*	1		Read Only
*	2		Write Only
*	3		Read-Write
----------------------------------------------------------------*/

int p80211item_getaccess(p80211meta_t *meta)
{
	int  access_type;

	access_type = 0;


    return access_type;
}


/*----------------------------------------------------------------
* p80211item_maxdatalen
*
* Returns the total maximum data size of an item identified
* by a given DID.  This is  the length of the data part of the
* item triple.  
*
* Arguments:
*	metalist	pointer to a category metadata list
*	did		A complete DID
*
* Returns: 
*	0xffffffff	Bad DID or unrecognized type in metadata
*	anything else	success, return value is maxdatalen
----------------------------------------------------------------*/
UINT32 p80211item_maxdatalen( catlistitem_t *metalist, UINT32 did )
{
	UINT32		maxlen;
	p80211meta_t 	*meta;

	if ( (meta = p80211_did2item(metalist, did)) != NULL ) {
		switch( p80211item_gettype(meta) ) {
			case P80211_TYPE_OCTETSTR:
				/* add size of pstr length byte */
				maxlen = meta->maxlen + sizeof(UINT8);
				break;
			case P80211_TYPE_DISPLAYSTR:
				/* add size of pstr length byte */
				maxlen = meta->maxlen + sizeof(UINT8);
				break;

			case P80211_TYPE_INT:
			case P80211_TYPE_ENUMINT:
			case P80211_TYPE_BITARRAY:
				/* all int types are 4 bytes */
				maxlen = 4;
				break;

			case P80211_TYPE_INTARRAY:
				/* int types are 4 bytes */
				maxlen = meta->maxlen * 4;
				break;

			case P80211_TYPE_MACARRAY:
				/* Addresses are 6 bytes, add a 4 byte count */
				maxlen = (meta->maxlen * 6) + 4;
				break;

			case P80211_TYPE_UNKDATA:
				maxlen = meta->maxlen;
				break;

			default:
				maxlen = 0xffffffffUL;
		}
	} else {
		maxlen = 0xffffffffUL;
	}

	/* pad for 32-bit aligmnent. */
	if (maxlen != 0xffffffffUL)
		if (maxlen % 4)
			maxlen += (4 - (maxlen % 4));

	return maxlen;
}

/*----------------------------------------------------------------
* p80211_metaname2did
*
* Traverses the metadata looking for an item whose name matches
* the given name.
*
* Arguments:
*	metalist	pointer to a category metadata list
*	itemname	buffer containing the name to search for.
*
* Returns: 
*	0	- name not found
*	~0	- complete DID of item having "itemname"
----------------------------------------------------------------*/
UINT32 p80211_metaname2did(catlistitem_t *metalist, char *itemname)
{
	UINT32	result = 0UL;
	int	sec;
	int	nsec;
	int	grp;
	int	ngrp;
	int	item;
	int	nitem;

	/* traverse the entire metadata for the item that matches */
	nsec = GETMETASIZE(metalist);
	for ( sec = 1; (sec < nsec) && (result == 0); sec++) {
		if ( metalist[sec].grplist == NULL ) continue;
		ngrp = GETMETASIZE(metalist[sec].grplist);
		for ( grp = 1; (grp < ngrp) && (result == 0); grp++) {
			if ( metalist[sec].grplist[grp].itemlist == NULL ) continue;
			nitem = GETMETASIZE(metalist[sec].grplist[grp].itemlist);
			for (item = 1;(item < nitem) && (result == 0);item++) {
				if ( strcmp(itemname, metalist[sec].grplist
					[grp].itemlist[item].name) == 0 ) {

					/* found it */
					result = P80211DID_MKID( sec, grp, item, 0, 0, 0);
					result |= metalist[sec].grplist
					[grp].itemlist[item].did;
				}
			}  /* for all items */
		}  /* for all groups */
	} /*  for all sections */
	return result;
}