/*!
    \file    usbh_enum.c
    \brief   USB host mode enumeration driver

    \version 2020-08-01, V3.0.0, firmware for GD32F30x
*/

/*
    Copyright (c) 2020, GigaDevice Semiconductor Inc.

    Redistribution and use in source and binary forms, with or without modification, 
are permitted provided that the following conditions are met:

    1. Redistributions of source code must retain the above copyright notice, this 
       list of conditions and the following disclaimer.
    2. Redistributions in binary form must reproduce the above copyright notice, 
       this list of conditions and the following disclaimer in the documentation 
       and/or other materials provided with the distribution.
    3. Neither the name of the copyright holder nor the names of its contributors 
       may be used to endorse or promote products derived from this software without 
       specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS 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.
*/

#include "usbh_pipe.h"
#include "usbh_transc.h"
#include "usbh_enum.h"
#include <string.h>

/* local function prototypes ('static') */
static void usbh_devdesc_parse (usb_desc_dev *dev_desc, uint8_t *buf, uint16_t len);
static void usbh_cfgdesc_parse (usb_desc_config *cfg_desc, uint8_t *buf);
static void usbh_cfgset_parse  (usb_dev_prop *udev, uint8_t *buf);
static void usbh_itfdesc_parse (usb_desc_itf *itf_desc, uint8_t *buf);
static void usbh_epdesc_parse  (usb_desc_ep *ep_desc, uint8_t *buf);
static void usbh_strdesc_parse (uint8_t *psrc, uint8_t *pdest, uint16_t len);

/*!
    \brief      configure USB control status parameters
    \param[in]  puhost: pointer to usb host
    \param[in]  buf: control transfer data buffer pointer
    \param[in]  len: length of the data buffer
    \param[out] none
    \retval     none
*/
void usbh_ctlstate_config (usbh_host *puhost, uint8_t *buf, uint16_t len)
{
    /* prepare the transactions */
    puhost->control.buf = buf;
    puhost->control.ctl_len = len;

    puhost->control.ctl_state = CTL_SETUP;
}

/*!
    \brief      get device descriptor from the USB device
    \param[in]  puhost: pointer to usb host
    \param[in]  len: length of the descriptor
    \param[out] none
    \retval     operation status
*/
usbh_status usbh_devdesc_get (usbh_host *puhost, uint8_t len)
{
    usbh_status status = USBH_BUSY;

    usbh_control *usb_ctl = &puhost->control;

    if (CTL_IDLE == usb_ctl->ctl_state) {
		/*
        usb_ctl->setup.req = (usb_req) {
            .bmRequestType = USB_TRX_IN | USB_RECPTYPE_DEV | USB_REQTYPE_STRD,
            .bRequest      = USB_GET_DESCRIPTOR,
            .wValue        = USBH_DESC(USB_DESCTYPE_DEV),
            .wIndex        = 0U,
            .wLength       = len
        };
		*/
		{
			usb_ctl->setup.req.bmRequestType = USB_TRX_IN | USB_RECPTYPE_DEV | USB_REQTYPE_STRD;
            usb_ctl->setup.req.bRequest      = USB_GET_DESCRIPTOR;
            usb_ctl->setup.req.wValue        = USBH_DESC(USB_DESCTYPE_DEV);
            usb_ctl->setup.req.wIndex        = 0U;
            usb_ctl->setup.req.wLength       = len;
		}

        usbh_ctlstate_config (puhost, puhost->dev_prop.data, (uint16_t)len);
    }

    status = usbh_ctl_handler (puhost);

    if (USBH_OK == status) {
        /* commands successfully sent and response received */
        usbh_devdesc_parse (&puhost->dev_prop.dev_desc, puhost->dev_prop.data, (uint16_t)len);
    }

    return status;
}

