/*
  ******************************************************************************
  * @file    usb_cdc.c
  * @author  FreqChip Firmware Team
  * @version V1.0.0
  * @date    2021
  * @brief   This file provides the high layer firmware functions to manage the 
  *          USB CDC Class.(Communication Device Class)
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2021 FreqChip.
  * All rights reserved.
  * 
  ******************************************************************************
  * How to use, for example:
  * 
  *    int main(void)
  *    {
  *        NVIC_ClearPendingIRQ(USBMCU_IRQn);
  *        NVIC_SetPriority(USBMCU_IRQn, 0);
  *        NVIC_EnableIRQ(USBMCU_IRQn);
  *
  *        usb_device_init();
  *        usb_cdc_init();
  *
  *        // Wait for other initialization of the MCU

  *        while(1)
  *        {
  *            usb_cdc_serialReceive();
  *        }
  *    }
  ******************************************************************************
*/
#include "usb_cdc.h"

extern UART_HandleTypeDef  Uart_CDC_handle;

#define CDC_MAX_PACK         (64)       /* Fixed 64 bytes */
#define CDC_MAX_IN_PACK      (1024)     /* IN Endpoint max pack buffer */

volatile bool COM_Activate = false;

volatile uint32_t Tx_Count = 0;
volatile uint32_t Tx_Total = 0;

uint8_t RxBuffer[CDC_MAX_PACK];
uint8_t TxBuffer[CDC_MAX_IN_PACK];

USBD_CDC_LineCodingTypeDef LineCoding;

/* USB Standard Device Descriptor */
const uint8_t USB_CDC_DeviceDesc[] =
{
    0x12,    /* bLength */
    0x01,    /* bDescriptorType */
    0x00,    /* bcdUSB */
    0x02,
    0x02,    /* bDeviceClass */
    0x02,    /* bDeviceSubClass */
    0x00,    /* bDeviceProtocol */
    0x40,    /* bMaxPacketSize */
    0xAA,    /* idVendor */
    0xFF,    /* idVendor */
    0x55,    /* idProduct */
    0x55,    /* idProduct */
    0x00,    /* bcdDevice rel. 2.00 */
    0x20,
    0x01,    /* Index of manufacturer string */
    0x02,    /* Index of product string */
    0x03,    /* Index of serial number string */
    0x01,    /* bNumConfigurations */
};

/* USB Standard Configuration Descriptor */
const uint8_t USB_CDC_ConfigurationDesc[] =
{
    /* Configuration Descriptor */
    0x09,    /* bLength */
    0x02,    /* bDescriptorType */
    0x43,    /* wTotalLength */
    0x00,
    0x02,    /* bNumInterfaces */
    0x01,    /* bConfigurationValue */
    0x00,    /* iConfiguration */
    0xC0,    /* bmAttributes */
    0x32,    /* bMaxPower */

    /* CDC Interface Descriptor */
    0x09,    /* bLength */
    0x04,    /* bDescriptorType */
    0x00,    /* bInterfaceNumber */
    0x00,    /* bAlternateSetting */
    0x01,    /* bNumEndpoints */
    0x02,    /* bInterfaceClass */
    0x02,    /* bInterfaceSubClass */
    0x01,    /* bInterfaceProtocol */
    0x00,    /* iConfiguration */

    /* Header Functional Descriptor */
    0x05,    /* bLength: Endpoint Descriptor size */
    0x24,    /* bDescriptorType: CS_INTERFACE */
    0x00,    /* bDescriptorSubtype: Header Func Desc */
    0x10,    /* bcdCDC: spec release number */
    0x01,

    /* Call Management Functional Descriptor */
    0x05,   /* bFunctionLength */
    0x24,   /* bDescriptorType: CS_INTERFACE */
    0x01,   /* bDescriptorSubtype: Call Management Func Desc */
    0x00,   /* bmCapabilities: D0+D1 */
    0x01,   /* bDataInterface: 1 */

    /* ACM Functional Descriptor */
    0x04,   /* bFunctionLength */
    0x24,   /* bDescriptorType: CS_INTERFACE */
    0x02,   /* bDescriptorSubtype: Abstract Control Management desc */
    0x02,   /* bmCapabilities */

    /* Union Functional Descriptor */
    0x05,   /* bFunctionLength */
    0x24,   /* bDescriptorType: CS_INTERFACE */
    0x06,   /* bDescriptorSubtype: Union func desc */
    0x00,   /* bMasterInterface: Communication class interface */
    0x01,   /* bSlaveInterface0: Data Class Interface */

    /* Endpoint 2 Descriptor */
    0x07,    /* bLength */
    0x05,    /* bDescriptorType */
    0x82,    /* bEndpointAddress */
    0x03,    /* bmAttributes: Interrupt */
    0x08,    /* wMaxPacketSize: */
    0x00,
    0x10,    /* bInterval */ 

    /* Data class interface descriptor */
    0x09,    /* bLength */
    0x04,    /* bDescriptorType */
    0x01,    /* bInterfaceNumber */
    0x00,    /* bAlternateSetting */
    0x02,    /* bNumEndpoints */
    0x0A,    /* bInterfaceClass */
    0x00,    /* bInterfaceSubClass */
    0x00,    /* bInterfaceProtocol */
    0x00,    /* iConfiguration */
    
    /* Endpoint OUT Descriptor */
    0x07,    /* bLength */
    0x05,    /* bDescriptorType */
    0x01,    /* bEndpointAddress */
    0x02,    /* bmAttributes: Bulk */
    0x40,    /* wMaxPacketSize */
    0x00,    
    0x00,    /* bInterval */
    
    /* Endpoint IN Descriptor */
    0x07,    /* bLength */
    0x05,    /* bDescriptorType */
    0x81,    /* bEndpointAddress */
    0x02,    /* bmAttributes: Bulk */
    0x40,    /* wMaxPacketSize */
    0x00,    
    0x00,    /* bInterval */
};

