/**
  **************************************************************************
  * @file     usbd_int.c
  * @brief    usb interrupt request
  **************************************************************************
  *                       Copyright notice & Disclaimer
  *
  * The software Board Support Package (BSP) that is made available to
  * download from Artery official website is the copyrighted work of Artery.
  * Artery authorizes customers to use, copy, and distribute the BSP
  * software and its related documentation for the purpose of design and
  * development in conjunction with Artery microcontrollers. Use of the
  * software is governed by this copyright notice and the following disclaimer.
  *
  * THIS SOFTWARE IS PROVIDED ON "AS IS" BASIS WITHOUT WARRANTIES,
  * GUARANTEES OR REPRESENTATIONS OF ANY KIND. ARTERY EXPRESSLY DISCLAIMS,
  * TO THE FULLEST EXTENT PERMITTED BY LAW, ALL EXPRESS, IMPLIED OR
  * STATUTORY OR OTHER WARRANTIES, GUARANTEES OR REPRESENTATIONS,
  * INCLUDING BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
  *
  **************************************************************************
  */

#include "usbd_int.h"

/** @defgroup USBD_drivers_interrupt
  * @brief usb device interrupt
  * @{
  */

/** @defgroup USBD_int_private_functions
  * @{
  */

#ifdef BSP_USING_USBD

/**
  * @brief  usb device interrput request handler.
  * @param  udev: to the structure of usbd_core_type
  * @retval none
  */
void usbd_irq_handler(usbd_core_type *udev)
{
  usbd_type *usbx = udev->usb_reg;
  uint32_t sts_val = usbx->intsts;
  uint32_t sts_ien = usbx->ctrl;

  if(sts_val & USB_TC_FLAG)
  {
    /* endpoint tc interrupt handler */
    usbd_ept_loop_handler(udev);
  }

  if(sts_val & USB_RST_FLAG)
  {
    /* clear reset flag */
    usb_flag_clear(usbx, USB_RST_FLAG);

    /* reset interrupt handler */
    usbd_reset_handler(udev);
  }

  if((sts_val & USB_SOF_FLAG) &&
    (sts_ien & USB_SOF_INT))
  {
    /* clear sof flag */
    usb_flag_clear(usbx, USB_SOF_FLAG);

    /* sof interrupt handler */
    usbd_sof_callback(udev);
  }

  if((sts_val & USB_LSOF_FLAG) &&
    (sts_ien & USB_LSOF_INT))
  {
    /* clear lsof flag */
    usb_flag_clear(usbx, USB_LSOF_FLAG);
  }

  if((sts_val & USB_SP_FLAG) &&
    (sts_ien & USB_SP_INT))
  {
    /* clear suspend flag */
    usb_flag_clear(usbx, USB_SP_FLAG);

    /* usb suspend interrupt handler */
    usbd_suspend_handler(udev);
  }

  if((sts_val & USB_WK_FLAG) &&
    (sts_ien & USB_WK_INT))
  {
    /* usb wakeup interrupt handler */
    usbd_wakeup_handler(udev);

    /* clear wakeup flag */
    usb_flag_clear(usbx, USB_WK_FLAG);
  }
}

/**
  * @brief  usb device endpoint request handler.
  * @param  udev: to the structure of usbd_core_type
  * @param  ept_num: endpoint number
  * @retval none
  */
void usbd_eptn_handler(usbd_core_type *udev, usb_ept_number_type ept_num)
{
  usbd_type *usbx = udev->usb_reg;
  usb_ept_info *ept_info;
  uint32_t ept_val = usbx->ept[ept_num];
  uint16_t length;

  /* in interrupt request  */
  if(ept_val & USB_TXTC)
  {
    /* get endpoint register and in transfer info struct */
    ept_info = &udev->ept_in[ept_num];

    /* clear endpoint tc flag */
    USB_CLEAR_TXTC(ept_num);

    /* get endpoint tx length */
    ept_info->trans_len = USB_GET_TX_LEN(ept_num);

    /* offset the trans buffer */
    ept_info->trans_buf += ept_info->trans_len;

    if(ept_info->total_len == 0 || ept_num == USB_EPT0)
    {
      /* in transfer complete */
      usbd_data_in_stage_callback(udev,ept_num);
    }
    else
    {
      /* endpoint continue send data */
      usbd_ept_send(udev, ept_num, ept_info->trans_buf, ept_info->total_len);
    }
    /* set the host assignment address */
    if(udev->conn_state == USB_CONN_STATE_ADDRESSED && udev->device_addr > 0)
    {
      usb_set_address(udev->usb_reg, udev->device_addr);
      udev->device_addr = 0;
    }
  }
  else
  {
    /* setup and out interrupt request */

    /* get endpoint register and out transfer info struct */
    ept_info = &udev->ept_out[ept_num];

    if((ept_val & USB_SETUPTC) != 0)
    {
      /* endpoint setup interrupt request */

      /* get endpoint received data length */
      ept_info->trans_len = USB_GET_RX_LEN(ept_num);

      /* read endpoint received data */
      usb_read_packet(udev->setup_buffer, ept_info->rx_addr, ept_info->trans_len);

      /* clear endpoint rx tc flag */
      USB_CLEAR_RXTC(USB_EPT0);

      /* endpoint setup complete handler */
      usbd_core_setup_handler(udev, ept_num);
      usbd_setup_phase_done_callback(udev);
    }
    else if(ept_val & USB_RXTC )
    {
      /* endpoint out interrupt request */
      USB_CLEAR_RXTC(ept_num);

      if(ept_info->is_double_buffer == 0)
      {
        /* get endpoint received data length */
        length = USB_GET_RX_LEN(ept_num);

        /* read endpoint received data */
        usb_read_packet(ept_info->trans_buf, ept_info->rx_addr, length);
      }
      else
      {
        if( ept_val & USB_RXDTS)
        {
          length = USB_DBUF0_GET_LEN(ept_num);
          usb_read_packet(ept_info->trans_buf, ept_info->tx_addr, length);
        }
        else
        {
          length = USB_DBUF1_GET_LEN(ept_num);
          usb_read_packet(ept_info->trans_buf, ept_info->rx_addr, length);
        }
        USB_FREE_DB_USER_BUFFER(ept_num, DATA_TRANS_OUT);
      }

      /* set received data length */
      ept_info->trans_len += length;
      ept_info->trans_buf += length;

      if(ept_info->total_len == 0 || length < ept_info->maxpacket || ept_num == USB_EPT0)
      {
        /* out transfer complete */
        usbd_data_out_stage_callback(udev, ept_num);
      }
      else
      {
        /* endpoint continue receive data  */
        usbd_ept_recv(udev, ept_num, ept_info->trans_buf, ept_info->total_len);
      }
    }
  }
}