/*!
    \brief      get configuration descriptor from the USB device
    \param[in]  puhost: pointer to usb host
    \param[in]  len: length of the descriptor
    \param[out] none
    \retval     operation status
*/
usbh_status usbh_cfgdesc_get (usbh_host *puhost, uint16_t len)
{
    uint8_t *pdata = NULL;

    usbh_status status = USBH_BUSY;

    usbh_control *usb_ctl = &puhost->control;

#if (USBH_KEEP_CFG_DESCRIPTOR == 1U)
    pdata = puhost->dev_prop.cfgdesc_rawdata;
#else
    pdata = puhost->dev_prop.data;
#endif

    if (CTL_IDLE == usb_ctl->ctl_state) {
		/*
        usb_ctl->setup.req = (usb_req) {
            .bmRequestType = USB_TRX_IN | USB_RECPTYPE_DEV | USB_REQTYPE_STRD,
            .bRequest      = USB_GET_DESCRIPTOR,
            .wValue        = USBH_DESC(USB_DESCTYPE_CONFIG),
            .wIndex        = 0U,
            .wLength       = len
        };
		*/
		 {
            usb_ctl->setup.req.bmRequestType = USB_TRX_IN | USB_RECPTYPE_DEV | USB_REQTYPE_STRD;
            usb_ctl->setup.req.bRequest      = USB_GET_DESCRIPTOR;
            usb_ctl->setup.req.wValue        = USBH_DESC(USB_DESCTYPE_CONFIG);
            usb_ctl->setup.req.wIndex        = 0U;
            usb_ctl->setup.req.wLength       = len;
        }

        usbh_ctlstate_config (puhost, pdata, len);
    }

    status = usbh_ctl_handler (puhost);

    if (USBH_OK == status) {
        if (len <= USB_CFG_DESC_LEN) {
            usbh_cfgdesc_parse (&puhost->dev_prop.cfg_desc_set.cfg_desc, pdata);
        } else {
            usbh_cfgset_parse (&puhost->dev_prop, pdata);
        }
    }

    return status;
}

/*!
    \brief      get string descriptor from the USB device
    \param[in]  puhost: pointer to usb host
    \param[in]  str_index: index for the string descriptor
    \param[in]  buf: buffer pointer to the string descriptor
    \param[in]  len: length of the descriptor
    \param[out] none
    \retval     operation status
*/
usbh_status usbh_strdesc_get (usbh_host *puhost,
                              uint8_t str_index, 
                              uint8_t *buf, 
                              uint16_t len)
{
    usbh_status status = USBH_BUSY;

    usbh_control *usb_ctl = &puhost->control;

    if (CTL_IDLE == usb_ctl->ctl_state) {
		/*
        usb_ctl->setup.req = (usb_req) {
            .bmRequestType = USB_TRX_IN | USB_RECPTYPE_DEV | USB_REQTYPE_STRD,
            .bRequest      = USB_GET_DESCRIPTOR,
            .wValue        = USBH_DESC(USB_DESCTYPE_STR) | str_index,
            .wIndex        = 0x0409U,
            .wLength       = len
        };
		*/
		{
			usb_ctl->setup.req.bmRequestType = USB_TRX_IN | USB_RECPTYPE_DEV | USB_REQTYPE_STRD;
            usb_ctl->setup.req.bRequest      = USB_GET_DESCRIPTOR;
            usb_ctl->setup.req.wValue        = USBH_DESC(USB_DESCTYPE_STR) | str_index;
            usb_ctl->setup.req.wIndex        = 0x0409U;
            usb_ctl->setup.req.wLength       = len;
		}

        usbh_ctlstate_config (puhost, puhost->dev_prop.data, len);
    }

    status = usbh_ctl_handler (puhost);

    if (USBH_OK == status) {
        /* commands successfully sent and response received */
        usbh_strdesc_parse (puhost->dev_prop.data, buf, len);
    }

    return status;
}