/* USB Standard Manufacture Descriptor */
const uint8_t USB_CDC_ManufactureDesc[] =
{
    0x12,        /* bLength */    
    0x03,        /* bDescriptorType */    
    'F', 0x00,   /* BString */
    'R', 0x00,
    'E', 0x00,
    'Q', 0x00,
    'C', 0x00,
    'H', 0x00,
    'I', 0x00,
    'P', 0x00,
};

/* USB Standard Configuration Descriptor */
const uint8_t USB_CDC_ProductDesc[] =
{
    0x1A,         /* bLength */
    0x03,         /* bDescriptorType */
    'F', 0x00,    /* BString */
    'R', 0x00,    
    'E', 0x00,    
    'Q', 0x00,    
    'C', 0x00,    
    'H', 0x00,    
    'I', 0x00,    
    'P', 0x00,    
    '-', 0x00,    
    'C', 0x00,    
    'O', 0x00,    
    'M', 0x00,    
};

/* USB Standard Configuration Descriptor */
const uint8_t USB_CDC_SerialNumberDesc[] =
{
    0x1E,         /* bLength */
    0x03,         /* bDescriptorType */
    '2', 0x00,    /* BString */
    '0', 0x00,
    '2', 0x00,
    '1', 0x00,
    '-', 0x00,
    '1', 0x00,
    '0', 0x00,
    '0', 0x00,
    '1', 0x00,
    '-', 0x00,
    'A', 0x00,
    '1', 0x00,
    '3', 0x00,
    '5', 0x00,
};

/* USB Standard Configuration Descriptor */
const uint8_t USB_CDC_LanuageIDDesc[] =
{
    0x04,    /* bLength */
    0x03,    /* bDescriptorType */
    0x09,    /* BString */
    0x04,
};

/*********************************************************************
 * @fn      usb_cdc_serialReceive
 *
 * @brief   serial port receives data
 *
 * @param   None.
 * @return  None.
 */
void usb_cdc_serialReceive(void)
{
    uint32_t SendLength;

    while (!__UART_IS_RxFIFO_EMPTY(Uart_CDC_handle.UARTx))
    {
        TxBuffer[Tx_Total++] = __UART_READ_FIFO(Uart_CDC_handle.UARTx);

        if (Tx_Total >= CDC_MAX_IN_PACK)
        {
            Tx_Total = 0;
        }
    }

    /*  have Data to be sent */
    SendLength =  Tx_Total >= Tx_Count ? Tx_Total - Tx_Count : CDC_MAX_IN_PACK - Tx_Count;

    if (SendLength) 
    {
        usb_selecet_endpoint(ENDPOINT_1);

        if (usb_Endpoints_GET_TxPktRdy() == false)
        {
            if (SendLength > CDC_MAX_PACK) 
            {
                usb_write_fifo(ENDPOINT_1, &TxBuffer[Tx_Count], CDC_MAX_PACK);

                Tx_Count += CDC_MAX_PACK;
            }
            else 
            {
                usb_write_fifo(ENDPOINT_1, &TxBuffer[Tx_Count], SendLength);

                Tx_Count += SendLength;
            }

            if (Tx_Count >= CDC_MAX_IN_PACK)
            {
                Tx_Count = 0;
            }

            usb_Endpoints_SET_TxPktRdy();
        }
    }
}

