Example #1
0
void USBD_SetStallEP(uint32_t EPNum)
{
    if (EPNum & 0x80) {
        EPNum &= 0x7F;
        ENDPTCTRL(EPNum) |= (1UL << 16);    /* IN endpoint stall */
    } else {
        ENDPTCTRL(EPNum) |= (1UL << 0);     /* OUT endpoint stall */
    }
}
Example #2
0
void USBD_EnableEP(uint32_t EPNum)
{
    if (EPNum & 0x80) {
        EPNum &= 0x7F;
        ENDPTCTRL(EPNum) |= (1UL << 23);    /* EP enabled */
    } else {
        ENDPTCTRL(EPNum) |= (1UL << 7);     /* EP enabled */
    }
}
Example #3
0
void USBD_DisableEP(uint32_t EPNum)
{
    if (EPNum & 0x80) {
        EPNum &= 0x7F;
        ENDPTCTRL(EPNum) &= ~(1UL << 23);   /* EP disabled */
    } else {
        ENDPTCTRL(EPNum)     &= ~(1UL << 7); /* EP disabled */
    }
}
Example #4
0
void USBD_EnableEP (uint32_t EPNum) {
  if (EPNum & 0x80) {
    EPNum &= 0x7F;
    ENDPTCTRL(EPNum) |= (1UL << 23);    /* EP enabled                         */
  }
  else {
    ENDPTCTRL(EPNum) |= (1UL << 7 );    /* EP enabled                         */
    LPC_USB0->ENDPTNAK    = (1UL << EPNum);
    LPC_USB0->ENDPTNAKEN |= (1UL << EPNum);
  }
}
void USBD_ClrStallEP (uint32_t EPNum) {
  if (EPNum & 0x80) {
    EPNum &= 0x7F;
    ENDPTCTRL(EPNum) &= ~(1UL << 16);   /* clear stall                        */
    ENDPTCTRL(EPNum) |=  (1UL << 22);   /* data toggle reset                  */
    while (ENDPTCTRL(EPNum) & (1UL << 16));
    USBD_ResetEP(EPNum | 0x80);
  }
  else {
    ENDPTCTRL(EPNum) &= ~(1UL << 0 );   /* clear stall                        */
    ENDPTCTRL(EPNum) |=  (1UL << 6 );   /* data toggle reset                  */
  }
}
Example #6
0
void USBD_ResetEP (uint32_t EPNum) {
  if (EPNum & 0x80) {
    EPNum &= 0x7F;
    EPQHx[EP_IN_IDX(EPNum)].dTD_token &= 0xC0;
    LPC_USB0->ENDPTFLUSH = (1UL << (EPNum + 16));  /* flush endpoint          */
    while (LPC_USB0->ENDPTFLUSH & (1UL << (EPNum + 16)));
    ENDPTCTRL(EPNum) |= (1UL << 22);    /* data toggle reset                  */
  }
  else {
    EPQHx[EP_OUT_IDX(EPNum)].dTD_token &= 0xC0;
    LPC_USB0->ENDPTFLUSH = (1UL << EPNum);         /* flush endpoint          */
    while (LPC_USB0->ENDPTFLUSH & (1UL << EPNum));
    ENDPTCTRL(EPNum) |= (1UL << 6 );    /* data toggle reset                  */
  }
} 
Example #7
0
void USBD_ConfigEP(USB_ENDPOINT_DESCRIPTOR *pEPD)
{
    uint32_t num, val, type, idx;

    if ((pEPD->bEndpointAddress & USB_ENDPOINT_DIRECTION_MASK)) {
        val = 16;
        num = pEPD->bEndpointAddress & ~0x80;
        idx = EP_IN_IDX(num);

    } else {
        val = 0;
        num = pEPD->bEndpointAddress;
        idx = EP_OUT_IDX(num);
    }

    type = pEPD->bmAttributes & USB_ENDPOINT_TYPE_MASK;

    if (!(Ep[idx].buf)) {
        Ep[idx].buf          =  &(EPBufPool[BufUsed]);
        Ep[idx].maxPacket    =  pEPD->wMaxPacketSize;
        BufUsed             +=  pEPD->wMaxPacketSize;

        /* Isochronous endpoint */
        if (type == USB_ENDPOINT_TYPE_ISOCHRONOUS) {
            IsoEp |= (1UL << (num + val));
        }
    }

    dTDx[idx].buf[0]    = (uint32_t)(Ep[idx].buf);
    dTDx[idx].next_dTD  =  1;
    EPQHx[idx].cap      = (Ep[idx].maxPacket << 16) |
                          (1UL               << 29);
    ENDPTCTRL(num)  &= ~(0xFFFF << val);
    ENDPTCTRL(num)  |= ((type << 2) << val) |
                       ((1UL  << 6) << val);   /* Data toogle reset */
}
Example #8
0
void USBD_Reset(void)
{
    uint32_t i;
    uint8_t *ptr;
    cmpl_pnd = 0;

    for (i = 1; i < USBD_EP_NUM + 1; i++) {
        ENDPTCTRL(i) &= ~((1UL << 7) | (1UL << 23));
    }

    /* clear interrupts */
    LPC_USBx->ENDPTNAK       = 0xFFFFFFFF;
    LPC_USBx->ENDPTNAKEN     = 0;
    LPC_USBx->USBSTS_D       = 0xFFFFFFFF;
    LPC_USBx->ENDPTSETUPSTAT = LPC_USBx->ENDPTSETUPSTAT;
    LPC_USBx->ENDPTCOMPLETE  = LPC_USBx->ENDPTCOMPLETE;

    while (LPC_USBx->ENDPTPRIME);

    LPC_USBx->ENDPTFLUSH = 0xFFFFFFFF;

    while (LPC_USBx->ENDPTFLUSH);

    LPC_USBx->USBCMD_D &= ~0x00FF0000;    /* immediate intrrupt treshold */
    /* clear endpoint queue heads */
    ptr = (uint8_t *)EPQHx;

    for (i = 0; i < sizeof(EPQHx); i++) {
        ptr[i] = 0;
    }

    /* clear endpoint transfer descriptors */
    ptr = (uint8_t *)dTDx;

    for (i = 0; i < sizeof(dTDx); i++) {
        ptr[i] = 0;
    }

    Ep[EP_OUT_IDX(0)].maxPacket  = USBD_MAX_PACKET0;
    Ep[EP_OUT_IDX(0)].buf        = EPBufPool;
    BufUsed                      = USBD_MAX_PACKET0;
    Ep[EP_IN_IDX(0)].maxPacket   = USBD_MAX_PACKET0;
    Ep[EP_IN_IDX(0)].buf         = &(EPBufPool[BufUsed]);
    BufUsed                     += USBD_MAX_PACKET0;
    dTDx[EP_OUT_IDX(0)].next_dTD = 1;
    dTDx[EP_IN_IDX(0)].next_dTD = 1;
    dTDx[EP_OUT_IDX(0)].dTD_token = (USBD_MAX_PACKET0 << 16) | /* total bytes */
                                    (1UL << 15);               /* int on compl */
    dTDx[EP_IN_IDX(0)].dTD_token = (USBD_MAX_PACKET0 << 16) |  /* total bytes */
                                   (1UL << 15);                /* int on compl */
    EPQHx[EP_OUT_IDX(0)].next_dTD = (uint32_t) &dTDx[EP_OUT_IDX(0)];
    EPQHx[EP_IN_IDX(0)].next_dTD = (uint32_t) &dTDx[EP_IN_IDX(0)];
    EPQHx[EP_OUT_IDX(0)].cap = ((USBD_MAX_PACKET0 & 0x0EFF) << 16) |
                               (1UL << 29) |
                               (1UL << 15);                    /* int on setup */
    EPQHx[EP_IN_IDX(0)].cap = (USBD_MAX_PACKET0 << 16) |
                              (1UL << 29) |
                              (1UL << 15);                    /* int on setup */
    LPC_USBx->ENDPOINTLISTADDR = (uint32_t)EPQHx;
    LPC_USBx->USBMODE_D |= (1UL << 3);    /* Setup lockouts off */
    LPC_USBx->ENDPTCTRL0 = 0x00C000C0;
    USBD_PrimeEp(0, Ep[EP_OUT_IDX(0)].maxPacket);
}