/*!
    \brief      set the address to the connected device
    \param[in]  puhost: pointer to usb host
    \param[in]  dev_addr: device address to assign
    \param[out] none
    \retval     operation status
*/
usbh_status usbh_setaddress (usbh_host *puhost, uint8_t dev_addr)
{
    usbh_status status = USBH_BUSY;

    usbh_control *usb_ctl = &puhost->control;

    if (CTL_IDLE == usb_ctl->ctl_state) {
		/*
        usb_ctl->setup.req = (usb_req) {
            .bmRequestType = USB_TRX_OUT | USB_RECPTYPE_DEV | USB_REQTYPE_STRD,
            .bRequest      = USB_SET_ADDRESS,
            .wValue        = (uint16_t)dev_addr,
            .wIndex        = 0U,
            .wLength       = 0U
        };
		*/
		{
            usb_ctl->setup.req.bmRequestType = USB_TRX_OUT | USB_RECPTYPE_DEV | USB_REQTYPE_STRD;
            usb_ctl->setup.req.bRequest      = USB_SET_ADDRESS;
            usb_ctl->setup.req.wValue        = (uint16_t)dev_addr;
            usb_ctl->setup.req.wIndex        = 0U;
            usb_ctl->setup.req.wLength       = 0U;
        }

        usbh_ctlstate_config (puhost, NULL, 0U);
    }

    status = usbh_ctl_handler (puhost);

    return status;
}

/*!
    \brief      set the configuration value to the connected device
    \param[in]  puhost: pointer to usb host
    \param[in]  config_index: configuration value
    \param[out] none
    \retval     operation status
*/
usbh_status usbh_setcfg (usbh_host *puhost, uint16_t config_index)
{
    usbh_status status = USBH_BUSY;

    usbh_control *usb_ctl = &puhost->control;

    if (CTL_IDLE == usb_ctl->ctl_state) {
		/*
        usb_ctl->setup.req = (usb_req) {
            .bmRequestType = USB_TRX_OUT | USB_RECPTYPE_DEV | USB_REQTYPE_STRD,
            .bRequest      = USB_SET_CONFIGURATION,
            .wValue        = config_index,
            .wIndex        = 0U,
            .wLength       = 0U
        };
		*/
		{
            usb_ctl->setup.req.bmRequestType = USB_TRX_OUT | USB_RECPTYPE_DEV | USB_REQTYPE_STRD;
            usb_ctl->setup.req.bRequest      = USB_SET_CONFIGURATION;
            usb_ctl->setup.req.wValue        = config_index;
            usb_ctl->setup.req.wIndex        = 0U;
            usb_ctl->setup.req.wLength       = 0U;
        }

        usbh_ctlstate_config (puhost, NULL, 0U);
    }

    status = usbh_ctl_handler (puhost);

    return status;
}

/*!
    \brief      set the interface value to the connected device
    \param[in]  puhost: pointer to usb host
    \param[in]  itf_num: interface number
    \param[in]  set: alternated setting value
    \param[out] none
    \retval     operation status
*/
usbh_status usbh_setinterface (usbh_host *puhost, uint8_t itf_num, uint8_t set)
{
    usbh_status status = USBH_BUSY;

    usbh_control *usb_ctl = &puhost->control;

    if (CTL_IDLE == usb_ctl->ctl_state) {
		/*
        usb_ctl->setup.req = (usb_req) {
            .bmRequestType = USB_TRX_OUT | USB_RECPTYPE_ITF | USB_REQTYPE_STRD,
            .bRequest      = USB_SET_INTERFACE,
            .wValue        = set,
            .wIndex        = itf_num,
            .wLength       = 0U
        };
		*/
		{
            usb_ctl->setup.req.bmRequestType = USB_TRX_OUT | USB_RECPTYPE_ITF | USB_REQTYPE_STRD;
            usb_ctl->setup.req.bRequest      = USB_SET_INTERFACE;
            usb_ctl->setup.req.wValue        = set;
            usb_ctl->setup.req.wIndex        = itf_num;
            usb_ctl->setup.req.wLength       = 0U;
        }

        usbh_ctlstate_config (puhost, NULL, 0U);
    }

    status = usbh_ctl_handler (puhost);

    return status;
}