/*********************************************************************
 * @fn      usb_cdc_serialSend
 *
 * @brief   Sending data over a serial port
 *
 * @param   None.
 * @return  None.
 */
static void usb_cdc_serialSend(uint8_t *Buffer, uint8_t Size)
{
    while (Size--) 
    {
        /* Tx empty */
        while(__UART_IS_TxFIFO_FULL(Uart_CDC_handle.UARTx));
        /* Send data */
        __UART_WRITE_FIFO(Uart_CDC_handle.UARTx, *Buffer++);
    }
}

/* CDC Line coding */
uint8_t CDC_LineCoding[7];

/*********************************************************************
 * @fn      usb_cdc_SetLineCoding
 *
 * @brief   receive Host data and Set Line Coding
 *
 * @param   None.
 * @return  None.
 */
static void usb_cdc_SetLineCoding(void)
{   
    USBD_CDC_LineCodingTypeDef Temp_LineCoding;

    uint8_t lu8_RxCount;
    uint8_t lu8_UartLine;

    lu8_RxCount = usb_Endpoint0_get_RxCount();

    usb_read_fifo(ENDPOINT_0, CDC_LineCoding, lu8_RxCount);

    usb_Endpoint0_FlushFIFO();

    Endpoint_0_DataOut_Handler = NULL;

    Temp_LineCoding.dwDTERate  = CDC_LineCoding[0];
    Temp_LineCoding.dwDTERate |= CDC_LineCoding[1] << 8;
    Temp_LineCoding.dwDTERate |= CDC_LineCoding[2] << 16;
    Temp_LineCoding.dwDTERate |= CDC_LineCoding[3] << 24;

    Temp_LineCoding.bCharFormat = CDC_LineCoding[4];
    Temp_LineCoding.bParityType = CDC_LineCoding[5];
    Temp_LineCoding.bDataBits   = CDC_LineCoding[6];

    /* Modify the uart configuration */
    
    if (LineCoding.dwDTERate != Temp_LineCoding.dwDTERate) 
    {
        LineCoding.dwDTERate = Temp_LineCoding.dwDTERate;

        Uart_CDC_handle.Init.BaudRate = LineCoding.dwDTERate;
        uart_config_baudRate(&Uart_CDC_handle);
    }

    if (LineCoding.bCharFormat != Temp_LineCoding.bCharFormat || 
        LineCoding.bParityType != Temp_LineCoding.bParityType ||
        LineCoding.bDataBits   != Temp_LineCoding.bDataBits) 
    {
        LineCoding.bCharFormat = Temp_LineCoding.bCharFormat;
        LineCoding.bParityType = Temp_LineCoding.bParityType;
        LineCoding.bDataBits   = Temp_LineCoding.bDataBits;

        switch (LineCoding.bDataBits)
        {
            case 8: lu8_UartLine = 0x03; break;
            case 7: lu8_UartLine = 0x02; break;
            case 6: lu8_UartLine = 0x01; break;
            case 5: lu8_UartLine = 0x00; break;

            default: break; 
        }

        switch (LineCoding.bCharFormat)
        {
            case 0: lu8_UartLine |= 0x03; break;

            case 1: 
            case 2: lu8_UartLine |= 1 << 2; break;

            default: break; 
        }

        switch (LineCoding.bParityType)
        {
            case 1: lu8_UartLine |= (1 << 3); break;
            case 2: lu8_UartLine |= (1 << 3) | (1 << 4); break;

            default: break; 
        }
        
        __UART_SET_LINE_CTRL(Uart_CDC_handle.UARTx, lu8_UartLine);
    }
}

/*********************************************************************
 * @fn      usb_cdc_ClassRequest_Handler
 *
 * @brief   CDC Class Request Handler
 *
 * @param   None.
 * @return  None.
 */
