//*****************************************************************************
//
//! Determines the number of individual descriptors of a particular type within
//! a supplied buffer.
//!
//! \param psDesc points to the first byte of a block of standard USB
//! descriptors.
//! \param ulSize is the number of bytes of descriptor data found at pointer
//! \e psDesc.
//! \param ulType identifies the type of descriptor that is to be found. If
//! the value is \b USB_DESC_ANY, the function returns a pointer to the n-th
//! descriptor regardless of type.
//! \param ulIndex is the zero based index of the descriptor whose pointer is
//! to be returned. For example, passing value 1 in \e ulIndex returns the
//! second matching descriptor.
//!
//! Return a pointer to the n-th descriptor of a particular type found in the
//! block of \e ulSize bytes starting at \e psDesc.
//!
//! \return Returns a pointer to the header of the required descriptor if
//! found or NULL otherwise.
//
//*****************************************************************************
tDescriptorHeader *
USBDescGet(tDescriptorHeader *psDesc, unsigned long ulSize,
unsigned long ulType, unsigned long ulIndex)
{
tDescriptorHeader *psDescCheck;
unsigned long ulTotLength;
unsigned long ulCount;
//
// Set up for our descriptor counting loop.
//
psDescCheck = psDesc;
ulTotLength = 0;
ulCount = 0;
//
// Keep looking through the supplied data until we reach the end.
//
while(ulTotLength < ulSize)
{
//
// Does this descriptor match the type passed (if a specific type
// has been specified)?
//
if((ulType == USB_DESC_ANY) ||
(psDescCheck->bDescriptorType == (unsigned char)(ulType & 0xFF)))
{
//
// We found a matching descriptor. If our count matches the
// supplied index, we are done so return the pointer.
//
if(ulCount == ulIndex)
{
return(psDescCheck);
}
//
// We have not found enough descriptors yet to satisfy the supplied
// index so increment our count and continue.
//
ulCount++;
}
//
// Move on to the next descriptor.
//
ulTotLength += (unsigned long)psDescCheck->bLength;
psDescCheck = NEXT_USB_DESCRIPTOR(psDescCheck);
}
//
// If we get here, we reached the end of the data without finding the
// required descriptor. Return NULL.
//
return((tDescriptorHeader *)0);
}
//*****************************************************************************
//
//! \internal
//!
//! Walk to the next descriptor after the supplied one within a section-based
//! config descriptor.
//!
//! \param psConfig points to the header structure for the configuration
//! descriptor which contains \e psDesc.
//! \param pulSec points to a variable containing the section within \e
//! psConfig which contains \e psDesc.
//! \param psDesc points to the descriptor that we want to step past.
//!
//! This function walks forward one descriptor within a config descriptor. The
//! value returned is a pointer to the header of the next descriptor after the
//! descriptor supplied in \e psDesc. If the next descriptor is in the next
//! section, \e *pulSec will be incremented accordlingly.
//!
//! \return Returns a pointer to the next descriptor in the config descrptor.
//
//*****************************************************************************
static tDescriptorHeader *
NextConfigDescGet(const tConfigHeader *psConfig, unsigned long *pulSec,
tDescriptorHeader *psDesc)
{
//
// Determine where the next descriptor after the supplied one should be
// assuming it is within the current section.
//
psDesc = NEXT_USB_DESCRIPTOR(psDesc);
//
// Did we run off the end of the section?
//
if((unsigned char *)psDesc >= (psConfig->psSections[*pulSec]->pucData +
psConfig->psSections[*pulSec]->usSize))
{
//
// Yes - move to the next section.
//
(*pulSec)++;
//
// Are we still within the config descriptor?
//
if(*pulSec < psConfig->ucNumSections)
{
//
// Yes - the new descriptor is at the start of the new section.
//
psDesc =
(tDescriptorHeader *)psConfig->psSections[*pulSec]->pucData;
}
else
{
//
// No - we ran off the end of the descriptor so return NULL.
//
psDesc = (tDescriptorHeader *)0;
}
}
//
// Return the new descriptor pointer.
//
return(psDesc);
}
//*****************************************************************************
//
//! Determines the number of different alternate configurations for a given
//! interface within a configuration descriptor.
//!
//! \param psConfig points to the first byte of a standard USB configuration
//! descriptor.
//! \param ucInterfaceNumber is the interface number for which the number of
//! alternate configurations is to be counted.
//!
//! This function can be used to count the number of alternate settings for a
//! specific interface within a configuration.
//!
//! \return Returns the number of alternate versions of the specified interface
//! or 0 if the interface number supplied cannot be found in the config
//! descriptor.
//
//*****************************************************************************
unsigned long
USBDescGetNumAlternateInterfaces(tConfigDescriptor *psConfig,
unsigned char ucInterfaceNumber)
{
tDescriptorHeader *psDescCheck;
unsigned long ulTotLength;
unsigned long ulCount;
//
// Set up for our descriptor counting loop.
//
psDescCheck = (tDescriptorHeader *)psConfig;
ulTotLength = 0;
ulCount = 0;
//
// Keep looking through the supplied data until we reach the end.
//
while(ulTotLength < (unsigned long)psConfig->wTotalLength)
{
//
// Is this an interface descriptor with the required interface number?
//
if((psDescCheck->bDescriptorType == USB_DTYPE_INTERFACE) &&
(((tInterfaceDescriptor *)psDescCheck)->bInterfaceNumber ==
ucInterfaceNumber))
{
//
// Yes - increment our count.
//
ulCount++;
}
//
// Move on to the next descriptor.
//
ulTotLength += (unsigned long)psDescCheck->bLength;
psDescCheck = NEXT_USB_DESCRIPTOR(psDescCheck);
}
//
// Return the descriptor count to the caller.
//
return(ulCount);
}
//*****************************************************************************
//
//! Determines the number of individual descriptors of a particular type within
//! a supplied buffer.
//!
//! \param psDesc points to the first byte of a block of standard USB
//! descriptors.
//! \param ulSize is the number of bytes of descriptor data found at pointer
//! \e psDesc.
//! \param ulType identifies the type of descriptor that is to be counted. If
//! the value is \b USB_DESC_ANY, the function returns the total number of
//! descriptors regardless of type.
//!
//! This function can be used to count the number of descriptors of a
//! particular type within a block of descriptors. The caller can provide a
//! specific type value which the function matches against the second byte of
//! each descriptor or, alternatively, can specify \b USB_DESC_ANY to have the
//! function count all descriptors regardless of their type.
//!
//! \return Returns the number of descriptors found in the supplied block of
//! data.
//
//*****************************************************************************
unsigned long
USBDescGetNum(tDescriptorHeader *psDesc, unsigned long ulSize,
unsigned long ulType)
{
tDescriptorHeader *psDescCheck;
unsigned long ulTotLength;
unsigned long ulCount;
//
// Set up for our descriptor counting loop.
//
psDescCheck = psDesc;
ulTotLength = 0;
ulCount = 0;
//
// Keep looking through the supplied data until we reach the end.
//
while(ulTotLength < ulSize)
{
//
// Does this descriptor match the type passed (if a specific type
// has been specified)?
//
if((ulType == USB_DESC_ANY) ||
(psDescCheck->bDescriptorType == (unsigned char)(ulType & 0xFF)))
{
ulCount++;
}
//
// Move on to the next descriptor.
//
ulTotLength += (unsigned long)psDescCheck->bLength;
psDescCheck = NEXT_USB_DESCRIPTOR(psDescCheck);
}
//
// Return the descriptor count to the caller.
//
return(ulCount);
}
//*****************************************************************************
//
//! Returns a pointer to the n-th interface descriptor in a config descriptor
//! with the supplied interface number.
//!
//! \param psConfig points to the first byte of a standard USB configuration
//! descriptor.
//! \param ucInterfaceNumber is the interface number of the descriptor that is
//! being queried.
//! \param ulIndex is the zero based index of the descriptor to return.
//!
//! This function returns a pointer to the n-th interface descriptor in the
//! supplied configuration which has the requested interface number. It may be
//! used by a client to retrieve the descriptors for each alternate setting
//! of a given interface within the configuration passed.
//!
//! \return Returns a pointer to the n-th interface descriptor with interface
//! number as specified or NULL of this descriptor does not exist.
//
//*****************************************************************************
static tInterfaceDescriptor *
USBDescGetAlternateInterface(tConfigDescriptor *psConfig,
unsigned char ucInterfaceNumber,
unsigned long ulIndex)
{
tDescriptorHeader *psDescCheck;
unsigned long ulTotLength;
unsigned long ulCount;
//
// Set up for our descriptor counting loop.
//
psDescCheck = (tDescriptorHeader *)psConfig;
ulTotLength = 0;
ulCount = 0;
//
// Keep looking through the supplied data until we reach the end.
//
while(ulTotLength < (unsigned long)psConfig->wTotalLength)
{
//
// Does this descriptor match the type passed (if a specific type
// has been specified)?
//
if((psDescCheck->bDescriptorType == USB_DTYPE_INTERFACE) &&
(((tInterfaceDescriptor *)psDescCheck)->bInterfaceNumber ==
ucInterfaceNumber))
{
//
// This is an interface descriptor for interface ucInterfaceNumber.
// Determine if this is the n-th one we have found and, if so,
// return its pointer.
//
if(ulCount == ulIndex)
{
//
// Found it - return the pointer.
//
return((tInterfaceDescriptor *)psDescCheck);
}
//
// Increment our count of matching descriptors found and go back
// to look for another since we have not yet reached the n-th
// match.
//
ulCount++;
}
//
// Move on to the next descriptor.
//
ulTotLength += (unsigned long)psDescCheck->bLength;
psDescCheck = NEXT_USB_DESCRIPTOR(psDescCheck);
}
//
// If we drop out the end of the loop, we did not find the requested
// descriptor so return NULL.
//
return((tInterfaceDescriptor *)0);
}