/*!
    \brief      set the interface value to the connected device
    \param[in]  puhost: pointer to usb host
    \param[in]  feature_selector: feature selector
    \param[in]  windex: index value
    \param[out] none
    \retval     operation status
*/
usbh_status usbh_setdevfeature (usbh_host *puhost, uint8_t feature_selector, uint16_t windex)
{
    usbh_status status = USBH_BUSY;

    usbh_control *usb_ctl = &puhost->control;

    if (CTL_IDLE == usb_ctl->ctl_state) {
		/*
        usb_ctl->setup.req = (usb_req) {
            .bmRequestType = USB_TRX_OUT | USB_RECPTYPE_DEV | USB_REQTYPE_STRD,
            .bRequest      = USB_SET_FEATURE,
            .wValue        = feature_selector,
            .wIndex        = windex,
            .wLength       = 0U
        };
		*/
		{
            usb_ctl->setup.req.bmRequestType = USB_TRX_OUT | USB_RECPTYPE_DEV | USB_REQTYPE_STRD;
            usb_ctl->setup.req.bRequest      = USB_SET_FEATURE;
            usb_ctl->setup.req.wValue        = feature_selector;
            usb_ctl->setup.req.wIndex        = windex;
            usb_ctl->setup.req.wLength       = 0U;
        }

        usbh_ctlstate_config (puhost, NULL, 0U);
    } 

    status = usbh_ctl_handler (puhost);

    return status;
}

/*!
    \brief      clear the interface value to the connected device
    \param[in]  puhost: pointer to usb host
    \param[in]  feature_selector: feature selector
    \param[in]  windex: index value
    \param[out] none
    \retval     operation status
*/
usbh_status usbh_clrdevfeature (usbh_host *puhost, uint8_t feature_selector, uint16_t windex)
{
    usbh_status status = USBH_BUSY;

    usbh_control *usb_ctl = &puhost->control;

    if (CTL_IDLE == usb_ctl->ctl_state) {
		/*
        usb_ctl->setup.req = (usb_req) {
            .bmRequestType = USB_TRX_OUT | USB_RECPTYPE_DEV | USB_REQTYPE_STRD,
            .bRequest      = USB_CLEAR_FEATURE,
            .wValue        = feature_selector,
            .wIndex        = windex,
            .wLength       = 0U
        };
		*/
		{
            usb_ctl->setup.req.bmRequestType = USB_TRX_OUT | USB_RECPTYPE_DEV | USB_REQTYPE_STRD;
            usb_ctl->setup.req.bRequest      = USB_CLEAR_FEATURE;
            usb_ctl->setup.req.wValue        = feature_selector;
            usb_ctl->setup.req.wIndex        = windex;
            usb_ctl->setup.req.wLength       = 0U;
        }

        usbh_ctlstate_config (puhost, NULL, 0U);
    }

    status = usbh_ctl_handler (puhost);

    return status;
}

