664 lines
19 KiB
C
664 lines
19 KiB
C
/*!
|
|
\file usbd_int.c
|
|
\brief USB device mode interrupt routines
|
|
|
|
\version 2014-12-26, V1.0.0, firmware for GD32F10x
|
|
\version 2017-06-20, V2.0.0, firmware for GD32F10x
|
|
\version 2018-07-31, V2.1.0, firmware for GD32F10x
|
|
*/
|
|
|
|
/*
|
|
Copyright (c) 2018, GigaDevice Semiconductor Inc.
|
|
|
|
All rights reserved.
|
|
|
|
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 "usbd_int.h"
|
|
#include "usbd_std.h"
|
|
|
|
/* interrupt handlers */
|
|
static uint32_t usbd_intf_outep (usb_core_handle_struct *pudev);
|
|
static uint32_t usbd_intf_inep (usb_core_handle_struct *pudev);
|
|
static uint32_t usbd_intf_earlysuspend (usb_core_handle_struct *pudev);
|
|
static uint32_t usbd_intf_suspend (usb_core_handle_struct *pudev);
|
|
static uint32_t usbd_intf_resume (usb_core_handle_struct *pudev);
|
|
static uint32_t usbd_intf_sof (usb_core_handle_struct *pudev);
|
|
static uint32_t usbd_intf_rxfifo (usb_core_handle_struct *pudev);
|
|
static uint32_t usbd_intf_reset (usb_core_handle_struct *pudev);
|
|
static uint32_t usbd_intf_enumfinish (usb_core_handle_struct *pudev);
|
|
static uint32_t usbd_intf_isoinincomplete (usb_core_handle_struct *pudev);
|
|
static uint32_t usbd_intf_isooutincomplete (usb_core_handle_struct *pudev);
|
|
|
|
static uint32_t usbd_emptytxfifo_write (usb_core_handle_struct *pudev, uint8_t ep_num);
|
|
|
|
#ifdef VBUS_SENSING_ENABLED
|
|
|
|
static uint32_t usbd_intf_otg (usb_core_handle_struct *pudev);
|
|
static uint32_t usbd_intf_sessionrequest (usb_core_handle_struct *pudev);
|
|
|
|
#endif /* VBUS_SENSING_ENABLED */
|
|
|
|
static usb_speed_enum USB_SPEED[4] = {
|
|
[DSTAT_ENUMSPD_HS_PHY_30MHZ_OR_60MHZ] = USB_SPEED_HIGH,
|
|
[DSTAT_ENUMSPD_FS_PHY_30MHZ_OR_60MHZ] = USB_SPEED_FULL,
|
|
[DSTAT_ENUMSPD_FS_PHY_48MHZ] = USB_SPEED_FULL,
|
|
[DSTAT_ENUMSPD_LS_PHY_6MHZ] = USB_SPEED_LOW
|
|
};
|
|
|
|
static const uint8_t EP0_MAXLEN[4] = {
|
|
[DSTAT_ENUMSPD_HS_PHY_30MHZ_OR_60MHZ] = EP0MPL_64,
|
|
[DSTAT_ENUMSPD_FS_PHY_30MHZ_OR_60MHZ] = EP0MPL_64,
|
|
[DSTAT_ENUMSPD_FS_PHY_48MHZ] = EP0MPL_64,
|
|
[DSTAT_ENUMSPD_LS_PHY_6MHZ] = EP0MPL_8
|
|
};
|
|
|
|
/*!
|
|
\brief USB device-mode interrupts global service routine handler
|
|
\param[in] pudev: pointer to usb device instance
|
|
\param[out] none
|
|
\retval operation status
|
|
*/
|
|
uint32_t usbd_isr (usb_core_handle_struct *pudev)
|
|
{
|
|
uint32_t retval = 0U;
|
|
uint32_t int_status = 0U, gintf = USB_GINTF, ginten = USB_GINTEN;
|
|
|
|
/* ensure the core is in device mode */
|
|
if (DEVICE_MODE == USB_CURRENT_MODE_GET()) {
|
|
int_status = gintf & ginten;
|
|
|
|
/* there are no interrupts, avoid spurious interrupt */
|
|
if (!int_status) {
|
|
return 0U;
|
|
}
|
|
|
|
/* OUT endpoints interrupts */
|
|
if (int_status & GINTF_OEPIF) {
|
|
retval |= usbd_intf_outep(pudev);
|
|
}
|
|
|
|
/* IN endpoints interrupts */
|
|
if (int_status & GINTF_IEPIF) {
|
|
retval |= usbd_intf_inep(pudev);
|
|
}
|
|
|
|
/* mode mismatch interrupt */
|
|
if (int_status & GINTF_MFIF) {
|
|
/* clear interrupt */
|
|
USB_GINTF = GINTF_MFIF;
|
|
}
|
|
|
|
/* early suspend interrupt */
|
|
if (int_status & GINTF_ESP) {
|
|
retval |= usbd_intf_earlysuspend(pudev);
|
|
}
|
|
|
|
/* suspend interrupt */
|
|
if (int_status & GINTF_SP) {
|
|
retval |= usbd_intf_suspend(pudev);
|
|
}
|
|
|
|
/* wakeup interrupt */
|
|
if (int_status & GINTF_WKUPIF) {
|
|
retval |= usbd_intf_resume(pudev);
|
|
}
|
|
|
|
/* start of frame interrupt */
|
|
if (int_status & GINTF_SOF) {
|
|
retval |= usbd_intf_sof(pudev);
|
|
}
|
|
|
|
/* reveive fifo not empty interrupt */
|
|
if (int_status & GINTF_RXFNEIF) {
|
|
retval |= usbd_intf_rxfifo(pudev);
|
|
}
|
|
|
|
/* USB reset interrupt */
|
|
if (int_status & GINTF_RST) {
|
|
retval |= usbd_intf_reset(pudev);
|
|
}
|
|
|
|
/* enumeration has been finished interrupt */
|
|
if (int_status & GINTF_ENUMF) {
|
|
retval |= usbd_intf_enumfinish(pudev);
|
|
}
|
|
|
|
/* incomplete synchronization in transfer interrupt*/
|
|
if (int_status & GINTF_ISOINCIF) {
|
|
retval |= usbd_intf_isoinincomplete(pudev);
|
|
}
|
|
|
|
/* incomplete synchronization out transfer interrupt*/
|
|
if (int_status & GINTF_ISOONCIF) {
|
|
retval |= usbd_intf_isooutincomplete(pudev);
|
|
}
|
|
|
|
#ifdef VBUS_SENSING_ENABLED
|
|
|
|
/* session request interrupt */
|
|
if (int_status & GINTF_SESIF) {
|
|
retval |= usbd_intf_sessionrequest(pudev);
|
|
}
|
|
|
|
/* OTG mode interrupt */
|
|
if (int_status & GINTF_OTGIF) {
|
|
retval |= usbd_intf_otg(pudev);
|
|
}
|
|
#endif /* VBUS_SENSING_ENABLED */
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/*!
|
|
\brief indicates that an OUT endpoint has a pending interrupt
|
|
\param[in] pudev: pointer to usb device instance
|
|
\param[out] none
|
|
\retval operation status
|
|
*/
|
|
static uint32_t usbd_intf_outep (usb_core_handle_struct *pudev)
|
|
{
|
|
uint8_t endp_num = 0U;
|
|
uint32_t endp_intr = 0U;
|
|
|
|
__IO uint32_t out_endp_intr = 0U;
|
|
|
|
/* read in the device interrupt bits */
|
|
USB_DAOEP_INTR_READ(endp_intr);
|
|
|
|
while (endp_intr) {
|
|
if (endp_intr & 0x1U) {
|
|
USB_DOEP_INTR_READ(out_endp_intr, (uint16_t)endp_num);
|
|
|
|
/* transfer complete interrupt */
|
|
if (out_endp_intr & DOEPINTF_TF) {
|
|
USB_DOEPxINTF((uint16_t)endp_num) = DOEPINTF_TF;
|
|
|
|
/* data receive is completed */
|
|
usbd_out_transaction(pudev, endp_num);
|
|
}
|
|
|
|
/* endpoint disable interrupt */
|
|
if (out_endp_intr & DOEPINTF_EPDIS) {
|
|
USB_DOEPxINTF((uint16_t)endp_num) = DOEPINTF_EPDIS;
|
|
}
|
|
|
|
/* setup phase finished interrupt (just for control endpoints) */
|
|
if (out_endp_intr & DOEPINTF_STPF) {
|
|
/* setup phase is completed */
|
|
usbd_setup_transaction(pudev);
|
|
|
|
USB_DOEPxINTF((uint16_t)endp_num) = DOEPINTF_STPF;
|
|
}
|
|
|
|
/* back to back setup packets received */
|
|
if (out_endp_intr & DOEPINTF_BTBSTP) {
|
|
USB_DOEPxINTF((uint16_t)endp_num) = DOEPINTF_BTBSTP;
|
|
}
|
|
}
|
|
|
|
endp_num ++;
|
|
endp_intr >>= 1;
|
|
}
|
|
|
|
return 1U;
|
|
}
|
|
|
|
/*!
|
|
\brief indicates that an in endpoint has a pending interrupt
|
|
\param[in] pudev: pointer to usb device instance
|
|
\param[out] none
|
|
\retval operation status
|
|
*/
|
|
static uint32_t usbd_intf_inep(usb_core_handle_struct *pudev)
|
|
{
|
|
uint8_t endp_num = 0U;
|
|
uint32_t endp_intr = 0U;
|
|
|
|
__IO uint32_t in_endp_intr = 0U;
|
|
|
|
/* get all in endpoints which have interrupts */
|
|
USB_DAIEP_INTR_READ(endp_intr);
|
|
|
|
while (endp_intr) {
|
|
if (endp_intr & 0x1U) {
|
|
USB_DIEP_INTR_READ(in_endp_intr, (uint16_t)endp_num);
|
|
|
|
if (in_endp_intr & DIEPINTF_TF) {
|
|
/* disable the fifo empty interrupt for the endpoint */
|
|
USB_DIEPFEINTEN &= ~(0x1U << endp_num);
|
|
|
|
USB_DIEPxINTF((uint16_t)endp_num) = DIEPINTF_TF;
|
|
|
|
/* data transmittion is completed */
|
|
usbd_in_transaction(pudev, endp_num);
|
|
}
|
|
|
|
if (in_endp_intr & DIEPINTF_CITO) {
|
|
USB_DIEPxINTF((uint16_t)endp_num) = DIEPINTF_CITO;
|
|
}
|
|
|
|
if (in_endp_intr & DIEPINTF_IEPNE) {
|
|
USB_DIEPxINTF((uint16_t)endp_num) = DIEPINTF_IEPNE;
|
|
}
|
|
|
|
if (in_endp_intr & DIEPINTF_EPDIS) {
|
|
USB_DIEPxINTF((uint16_t)endp_num) = DIEPINTF_EPDIS;
|
|
}
|
|
|
|
if (in_endp_intr & DIEPINTF_TXFE) {
|
|
usbd_emptytxfifo_write(pudev, endp_num);
|
|
USB_DIEPxINTF((uint16_t)endp_num) = DIEPINTF_TXFE;
|
|
}
|
|
}
|
|
|
|
endp_num ++;
|
|
endp_intr >>= 1;
|
|
}
|
|
|
|
return 1U;
|
|
}
|
|
|
|
/*!
|
|
\brief indicates that early suspend state has been detected on the USB
|
|
\param[in] pudev: pointer to usb device instance
|
|
\param[out] none
|
|
\retval operation status
|
|
*/
|
|
static uint32_t usbd_intf_earlysuspend (usb_core_handle_struct *pudev)
|
|
{
|
|
USB_GINTEN &= ~GINTEN_ESPIE;
|
|
USB_GINTF = GINTF_ESP;
|
|
|
|
return 1U;
|
|
}
|
|
|
|
/*!
|
|
\brief indicates that suspend state has been detected on the USB
|
|
\param[in] pudev: pointer to usb device instance
|
|
\param[out] none
|
|
\retval operation status
|
|
*/
|
|
static uint32_t usbd_intf_suspend(usb_core_handle_struct *pudev)
|
|
{
|
|
__IO uint8_t low_power = pudev->cfg.low_power;
|
|
__IO uint8_t suspend = (uint8_t)(USB_DSTAT & DSTAT_SPST);
|
|
__IO uint8_t is_configured = (pudev->dev.status == USB_STATUS_CONFIGURED)? 1U : 0U;
|
|
|
|
pudev->dev.prev_status = pudev->dev.status;
|
|
pudev->dev.status = USB_STATUS_SUSPENDED;
|
|
|
|
if (low_power && suspend && is_configured) {
|
|
/* switch-off the otg clocks */
|
|
USB_PWRCLKCTL |= PWRCLKCTL_SUCLK | PWRCLKCTL_SHCLK;
|
|
|
|
/* enter DEEP_SLEEP mode with LDO in low power mode */
|
|
pmu_to_deepsleepmode(PMU_LDO_LOWPOWER, WFI_CMD);
|
|
}
|
|
|
|
/* clear interrupt */
|
|
USB_GINTF = GINTF_SP;
|
|
|
|
return 1U;
|
|
}
|
|
|
|
/*!
|
|
\brief indicates that the USB controller has detected a resume or remote Wake-up sequence
|
|
\param[in] pudev: pointer to usb device instance
|
|
\param[out] none
|
|
\retval operation status
|
|
*/
|
|
static uint32_t usbd_intf_resume (usb_core_handle_struct *pudev)
|
|
{
|
|
pudev->dev.status = pudev->dev.prev_status;
|
|
pudev->dev.status = USB_STATUS_CONFIGURED;
|
|
|
|
/* clear interrupt */
|
|
USB_GINTF = GINTF_WKUPIF;
|
|
|
|
return 1U;
|
|
}
|
|
|
|
/*!
|
|
\brief handle the SOF interrupts
|
|
\param[in] pudev: pointer to usb device instance
|
|
\param[out] none
|
|
\retval operation status
|
|
*/
|
|
static uint32_t usbd_intf_sof(usb_core_handle_struct *pudev)
|
|
{
|
|
if (NULL != usbd_int_fops) {
|
|
usbd_int_fops->SOF(pudev);
|
|
}
|
|
|
|
USB_GINTF = GINTF_SOF;
|
|
|
|
return 1U;
|
|
}
|
|
|
|
/*!
|
|
\brief handle the rx status queue level interrupt
|
|
\param[in] pudev: pointer to usb device instance
|
|
\param[out] none
|
|
\retval operation status
|
|
*/
|
|
static uint32_t usbd_intf_rxfifo (usb_core_handle_struct *pudev)
|
|
{
|
|
usb_ep_struct *ep;
|
|
uint8_t data_pid = 0U, endp_num = 0U;
|
|
uint32_t bcount = 0U, packet_num = 0U;
|
|
|
|
/* get the status from the top of the fifo (must be read to a variable) */
|
|
__IO uint32_t rx_status = USB_GRSTATP;
|
|
|
|
/* disable the rx fifo non-empty interrupt */
|
|
USB_GINTEN &= ~GINTEN_RXFNEIE;
|
|
|
|
endp_num = (uint8_t)(rx_status & GRSTATRP_EPNUM);
|
|
bcount = (rx_status & GRSTATRP_BCOUNT) >> 4U;
|
|
data_pid = (uint8_t)((rx_status & GRSTATRP_DPID) >> 15U);
|
|
|
|
/* ensure no-DMA mode can work */
|
|
packet_num = USB_DOEPxLEN((uint16_t)endp_num) & DEPLEN_PCNT;
|
|
if ((1U == endp_num) && (0U == packet_num)) {
|
|
uint32_t devepctl = USB_DOEPxCTL((uint16_t)endp_num);
|
|
|
|
devepctl |= DEPCTL_SNAK;
|
|
devepctl &= ~DEPCTL_EPEN;
|
|
devepctl &= ~DEPCTL_EPD;
|
|
|
|
USB_DOEPxCTL((uint16_t)endp_num) = devepctl;
|
|
}
|
|
|
|
ep = &pudev->dev.out_ep[endp_num];
|
|
|
|
switch ((rx_status & GRSTATRP_RPCKST) >> 17U) {
|
|
case RXSTAT_GOUT_NAK:
|
|
break;
|
|
case RXSTAT_DATA_UPDT:
|
|
if (bcount > 0U) {
|
|
usb_fifo_read(ep->xfer_buff, (uint16_t)bcount);
|
|
ep->xfer_buff += bcount;
|
|
ep->xfer_count += bcount;
|
|
}
|
|
break;
|
|
case RXSTAT_XFER_COMP:
|
|
break;
|
|
case RXSTAT_SETUP_COMP:
|
|
break;
|
|
case RXSTAT_SETUP_UPDT:
|
|
*(uint32_t *)0x5000081CU |= 0x00020000U;
|
|
if ((0U == endp_num) && (8U == bcount) && (DPID_DATA0 == data_pid)) {
|
|
/* copy the setup packet received in fifo into the setup buffer in ram */
|
|
usb_fifo_read(pudev->dev.setup_packet, 8U);
|
|
|
|
ep->xfer_count += bcount;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* enable the rx fifo non-empty interrupt */
|
|
USB_GINTEN |= GINTEN_RXFNEIE;
|
|
|
|
return 1U;
|
|
}
|
|
|
|
/*!
|
|
\brief handle USB reset interrupt
|
|
\param[in] pudev: pointer to usb device instance
|
|
\param[out] none
|
|
\retval status
|
|
*/
|
|
static uint32_t usbd_intf_reset(usb_core_handle_struct *pudev)
|
|
{
|
|
uint8_t i = 0U;
|
|
usb_ep_struct *ep;
|
|
|
|
/* clear the remote wakeup signaling */
|
|
USB_DCTL &= ~DCTL_RWKUP;
|
|
|
|
/* flush the tx fifo */
|
|
usb_txfifo_flush(pudev, 0U);
|
|
|
|
for (i = 0U; i < pudev->cfg.dev_endp_num; i++) {
|
|
USB_DIEPxINTF((uint16_t)i) = 0xFFU;
|
|
USB_DOEPxINTF((uint16_t)i) = 0xFFU;
|
|
}
|
|
|
|
/* clear all pending device endpoint interrupts */
|
|
USB_DAEPINT = 0xFFFFFFFFU;
|
|
|
|
/* enable endpoint 0 interrupts */
|
|
USB_DAEPINTEN &= ~DAEPINTEN_OEPIE;
|
|
USB_DAEPINTEN &= ~DAEPINTEN_IEPIE;
|
|
USB_DAEPINTEN = (1U << 16) | 1U;
|
|
|
|
/* enable out endpoint interrupts */
|
|
USB_DOEPINTEN = DOEPINTEN_STPFEN | DOEPINTEN_TFEN | DOEPINTEN_EPDISEN;
|
|
|
|
/* enable in endpoint interrupts */
|
|
USB_DIEPINTEN = DIEPINTEN_TFEN | DIEPINTEN_CITOEN | DIEPINTEN_EPDISEN;
|
|
|
|
/* reset device address */
|
|
USB_DCFG &= ~DCFG_DAR;
|
|
USB_DCFG |= 0U << 4U;
|
|
|
|
/* configure endpoint 0 to receive setup packets */
|
|
usb_ep0_startout(pudev);
|
|
|
|
/* clear usb reset interrupt */
|
|
USB_GINTF = GINTF_RST;
|
|
|
|
/* open EP0 IN */
|
|
ep = &pudev->dev.in_ep[0];
|
|
|
|
USB_DIEPxCTL(0U) &= ~DEP0CTL_MPL;
|
|
USB_DIEPxCTL(0U) &= ~DEPCTL_EPTYPE;
|
|
USB_DIEPxCTL(0U) &= ~DIEPCTL_TXFNUM;
|
|
|
|
if (!(USB_DIEPxCTL(0U) & DEP0CTL_EPACT)) {
|
|
USB_DIEPxCTL(0U) |= USB_MAX_EP0_SIZE;
|
|
USB_DIEPxCTL(0U) |= (USB_EPTYPE_CTRL << 18U);
|
|
USB_DIEPxCTL(0U) |= DEP0CTL_EPACT;
|
|
}
|
|
|
|
ep->endp_mps = USB_MAX_EP0_SIZE;
|
|
ep->endp_type = USB_EPTYPE_CTRL;
|
|
|
|
/* open EP0 OUT */
|
|
ep = &pudev->dev.out_ep[0];
|
|
|
|
USB_DOEPxCTL(0U) &= ~DEP0CTL_MPL;
|
|
USB_DOEPxCTL(0U) &= ~DEPCTL_EPTYPE;
|
|
|
|
if (!(USB_DOEPxCTL(0U) & DEP0CTL_EPACT)) {
|
|
USB_DOEPxCTL(0U) |= USB_MAX_EP0_SIZE;
|
|
USB_DOEPxCTL(0U) |= (USB_EPTYPE_CTRL << 18U);
|
|
USB_DOEPxCTL(0U) |= DEP0CTL_EPACT;
|
|
}
|
|
|
|
ep->endp_mps = USB_MAX_EP0_SIZE;
|
|
ep->endp_type = USB_EPTYPE_CTRL;
|
|
|
|
pudev->dev.status = USB_STATUS_DEFAULT;
|
|
|
|
return 1U;
|
|
}
|
|
|
|
/*!
|
|
\brief handle enumeration finish interrupt
|
|
\param[in] pudev: pointer to usb device instance
|
|
\param[out] none
|
|
\retval status
|
|
*/
|
|
static uint32_t usbd_intf_enumfinish(usb_core_handle_struct *pudev)
|
|
{
|
|
uint8_t enum_speed = (uint8_t)((USB_DSTAT & DSTAT_ES) >> 1U);
|
|
|
|
/* set the max packet size of devie in endpoint based on the enumeration speed */
|
|
USB_DIEPxCTL(0U) |= EP0_MAXLEN[enum_speed];
|
|
|
|
/* clear global in NAK */
|
|
USB_DCTL &= ~DCTL_CGINAK;
|
|
USB_DCTL |= DCTL_CGINAK;
|
|
|
|
/* set USB turn-around time based on device speed and PHY interface */
|
|
if (USB_SPEED_HIGH == USB_SPEED[enum_speed]) {
|
|
pudev->cfg.core_speed = USB_CORE_SPEED_HIGH;
|
|
pudev->cfg.max_packet_size = USBHS_MAX_PACKET_SIZE;
|
|
|
|
USB_GUSBCS &= ~GUSBCS_UTT;
|
|
USB_GUSBCS |= 0x09U << 10;
|
|
} else {
|
|
pudev->cfg.core_speed = USB_CORE_SPEED_FULL;
|
|
pudev->cfg.max_packet_size = USBFS_MAX_PACKET_SIZE;
|
|
|
|
USB_GUSBCS &= ~GUSBCS_UTT;
|
|
USB_GUSBCS |= 0x05U << 10;
|
|
}
|
|
|
|
/* clear interrupt */
|
|
USB_GINTF = GINTF_ENUMF;
|
|
|
|
return 1U;
|
|
}
|
|
|
|
/*!
|
|
\brief handle the ISO in incomplete interrupt
|
|
\param[in] pudev: pointer to usb device instance
|
|
\param[out] none
|
|
\retval status
|
|
*/
|
|
static uint32_t usbd_intf_isoinincomplete(usb_core_handle_struct *pudev)
|
|
{
|
|
|
|
/* clear interrupt */
|
|
USB_GINTF = GINTF_ISOINCIF;
|
|
|
|
return 1U;
|
|
}
|
|
|
|
/*!
|
|
\brief handle the ISO OUT incomplete interrupt
|
|
\param[in] pudev: pointer to usb device instance
|
|
\param[out] none
|
|
\retval status
|
|
*/
|
|
static uint32_t usbd_intf_isooutincomplete(usb_core_handle_struct *pudev)
|
|
{
|
|
/* clear interrupt */
|
|
USB_GINTF = GINTF_ISOONCIF;
|
|
|
|
return 1U;
|
|
}
|
|
|
|
/*!
|
|
\brief check FIFO for the next packet to be loaded
|
|
\param[in] pudev: pointer to usb device instance
|
|
\param[in] ep_id: endpoint identifier which is in (0..3)
|
|
\param[out] none
|
|
\retval status
|
|
*/
|
|
static uint32_t usbd_emptytxfifo_write(usb_core_handle_struct *pudev, uint8_t ep_num)
|
|
{
|
|
uint32_t len = 0U, word_len = 0U, fifo_empty_mask = 0U;
|
|
usb_ep_struct *ep;
|
|
|
|
ep = &pudev->dev.in_ep[ep_num];
|
|
len = ep->xfer_len - ep->xfer_count;
|
|
|
|
if (len > ep->endp_mps) {
|
|
len = ep->endp_mps;
|
|
}
|
|
|
|
word_len = (len + 3U) / 4U;
|
|
|
|
while (((USB_DIEPxTFSTAT((uint16_t)ep_num) & DIEPTFSTAT_IEPTFS) > word_len) &&
|
|
(ep->xfer_count < ep->xfer_len)) {
|
|
/* write the FIFO */
|
|
len = ep->xfer_len - ep->xfer_count;
|
|
|
|
if (len > ep->endp_mps) {
|
|
len = ep->endp_mps;
|
|
}
|
|
|
|
word_len = (len + 3U) / 4U;
|
|
|
|
usb_fifo_write (ep->xfer_buff, ep_num, (uint16_t)len);
|
|
|
|
ep->xfer_buff += len;
|
|
ep->xfer_count += len;
|
|
|
|
if(ep->xfer_len == ep->xfer_count) {
|
|
fifo_empty_mask = 0x1U << ep_num;
|
|
USB_DIEPFEINTEN &= ~fifo_empty_mask;
|
|
}
|
|
}
|
|
|
|
return 1U;
|
|
}
|
|
|
|
#ifdef VBUS_SENSING_ENABLED
|
|
|
|
/*!
|
|
\brief indicates that the USB_OTG controller has detected a connection
|
|
\param[in] pudev: pointer to usb device instance
|
|
\param[out] none
|
|
\retval status
|
|
*/
|
|
static uint32_t usbd_intf_sessionrequest(usb_core_handle_struct *pudev)
|
|
{
|
|
pudev->dev.connection_status = 1U;
|
|
|
|
/* clear the interrupt bit */
|
|
USB_GINTF = GINTF_SESIF;
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*!
|
|
\brief indicates that the USB_OTG controller has detected an OTG event
|
|
\param[in] pudev: pointer to usb device instance
|
|
\param[out] none
|
|
\retval status
|
|
*/
|
|
static uint32_t usbd_intf_otg(usb_core_handle_struct *pudev)
|
|
{
|
|
if (USB_GOTGINTF & GOTGINTF_SESEND) {
|
|
pudev->dev.class_deinit(pudev, 0);
|
|
pudev->dev.connection_status = 0;
|
|
}
|
|
|
|
/* clear OTG interrupt */
|
|
USB_GOTGINTF |= GOTGINTF_SESEND;
|
|
|
|
return 1;
|
|
}
|
|
|
|
#endif /* VBUS_SENSING_ENABLED */
|