Easyelectronics.ru

extern "C" void OTG_FS_IRQHandler(void)
{
  uint32_t tmp32;

  if(USB_OTG_GLOBAL->GINTSTS & USB_OTG_GINTMSK_USBRST)  // возникло прерывание RESET
  {     
    SEGGER_RTT_printf(0, "Interrupt USBRST\r\n");
    usb.Enumerate_Reset();       
    return;
  }
 
  if(USB_OTG_GLOBAL->GINTSTS & USB_OTG_GINTMSK_ENUMDNE)
  {
    SEGGER_RTT_printf(0, "Interrupt ENUMDNE\r\n");
    USB_GINTSTS_CLEAR_FLAGS(USB_OTG_GINTMSK_ENUMDNE);
    USB_OTG_GLOBAL->GUSBCFG |= USB_OTG_GUSBCFG_TRDT(5);   
    USB_OTG_GLOBAL->GINTMSK |= USB_OTG_GINTMSK_RXFLVL | USB_OTG_GINTMSK_IEPINT | USB_OTG_GINTMSK_OEPINT;
    return;
  }
 
  if(USB_OTG_GLOBAL->GINTSTS & USB_OTG_GINTMSK_IEPINT)
  {
    uint32_t epnums  = USB_OTG_DEVICE->DAINT;
    uint32_t epint;
    epnums &= USB_OTG_DEVICE->DAINTMSK;   
    SEGGER_RTT_printf(0, "Interrupt IEPINT ");   
    if( epnums & 0x0001)
    { //EP0 IEPINT     
      epint = USB_OTG_INEP(0)->DIEPINT;
      epint &= USB_OTG_DEVICE->DIEPMSK;
     
      if(epint & USB_OTG_DIEPINT_XFRC)
      {
        SEGGER_RTT_printf(0, "XFRC\r\n");
        if( usb.Get_TX_Q_cnt(0)) usb.EP_TX_Q(0);
        else
        {
          USB_OTG_OUTEP(0)->DOEPCTL |= (USB_OTG_DOEPCTL_CNAK | USB_OTG_DOEPCTL_EPENA);
        }
      }
      if(epint & USB_OTG_DIEPINT_TOC)
      {
        SEGGER_RTT_printf(0, "TOC\r\n");
      }
      if(epint & USB_OTG_DIEPINT_ITTXFE)
      {
        SEGGER_RTT_printf(0, "ITTXFE\r\n");
      }
      if(epint & USB_OTG_DIEPINT_INEPNE)
      {
        SEGGER_RTT_printf(0, "INEPNE\r\n");
      }
      if(( epint & USB_OTG_DIEPINT_EPDISD) == USB_OTG_DIEPINT_EPDISD)
      {
        SEGGER_RTT_printf(0, "EPDISD\r\n");
      }
      if(epint & USB_OTG_DIEPINT_TXFE)
      {
        SEGGER_RTT_printf(0, "TXFE\r\n");       
      }
      USB_OTG_INEP(0)->DIEPINT = epint;
    }
    if( epnums & 0x0002)
    { //EP1 IEPINT
      SEGGER_RTT_printf(0, " EP1\r\n");
      USB_OTG_INEP(1)->DIEPINT = epint;
    }
    if( epnums & 0x0004)
    { //EP2 IEPINT
      SEGGER_RTT_printf(0, " EP2\r\n");
      USB_OTG_INEP(2)->DIEPINT = epint;
    }
   
    USB_GINTSTS_CLEAR_FLAGS(USB_OTG_GINTMSK_IEPINT);
    return;
  }

  if(USB_OTG_GLOBAL->GINTSTS & USB_OTG_GINTMSK_OEPINT)
  {
    uint32_t epnums  = USB_OTG_DEVICE->DAINT;
    uint32_t epint;
    epnums &= USB_OTG_DEVICE->DAINTMSK;
   
    SEGGER_RTT_printf(0, "Interrupt OEPINT ");
   
    if( epnums & 0x00010000)
    { //EP0 OEPINT     
      epint = USB_OTG_OUTEP(0)->DOEPINT;
      epint &= USB_OTG_DEVICE->DOEPMSK;
     
      if(epint & USB_OTG_DOEPINT_XFRC)
      {
        SEGGER_RTT_printf(0, "EP0 XFRC\r\n");
      }
      if(epint & USB_OTG_DOEPINT_STUP)
      {
        SEGGER_RTT_printf(0, "EP0 STUP ");
        usb.Enumerate_Setup();
      }   
      if(epint & USB_OTG_DOEPINT_OTEPDIS)
      {
        SEGGER_RTT_printf(0, "EP0 OTEPDIS\r\n");
      }
      USB_OTG_OUTEP(0)->DOEPINT = epint;
    }
    if( epnums & 0x00020000)
    { //EP1 OEPINT
      SEGGER_RTT_printf(0, " EP1\r\n");
      USB_OTG_OUTEP(1)->DOEPINT = epint;
    }
    if( epnums & 0x00040000)
    { //EP2 OEPINT
      SEGGER_RTT_printf(0, " EP2\r\n");
      USB_OTG_OUTEP(2)->DOEPINT = epint;
    }

    USB_GINTSTS_CLEAR_FLAGS(USB_OTG_GINTMSK_OEPINT);
    return;
  }
 
  if(USB_OTG_GLOBAL->GINTSTS & USB_OTG_GINTMSK_RXFLVL)
  {
   
    tmp32 = USB_OTG_GLOBAL->GRXSTSP;
   
    switch(tmp32 & USB_OTG_GRXSTSP_PKTSTS_Msk)
    {
      case PKTSTS_SETUP_UPDT:  //SETUP data packet received
        SEGGER_RTT_printf(0, "Interrupt RXFLVL SETUP_UPDT\r\n");
        usb.ReadSetupFIFO();
        break;
      case PKTSTS_SETUP_COMP:  //SETUP transaction completed (triggers an interrupt)
        SEGGER_RTT_printf(0, "Interrupt RXFLVL SETUP_COMP\r\n");
        break;
      case PKTSTS_XFER_COMP:   //OUT transfer completed (triggers an interrupt)
        SEGGER_RTT_printf(0, "Interrupt RXFLVL XFER_COMP\r\n");
        break;
      case PKTSTS_DATA_UPDT:   //OUT data packet received
        SEGGER_RTT_printf(0, "Interrupt RXFLVL DATA_UPDT %d\r\n",(tmp32&USB_OTG_GRXSTSP_BCNT_Msk)>>USB_OTG_GRXSTSP_BCNT_Pos);
        break;
      case PKTSTS_GOUT_NAK:    //Global OUT NAK (triggers an interrupt)
        SEGGER_RTT_printf(0, "Interrupt RXFLVL GOUT_NAK\r\n");
        break;
    }
   
    USB_GINTSTS_CLEAR_FLAGS(USB_OTG_GINTMSK_RXFLVL);
    return;
  }
   
//  if(istatus & USB_OTG_GINTMSK_SRQINT)
//  {
//    SEGGER_RTT_printf(0, "Interrupt SRQINT (VBUS On)\r\n");
//    USB_GINTSTS_CLEAR_FLAGS(USB_OTG_GINTMSK_SRQINT);
//  }

 
//  if(istatus & USB_OTG_GINTMSK_OTGINT)
//  {
//    uint32_t ostatus = USB_OTG_GLOBAL->GOTGINT;
//    if(ostatus & USB_OTG_GOTGINT_SEDET)
//      SEGGER_RTT_printf(0, "Interrupt OTGINT (VBUS Off)\r\n");
//    USB_OTG_GLOBAL->GOTGINT = ostatus;
//    USB_GINTSTS_CLEAR_FLAGS(USB_OTG_GINTMSK_OTGINT);
//  }
     
  return;
}