/*!
    \brief      clear or disable a specific feature
    \param[in]  puhost: pointer to usb host
    \param[in]  ep_addr: endpoint address
    \param[in]  pp_num: pipe number
    \param[out] none
    \retval     operation status
*/
usbh_status usbh_clrfeature (usbh_host *puhost, uint8_t ep_addr, uint8_t pp_num) 
{
    usbh_status status = USBH_BUSY;
    usbh_control *usb_ctl = &puhost->control;
    usb_core_driver *pudev = (usb_core_driver *)puhost->data;

    if (CTL_IDLE == usb_ctl->ctl_state) {
		/*
        usb_ctl->setup.req = (usb_req) {
            .bmRequestType = USB_TRX_OUT | USB_RECPTYPE_EP | USB_REQTYPE_STRD,
            .bRequest      = USB_CLEAR_FEATURE,
            .wValue        = FEATURE_SELECTOR_EP,
            .wIndex        = ep_addr,
            .wLength       = 0U
        };
		*/
		{
            usb_ctl->setup.req.bmRequestType = USB_TRX_OUT | USB_RECPTYPE_EP | USB_REQTYPE_STRD;
            usb_ctl->setup.req.bRequest      = USB_CLEAR_FEATURE;
            usb_ctl->setup.req.wValue        = FEATURE_SELECTOR_EP;
            usb_ctl->setup.req.wIndex        = ep_addr;
            usb_ctl->setup.req.wLength       = 0U;
        }

        if (EP_ID(ep_addr) == pudev->host.pipe[pp_num].ep.num) {
            usbh_pipe_toggle_set(pudev, pp_num, 0U);
        } else {
            return USBH_FAIL;
        }

        usbh_ctlstate_config (puhost, NULL, 0U);
    } 

    status = usbh_ctl_handler (puhost);

    return status;
}

/*!
    \brief      get the next descriptor header
    \param[in]  pbuf: pointer to buffer where the configuration descriptor set is available
    \param[in]  ptr: data pointer inside the configuration descriptor set
    \param[out] none
    \retval     return descriptor header
*/
usb_desc_header *usbh_nextdesc_get (uint8_t *pbuf, uint16_t *ptr)
{
    usb_desc_header *pnext;

    *ptr += ((usb_desc_header *)pbuf)->bLength;

    pnext = (usb_desc_header *)((uint8_t *)pbuf + ((usb_desc_header *)pbuf)->bLength);

    return (pnext);
}

/*!
    \brief      get the next descriptor header
    \param[in]  udev: pointer to device property
    \param[in]  interface: interface number
    \param[out] none
    \retval     operation status
*/
usbh_status usbh_interface_select (usb_dev_prop *udev, uint8_t interface)
{
    usbh_status status = USBH_OK;

    if (interface < udev->cfg_desc_set.cfg_desc.bNumInterfaces) {
        udev->cur_itf = interface;
    } else {
        status = USBH_FAIL;
    }

    return status;
}

/*!
    \brief      find the interface index for a specific class
    \param[in]  udev: pointer to device property
    \param[in]  main_class: class code
    \param[in]  sub_class: subclass code
    \param[in]  protocol: Protocol code
    \param[out] none
    \retval     interface index in the configuration structure
    \note       interface index 0xFF means interface index not found
*/
uint8_t usbh_interface_find (usb_dev_prop *udev, uint8_t main_class, uint8_t sub_class, uint8_t protocol)
{
    usb_desc_itf *pif;

    uint8_t if_ix = 0U;

    pif = (usb_desc_itf *)0;

    while (if_ix < udev->cfg_desc_set.cfg_desc.bNumInterfaces) {
        pif = &udev->cfg_desc_set.itf_desc_set[if_ix][0].itf_desc;

        if (((pif->bInterfaceClass == main_class) || (main_class == 0xFFU))&&
             ((pif->bInterfaceSubClass == sub_class) || (sub_class == 0xFFU))&&
               ((pif->bInterfaceProtocol == protocol) || (protocol == 0xFFU))) {
            return if_ix;
        }

        if_ix++;
    }

    return 0xFFU;
}

/*!
    \brief      find the interface index for a specific class interface and alternate setting number
    \param[in]  udev: pointer to device property
    \param[in]  interface_number: interface number
    \param[in]  alt_settings: alternate setting number
    \param[out] none
    \retval     interface index in the configuration structure
    \note       interface index 0xFF means interface index not found
*/
uint8_t usbh_interfaceindex_find (usb_dev_prop *udev, uint8_t interface_number, uint8_t alt_settings)
{
    usb_desc_itf *pif;

    uint8_t if_ix = 0U;

    pif = (usb_desc_itf *)0;

    while (if_ix < USBH_MAX_INTERFACES_NUM) {
        pif = &udev->cfg_desc_set.itf_desc_set[if_ix][alt_settings].itf_desc;

        if ((pif->bInterfaceNumber == interface_number) && (pif->bAlternateSetting == alt_settings)) {
            return if_ix;
        }

        if_ix++;
    }

    return 0xFFU;
}