/**
  * @brief  usb device endpoint loop handler.
  * @param  udev: to the structure of usbd_core_type
  * @retval none
  */
void usbd_ept_loop_handler(usbd_core_type *udev)
{
  usbd_type *usbx = udev->usb_reg;
  usb_ept_number_type ept_num = USB_EPT0;
  uint32_t sts_val;

  while((sts_val = usbx->intsts) & USB_TC_FLAG)
  {
    /* get the interrupt endpoint number */
    ept_num = (usb_ept_number_type)(sts_val & USB_EPT_NUM_FLAG);

    usbd_eptn_handler(udev, ept_num);
  }
}

/**
  * @brief  usb device reset interrupt request handler.
  * @param  udev: to the structure of usbd_core_type
  * @retval none
  */
void usbd_reset_handler(usbd_core_type *udev)
{
  /* free usb buffer */
  usb_buffer_free();

  usbd_ept_defaut_init(udev);
#ifndef USB_EPT_AUTO_MALLOC_BUFFER
  usbd_ept_buf_custom_define(udev, 0x80, EPT0_TX_ADDR);
  usbd_ept_buf_custom_define(udev, 0x00, EPT0_RX_ADDR);
#endif

  /* open endpoint 0 out */
  usbd_ept_open(udev, 0x00, EPT_CONTROL_TYPE, 0x40);

  /* open endpoint 0 in */
  usbd_ept_open(udev, 0x80, EPT_CONTROL_TYPE, 0x40);

  /* set device address to 0 */
  usb_set_address(udev->usb_reg, 0);

  /* usb connect state set to default */
  udev->conn_state = USB_CONN_STATE_DEFAULT;

  /* user define reset event */
  usbd_reset_callback(udev);
}

/**
  * @brief  usb device sof interrupt request handler.
  * @param  udev: to the structure of usbd_core_type
  * @retval none
  */
void usbd_sof_handler(usbd_core_type *udev)
{
  /* user sof handler in class define*/
  if(udev->class_handler->sof_handler)
    udev->class_handler->sof_handler(udev);
}

/**
  * @brief  usb device suspend interrupt request handler.
  * @param  udev: to the structure of usbd_core_type
  * @retval none
  */
void usbd_suspend_handler(usbd_core_type *udev)
{
  /* save connect state */
  udev->old_conn_state = udev->conn_state;

  /* set current state to suspend */
  udev->conn_state = USB_CONN_STATE_SUSPENDED;

  /* enter suspend mode */
  usbd_enter_suspend(udev);
}

/**
  * @brief  usb device wakup interrupt request handler.
  * @param  udev: to the structure of usbd_core_type
  * @retval none
  */
void usbd_wakeup_handler(usbd_core_type *udev)
{
  /* exit suspend mode */
  usb_exit_suspend(udev->usb_reg);

  /* restore connect state */
  udev->conn_state = udev->old_conn_state;

  /* user define wakeup event */
}

rt_weak void usbd_reset_callback(usbd_core_type *udev)
{
}

rt_weak void usbd_setup_phase_done_callback(usbd_core_type *udev)
{
}

rt_weak void usbd_data_in_stage_callback(usbd_core_type *udev, uint32_t ept_num)
{
}

rt_weak void usbd_sof_callback(usbd_core_type *udev)
{
}

rt_weak void usbd_data_out_stage_callback(usbd_core_type *udev, uint32_t ept_num)
{
}

rt_weak void usbd_connectCallback(usbd_core_type *udev)
{
}

rt_weak void usbd_disconnectCallback(usbd_core_type *udev)
{
}

#endif

/**
  * @}
  */

/**
  * @}
  */