void Endpoint::clearStall()
{
   if (is_in)
   {
      in(num)->DIEPCTL &= ~USB_OTG_DIEPCTL_STALL;
      if (type == EpType::Intr || type == EpType::Bulk)
      {
         in(num)->DIEPCTL |= USB_OTG_DIEPCTL_SD0PID_SEVNFRM;
      }
   }
   else
   {
      out(num)->DOEPCTL &= ~USB_OTG_DOEPCTL_STALL;
      if (type == EpType::Intr || type == EpType::Bulk)
      {
         out(num)->DOEPCTL |= USB_OTG_DOEPCTL_SD0PID_SEVNFRM;
      }
   }
}

USB_OTG_INEndpointTypeDef* Endpoint::in(uint32_t i)
{
   return (USB_OTG_INEndpointTypeDef*)((uint32_t)hpcd->Instance + USB_OTG_IN_ENDPOINT_BASE + i * USB_OTG_EP_REG_SIZE);
}

USB_OTG_OUTEndpointTypeDef* Endpoint::out(uint32_t i)
{
   return (USB_OTG_OUTEndpointTypeDef*)((uint32_t)hpcd->Instance + USB_OTG_OUT_ENDPOINT_BASE + i * USB_OTG_EP_REG_SIZE);
}

UsbStatus Endpoint::clearStall(uint8_t ep_addr)
{
   auto& ep = refInOut(ep_addr);
   ep.is_stall = false;
   ep.num = ep_addr & 0x7F;
   ep.is_in = ep_addr & 0x80;

   if (UsbCdc::lock)  return UsbStatus::Busy;
   UsbCdc::lock = true;

   if (ep.is_in)
   {
      ep.clearTxDTOG();
      ep.setStatus(EpTxStatus::Valid);
   }
   else
   {
      ep.clearRxDTOG();
      ep.setStatus(EpRxStatus::Valid);
   }

   UsbCdc::lock = false;
   return UsbStatus::Ok;
}