/*!
    \brief      parse the device descriptor
    \param[in]  dev_desc: pointer to usb device descriptor buffer
    \param[in]  buf: pointer to the source descriptor buffer
    \param[in]  len: length of the descriptor
    \param[out] none
    \retval     none
*/
static void usbh_devdesc_parse (usb_desc_dev *dev_desc, uint8_t *buf, uint16_t len)
{
	/*
    *dev_desc = (usb_desc_dev) {
        .header = {
            .bLength         = *(uint8_t *)(buf + 0U),
            .bDescriptorType = *(uint8_t *)(buf + 1U)
        },

        .bcdUSB              = BYTE_SWAP(buf + 2U),
        .bDeviceClass        = *(uint8_t *)(buf + 4U),
        .bDeviceSubClass     = *(uint8_t *)(buf + 5U),
        .bDeviceProtocol     = *(uint8_t *)(buf + 6U),
        .bMaxPacketSize0     = *(uint8_t *)(buf + 7U)
    };
	*/
	{
        {
            dev_desc->header.bLength         = *(uint8_t *)(buf + 0U);
            dev_desc->header.bDescriptorType = *(uint8_t *)(buf + 1U);
        }

        dev_desc->bcdUSB              = BYTE_SWAP(buf + 2U);
        dev_desc->bDeviceClass        = *(uint8_t *)(buf + 4U);
        dev_desc->bDeviceSubClass     = *(uint8_t *)(buf + 5U);
        dev_desc->bDeviceProtocol     = *(uint8_t *)(buf + 6U);
        dev_desc->bMaxPacketSize0     = *(uint8_t *)(buf + 7U);
    }

    if (len > 8U) {
        /* for 1st time after device connection, host may issue only 8 bytes for device descriptor length  */
        dev_desc->idVendor              = BYTE_SWAP(buf + 8U);
        dev_desc->idProduct             = BYTE_SWAP(buf + 10U);
        dev_desc->bcdDevice             = BYTE_SWAP(buf + 12U);
        dev_desc->iManufacturer         = *(uint8_t *)(buf + 14U);
        dev_desc->iProduct              = *(uint8_t *)(buf + 15U);
        dev_desc->iSerialNumber         = *(uint8_t *)(buf + 16U);
        dev_desc->bNumberConfigurations = *(uint8_t *)(buf + 17U);
    }
}

/*!
    \brief      parse the configuration descriptor
    \param[in]  cfg_desc: pointer to usb configuration descriptor buffer
    \param[in]  buf: pointer to the source descriptor buffer
    \param[out] none
    \retval     none
*/
static void usbh_cfgdesc_parse (usb_desc_config *cfg_desc, uint8_t *buf)
{
    /* parse configuration descriptor */
	/*
    *cfg_desc = (usb_desc_config) {
        .header = {
            .bLength         = *(uint8_t *)(buf + 0U),
            .bDescriptorType = *(uint8_t *)(buf + 1U),
        },

        .wTotalLength        = BYTE_SWAP(buf + 2U),
        .bNumInterfaces      = *(uint8_t *)(buf + 4U),
        .bConfigurationValue = *(uint8_t *)(buf + 5U),
        .iConfiguration      = *(uint8_t *)(buf + 6U),
        .bmAttributes        = *(uint8_t *)(buf + 7U),
        .bMaxPower           = *(uint8_t *)(buf + 8U)
    };
	*/
	{
        {
            cfg_desc->header.bLength         = *(uint8_t *)(buf + 0U);
            cfg_desc->header.bDescriptorType = *(uint8_t *)(buf + 1U);
        }

        cfg_desc->wTotalLength        = BYTE_SWAP(buf + 2U);
        cfg_desc->bNumInterfaces      = *(uint8_t *)(buf + 4U);
        cfg_desc->bConfigurationValue = *(uint8_t *)(buf + 5U);
        cfg_desc->iConfiguration      = *(uint8_t *)(buf + 6U);
        cfg_desc->bmAttributes        = *(uint8_t *)(buf + 7U);
        cfg_desc->bMaxPower           = *(uint8_t *)(buf + 8U);
    }
}