static void usb_cdc_ClassRequest_Handler(usb_StandardRequest_t* pStandardRequest, usb_ReturnData_t* pReturnData)
{
    switch (pStandardRequest->bRequest)
    {
        case CDC_SET_LINE_CODING: 
        {
            /* Host data out */
            Endpoint_0_DataOut_Handler = usb_cdc_SetLineCoding;
        }break;

        case CDC_GET_LINE_CODING:
        {
            CDC_LineCoding[0] = (LineCoding.dwDTERate >> 0)  & 0xFF;
            CDC_LineCoding[1] = (LineCoding.dwDTERate >> 8)  & 0xFF;
            CDC_LineCoding[2] = (LineCoding.dwDTERate >> 16) & 0xFF;
            CDC_LineCoding[3] = (LineCoding.dwDTERate >> 24) & 0xFF;
            CDC_LineCoding[4] = LineCoding.bCharFormat;
            CDC_LineCoding[5] = LineCoding.bParityType;
            CDC_LineCoding[6] = LineCoding.bDataBits;

            pReturnData->DataBuffer = CDC_LineCoding;
            pReturnData->DataLength = sizeof(CDC_LineCoding);
        }break;

        case CDC_SET_CONTROL_LINE_STATE:
        {
            /* COM acitvate or inacitvate */
            if (pStandardRequest->wValue[0])
            {
                COM_Activate = true;
            }
            else 
            {
                COM_Activate = false;
            }

            /* clear count */
            Tx_Count = 0;
            Tx_Total = 0;

            /* Flush FIFO */
            usb_selecet_endpoint(ENDPOINT_1);
            usb_Endpoints_FlushRxFIFO();
            usb_Endpoints_FlushTxFIFO();
            usb_selecet_endpoint(ENDPOINT_0);
        }break;

        default: break; 
    }
}

/*********************************************************************
 * @fn      usb_cdc_OtherEndpoints_Handler
 *
 * @brief   CDC other Endpoints handler
 *
 * @param   None.
 * @return  None.
 */
static void usb_cdc_OtherEndpoints_Handler(uint8_t RxStatus, uint8_t TxStatus)
{
    uint8_t lu8_RxCount;

    /* DATA OUT */
    if (RxStatus & ENDPOINT_1_MASK) 
    {
        usb_selecet_endpoint(ENDPOINT_1);

        lu8_RxCount = usb_Endpoints_get_RxCount();

        usb_read_fifo(ENDPOINT_1, RxBuffer, lu8_RxCount);

        usb_cdc_serialSend(RxBuffer, lu8_RxCount);

        usb_Endpoints_FlushRxFIFO();
    }
}

/*********************************************************************
 * @fn      usb_cdc_init
 *
 * @brief   CDC device parameter initialization 
 *
 * @param   None.
 * @return  None.
 */
void usb_cdc_init(void)
{
    /* Initialize the relevant pointer  */
    usbdev_get_dev_desc((uint8_t *)USB_CDC_DeviceDesc);
    usbdev_get_config_desc((uint8_t *)USB_CDC_ConfigurationDesc);
    usbdev_get_string_Manufacture((uint8_t *)USB_CDC_ManufactureDesc);
    usbdev_get_string_Product((uint8_t *)USB_CDC_ProductDesc);
    usbdev_get_string_SerialNumber((uint8_t *)USB_CDC_SerialNumberDesc);
    usbdev_get_string_LanuageID((uint8_t *)USB_CDC_LanuageIDDesc);
    
    Endpoint_0_ClassRequest_Handler = usb_cdc_ClassRequest_Handler;

    Endpoints_Handler = usb_cdc_OtherEndpoints_Handler;

    USB_Reset_Handler = usb_cdc_init;
    
    /* config data endpoint fifo */
    usb_selecet_endpoint(ENDPOINT_1);
    usb_endpoint_Txfifo_config(0x08, 3);
    usb_endpoint_Rxfifo_config(0x10, 3);
    usb_TxMaxP_set(8);
    usb_RxMaxP_set(8);

    usb_selecet_endpoint(ENDPOINT_2);
    usb_endpoint_Txfifo_config(0x28, 1);
    usb_RxMaxP_set(1);

    /* Endpoint_1 Rx interrupt enable */
    usb_RxInt_Enable(ENDPOINT_1);

    LineCoding.dwDTERate   = 115200;
    LineCoding.bCharFormat = 0x00;
    LineCoding.bParityType = 0x00;
    LineCoding.bDataBits   = 0x08;
}