volatile uint16_t& epref() const { return *(&USB->EP0R + num * 2); }

Endpoint& Endpoint::refInOut(uint8_t ep_addr)
{
   return (ep_addr & 0x80) ? epin[ep_addr & 0x7F] : epout[ep_addr & 0x7F];
}

void Endpoint::clearTxDTOG() const
{
   if (epref() & USB_EP_DTOG_TX)
   {
      epref() = epref() & USB_EPREG_MASK | USB_EP_CTR_RX | USB_EP_CTR_TX | USB_EP_DTOG_TX;
   }
}

void Endpoint::clearRxDTOG() const
{
   if (epref() & USB_EP_DTOG_RX)
   {
      epref() = epref() & USB_EPREG_MASK | USB_EP_CTR_RX | USB_EP_CTR_TX | USB_EP_DTOG_RX;
   }
}

void Endpoint::setStatus(EpTxStatus state) const
{
   uint16_t regVal = epref() & USB_EPTX_DTOGMASK;
   if (USB_EPTX_DTOG1 & uint32_t(state))  regVal ^= USB_EPTX_DTOG1;
   if (USB_EPTX_DTOG2 & uint32_t(state))  regVal ^= USB_EPTX_DTOG2;
   epref() = regVal | USB_EP_CTR_RX | USB_EP_CTR_TX;
}

void Endpoint::setStatus(EpRxStatus state) const
{
   uint16_t regVal = epref() & USB_EPRX_DTOGMASK;
   if (USB_EPRX_DTOG1 & uint32_t(state))  regVal ^= USB_EPRX_DTOG1;
   if (USB_EPRX_DTOG2 & uint32_t(state))  regVal ^= USB_EPRX_DTOG2;
   epref() = regVal | USB_EP_CTR_RX | USB_EP_CTR_TX;
}