/*!
    \brief      parse the configuration descriptor set
    \param[in]  udev:  pointer to device property
    \param[in]  buf: pointer to the source descriptor buffer
    \param[out] none
    \retval     none
*/
static void  usbh_cfgset_parse (usb_dev_prop *udev, uint8_t *buf)
{
    usb_desc_ep *ep = NULL;
    usb_desc_itf_set *itf = NULL;
    usb_desc_itf itf_value;
    usb_desc_config *cfg = NULL;

    usb_desc_header *pdesc = (usb_desc_header *)buf;

    uint8_t itf_index = 0U, ep_index = 0U, alt_setting = 0U;
    uint8_t pre_itf_index = 0U;
    uint16_t ptr;

    /* parse configuration descriptor */
    usbh_cfgdesc_parse (&udev->cfg_desc_set.cfg_desc, buf);
    cfg = &udev->cfg_desc_set.cfg_desc;
    ptr = USB_CFG_DESC_LEN;

    if (cfg->bNumInterfaces > USBH_MAX_INTERFACES_NUM) {
        return;
    }

    while (ptr < cfg->wTotalLength) {
        pdesc = usbh_nextdesc_get ((uint8_t *)pdesc, &ptr);

        if (pdesc->bDescriptorType == USB_DESCTYPE_ITF) {
            itf_index = *(((uint8_t *)pdesc) + 2U);

            if (pre_itf_index != itf_index) {
                alt_setting = 0U;
            }

            itf = &udev->cfg_desc_set.itf_desc_set[itf_index][alt_setting];

            alt_setting++;

            if ((*((uint8_t *)pdesc + 3U)) < 3U) {
                usbh_itfdesc_parse (&itf_value, (uint8_t *)pdesc);

                /* parse endpoint descriptors relative to the current interface */
                if (itf_value.bNumEndpoints > USBH_MAX_EP_NUM) {
                    return;
                }

                usbh_itfdesc_parse (&itf->itf_desc, (uint8_t *)&itf_value);

                /* store the previous interface index */
                pre_itf_index = itf_index;

                if (0U == itf_value.bNumEndpoints) {
                    continue;
                }

                for (ep_index = 0U; ep_index < itf_value.bNumEndpoints; ) {
                    pdesc = usbh_nextdesc_get ((uint8_t *)pdesc, &ptr);

                    if (pdesc->bDescriptorType == USB_DESCTYPE_EP) {
                        ep = &itf->ep_desc[ep_index];

                        usbh_epdesc_parse (ep, (uint8_t *)pdesc);

                        ep_index++;
                    }
                }
            }
        }
    }
}

