Ejemplo n.º 1
0
void USB_LP_CAN1_RX0_IRQHandler(void) {
  U32 istr, num, val;

  istr = ISTR;

  /* USB Reset Request                                                        */
  if (istr & ISTR_RESET) {
    USBD_Reset();
    usbd_reset_core();
#ifdef __RTX
    if (USBD_RTX_DevTask) {
      isr_evt_set(USBD_EVT_RESET, USBD_RTX_DevTask);
    }
#else
    if (USBD_P_Reset_Event) {
      USBD_P_Reset_Event();
    }
#endif
    ISTR = ~ISTR_RESET;
  }

  /* USB Suspend Request                                                      */
  if (istr & ISTR_SUSP) {
    USBD_Suspend();
#ifdef __RTX
    if (USBD_RTX_DevTask) {
      isr_evt_set(USBD_EVT_SUSPEND, USBD_RTX_DevTask);
    }
#else
    if (USBD_P_Suspend_Event) {
      USBD_P_Suspend_Event();
    }
#endif
    ISTR = ~ISTR_SUSP;
  }

  /* USB Wakeup                                                               */
  if (istr & ISTR_WKUP) {
    USBD_WakeUp();
#ifdef __RTX
    if (USBD_RTX_DevTask) {
      isr_evt_set(USBD_EVT_RESUME,  USBD_RTX_DevTask);
    }
#else
    if (USBD_P_Resume_Event) {
      USBD_P_Resume_Event();
    }
#endif
    ISTR = ~ISTR_WKUP;
  }

  /* Start of Frame                                                           */
  if (istr & ISTR_SOF) {
#ifdef __RTX
    if (USBD_RTX_DevTask) {
      isr_evt_set(USBD_EVT_SOF, USBD_RTX_DevTask);
    }
#else
    if (USBD_P_SOF_Event) {
      USBD_P_SOF_Event();
    }
#endif
    ISTR = ~ISTR_SOF;
  }

  /* PMA Over/underrun                                                        */
  if (istr & ISTR_PMAOVR) {
#ifdef __RTX
    LastError = 2;
    if (USBD_RTX_DevTask) {
      isr_evt_set(USBD_EVT_ERROR, USBD_RTX_DevTask);
    }
#else
    if (USBD_P_Error_Event) {
      USBD_P_Error_Event(2);
    }
#endif
    ISTR = ~ISTR_PMAOVR;
  }

  /* Error: No Answer, CRC Error, Bit Stuff Error, Frame Format Error         */
  if (istr & ISTR_ERR) {
#ifdef __RTX
    LastError = 1;
    if (USBD_RTX_DevTask) {
      isr_evt_set(USBD_EVT_ERROR, USBD_RTX_DevTask);
    }
#else
    if (USBD_P_Error_Event) {
      USBD_P_Error_Event(1);
    }
#endif
    ISTR = ~ISTR_ERR;
  }

  /* Endpoint Interrupts                                                      */
  while ((istr = ISTR) & ISTR_CTR) {
    ISTR = ~ISTR_CTR;

    num = istr & ISTR_EP_ID;

    val = EPxREG(num);
    if (val & EP_CTR_RX) {
      EPxREG(num) = val & ~EP_CTR_RX & EP_MASK;
#ifdef __RTX
      if (USBD_RTX_EPTask[num]) {
        isr_evt_set((val & EP_SETUP) ? USBD_EVT_SETUP : USBD_EVT_OUT, USBD_RTX_EPTask[num]);
      }
#else
      if (USBD_P_EP[num]) {
        USBD_P_EP[num]((val & EP_SETUP) ? USBD_EVT_SETUP : USBD_EVT_OUT);
      }
#endif
    }
    if (val & EP_CTR_TX) {
      EPxREG(num) = val & ~EP_CTR_TX & EP_MASK;
#ifdef __RTX
      if (USBD_RTX_EPTask[num]) {
        isr_evt_set(USBD_EVT_IN,  USBD_RTX_EPTask[num]);
      }
#else
      if (USBD_P_EP[num]) {
        USBD_P_EP[num](USBD_EVT_IN);
      }
#endif
    }
  }

}
Ejemplo n.º 2
0
void USBD_Handler(void)
{
    uint32_t irq_flags;
    unsigned int ep;
    uint32_t ep_int, mask;

    // Read and clear interrupts
    irq_flags = MXC_USB->dev_intfl;
    MXC_USB->dev_intfl = irq_flags;

    /* reset interrupt */
    if (irq_flags & MXC_F_USB_DEV_INTFL_BRST) {
        if (suspended) {
            suspended = 0;
#ifdef __RTX
            if (USBD_RTX_DevTask) {
                isr_evt_set(USBD_EVT_RESUME, USBD_RTX_DevTask);
            }
#else
            if (USBD_P_Resume_Event) {
                USBD_P_Resume_Event();
            }
#endif
        }

        reset_state();
        usbd_reset_core();

#ifdef __RTX
        if (USBD_RTX_DevTask) {
            isr_evt_set(USBD_EVT_RESET, USBD_RTX_DevTask);
        }
#else
        if (USBD_P_Reset_Event) {
            USBD_P_Reset_Event();
        }
#endif

    }

    /* reset done interrupt */
    if (irq_flags & MXC_F_USB_DEV_INTFL_BRST_DN) {
        reset_state();
    }

    /* suspend interrupt */
    if (irq_flags & MXC_F_USB_DEV_INTFL_SUSP) {
        suspended = 1;
#ifdef __RTX
        if (USBD_RTX_DevTask) {
            isr_evt_set(USBD_EVT_SUSPEND, USBD_RTX_DevTask);
        }
#else
        if (USBD_P_Suspend_Event) {
            USBD_P_Suspend_Event();
        }
#endif
    }

    if (irq_flags & MXC_F_USB_DEV_INTFL_VBUS) {
#ifdef __RTX
        if (USBD_RTX_DevTask) {
            isr_evt_set(USBD_EVT_POWER_ON,  USBD_RTX_DevTask);
        }
#else
        if (USBD_P_Power_Event) {
            USBD_P_Power_Event(1);
        }
#endif
    }

    if (irq_flags & MXC_F_USB_DEV_INTFL_NO_VBUS) {
#ifdef __RTX
        if (USBD_RTX_DevTask) {
            isr_evt_set(USBD_EVT_POWER_OFF, USBD_RTX_DevTask);
        }
#else
        if (USBD_P_Power_Event) {
            USBD_P_Power_Event(0);
        }
#endif
    }

    if (irq_flags & MXC_F_USB_DEV_INTFL_SETUP) {
        setup_waiting = 1;
#ifdef __RTX
        if (USBD_RTX_EPTask[0]) {
            isr_evt_set(USBD_EVT_SETUP, USBD_RTX_EPTask[0]);
        }
#else
        if (USBD_P_EP[0]) {
            USBD_P_EP[0](USBD_EVT_SETUP);
        }
#endif
    }

    if (irq_flags & MXC_F_USB_DEV_INTFL_EP_IN) {

        // Read and clear endpoint interrupts
        ep_int = MXC_USB->in_int;
        MXC_USB->in_int = ep_int;

        mask = 1;
        for (ep = 0; ep < MXC_USB_NUM_EP; ep++) {
            if (ep_int & mask) {
#ifdef __RTX
                if (USBD_RTX_EPTask[ep]) {
                    isr_evt_set(USBD_EVT_IN,  USBD_RTX_EPTask[ep]);
                }
#else
                if (USBD_P_EP[ep]) {
                    USBD_P_EP[ep](USBD_EVT_IN);
                }
#endif
            }

            mask <<= 1;
        }
    }

    if (irq_flags & MXC_F_USB_DEV_INTFL_EP_OUT) {

        // Read and clear endpoint interrupts
        ep_int = MXC_USB->out_int;
        MXC_USB->out_int = ep_int;

        mask = 1;
        for (ep = 0; ep < MXC_USB_NUM_EP; ep++) {
            if (ep_int & mask) {
#ifdef __RTX
                if (USBD_RTX_EPTask[ep]) {
                    isr_evt_set(USBD_EVT_OUT, USBD_RTX_EPTask[ep]);
                }
#else
                if (USBD_P_EP[ep]) {
                    USBD_P_EP[ep](USBD_EVT_OUT);
                }
#endif
            }

            mask <<= 1;
        }
    }

    if (irq_flags & MXC_F_USB_DEV_INTFL_DMA_ERR) {
        // Read and clear endpoint interrupts
        ep_int = MXC_USB->dma_err_int;
        MXC_USB->dma_err_int = ep_int;
        while(1); // not recoverable
    }

    NVIC_EnableIRQ(USB_IRQn);

}