USBDescriptors.c

Go to the documentation of this file.

/* ---------------------------------------------------------------------------- */
/*                  Atmel Microcontroller Software Support                      */
/*                       SAM Software Package License                           */
/* ---------------------------------------------------------------------------- */
/* Copyright (c) 2015, Atmel Corporation                                        */
/*                                                                              */
/* All rights reserved.                                                         */
/*                                                                              */
/* Redistribution and use in source and binary forms, with or without           */
/* modification, are permitted provided that the following condition is met:    */
/*                                                                              */
/* - Redistributions of source code must retain the above copyright notice,     */
/* this list of conditions and the disclaimer below.                            */
/*                                                                              */
/* Atmel's name may not be used to endorse or promote products derived from     */
/* this software without specific prior written permission.                     */
/*                                                                              */
/* DISCLAIMER:  THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR   */
/* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE   */
/* DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,      */
/* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT */
/* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,  */
/* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    */
/* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING         */
/* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, */
/* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                           */
/* ---------------------------------------------------------------------------- */

/*------------------------------------------------------------------------------
 *         Headers
 *------------------------------------------------------------------------------*/

#include "USBDescriptors.h"

/*------------------------------------------------------------------------------
 *         Exported functions
 *------------------------------------------------------------------------------*/

uint32_t USBGenericDescriptor_GetLength(
        const USBGenericDescriptor *descriptor)
{
        return descriptor->bLength;
}

uint8_t USBGenericDescriptor_GetType(
        const USBGenericDescriptor *descriptor)
{
        return descriptor->bDescriptorType;
}

USBGenericDescriptor *USBGenericDescriptor_GetNextDescriptor(
        const USBGenericDescriptor *descriptor)
{
        return (USBGenericDescriptor *)
                   (((char *) descriptor) + USBGenericDescriptor_GetLength(descriptor));
}

USBGenericDescriptor *USBGenericDescriptor_Parse(
        const USBGenericDescriptor *descriptor,
        uint32_t totalLength,
        USBDescriptorParseFunction parseFunction,
        void *parseArg)
{
        int32_t size = totalLength;

        if (size == 0)
                return 0;

        /* Start parsing descriptors */
        while (1) {
                uint32_t parseRC = 0;

                /* Parse current descriptor */
                if (parseFunction)
                        parseRC = parseFunction((void *)descriptor, parseArg);

                /* Get next descriptor */
                size -= USBGenericDescriptor_GetLength(descriptor);
                descriptor = USBGenericDescriptor_GetNextDescriptor(descriptor);

                if (size) {
                        if (parseRC != 0)

                                return (USBGenericDescriptor *)descriptor;
                } else
                        break;
        }

        /* No descriptors remaining */
        return 0;
}


uint8_t USBEndpointDescriptor_GetNumber(
        const USBEndpointDescriptor *endpoint)
{
        return endpoint->bEndpointAddress & 0xF;
}

uint8_t USBEndpointDescriptor_GetDirection(
        const USBEndpointDescriptor *endpoint)
{
        if ((endpoint->bEndpointAddress & 0x80) != 0)

                return USBEndpointDescriptor_IN;
        else

                return USBEndpointDescriptor_OUT;
}

uint8_t USBEndpointDescriptor_GetType(
        const USBEndpointDescriptor *endpoint)
{
        return endpoint->bmAttributes & 0x3;
}

uint16_t USBEndpointDescriptor_GetMaxPacketSize(
        const USBEndpointDescriptor *endpoint)
{
        return endpoint->wMaxPacketSize;
}

uint8_t USBEndpointDescriptor_GetInterval(
        const USBEndpointDescriptor *endpoint)
{
        return endpoint->bInterval;
}



uint32_t USBConfigurationDescriptor_GetTotalLength(
        const USBConfigurationDescriptor *configuration)
{
        return configuration->wTotalLength;
}

unsigned char USBConfigurationDescriptor_GetNumInterfaces(
        const USBConfigurationDescriptor *configuration)
{
        return configuration->bNumInterfaces;
}

unsigned char USBConfigurationDescriptor_IsSelfPowered(
        const USBConfigurationDescriptor *configuration)
{
        if ((configuration->bmAttributes & (1 << 6)) != 0)

                return 1;
        else

                return 0;
}

void USBConfigurationDescriptor_Parse(
        const USBConfigurationDescriptor *configuration,
        USBInterfaceDescriptor **interfaces,
        USBEndpointDescriptor **endpoints,
        USBGenericDescriptor **others)
{
        /* Get size of configuration to parse */
        int size = USBConfigurationDescriptor_GetTotalLength(configuration);
        size -= sizeof(USBConfigurationDescriptor);

        /* Start parsing descriptors */
        USBGenericDescriptor *descriptor = (USBGenericDescriptor *) configuration;

        while (size > 0) {
                /* Get next descriptor */
                descriptor = USBGenericDescriptor_GetNextDescriptor(descriptor);
                size -= USBGenericDescriptor_GetLength(descriptor);

                /* Store descriptor in corresponding array */
                if (USBGenericDescriptor_GetType(descriptor)
                        == USBGenericDescriptor_INTERFACE) {

                        if (interfaces) {
                                *interfaces = (USBInterfaceDescriptor *) descriptor;
                                interfaces++;
                        }
                } else if (USBGenericDescriptor_GetType(descriptor)
                                   == USBGenericDescriptor_ENDPOINT) {

                        if (endpoints) {
                                *endpoints = (USBEndpointDescriptor *) descriptor;
                                endpoints++;
                        }
                } else if (others) {
                        *others = descriptor;
                        others++;
                }
        }

        /* Null-terminate arrays */
        if (interfaces)
                *interfaces = 0;

        if (endpoints)
                *endpoints = 0;

        if (others)
                *others = 0;
}