new_cmsis/usb/hw.c

   1 /*----------------------------------------------------------------------------
   2  *      U S B  -  K e r n e l
   3  *----------------------------------------------------------------------------
   4  * Name:    usbhw.c
   5  * Purpose: USB Hardware Layer Module for NXP's LPC17xx MCU
   6  * Version: V1.20
   7  *----------------------------------------------------------------------------
   8  *      This software is supplied "AS IS" without any warranties, express,
   9  *      implied or statutory, including but not limited to the implied
  10  *      warranties of fitness for purpose, satisfactory quality and
  11  *      noninfringement. Keil extends you a royalty-free right to reproduce
  12  *      and distribute executable files created using this software for use
  13  *      on NXP Semiconductors LPC family microcontroller devices only. Nothing
  14  *      else gives you the right to use this software.
  15  *
  16  * Copyright (c) 2009 Keil - An ARM Company. All rights reserved.
  17  *----------------------------------------------------------------------------
  18  * History:
  19  *          V1.20 Added USB_ClearEPBuf
  20  *          V1.00 Initial Version
  21  *----------------------------------------------------------------------------*/
  22 #include <board.h>                        /* LPC17xx definitions */
  23 #include "usb.h"
  24 #include "cfg.h"
  25 #include "reg.h"
  26 #include "hw.h"
  27 #include "core.h"
  28 #include "user.h"
  29
  30 #if defined (  __CC_ARM__  )
  31 #pragma diag_suppress 1441
  32 #endif
  33
  34
  35 #define EP_MSK_CTRL 0x0001      /* Control Endpoint Logical Address Mask */
  36 #define EP_MSK_BULK 0xC924      /* Bulk Endpoint Logical Address Mask */
  37 #define EP_MSK_INT  0x4492      /* Interrupt Endpoint Logical Address Mask */
  38 #define EP_MSK_ISO  0x1248      /* Isochronous Endpoint Logical Address Mask */
  39
  40
  41 #if USB_DMA
  42
  43 #pragma arm section zidata = "USB_RAM"
  44 uint32_t UDCA[USB_EP_NUM];                     /* UDCA in USB RAM */
  45 uint32_t DD_NISO_Mem[4*DD_NISO_CNT];           /* Non-Iso DMA Descriptor Memory */
  46 uint32_t DD_ISO_Mem [5*DD_ISO_CNT];            /* Iso DMA Descriptor Memory */
  47 #pragma arm section zidata
  48 uint32_t udca[USB_EP_NUM];                     /* UDCA saved values */
  49
  50 uint32_t DDMemMap[2];                          /* DMA Descriptor Memory Usage */
  51
  52 #endif
  53
  54
  55 /*
  56  *  Get Endpoint Physical Address
  57  *    Parameters:      EPNum: Endpoint Number
  58  *                       EPNum.0..3: Address
  59  *                       EPNum.7:    Dir
  60  *    Return Value:    Endpoint Physical Address
  61  */
  62
  63 uint32_t EPAdr (uint32_t EPNum) {
  64   uint32_t val;
  65
  66   val = (EPNum & 0x0F) << 1;
  67   if (EPNum & 0x80) {
  68     val += 1;
  69   }
  70   return (val);
  71 }
  72
  73
  74 /*
  75  *  Write Command
  76  *    Parameters:      cmd:   Command
  77  *    Return Value:    None
  78  */
  79
  80 void WrCmd (uint32_t cmd) {
  81
  82   USB->USBDevIntClr = CCEMTY_INT;
  83   USB->USBCmdCode = cmd;
  84   while ((USB->USBDevIntSt & CCEMTY_INT) == 0);
  85 }
  86
  87
  88 /*
  89  *  Write Command Data
  90  *    Parameters:      cmd:   Command
  91  *                     val:   Data
  92  *    Return Value:    None
  93  */
  94
  95 void WrCmdDat (uint32_t cmd, uint32_t val) {
  96
  97   USB->USBDevIntClr = CCEMTY_INT;
  98   USB->USBCmdCode = cmd;
  99   while ((USB->USBDevIntSt & CCEMTY_INT) == 0);
 100   USB->USBDevIntClr = CCEMTY_INT;
 101   USB->USBCmdCode = val;
 102   while ((USB->USBDevIntSt & CCEMTY_INT) == 0);
 103 }
 104
 105
 106 /*
 107  *  Write Command to Endpoint
 108  *    Parameters:      cmd:   Command
 109  *                     val:   Data
 110  *    Return Value:    None
 111  */
 112
 113 void WrCmdEP (uint32_t EPNum, uint32_t cmd){
 114
 115   USB->USBDevIntClr = CCEMTY_INT;
 116   USB->USBCmdCode = CMD_SEL_EP(EPAdr(EPNum));
 117   while ((USB->USBDevIntSt & CCEMTY_INT) == 0);
 118   USB->USBDevIntClr = CCEMTY_INT;
 119   USB->USBCmdCode = cmd;
 120   while ((USB->USBDevIntSt & CCEMTY_INT) == 0);
 121 }
 122
 123
 124 /*
 125  *  Read Command Data
 126  *    Parameters:      cmd:   Command
 127  *    Return Value:    Data Value
 128  */
 129
 130 uint32_t RdCmdDat (uint32_t cmd) {
 131
 132   USB->USBDevIntClr = CCEMTY_INT | CDFULL_INT;
 133   USB->USBCmdCode = cmd;
 134   while ((USB->USBDevIntSt & CDFULL_INT) == 0);
 135   return (USB->USBCmdData);
 136 }
 137
 138
 139 /*
 140  *  USB Initialize Function
 141  *   Called by the User to initialize USB
 142  *    Return Value:    None
 143  */
 144
 145 void USB_Init (void) {
 146
 147   PINCON->PINSEL1 &= ~((3<<26)|(3<<28));   /* P0.29 D+, P0.30 D- */
 148   PINCON->PINSEL1 |=  ((1<<26)|(1<<28));   /* PINSEL1 26.27, 28.29  = 01 */
 149
 150   PINCON->PINSEL3 &= ~((3<< 4)|(3<<28));   /* P1.18 GoodLink, P1.30 VBUS */
 151   PINCON->PINSEL3 |=  ((1<< 4)|(2<<28));   /* PINSEL3 4.5 = 01, 28.29 = 10 */
 152
 153   PINCON->PINSEL4 &= ~((3<<18)        );   /* P2.9 SoftConnect */
 154   PINCON->PINSEL4 |=  ((1<<18)        );   /* PINSEL4 18.19 = 01 */
 155
 156   SC->PCONP |= (1UL<<31);                /* USB PCLK -> enable USB Per.       */
 157
 158   USB->USBClkCtrl = 0x1A;                /* Dev, PortSel, AHB clock enable */
 159   while ((USB->USBClkSt & 0x1A) != 0x1A);
 160
 161   NVIC_EnableIRQ(USB_IRQn);               /* enable USB interrupt */
 162
 163   USB_Reset();
 164   USB_SetAddress(0);
 165 }
 166
 167
 168 /*
 169  *  USB Connect Function
 170  *   Called by the User to Connect/Disconnect USB
 171  *    Parameters:      con:   Connect/Disconnect
 172  *    Return Value:    None
 173  */
 174
 175 void USB_Connect (uint32_t con) {
 176   WrCmdDat(CMD_SET_DEV_STAT, DAT_WR_BYTE(con ? DEV_CON : 0));
 177 }
 178
 179
 180 /*
 181  *  USB Reset Function
 182  *   Called automatically on USB Reset
 183  *    Return Value:    None
 184  */
 185
 186 void USB_Reset (void) {
 187 #if USB_DMA
 188   uint32_t n;
 189 #endif
 190
 191   USB->USBEpInd = 0;
 192   USB->USBMaxPSize = USB_MAX_PACKET0;
 193   USB->USBEpInd = 1;
 194   USB->USBMaxPSize = USB_MAX_PACKET0;
 195   while ((USB->USBDevIntSt & EP_RLZED_INT) == 0);
 196
 197   USB->USBEpIntClr  = 0xFFFFFFFF;
 198   USB->USBEpIntEn   = 0xFFFFFFFF ^ USB_DMA_EP;
 199   USB->USBDevIntClr = 0xFFFFFFFF;
 200   USB->USBDevIntEn  = DEV_STAT_INT    | EP_SLOW_INT    |
 201                (USB_SOF_EVENT   ? FRAME_INT : 0) |
 202                (USB_ERROR_EVENT ? ERR_INT   : 0);
 203
 204 #if USB_DMA
 205   USB->USBUDCAH   = USB_RAM_ADR;
 206   USB->USBDMARClr = 0xFFFFFFFF;
 207   USB->USBEpDMADis  = 0xFFFFFFFF;
 208   USB->USBEpDMAEn   = USB_DMA_EP;
 209   USB->USBEoTIntClr = 0xFFFFFFFF;
 210   USB->USBNDDRIntClr = 0xFFFFFFFF;
 211   USB->USBSysErrIntClr = 0xFFFFFFFF;
 212   USB->USBDMAIntEn  = 0x00000007;
 213   DDMemMap[0] = 0x00000000;
 214   DDMemMap[1] = 0x00000000;
 215   for (n = 0; n < USB_EP_NUM; n++) {
 216     udca[n] = 0;
 217     UDCA[n] = 0;
 218   }
 219 #endif
 220 }
 221
 222
 223 /*
 224  *  USB Suspend Function
 225  *   Called automatically on USB Suspend
 226  *    Return Value:    None
 227  */
 228
 229 void USB_Suspend (void) {
 230   /* Performed by Hardware */
 231 }
 232
 233
 234 /*
 235  *  USB Resume Function
 236  *   Called automatically on USB Resume
 237  *    Return Value:    None
 238  */
 239
 240 void USB_Resume (void) {
 241   /* Performed by Hardware */
 242 }
 243
 244
 245 /*
 246  *  USB Remote Wakeup Function
 247  *   Called automatically on USB Remote Wakeup
 248  *    Return Value:    None
 249  */
 250
 251 void USB_WakeUp (void) {
 252
 253   if (USB_DeviceStatus & USB_GETSTATUS_REMOTE_WAKEUP) {
 254     WrCmdDat(CMD_SET_DEV_STAT, DAT_WR_BYTE(DEV_CON));
 255   }
 256 }
 257
 258
 259 /*
 260  *  USB Remote Wakeup Configuration Function
 261  *    Parameters:      cfg:   Enable/Disable
 262  *    Return Value:    None
 263  */
 264
 265 void USB_WakeUpCfg (uint32_t cfg) {
 266   /* Not needed */
 267 }
 268
 269
 270 /*
 271  *  USB Set Address Function
 272  *    Parameters:      adr:   USB Address
 273  *    Return Value:    None
 274  */
 275
 276 void USB_SetAddress (uint32_t adr) {
 277   WrCmdDat(CMD_SET_ADDR, DAT_WR_BYTE(DEV_EN | adr)); /* Don't wait for next */
 278   WrCmdDat(CMD_SET_ADDR, DAT_WR_BYTE(DEV_EN | adr)); /*  Setup Status Phase */
 279 }
 280
 281
 282 /*
 283  *  USB Configure Function
 284  *    Parameters:      cfg:   Configure/Deconfigure
 285  *    Return Value:    None
 286  */
 287
 288 void USB_Configure (uint32_t cfg) {
 289
 290   WrCmdDat(CMD_CFG_DEV, DAT_WR_BYTE(cfg ? CONF_DVICE : 0));
 291
 292   USB->USBReEp = 0x00000003;
 293   while ((USB->USBDevIntSt & EP_RLZED_INT) == 0);
 294   USB->USBDevIntClr = EP_RLZED_INT;
 295 }
 296
 297
 298 /*
 299  *  Configure USB Endpoint according to Descriptor
 300  *    Parameters:      pEPD:  Pointer to Endpoint Descriptor
 301  *    Return Value:    None
 302  */
 303
 304 void USB_ConfigEP (USB_ENDPOINT_DESCRIPTOR *pEPD) {
 305   uint32_t num;
 306
 307   num = EPAdr(pEPD->bEndpointAddress);
 308   USB->USBReEp |= (1 << num);
 309   USB->USBEpInd = num;
 310   USB->USBMaxPSize = pEPD->wMaxPacketSize;
 311   while ((USB->USBDevIntSt & EP_RLZED_INT) == 0);
 312   USB->USBDevIntClr = EP_RLZED_INT;
 313 }
 314
 315
 316 /*
 317  *  Set Direction for USB Control Endpoint
 318  *    Parameters:      dir:   Out (dir == 0), In (dir <> 0)
 319  *    Return Value:    None
 320  */
 321
 322 void USB_DirCtrlEP (uint32_t dir) {
 323   /* Not needed */
 324 }
 325
 326
 327 /*
 328  *  Enable USB Endpoint
 329  *    Parameters:      EPNum: Endpoint Number
 330  *                       EPNum.0..3: Address
 331  *                       EPNum.7:    Dir
 332  *    Return Value:    None
 333  */
 334
 335 void USB_EnableEP (uint32_t EPNum) {
 336   WrCmdDat(CMD_SET_EP_STAT(EPAdr(EPNum)), DAT_WR_BYTE(0));
 337 }
 338
 339
 340 /*
 341  *  Disable USB Endpoint
 342  *    Parameters:      EPNum: Endpoint Number
 343  *                       EPNum.0..3: Address
 344  *                       EPNum.7:    Dir
 345  *    Return Value:    None
 346  */
 347
 348 void USB_DisableEP (uint32_t EPNum) {
 349   WrCmdDat(CMD_SET_EP_STAT(EPAdr(EPNum)), DAT_WR_BYTE(EP_STAT_DA));
 350 }
 351
 352
 353 /*
 354  *  Reset USB Endpoint
 355  *    Parameters:      EPNum: Endpoint Number
 356  *                       EPNum.0..3: Address
 357  *                       EPNum.7:    Dir
 358  *    Return Value:    None
 359  */
 360
 361 void USB_ResetEP (uint32_t EPNum) {
 362   WrCmdDat(CMD_SET_EP_STAT(EPAdr(EPNum)), DAT_WR_BYTE(0));
 363 }
 364
 365
 366 /*
 367  *  Set Stall for USB Endpoint
 368  *    Parameters:      EPNum: Endpoint Number
 369  *                       EPNum.0..3: Address
 370  *                       EPNum.7:    Dir
 371  *    Return Value:    None
 372  */
 373
 374 void USB_SetStallEP (uint32_t EPNum) {
 375   WrCmdDat(CMD_SET_EP_STAT(EPAdr(EPNum)), DAT_WR_BYTE(EP_STAT_ST));
 376 }
 377
 378
 379 /*
 380  *  Clear Stall for USB Endpoint
 381  *    Parameters:      EPNum: Endpoint Number
 382  *                       EPNum.0..3: Address
 383  *                       EPNum.7:    Dir
 384  *    Return Value:    None
 385  */
 386
 387 void USB_ClrStallEP (uint32_t EPNum) {
 388   WrCmdDat(CMD_SET_EP_STAT(EPAdr(EPNum)), DAT_WR_BYTE(0));
 389 }
 390
 391
 392 /*
 393  *  Clear USB Endpoint Buffer
 394  *    Parameters:      EPNum: Endpoint Number
 395  *                       EPNum.0..3: Address
 396  *                       EPNum.7:    Dir
 397  *    Return Value:    None
 398  */
 399
 400 void USB_ClearEPBuf (uint32_t EPNum) {
 401   WrCmdEP(EPNum, CMD_CLR_BUF);
 402 }
 403
 404
 405 /*
 406  *  Read USB Endpoint Data
 407  *    Parameters:      EPNum: Endpoint Number
 408  *                       EPNum.0..3: Address
 409  *                       EPNum.7:    Dir
 410  *                     pData: Pointer to Data Buffer
 411  *    Return Value:    Number of bytes read
 412  */
 413
 414 uint32_t USB_ReadEP (uint32_t EPNum, uint8_t *pData) {
 415   uint32_t cnt, n;
 416
 417   USB->USBCtrl = ((EPNum & 0x0F) << 2) | CTRL_RD_EN;
 418
 419   do {
 420     cnt = USB->USBRxPLen;
 421   } while ((cnt & PKT_RDY) == 0);
 422   cnt &= PKT_LNGTH_MASK;
 423
 424   for (n = 0; n < (cnt + 3) / 4; n++) {
 425     *((__packed uint32_t *)pData) = USB->USBRxData;
 426     pData += 4;
 427   }
 428   USB->USBCtrl = 0;
 429
 430   if (((EP_MSK_ISO >> EPNum) & 1) == 0) {   /* Non-Isochronous Endpoint */
 431     WrCmdEP(EPNum, CMD_CLR_BUF);
 432   }
 433
 434   return (cnt);
 435 }
 436
 437
 438 /*
 439  *  Write USB Endpoint Data
 440  *    Parameters:      EPNum: Endpoint Number
 441  *                       EPNum.0..3: Address
 442  *                       EPNum.7:    Dir
 443  *                     pData: Pointer to Data Buffer
 444  *                     cnt:   Number of bytes to write
 445  *    Return Value:    Number of bytes written
 446  */
 447
 448 uint32_t USB_WriteEP (uint32_t EPNum, uint8_t *pData, uint32_t cnt) {
 449   uint32_t n;
 450
 451   USB->USBCtrl = ((EPNum & 0x0F) << 2) | CTRL_WR_EN;
 452
 453   USB->USBTxPLen = cnt;
 454
 455   for (n = 0; n < (cnt + 3) / 4; n++) {
 456     USB->USBTxData = *((__packed uint32_t *)pData);
 457     pData += 4;
 458   }
 459   USB->USBCtrl = 0;
 460   WrCmdEP(EPNum, CMD_VALID_BUF);
 461   return (cnt);
 462 }
 463
 464 #if USB_DMA
 465
 466 /* DMA Descriptor Memory Layout */
 467 const uint32_t DDAdr[2] = { DD_NISO_ADR, DD_ISO_ADR };
 468 const uint32_t DDSz [2] = { 16,          20         };
 469
 470
 471 /*
 472  *  Setup USB DMA Transfer for selected Endpoint
 473  *    Parameters:      EPNum: Endpoint Number
 474  *                     pDD: Pointer to DMA Descriptor
 475  *    Return Value:    TRUE - Success, FALSE - Error
 476  */
 477
 478 uint32_t USB_DMA_Setup(uint32_t EPNum, USB_DMA_DESCRIPTOR *pDD) {
 479   uint32_t num, ptr, nxt, iso, n;
 480
 481   iso = pDD->Cfg.Type.IsoEP;                /* Iso or Non-Iso Descriptor */
 482   num = EPAdr(EPNum);                       /* Endpoint's Physical Address */
 483
 484   ptr = 0;                                  /* Current Descriptor */
 485   nxt = udca[num];                          /* Initial Descriptor */
 486   while (nxt) {                             /* Go through Descriptor List */
 487     ptr = nxt;                              /* Current Descriptor */
 488     if (!pDD->Cfg.Type.Link) {              /* Check for Linked Descriptors */
 489       n = (ptr - DDAdr[iso]) / DDSz[iso];   /* Descriptor Index */
 490       DDMemMap[iso] &= ~(1 << n);           /* Unmark Memory Usage */
 491     }
 492     nxt = *((uint32_t *)ptr);                  /* Next Descriptor */
 493   }
 494
 495   for (n = 0; n < 32; n++) {                /* Search for available Memory */
 496     if ((DDMemMap[iso] & (1 << n)) == 0) {
 497       break;                                /* Memory found */
 498     }
 499   }
 500   if (n == 32) return (FALSE);              /* Memory not available */
 501
 502   DDMemMap[iso] |= 1 << n;                  /* Mark Memory Usage */
 503   nxt = DDAdr[iso] + n * DDSz[iso];         /* Next Descriptor */
 504
 505   if (ptr && pDD->Cfg.Type.Link) {
 506     *((uint32_t *)(ptr + 0))  = nxt;           /* Link in new Descriptor */
 507     *((uint32_t *)(ptr + 4)) |= 0x00000004;    /* Next DD is Valid */
 508   } else {
 509     udca[num] = nxt;                        /* Save new Descriptor */
 510     UDCA[num] = nxt;                        /* Update UDCA in USB */
 511   }
 512
 513   /* Fill in DMA Descriptor */
 514   *(((uint32_t *)nxt)++) =  0;                 /* Next DD Pointer */
 515   *(((uint32_t *)nxt)++) =  pDD->Cfg.Type.ATLE |
 516                        (pDD->Cfg.Type.IsoEP << 4) |
 517                        (pDD->MaxSize <<  5) |
 518                        (pDD->BufLen  << 16);
 519   *(((uint32_t *)nxt)++) =  pDD->BufAdr;
 520   *(((uint32_t *)nxt)++) =  pDD->Cfg.Type.LenPos << 8;
 521   if (iso) {
 522     *((uint32_t *)nxt) =  pDD->InfoAdr;
 523   }
 524
 525   return (TRUE); /* Success */
 526 }
 527
 528
 529 /*
 530  *  Enable USB DMA Endpoint
 531  *    Parameters:      EPNum: Endpoint Number
 532  *                       EPNum.0..3: Address
 533  *                       EPNum.7:    Dir
 534  *    Return Value:    None
 535  */
 536
 537 void USB_DMA_Enable (uint32_t EPNum) {
 538   USB->USBEpDMAEn = 1 << EPAdr(EPNum);
 539 }
 540
 541
 542 /*
 543  *  Disable USB DMA Endpoint
 544  *    Parameters:      EPNum: Endpoint Number
 545  *                       EPNum.0..3: Address
 546  *                       EPNum.7:    Dir
 547  *    Return Value:    None
 548  */
 549
 550 void USB_DMA_Disable (uint32_t EPNum) {
 551   USB->USBEpDMADis = 1 << EPAdr(EPNum);
 552 }
 553
 554
 555 /*
 556  *  Get USB DMA Endpoint Status
 557  *    Parameters:      EPNum: Endpoint Number
 558  *                       EPNum.0..3: Address
 559  *                       EPNum.7:    Dir
 560  *    Return Value:    DMA Status
 561  */
 562
 563 uint32_t USB_DMA_Status (uint32_t EPNum) {
 564   uint32_t ptr, val;
 565
 566   ptr = UDCA[EPAdr(EPNum)];                 /* Current Descriptor */
 567   if (ptr == 0)
 568         return (USB_DMA_INVALID);
 569
 570   val = *((uint32_t *)(ptr + 3*4));            /* Status Information */
 571   switch ((val >> 1) & 0x0F) {
 572     case 0x00:                              /* Not serviced */
 573       return (USB_DMA_IDLE);
 574     case 0x01:                              /* Being serviced */
 575       return (USB_DMA_BUSY);
 576     case 0x02:                              /* Normal Completition */
 577       return (USB_DMA_DONE);
 578     case 0x03:                              /* Data Under Run */
 579       return (USB_DMA_UNDER_RUN);
 580     case 0x08:                              /* Data Over Run */
 581       return (USB_DMA_OVER_RUN);
 582     case 0x09:                              /* System Error */
 583       return (USB_DMA_ERROR);
 584   }
 585
 586   return (USB_DMA_UNKNOWN);
 587 }
 588
 589
 590 /*
 591  *  Get USB DMA Endpoint Current Buffer Address
 592  *    Parameters:      EPNum: Endpoint Number
 593  *                       EPNum.0..3: Address
 594  *                       EPNum.7:    Dir
 595  *    Return Value:    DMA Address (or -1 when DMA is Invalid)
 596  */
 597
 598 uint32_t USB_DMA_BufAdr (uint32_t EPNum) {
 599   uint32_t ptr, val;
 600
 601   ptr = UDCA[EPAdr(EPNum)];                 /* Current Descriptor */
 602   if (ptr == 0)
 603   {
 604         return ((uint32_t)(-1));                /* DMA Invalid */
 605   }
 606
 607   val = *((uint32_t *)(ptr + 2*4));         /* Buffer Address */
 608   return (val);                             /* Current Address */
 609 }
 610
 611
 612 /*
 613  *  Get USB DMA Endpoint Current Buffer Count
 614  *   Number of transfered Bytes or Iso Packets
 615  *    Parameters:      EPNum: Endpoint Number
 616  *                       EPNum.0..3: Address
 617  *                       EPNum.7:    Dir
 618  *    Return Value:    DMA Count (or -1 when DMA is Invalid)
 619  */
 620
 621 uint32_t USB_DMA_BufCnt (uint32_t EPNum) {
 622   uint32_t ptr, val;
 623
 624   ptr = UDCA[EPAdr(EPNum)];                 /* Current Descriptor */
 625   if (ptr == 0)
 626   {
 627         return ((uint32_t)(-1));                /* DMA Invalid */
 628   }
 629   val = *((uint32_t *)(ptr + 3*4));         /* Status Information */
 630   return (val >> 16);                       /* Current Count */
 631 }
 632
 633
 634 #endif /* USB_DMA */
 635
 636
 637 /*
 638  *  Get USB Last Frame Number
 639  *    Parameters:      None
 640  *    Return Value:    Frame Number
 641  */
 642
 643 uint32_t USB_GetFrame (void) {
 644   uint32_t val;
 645
 646   WrCmd(CMD_RD_FRAME);
 647   val = RdCmdDat(DAT_RD_FRAME);
 648   val = val | (RdCmdDat(DAT_RD_FRAME) << 8);
 649
 650   return (val);
 651 }
 652
 653
 654 /*
 655  *  USB Interrupt Service Routine
 656  */
 657
 658 void USB_IRQHandler (void) {
 659   uint32_t disr, val, n, m;
 660   uint32_t episr, episrCur;
 661
 662   disr = USB->USBDevIntSt;       /* Device Interrupt Status */
 663
 664   /* Device Status Interrupt (Reset, Connect change, Suspend/Resume) */
 665   if (disr & DEV_STAT_INT) {
 666     USB->USBDevIntClr = DEV_STAT_INT;
 667     WrCmd(CMD_GET_DEV_STAT);
 668     val = RdCmdDat(DAT_GET_DEV_STAT);       /* Device Status */
 669     if (val & DEV_RST) {                    /* Reset */
 670       USB_Reset();
 671 #if   USB_RESET_EVENT
 672       USB_Reset_Event();
 673 #endif
 674     }
 675     if (val & DEV_CON_CH) {                 /* Connect change */
 676 #if   USB_POWER_EVENT
 677       USB_Power_Event(val & DEV_CON);
 678 #endif
 679     }
 680     if (val & DEV_SUS_CH) {                 /* Suspend/Resume */
 681       if (val & DEV_SUS) {                  /* Suspend */
 682         USB_Suspend();
 683 #if     USB_SUSPEND_EVENT
 684         USB_Suspend_Event();
 685 #endif
 686       } else {                              /* Resume */
 687         USB_Resume();
 688 #if     USB_RESUME_EVENT
 689         USB_Resume_Event();
 690 #endif
 691       }
 692     }
 693     goto isr_end;
 694   }
 695
 696 #if USB_SOF_EVENT
 697   /* Start of Frame Interrupt */
 698   if (disr & FRAME_INT) {
 699     USB_SOF_Event();
 700   }
 701 #endif
 702
 703 #if USB_ERROR_EVENT
 704   /* Error Interrupt */
 705   if (disr & ERR_INT) {
 706     WrCmd(CMD_RD_ERR_STAT);
 707     val = RdCmdDat(DAT_RD_ERR_STAT);
 708     USB_Error_Event(val);
 709   }
 710 #endif
 711
 712   /* Endpoint's Slow Interrupt */
 713   if (disr & EP_SLOW_INT) {
 714     episrCur = 0;
 715     episr    = USB->USBEpIntSt;
 716     for (n = 0; n < USB_EP_NUM; n++) {      /* Check All Endpoints */
 717       if (episr == episrCur) break;         /* break if all EP interrupts handled */
 718       if (episr & (1 << n)) {
 719         episrCur |= (1 << n);
 720         m = n >> 1;
 721
 722         USB->USBEpIntClr = (1 << n);
 723         while ((USB->USBDevIntSt & CDFULL_INT) == 0);
 724         val = USB->USBCmdData;
 725
 726         if ((n & 1) == 0) {                 /* OUT Endpoint */
 727           if (n == 0) {                     /* Control OUT Endpoint */
 728             if (val & EP_SEL_STP) {         /* Setup Packet */
 729               if (USB_P_EP[0]) {
 730                 USB_P_EP[0](USB_EVT_SETUP);
 731                 continue;
 732               }
 733             }
 734           }
 735           if (USB_P_EP[m]) {
 736             USB_P_EP[m](USB_EVT_OUT);
 737           }
 738         } else {                            /* IN Endpoint */
 739           if (USB_P_EP[m]) {
 740             USB_P_EP[m](USB_EVT_IN);
 741           }
 742         }
 743       }
 744     }
 745     USB->USBDevIntClr = EP_SLOW_INT;
 746   }
 747
 748 #if USB_DMA
 749
 750   if (USB->USBDMAIntSt & 0x00000001) {          /* End of Transfer Interrupt */
 751     val = USB->USBEoTIntSt;
 752     for (n = 2; n < USB_EP_NUM; n++) {      /* Check All Endpoints */
 753       if (val & (1 << n)) {
 754         m = n >> 1;
 755         if ((n & 1) == 0) {                 /* OUT Endpoint */
 756           if (USB_P_EP[m]) {
 757             USB_P_EP[m](USB_EVT_OUT_DMA_EOT);
 758           }
 759         } else {                            /* IN Endpoint */
 760           if (USB_P_EP[m]) {
 761             USB_P_EP[m](USB_EVT_IN_DMA_EOT);
 762           }
 763         }
 764       }
 765     }
 766     USB->USBEoTIntClr = val;
 767   }
 768
 769   if (USB->USBDMAIntSt & 0x00000002) {          /* New DD Request Interrupt */
 770     val = USB->USBNDDRIntSt;
 771     for (n = 2; n < USB_EP_NUM; n++) {      /* Check All Endpoints */
 772       if (val & (1 << n)) {
 773         m = n >> 1;
 774         if ((n & 1) == 0) {                 /* OUT Endpoint */
 775           if (USB_P_EP[m]) {
 776             USB_P_EP[m](USB_EVT_OUT_DMA_NDR);
 777           }
 778         } else {                            /* IN Endpoint */
 779           if (USB_P_EP[m]) {
 780             USB_P_EP[m](USB_EVT_IN_DMA_NDR);
 781           }
 782         }
 783       }
 784     }
 785     USB->USBNDDRIntClr = val;
 786   }
 787
 788   if (USB->USBDMAIntSt & 0x00000004) {          /* System Error Interrupt */
 789     val = USB->USBSysErrIntSt;
 790     for (n = 2; n < USB_EP_NUM; n++) {      /* Check All Endpoints */
 791       if (val & (1 << n)) {
 792         m = n >> 1;
 793         if ((n & 1) == 0) {                 /* OUT Endpoint */
 794           if (USB_P_EP[m]) {
 795             USB_P_EP[m](USB_EVT_OUT_DMA_ERR);
 796           }
 797         } else {                            /* IN Endpoint */
 798           if (USB_P_EP[m]) {
 799             USB_P_EP[m](USB_EVT_IN_DMA_ERR);
 800           }
 801         }
 802       }
 803     }
 804     USB->USBSysErrIntClr = val;
 805   }
 806
 807 #endif /* USB_DMA */
 808
 809 isr_end:
 810   return;
 811 }