/*!
    \brief      parse the interface descriptor
    \param[in]  itf_desc: pointer to usb interface descriptor buffer
    \param[in]  buf: pointer to the source descriptor buffer
    \param[out] none
    \retval     none
*/
static void  usbh_itfdesc_parse (usb_desc_itf *itf_desc, uint8_t *buf)
{
	/*
    *itf_desc = (usb_desc_itf) {
        .header = {
            .bLength         = *(uint8_t *)(buf + 0U),
            .bDescriptorType = *(uint8_t *)(buf + 1U),
        },

        .bInterfaceNumber    = *(uint8_t *)(buf + 2U),
        .bAlternateSetting   = *(uint8_t *)(buf + 3U),
        .bNumEndpoints       = *(uint8_t *)(buf + 4U),
        .bInterfaceClass     = *(uint8_t *)(buf + 5U),
        .bInterfaceSubClass  = *(uint8_t *)(buf + 6U),
        .bInterfaceProtocol  = *(uint8_t *)(buf + 7U),
        .iInterface          = *(uint8_t *)(buf + 8U)
    };
	*/
	{
        {
            itf_desc->header.bLength         = *(uint8_t *)(buf + 0U);
            itf_desc->header.bDescriptorType = *(uint8_t *)(buf + 1U);
        }

        itf_desc->bInterfaceNumber    = *(uint8_t *)(buf + 2U);
        itf_desc->bAlternateSetting   = *(uint8_t *)(buf + 3U);
        itf_desc->bNumEndpoints       = *(uint8_t *)(buf + 4U);
        itf_desc->bInterfaceClass     = *(uint8_t *)(buf + 5U);
        itf_desc->bInterfaceSubClass  = *(uint8_t *)(buf + 6U);
        itf_desc->bInterfaceProtocol  = *(uint8_t *)(buf + 7U);
        itf_desc->iInterface          = *(uint8_t *)(buf + 8U);
    }
}

/*!
    \brief      parse the endpoint descriptor
    \param[in]  ep_desc: pointer to usb endpoint descriptor buffer
    \param[in]  buf: pointer to the source descriptor buffer
    \param[out] none
    \retval     none
*/
static void  usbh_epdesc_parse (usb_desc_ep *ep_desc, uint8_t *buf)
{
	/*
    *ep_desc = (usb_desc_ep) {
        .header = {
            .bLength         = *(uint8_t *)(buf + 0U),
            .bDescriptorType = *(uint8_t *)(buf + 1U)
        },

        .bEndpointAddress    = *(uint8_t *)(buf + 2U),
        .bmAttributes        = *(uint8_t *)(buf + 3U),
        .wMaxPacketSize      = BYTE_SWAP(buf + 4U),
        .bInterval           = *(uint8_t *)(buf + 6U)
    };
	*/
	{
        {
            ep_desc->header.bLength         = *(uint8_t *)(buf + 0U);
            ep_desc->header.bDescriptorType = *(uint8_t *)(buf + 1U);
        }

        ep_desc->bEndpointAddress    = *(uint8_t *)(buf + 2U);
        ep_desc->bmAttributes        = *(uint8_t *)(buf + 3U);
        ep_desc->wMaxPacketSize      = BYTE_SWAP(buf + 4U);
        ep_desc->bInterval           = *(uint8_t *)(buf + 6U);
    }
}

/*!
    \brief      parse the string descriptor
    \param[in]  psrc: source pointer containing the descriptor data
    \param[in]  pdest: destination address pointer
    \param[in]  len: length of the descriptor
    \param[out] none
    \retval     none
*/
static void usbh_strdesc_parse (uint8_t *psrc, uint8_t *pdest, uint16_t len)
{
    uint16_t str_len = 0U, index = 0U;

    /* the unicode string descriptor is not NULL-terminated. The string length is
     * computed by substracting two from the value of the first byte of the descriptor.
     */

    /* check which is lower size, the size of string or the length of bytes read from the device */
    if (USB_DESCTYPE_STR == psrc[1]) {
        /* make sure the descriptor is string type */

        /* psrc[0] contains Size of Descriptor, subtract 2 to get the length of string */
        str_len = USB_MIN((uint16_t)psrc[0] - 2U, len);

        psrc += 2U; /* adjust the offset ignoring the string len and descriptor type */

        for (index = 0U; index < str_len; index += 2U) {
            /* copy only the string and ignore the unicode id, hence add the src */
            *pdest = psrc[index];

            pdest++;
        }

        *pdest = 0U; /* mark end of string */  
    }
}