00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048 #include "chip.h"
00049 #include "USBD_HAL.h"
00050
00051 #include <stdbool.h>
00052 #include <stdint.h>
00053 #include <stdio.h>
00054
00055
00056
00057
00058
00059
00060 #define CHIP_USB_UDP
00061
00062
00063 #define CHIP_USB_PULLUP_INTERNAL
00064
00065
00066 #define CHIP_USB_NUMENDPOINTS 8
00067
00068
00069 #define CHIP_USB_ENDPOINTS_MAXPACKETSIZE(i) \
00070 ((i == 0) ? 64 : \
00071 ((i == 1) ? 64 : \
00072 ((i == 2) ? 64 : \
00073 ((i == 3) ? 64 : \
00074 ((i == 4) ? 512 : \
00075 ((i == 5) ? 512 : \
00076 ((i == 6) ? 64 : \
00077 ((i == 7) ? 64 : 0 ))))))))
00078
00079
00080 #define CHIP_USB_ENDPOINTS_BANKS(i) \
00081 ((i == 0) ? 1 : \
00082 ((i == 1) ? 2 : \
00083 ((i == 2) ? 2 : \
00084 ((i == 3) ? 1 : \
00085 ((i == 4) ? 2 : \
00086 ((i == 5) ? 2 : \
00087 ((i == 6) ? 2 : \
00088 ((i == 7) ? 2 : 0 ))))))))
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099 #define UDP_CSR_RXDATA_BK (UDP_CSR_RX_DATA_BK0 | UDP_CSR_RX_DATA_BK1)
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117 #define UDP_ENDPOINT_DISABLED 0
00118
00119 #define UDP_ENDPOINT_HALTED 1
00120
00121 #define UDP_ENDPOINT_IDLE 2
00122
00123 #define UDP_ENDPOINT_SENDING 3
00124
00125 #define UDP_ENDPOINT_RECEIVING 4
00126
00127 #define UDP_ENDPOINT_SENDINGM 5
00128
00129 #define UDP_ENDPOINT_RECEIVINGM 6
00130
00131
00132
00133
00134
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148 #if defined ( __CC_ARM )
00149 #define nop() {volatile int h; for(h=0;h<10;h++){}}
00150 #elif defined ( __ICCARM__ )
00151 #include <intrinsics.h>
00152 #define nop() (__no_operation())
00153 #elif defined ( __GNUC__ )
00154 #define nop() __asm__ __volatile__ ( "nop" )
00155 #endif
00156
00157
00158
00159 #define REG_NO_EFFECT_1_ALL UDP_CSR_RX_DATA_BK0 | UDP_CSR_RX_DATA_BK1 \
00160 |UDP_CSR_STALLSENTISOERROR | UDP_CSR_RXSETUP \
00161 |UDP_CSR_TXCOMP
00162
00163
00164
00165
00166
00167
00168
00169 #define SET_CSR(endpoint, flags) \
00170 { \
00171 volatile uint32_t reg; \
00172 int32_t nop_count ; \
00173 reg = UDP->UDP_CSR[endpoint] ; \
00174 reg |= REG_NO_EFFECT_1_ALL; \
00175 reg |= (flags); \
00176 UDP->UDP_CSR[endpoint] = reg; \
00177 for( nop_count=0; nop_count<15; nop_count++ ) {\
00178 nop();\
00179 }\
00180 }
00181
00182
00183
00184
00185
00186
00187
00188 #define CLEAR_CSR(endpoint, flags) \
00189 { \
00190 volatile uint32_t reg; \
00191 int32_t nop_count ; \
00192 reg = UDP->UDP_CSR[endpoint]; \
00193 reg |= REG_NO_EFFECT_1_ALL; \
00194 reg &= ~((uint32_t)(flags)); \
00195 UDP->UDP_CSR[endpoint] = reg; \
00196 for( nop_count=0; nop_count<15; nop_count++ ) {\
00197 nop();\
00198 }\
00199 }
00200
00201
00202
00203
00204
00205
00206
00207 #define MBL_NbBuffer(i, o, size) (((i)>(o))?((i)-(o)):((i)+(size)-(o)))
00208
00209
00210 #define MBL_FULL 1
00211
00212 #define MBL_NULL 2
00213
00214
00215
00216
00217
00218
00219 typedef struct {
00220
00221 void* fCallback;
00222
00223 void* pArgument;
00224
00225 uint8_t transType;
00226 } TransferHeader;
00227
00228
00229 typedef struct {
00230
00231
00232 TransferCallback fCallback;
00233
00234 void *pArgument;
00235
00236 uint16_t transType;
00237
00238
00239 int16_t buffered;
00240
00241 uint8_t *pData;
00242
00243 int32_t transferred;
00244
00245 int32_t remaining;
00246 } Transfer;
00247
00248
00249 typedef struct {
00250
00251 MblTransferCallback fCallback;
00252
00253 void *pArgument;
00254
00255 volatile uint8_t transType;
00256
00257 uint8_t listState;
00258
00259 uint16_t listSize;
00260
00261 USBDTransferBuffer *pMbl;
00262
00263 uint16_t offsetSize;
00264
00265 uint16_t outCurr;
00266
00267 uint16_t outLast;
00268
00269 uint16_t inCurr;
00270 } MblTransfer;
00271
00272
00273
00274
00275 typedef struct {
00276
00277
00278
00279
00280 volatile uint8_t state;
00281
00282 volatile uint8_t bank;
00283
00284 volatile uint16_t size;
00285
00286
00287 union {
00288 TransferHeader transHdr;
00289 Transfer singleTransfer;
00290 MblTransfer mblTransfer;
00291 } transfer;
00292 } Endpoint;
00293
00294
00295
00296
00297
00298
00299 static Endpoint endpoints[CHIP_USB_NUMENDPOINTS];
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309 static uint8_t UDP_EnablePeripheralClock(void)
00310 {
00311 if (!PMC_IsPeriphEnabled(ID_UDP)) {
00312 PMC_EnablePeripheral(ID_UDP);
00313 return 1;
00314 }
00315 return 0;
00316 }
00317
00318
00319
00320
00321 static inline void UDP_DisablePeripheralClock(void)
00322 {
00323 PMC_DisablePeripheral(ID_UDP);
00324 }
00325
00326
00327
00328
00329 static inline void UDP_EnableUsbClock(void)
00330 {
00331 REG_PMC_SCER = PMC_SCER_UDP;
00332 }
00333
00334
00335
00336
00337 static inline void UDP_DisableUsbClock(void)
00338 {
00339 REG_PMC_SCDR = PMC_SCER_UDP;
00340 }
00341
00342
00343
00344
00345 static inline void UDP_EnableTransceiver(void)
00346 {
00347 UDP->UDP_TXVC &= ~(uint32_t)UDP_TXVC_TXVDIS;
00348 }
00349
00350
00351
00352
00353 static inline void UDP_DisableTransceiver(void)
00354 {
00355 UDP->UDP_TXVC |= UDP_TXVC_TXVDIS;
00356 }
00357
00358
00359
00360
00361
00362
00363
00364 static void UDP_EndOfTransfer(uint8_t bEndpoint, uint8_t bStatus)
00365 {
00366 Endpoint *pEndpoint = &(endpoints[bEndpoint]);
00367
00368
00369 if( (pEndpoint->state == UDP_ENDPOINT_RECEIVING)
00370 || (pEndpoint->state == UDP_ENDPOINT_SENDING)) {
00371
00372 Transfer *pTransfer = (Transfer *)&(pEndpoint->transfer);
00373 uint32_t transferred = pTransfer->transferred;
00374 uint32_t remaining = pTransfer->remaining + pTransfer->buffered;
00375
00376 TRACE_DEBUG_WP("EoT ");
00377
00378
00379 pEndpoint->state = UDP_ENDPOINT_IDLE;
00380
00381 pTransfer->pData = 0;
00382 pTransfer->transferred = -1;
00383 pTransfer->buffered = -1;
00384 pTransfer->remaining = -1;
00385
00386
00387 if (pTransfer->fCallback != 0) {
00388
00389 ((TransferCallback) pTransfer->fCallback)
00390 (pTransfer->pArgument,
00391 bStatus,
00392 transferred,
00393 remaining);
00394 }
00395 else {
00396 TRACE_DEBUG_WP("NoCB ");
00397 }
00398 }
00399 else if ( (pEndpoint->state == UDP_ENDPOINT_RECEIVINGM)
00400 || (pEndpoint->state == UDP_ENDPOINT_SENDINGM) ) {
00401
00402 MblTransfer *pTransfer = (MblTransfer*)&(pEndpoint->transfer);
00403
00404 TRACE_DEBUG_WP("EoMT ");
00405
00406
00407 pEndpoint->state = UDP_ENDPOINT_IDLE;
00408
00409 if (pTransfer->transType) {
00410 MblTransfer *pMblt = (MblTransfer*)&(pEndpoint->transfer);
00411 pMblt->listState = 0;
00412 pMblt->outCurr = pMblt->inCurr = pMblt->outLast = 0;
00413 }
00414
00415 if (pTransfer->fCallback != 0) {
00416
00417 ((MblTransferCallback) pTransfer->fCallback)
00418 (pTransfer->pArgument,
00419 bStatus);
00420 }
00421 else {
00422 TRACE_DEBUG_WP("NoCB ");
00423 }
00424 }
00425 }
00426
00427
00428
00429
00430
00431 static void UDP_ClearRxFlag(uint8_t bEndpoint)
00432 {
00433 Endpoint *pEndpoint = &(endpoints[bEndpoint]);
00434
00435
00436 if (pEndpoint->bank == 0) {
00437
00438 CLEAR_CSR(bEndpoint, UDP_CSR_RX_DATA_BK0);
00439
00440 if (CHIP_USB_ENDPOINTS_BANKS(bEndpoint) > 1) {
00441
00442 pEndpoint->bank = 1;
00443 }
00444 }
00445 else {
00446
00447 CLEAR_CSR(bEndpoint, UDP_CSR_RX_DATA_BK1);
00448 pEndpoint->bank = 0;
00449 }
00450 }
00451
00452
00453
00454
00455
00456
00457
00458
00459 static uint8_t UDP_MblUpdate(MblTransfer *pTransfer,
00460 USBDTransferBuffer * pBi,
00461 uint16_t size,
00462 uint8_t forceEnd)
00463 {
00464
00465 pBi->remaining -= size;
00466
00467 if (pTransfer->listState == MBL_NULL) {
00468 return 1;
00469 }
00470
00471 if (pBi->remaining == 0 || forceEnd || size == 0) {
00472
00473
00474 if ((++ pTransfer->outCurr) == pTransfer->listSize)
00475 pTransfer->outCurr = 0;
00476
00477 if (pTransfer->outCurr == pTransfer->inCurr)
00478 pTransfer->listState = MBL_NULL;
00479 else {
00480 pTransfer->listState = 0;
00481
00482 pBi = &pTransfer->pMbl[pTransfer->outCurr];
00483 pBi->buffered = 0;
00484 pBi->transferred = 0;
00485 pBi->remaining = pBi->size;
00486 }
00487 return 1;
00488 }
00489 return 0;
00490 }
00491
00492
00493
00494
00495
00496
00497 static uint8_t UDP_MblWriteFifo(uint8_t bEndpoint)
00498 {
00499 Endpoint *pEndpoint = &(endpoints[bEndpoint]);
00500 MblTransfer *pTransfer = (MblTransfer*)&(pEndpoint->transfer);
00501 USBDTransferBuffer *pBi = &(pTransfer->pMbl[pTransfer->outCurr]);
00502 int32_t size;
00503
00504 volatile uint8_t * pBytes;
00505 volatile uint8_t bufferEnd = 1;
00506
00507
00508 size = pEndpoint->size;
00509 if (size > pBi->remaining) size = pBi->remaining;
00510
00511 TRACE_DEBUG_WP("w%d.%d ", pTransfer->outCurr, size);
00512
00513
00514 pTransfer->outLast = pTransfer->outCurr;
00515
00516 pBytes = &(pBi->pBuffer[pBi->transferred + pBi->buffered]);
00517 pBi->buffered += size;
00518 bufferEnd = UDP_MblUpdate(pTransfer, pBi, size, 0);
00519
00520
00521 if (size) {
00522 int32_t c8 = size >> 3;
00523 int32_t c1 = size & 0x7;
00524 for (; c8; c8 --) {
00525 UDP->UDP_FDR[bEndpoint] = *(pBytes ++);
00526 UDP->UDP_FDR[bEndpoint] = *(pBytes ++);
00527 UDP->UDP_FDR[bEndpoint] = *(pBytes ++);
00528 UDP->UDP_FDR[bEndpoint] = *(pBytes ++);
00529
00530 UDP->UDP_FDR[bEndpoint] = *(pBytes ++);
00531 UDP->UDP_FDR[bEndpoint] = *(pBytes ++);
00532 UDP->UDP_FDR[bEndpoint] = *(pBytes ++);
00533 UDP->UDP_FDR[bEndpoint] = *(pBytes ++);
00534 }
00535 for (; c1; c1 --) {
00536 UDP->UDP_FDR[bEndpoint] = *(pBytes ++);
00537 }
00538 }
00539 return bufferEnd;
00540 }
00541
00542
00543
00544
00545
00546
00547 static void UDP_WritePayload(uint8_t bEndpoint)
00548 {
00549 Endpoint *pEndpoint = &(endpoints[bEndpoint]);
00550 Transfer *pTransfer = (Transfer*)&(pEndpoint->transfer);
00551 int32_t size;
00552
00553
00554 size = pEndpoint->size;
00555 if (size > pTransfer->remaining) {
00556
00557 size = pTransfer->remaining;
00558 }
00559
00560
00561 pTransfer->buffered += size;
00562 pTransfer->remaining -= size;
00563
00564
00565 while (size > 0) {
00566
00567 UDP->UDP_FDR[bEndpoint] = *(pTransfer->pData);
00568 pTransfer->pData++;
00569 size--;
00570 }
00571 }
00572
00573
00574
00575
00576
00577
00578
00579 static void UDP_ReadPayload(uint8_t bEndpoint, int32_t wPacketSize)
00580 {
00581 Endpoint *pEndpoint = &(endpoints[bEndpoint]);
00582 Transfer *pTransfer = (Transfer*)&(pEndpoint->transfer);
00583
00584
00585 if (wPacketSize > pTransfer->remaining) {
00586
00587 pTransfer->buffered += wPacketSize - pTransfer->remaining;
00588 wPacketSize = pTransfer->remaining;
00589 }
00590
00591
00592 pTransfer->remaining -= wPacketSize;
00593 pTransfer->transferred += wPacketSize;
00594
00595
00596 while (wPacketSize > 0) {
00597
00598 *(pTransfer->pData) = (uint8_t) UDP->UDP_FDR[bEndpoint];
00599 pTransfer->pData++;
00600 wPacketSize--;
00601 }
00602 }
00603
00604
00605
00606
00607
00608 static void UDP_ReadRequest(USBGenericRequest *pRequest)
00609 {
00610 uint8_t *pData = (uint8_t *)pRequest;
00611 uint32_t i;
00612
00613
00614 for (i = 0; i < 8; i++) {
00615
00616 *pData = (uint8_t) UDP->UDP_FDR[0];
00617 pData++;
00618 }
00619 }
00620
00621
00622
00623
00624
00625
00626
00627 static uint8_t UDP_IsTransferFinished(uint8_t bEndpoint)
00628 {
00629 Endpoint *pEndpoint = &(endpoints[bEndpoint]);
00630 Transfer *pTransfer = (Transfer*)&(pEndpoint->transfer);
00631
00632
00633
00634
00635 if ((UDP->UDP_CSR[bEndpoint] & UDP_CSR_EPTYPE_Msk) == UDP_CSR_EPTYPE_CTRL) {
00636
00637 return (pTransfer->buffered < pEndpoint->size);
00638 }
00639
00640 else {
00641
00642 return (pTransfer->buffered <= pEndpoint->size)
00643 && (pTransfer->remaining == 0);
00644 }
00645 }
00646
00647
00648
00649
00650
00651
00652 static void UDP_EndpointHandler(uint8_t bEndpoint)
00653 {
00654 Endpoint *pEndpoint = &(endpoints[bEndpoint]);
00655 Transfer *pTransfer = (Transfer*)&(pEndpoint->transfer);
00656 MblTransfer *pMblt = (MblTransfer*)&(pEndpoint->transfer);
00657 uint32_t status = UDP->UDP_CSR[bEndpoint];
00658 uint16_t wPacketSize;
00659 USBGenericRequest request;
00660
00661 TRACE_DEBUG_WP("E%d ", bEndpoint);
00662 TRACE_DEBUG_WP("st:0x%X ", status);
00663
00664
00665
00666 if ((status & UDP_CSR_TXCOMP) != 0) {
00667
00668 TRACE_DEBUG_WP("Wr ");
00669
00670
00671 if (pEndpoint->state == UDP_ENDPOINT_SENDINGM) {
00672
00673 USBDTransferBuffer * pMbli = &(pMblt->pMbl[pMblt->outLast]);
00674 uint8_t bufferEnd = 0;
00675
00676 TRACE_DEBUG_WP("TxM%d.%d ", pMblt->listState, pMbli->buffered);
00677
00678
00679 if (pMblt->listState == MBL_NULL && pMbli->buffered == 0) {
00680
00681 pMbli->transferred += pMbli->buffered;
00682 pMbli->buffered = 0;
00683
00684
00685 UDP->UDP_IDR = 1 << bEndpoint;
00686 UDP_EndOfTransfer(bEndpoint, USBD_STATUS_SUCCESS);
00687 CLEAR_CSR(bEndpoint, UDP_CSR_TXCOMP);
00688 }
00689 else {
00690
00691
00692 TRACE_DEBUG_WP("%d ", pEndpoint->size);
00693
00694 if (pMbli->buffered > pEndpoint->size) {
00695 pMbli->transferred += pEndpoint->size;
00696 pMbli->buffered -= pEndpoint->size;
00697 }
00698 else {
00699 pMbli->transferred += pMbli->buffered;
00700 pMbli->buffered = 0;
00701 }
00702
00703
00704 if (CHIP_USB_ENDPOINTS_BANKS(bEndpoint) == 1) {
00705
00706
00707 bufferEnd = UDP_MblWriteFifo(bEndpoint);
00708 SET_CSR(bEndpoint, UDP_CSR_TXPKTRDY);
00709 CLEAR_CSR(bEndpoint, UDP_CSR_TXCOMP);
00710 }
00711 else {
00712
00713 SET_CSR(bEndpoint, UDP_CSR_TXPKTRDY);
00714 CLEAR_CSR(bEndpoint, UDP_CSR_TXCOMP);
00715 bufferEnd = UDP_MblWriteFifo(bEndpoint);
00716 }
00717
00718 if (bufferEnd && pMblt->fCallback) {
00719 ((MblTransferCallback) pTransfer->fCallback)
00720 (pTransfer->pArgument,
00721 USBD_STATUS_PARTIAL_DONE);
00722 }
00723 }
00724 }
00725
00726 else if (pEndpoint->state == UDP_ENDPOINT_SENDING) {
00727
00728
00729 if (UDP_IsTransferFinished(bEndpoint)) {
00730
00731 pTransfer->transferred += pTransfer->buffered;
00732 pTransfer->buffered = 0;
00733
00734
00735 if ((status & UDP_CSR_EPTYPE_Msk) != UDP_CSR_EPTYPE_CTRL) {
00736
00737 UDP->UDP_IDR = 1 << bEndpoint;
00738 }
00739
00740 UDP_EndOfTransfer(bEndpoint, USBD_STATUS_SUCCESS);
00741 CLEAR_CSR(bEndpoint, UDP_CSR_TXCOMP);
00742 }
00743 else {
00744
00745
00746 TRACE_DEBUG_WP(" %d ", pEndpoint->size);
00747
00748 pTransfer->transferred += pEndpoint->size;
00749 pTransfer->buffered -= pEndpoint->size;
00750
00751
00752 if (CHIP_USB_ENDPOINTS_BANKS(bEndpoint) == 1) {
00753
00754
00755 UDP_WritePayload(bEndpoint);
00756 SET_CSR(bEndpoint, UDP_CSR_TXPKTRDY);
00757 CLEAR_CSR(bEndpoint, UDP_CSR_TXCOMP);
00758 }
00759 else {
00760
00761 SET_CSR(bEndpoint, UDP_CSR_TXPKTRDY);
00762 CLEAR_CSR(bEndpoint, UDP_CSR_TXCOMP);
00763 UDP_WritePayload(bEndpoint);
00764 }
00765 }
00766 }
00767 else {
00768
00769 TRACE_ERROR("Error Wr%d, %x\n\r", bEndpoint, pEndpoint->state);
00770 CLEAR_CSR(bEndpoint, UDP_CSR_TXCOMP);
00771 }
00772 }
00773
00774
00775 if ((status & UDP_CSR_RXDATA_BK) != 0) {
00776
00777 TRACE_DEBUG_WP("Rd ");
00778
00779
00780 if (pEndpoint->state != UDP_ENDPOINT_RECEIVING) {
00781
00782
00783 if (((status & UDP_CSR_EPTYPE_Msk) == UDP_CSR_EPTYPE_CTRL)
00784 && ((status & UDP_CSR_RXBYTECNT_Msk) == 0)) {
00785
00786
00787 UDP_ClearRxFlag(bEndpoint);
00788 UDP_EndOfTransfer(bEndpoint, USBD_STATUS_SUCCESS);
00789 }
00790
00791 else if ((status & UDP_CSR_FORCESTALL) != 0) {
00792
00793
00794 TRACE_DEBUG_WP("Discard ");
00795 UDP_ClearRxFlag(bEndpoint);
00796 }
00797
00798 else {
00799
00800 TRACE_DEBUG_WP("Nak ");
00801 UDP->UDP_IDR = 1 << bEndpoint;
00802 }
00803 }
00804
00805 else {
00806
00807
00808 wPacketSize = (uint16_t) (status >> 16);
00809 TRACE_DEBUG_WP("%d ", wPacketSize);
00810 UDP_ReadPayload(bEndpoint, wPacketSize);
00811 UDP_ClearRxFlag(bEndpoint);
00812
00813
00814 if ((pTransfer->remaining == 0) || (wPacketSize < pEndpoint->size)) {
00815
00816
00817 if ((status & UDP_CSR_EPTYPE_Msk) != UDP_CSR_EPTYPE_CTRL) {
00818
00819 UDP->UDP_IDR = 1 << bEndpoint;
00820 }
00821 UDP_EndOfTransfer(bEndpoint, USBD_STATUS_SUCCESS);
00822 }
00823 }
00824 }
00825
00826
00827 if ((status & UDP_CSR_STALLSENTISOERROR) != 0) {
00828
00829 CLEAR_CSR(bEndpoint, UDP_CSR_STALLSENTISOERROR);
00830
00831 if ( (status & UDP_CSR_EPTYPE_Msk) == UDP_CSR_EPTYPE_ISO_IN
00832 || (status & UDP_CSR_EPTYPE_Msk) == UDP_CSR_EPTYPE_ISO_OUT ) {
00833
00834 TRACE_WARNING("Isoe [%d] ", bEndpoint);
00835 UDP_EndOfTransfer(bEndpoint, USBD_STATUS_ABORTED);
00836 }
00837 else {
00838
00839 TRACE_WARNING("Sta 0x%X [%d] ", (int)status, bEndpoint);
00840
00841 if (pEndpoint->state != UDP_ENDPOINT_HALTED) {
00842
00843 TRACE_WARNING( "_ " );
00844
00845 CLEAR_CSR(bEndpoint, UDP_CSR_FORCESTALL);
00846 }
00847 }
00848 }
00849
00850
00851 if ((status & UDP_CSR_RXSETUP) != 0) {
00852
00853 TRACE_DEBUG_WP("Stp ");
00854
00855
00856
00857
00858
00859 if ((pEndpoint->state == UDP_ENDPOINT_RECEIVING)
00860 || (pEndpoint->state == UDP_ENDPOINT_SENDING)) {
00861
00862 UDP_EndOfTransfer(bEndpoint, USBD_STATUS_SUCCESS);
00863 }
00864
00865 UDP_ReadRequest(&request);
00866
00867
00868 if (USBGenericRequest_GetDirection(&request) == USBGenericRequest_IN) {
00869
00870 SET_CSR(bEndpoint, UDP_CSR_DIR);
00871 }
00872
00873 CLEAR_CSR(bEndpoint, UDP_CSR_RXSETUP);
00874
00875
00876 USBD_RequestHandler(0, &request);
00877 }
00878
00879 }
00880
00881
00882
00883
00884
00885
00886
00887
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898
00899 static inline uint8_t UDP_Write(uint8_t bEndpoint,
00900 const void *pData,
00901 uint32_t dLength)
00902 {
00903 Endpoint *pEndpoint = &(endpoints[bEndpoint]);
00904 Transfer *pTransfer = (Transfer*)&(pEndpoint->transfer);
00905
00906
00907 if (pEndpoint->state != UDP_ENDPOINT_IDLE) {
00908
00909 return USBD_STATUS_LOCKED;
00910 }
00911 TRACE_DEBUG_WP("Write%d(%d) ", bEndpoint, dLength);
00912
00913
00914 pTransfer->pData = (void *) pData;
00915 pTransfer->remaining = dLength;
00916 pTransfer->buffered = 0;
00917 pTransfer->transferred = 0;
00918
00919
00920 pEndpoint->state = UDP_ENDPOINT_SENDING;
00921 while((UDP->UDP_CSR[bEndpoint]&UDP_CSR_TXPKTRDY)==UDP_CSR_TXPKTRDY);
00922 UDP_WritePayload(bEndpoint);
00923 SET_CSR(bEndpoint, UDP_CSR_TXPKTRDY);
00924
00925
00926
00927 if ((CHIP_USB_ENDPOINTS_BANKS(bEndpoint) > 1) && (pTransfer->remaining > 0)) {
00928
00929 UDP_WritePayload(bEndpoint);
00930 }
00931
00932
00933 UDP->UDP_IER = 1 << bEndpoint;
00934
00935 return USBD_STATUS_SUCCESS;
00936 }
00937
00938
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953
00954
00955
00956 static inline uint8_t UDP_AddWr(uint8_t bEndpoint,
00957 const void *pData,
00958 uint32_t dLength)
00959 {
00960 Endpoint *pEndpoint = &(endpoints[bEndpoint]);
00961 MblTransfer *pMbl = (MblTransfer*)&(pEndpoint->transfer);
00962 USBDTransferBuffer *pTx;
00963
00964
00965 if (dLength >= 0x10000)
00966 return USBD_STATUS_INVALID_PARAMETER;
00967
00968
00969 if (pEndpoint->state > UDP_ENDPOINT_IDLE) {
00970
00971 if (pMbl->listState == MBL_FULL) {
00972 return USBD_STATUS_LOCKED;
00973 }
00974 }
00975
00976 TRACE_DEBUG_WP("AddW%d(%d) ", bEndpoint, dLength);
00977
00978
00979 pTx = &(pMbl->pMbl[pMbl->inCurr]);
00980 pTx->pBuffer = (uint8_t*)pData;
00981 pTx->size = pTx->remaining = dLength;
00982 pTx->transferred = pTx->buffered = 0;
00983
00984 if (pMbl->inCurr >= (pMbl->listSize-1)) pMbl->inCurr = 0;
00985 else pMbl->inCurr ++;
00986 if (pMbl->inCurr == pMbl->outCurr) pMbl->listState = MBL_FULL;
00987 else pMbl->listState = 0;
00988
00989 if (MBL_NbBuffer(pMbl->inCurr, pMbl->outCurr, pMbl->listSize)
00990 >= pMbl->offsetSize
00991 && pEndpoint->state == UDP_ENDPOINT_IDLE) {
00992 TRACE_DEBUG_WP("StartT ");
00993
00994 pEndpoint->state = UDP_ENDPOINT_SENDINGM;
00995 while((UDP->UDP_CSR[bEndpoint]&UDP_CSR_TXPKTRDY)==UDP_CSR_TXPKTRDY);
00996
00997 UDP_MblWriteFifo(bEndpoint);
00998 SET_CSR(bEndpoint, UDP_CSR_TXPKTRDY);
00999
01000 if ((CHIP_USB_ENDPOINTS_BANKS(bEndpoint) > 1)
01001 && pMbl->pMbl[pMbl->outCurr].remaining) {
01002 UDP_MblWriteFifo(bEndpoint);
01003 }
01004
01005 UDP->UDP_IER = 1 << bEndpoint;
01006 }
01007
01008 return USBD_STATUS_SUCCESS;
01009 }
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024
01025 static inline uint8_t UDP_Read(uint8_t bEndpoint,
01026 void *pData,
01027 uint32_t dLength)
01028 {
01029 Endpoint *pEndpoint = &(endpoints[bEndpoint]);
01030 Transfer *pTransfer = (Transfer*)&(pEndpoint->transfer);
01031
01032
01033 if (pEndpoint->state != UDP_ENDPOINT_IDLE) {
01034
01035 return USBD_STATUS_LOCKED;
01036 }
01037
01038
01039 pEndpoint->state = UDP_ENDPOINT_RECEIVING;
01040 TRACE_DEBUG_WP("Read%d(%d) ", bEndpoint, dLength);
01041
01042
01043 pTransfer->pData = pData;
01044 pTransfer->remaining = dLength;
01045 pTransfer->buffered = 0;
01046 pTransfer->transferred = 0;
01047
01048
01049 UDP->UDP_IER = 1 << bEndpoint;
01050
01051 return USBD_STATUS_SUCCESS;
01052 }
01053
01054
01055
01056
01057
01058
01059
01060
01061
01062
01063
01064 void USBD_IrqHandler(void)
01065 {
01066 uint32_t status;
01067 int32_t eptnum = 0;
01068
01069
01070
01071
01072
01073
01074 status = UDP->UDP_ISR;
01075 status &= UDP->UDP_IMR;
01076
01077 if (USBD_GetState() < USBD_STATE_POWERED) {
01078
01079 status &= UDP_ICR_WAKEUP | UDP_ICR_RXRSM;
01080 UDP->UDP_ICR = ~status;
01081 }
01082
01083
01084 if (status == 0) {
01085
01086 TRACE_DEBUG_WP(".\n\r");
01087 return;
01088 }
01089
01090
01091 if (USBD_GetState() >= USBD_STATE_POWERED) {
01092
01093
01094 }
01095
01096
01097
01098
01099
01100
01101
01102
01103
01104
01105
01106
01107
01108
01109
01110
01111 if ((status & (UDP_ISR_WAKEUP | UDP_ISR_RXRSM)) != 0) {
01112
01113 TRACE_INFO_WP("Res ");
01114
01115 UDP->UDP_ICR = UDP_ICR_WAKEUP | UDP_ICR_RXRSM | UDP_ICR_RXSUSP;
01116 UDP->UDP_IDR = UDP_IDR_WAKEUP | UDP_IDR_RXRSM;
01117
01118 USBD_ResumeHandler();
01119 }
01120
01121
01122
01123 if (status == UDP_ISR_RXSUSP) {
01124
01125 TRACE_INFO_WP("Susp ");
01126
01127 UDP->UDP_IER = UDP_IER_WAKEUP | UDP_IER_RXRSM;
01128
01129 UDP->UDP_ICR = UDP_ICR_RXSUSP;
01130
01131 USBD_SuspendHandler();
01132 }
01133
01134 else if ((status & UDP_ISR_ENDBUSRES) != 0) {
01135
01136 TRACE_INFO_WP("EoBRes ");
01137
01138 UDP->UDP_ICR = UDP_ICR_WAKEUP | UDP_ICR_RXRSM | UDP_ICR_RXSUSP;
01139 UDP->UDP_IER = UDP_IER_RXSUSP;
01140
01141
01142 USBD_ResetHandler();
01143
01144
01145 UDP->UDP_ICR = UDP_ICR_ENDBUSRES;
01146 }
01147
01148 else {
01149
01150 status &= ((1 << CHIP_USB_NUMENDPOINTS) - 1);
01151 while (status != 0) {
01152
01153
01154 if ((status & (1 << eptnum)) != 0) {
01155
01156 UDP_EndpointHandler(eptnum);
01157 status &= ~(1 << eptnum);
01158
01159 if (status != 0) {
01160
01161 TRACE_INFO_WP("\n\r - ");
01162 }
01163 }
01164 eptnum++;
01165 }
01166 }
01167
01168
01169 TRACE_DEBUG_WP("!");
01170 TRACE_INFO_WP("\n\r");
01171 if (USBD_GetState() >= USBD_STATE_POWERED) {
01172
01173
01174 }
01175 }
01176
01177
01178
01179
01180
01181
01182
01183
01184
01185
01186
01187
01188 void USBD_HAL_ResetEPs(uint32_t bmEPs, uint8_t bStatus, uint8_t bKeepCfg)
01189 {
01190 Endpoint *pEndpoint;
01191 uint32_t tmp = bmEPs & ((1<<CHIP_USB_NUMENDPOINTS)-1);
01192 uint8_t ep;
01193 uint32_t epBit, epCfg;
01194 for (ep = 0, epBit = 1; ep < CHIP_USB_NUMENDPOINTS; ep ++) {
01195 if (tmp & epBit) {
01196
01197
01198 UDP->UDP_IDR = epBit;
01199
01200 CLEAR_CSR(ep, UDP_CSR_TXPKTRDY);
01201
01202
01203 pEndpoint = &(endpoints[ep]);
01204
01205 pEndpoint->bank = 0;
01206
01207 epCfg = UDP->UDP_CSR[ep];
01208
01209 UDP->UDP_RST_EP |= epBit;
01210 UDP->UDP_RST_EP &= ~epBit;
01211
01212 if (bKeepCfg) {
01213
01214 SET_CSR(ep, epCfg);
01215 }
01216 else {
01217
01218 pEndpoint->state = UDP_ENDPOINT_DISABLED;
01219 }
01220
01221
01222 UDP_EndOfTransfer(ep, bStatus);
01223 }
01224 epBit <<= 1;
01225 }
01226
01227
01228
01229 }
01230
01231
01232
01233
01234
01235
01236 void USBD_HAL_CancelIo(uint32_t bmEPs)
01237 {
01238 uint32_t tmp = bmEPs & ((1<<CHIP_USB_NUMENDPOINTS)-1);
01239 uint8_t ep;
01240 uint32_t epBit;
01241 for (ep = 0, epBit = 1; ep < CHIP_USB_NUMENDPOINTS; ep ++) {
01242 if (tmp & epBit) {
01243
01244
01245 UDP->UDP_IDR = epBit;
01246
01247 CLEAR_CSR(ep, UDP_CSR_TXPKTRDY);
01248
01249
01250 UDP_EndOfTransfer(ep, USBD_STATUS_CANCELED);
01251 }
01252 epBit <<= 1;
01253 }
01254 }
01255
01256
01257
01258
01259
01260 uint8_t USBD_HAL_ConfigureEP(const USBEndpointDescriptor *pDescriptor)
01261 {
01262 Endpoint *pEndpoint;
01263 uint8_t bEndpoint;
01264 uint8_t bType;
01265 uint8_t bEndpointDir;
01266
01267
01268 if (pDescriptor == 0) {
01269 bEndpoint = 0;
01270 pEndpoint = &(endpoints[bEndpoint]);
01271 bType= USBEndpointDescriptor_CONTROL;
01272 bEndpointDir = 0;
01273 pEndpoint->size = CHIP_USB_ENDPOINTS_MAXPACKETSIZE(0);
01274 }
01275
01276 else if (pDescriptor->bDescriptorType == USBGenericDescriptor_DEVICE) {
01277 bEndpoint = 0;
01278 pEndpoint = &(endpoints[bEndpoint]);
01279 bType = USBEndpointDescriptor_CONTROL;
01280 bEndpointDir = 0;
01281 pEndpoint->size = ((USBDeviceDescriptor *)pDescriptor)->bMaxPacketSize0;
01282 }
01283
01284 else if (pDescriptor->bDescriptorType != USBGenericDescriptor_ENDPOINT) {
01285 return 0xFF;
01286 }
01287 else {
01288 bEndpoint = USBEndpointDescriptor_GetNumber(pDescriptor);
01289 pEndpoint = &(endpoints[bEndpoint]);
01290 bType = USBEndpointDescriptor_GetType(pDescriptor);
01291 bEndpointDir = USBEndpointDescriptor_GetDirection(pDescriptor);
01292 pEndpoint->size = USBEndpointDescriptor_GetMaxPacketSize(pDescriptor);
01293 }
01294
01295
01296
01297 if ((pEndpoint->state == UDP_ENDPOINT_RECEIVING)
01298 || (pEndpoint->state == UDP_ENDPOINT_SENDING)
01299 || (pEndpoint->state == UDP_ENDPOINT_RECEIVINGM)
01300 || (pEndpoint->state == UDP_ENDPOINT_SENDINGM)) {
01301 UDP_EndOfTransfer(bEndpoint, USBD_STATUS_RESET);
01302 }
01303 pEndpoint->state = UDP_ENDPOINT_IDLE;
01304
01305
01306 UDP->UDP_RST_EP |= (1 << bEndpoint);
01307 UDP->UDP_RST_EP &= ~(1 << bEndpoint);
01308
01309
01310 SET_CSR(bEndpoint, (uint32_t)UDP_CSR_EPEDS
01311 | (bType << 8) | (bEndpointDir << 10));
01312 if (bType != USBEndpointDescriptor_CONTROL) {
01313
01314 }
01315 else {
01316
01317 UDP->UDP_IER = (1 << bEndpoint);
01318 }
01319
01320 TRACE_INFO_WP("CfgEp%d ", bEndpoint);
01321 return bEndpoint;
01322 }
01323
01324
01325
01326
01327
01328
01329
01330
01331
01332
01333 uint8_t USBD_HAL_SetTransferCallback(uint8_t bEP,
01334 TransferCallback fCallback,
01335 void *pCbData)
01336 {
01337 Endpoint *pEndpoint = &(endpoints[bEP]);
01338 TransferHeader *pTransfer = (TransferHeader*)&(pEndpoint->transfer);
01339
01340 if (pEndpoint->state > UDP_ENDPOINT_IDLE) {
01341 return USBD_STATUS_LOCKED;
01342 }
01343 TRACE_DEBUG_WP("sXfrCb ");
01344
01345 pTransfer->fCallback = (void*)fCallback;
01346 pTransfer->pArgument = pCbData;
01347 return USBD_STATUS_SUCCESS;
01348 }
01349
01350
01351
01352
01353
01354
01355
01356
01357 uint8_t USBD_HAL_SetupMblTransfer( uint8_t bEndpoint,
01358 USBDTransferBuffer* pMbList,
01359 uint16_t mblSize,
01360 uint16_t startOffset)
01361 {
01362 Endpoint *pEndpoint = &(endpoints[bEndpoint]);
01363 MblTransfer *pXfr = (MblTransfer*)&(pEndpoint->transfer);
01364 uint16_t i;
01365
01366 if (pEndpoint->state > UDP_ENDPOINT_IDLE) {
01367 return USBD_STATUS_LOCKED;
01368 }
01369 TRACE_DEBUG_WP("sMblXfr ");
01370
01371 if (pMbList) {
01372
01373 for (i = 0; i < mblSize; i --) {
01374 pMbList[i].pBuffer = NULL;
01375 pMbList[i].size = 0;
01376 pMbList[i].transferred = 0;
01377 pMbList[i].buffered = 0;
01378 pMbList[i].remaining = 0;
01379 }
01380
01381 pXfr->transType = 1;
01382 pXfr->listState = 0;
01383 pXfr->listSize = mblSize;
01384 pXfr->pMbl = pMbList;
01385 pXfr->outCurr = pXfr->outLast = 0;
01386 pXfr->inCurr = 0;
01387 pXfr->offsetSize = startOffset;
01388 }
01389
01390 else {
01391 pXfr->transType = 0;
01392 pXfr->pMbl = NULL;
01393 pXfr->listSize = 0;
01394 pXfr->offsetSize = 1;
01395 }
01396 return USBD_STATUS_SUCCESS;
01397 }
01398
01399
01400
01401
01402
01403
01404
01405
01406
01407
01408
01409
01410
01411
01412
01413
01414
01415
01416
01417 uint8_t USBD_HAL_Write( uint8_t bEndpoint,
01418 const void *pData,
01419 uint32_t dLength)
01420 {
01421 if (endpoints[bEndpoint].transfer.transHdr.transType)
01422 return UDP_AddWr(bEndpoint, pData, dLength);
01423 else
01424 return UDP_Write(bEndpoint, pData, dLength);
01425 }
01426
01427
01428
01429
01430
01431
01432
01433
01434
01435
01436
01437
01438
01439
01440
01441 uint8_t USBD_HAL_Read(uint8_t bEndpoint,
01442 void *pData,
01443 uint32_t dLength)
01444 {
01445 if (endpoints[bEndpoint].transfer.transHdr.transType)
01446 return USBD_STATUS_SW_NOT_SUPPORTED;
01447 else
01448 return UDP_Read(bEndpoint, pData, dLength);
01449 }
01450
01451
01452
01453
01454
01455
01456
01457
01458 void USBD_HAL_Connect(void)
01459 {
01460 uint8_t dis = UDP_EnablePeripheralClock();
01461 UDP->UDP_TXVC |= UDP_TXVC_PUON;
01462 if (dis) UDP_DisablePeripheralClock();
01463 }
01464
01465
01466
01467
01468
01469
01470
01471
01472 void USBD_HAL_Disconnect(void)
01473 {
01474 uint8_t dis = UDP_EnablePeripheralClock();
01475 UDP->UDP_TXVC &= ~(uint32_t)UDP_TXVC_PUON;
01476 if (dis) UDP_DisablePeripheralClock();
01477 }
01478
01479
01480
01481
01482 void USBD_HAL_RemoteWakeUp(void)
01483 {
01484 UDP_EnablePeripheralClock();
01485 UDP_EnableUsbClock();
01486 UDP_EnableTransceiver();
01487
01488 TRACE_INFO_WP("RWUp ");
01489
01490
01491 UDP->UDP_GLB_STAT |= UDP_GLB_STAT_ESR;
01492 UDP->UDP_GLB_STAT &= ~(uint32_t)UDP_GLB_STAT_ESR;
01493 }
01494
01495
01496
01497
01498
01499 void USBD_HAL_SetAddress(uint8_t address)
01500 {
01501
01502 UDP->UDP_FADDR = UDP_FADDR_FEN | (address & UDP_FADDR_FADD_Msk);
01503
01504 if (address == 0) UDP->UDP_GLB_STAT = 0;
01505
01506 else UDP->UDP_GLB_STAT = UDP_GLB_STAT_FADDEN;
01507 }
01508
01509
01510
01511
01512
01513 void USBD_HAL_SetConfiguration(uint8_t cfgnum)
01514 {
01515
01516
01517 if (cfgnum != 0) UDP->UDP_GLB_STAT |= UDP_GLB_STAT_CONFG;
01518
01519
01520 else {
01521 UDP->UDP_GLB_STAT = UDP_FADDR_FEN;
01522 }
01523 }
01524
01525
01526
01527
01528 void USBD_HAL_Init(void)
01529 {
01530
01531 UDP_EnablePeripheralClock();
01532
01533
01534 USBD_HAL_ResetEPs(0xFFFFFFFF, USBD_STATUS_RESET, 0);
01535
01536
01537 UDP->UDP_TXVC &= ~(uint32_t)UDP_TXVC_PUON;
01538
01539 UDP_EnableUsbClock();
01540
01541 UDP->UDP_IDR = 0xFE;
01542 UDP->UDP_IER = UDP_IER_WAKEUP;
01543 }
01544
01545
01546
01547
01548
01549
01550
01551 uint8_t USBD_HAL_Stall(uint8_t bEP)
01552 {
01553 Endpoint *pEndpoint = &(endpoints[bEP]);
01554
01555
01556 if (pEndpoint->state != UDP_ENDPOINT_IDLE) {
01557 TRACE_WARNING("UDP_Stall: EP%d locked\n\r", bEP);
01558 return USBD_STATUS_LOCKED;
01559 }
01560
01561 SET_CSR(bEP, UDP_CSR_FORCESTALL);
01562 TRACE_DEBUG_WP("Stall%d ", bEP);
01563 return USBD_STATUS_SUCCESS;
01564 }
01565
01566
01567
01568
01569
01570
01571
01572
01573
01574
01575
01576
01577 uint8_t USBD_HAL_Halt(uint8_t bEndpoint, uint8_t ctl)
01578 {
01579 Endpoint *pEndpoint = &(endpoints[bEndpoint]);
01580 uint8_t status = 0;
01581
01582
01583 if (ctl == 1) {
01584
01585 if ((pEndpoint->state != UDP_ENDPOINT_DISABLED)
01586 && (pEndpoint->state != UDP_ENDPOINT_HALTED)) {
01587
01588 TRACE_DEBUG_WP("Halt%d ", bEndpoint);
01589
01590
01591 UDP_EndOfTransfer(bEndpoint, USBD_STATUS_ABORTED);
01592
01593
01594 SET_CSR(bEndpoint, UDP_CSR_FORCESTALL);
01595 pEndpoint->state = UDP_ENDPOINT_HALTED;
01596
01597
01598 UDP->UDP_IER = 1 << bEndpoint;
01599 }
01600 }
01601
01602 else if (ctl == 0) {
01603
01604
01605 if (pEndpoint->state == UDP_ENDPOINT_HALTED) {
01606
01607 TRACE_DEBUG_WP("Unhalt%d ", bEndpoint);
01608
01609
01610 pEndpoint->state = UDP_ENDPOINT_IDLE;
01611
01612
01613 CLEAR_CSR(bEndpoint, UDP_CSR_FORCESTALL);
01614
01615
01616 UDP->UDP_RST_EP |= 1 << bEndpoint;
01617 UDP->UDP_RST_EP &= ~(1 << bEndpoint);
01618 }
01619 }
01620
01621
01622 if (pEndpoint->state == UDP_ENDPOINT_HALTED) {
01623 status = 1;
01624 }
01625 return( status );
01626 }
01627
01628
01629
01630
01631
01632 uint8_t USBD_HAL_IsHighSpeed(void)
01633 {
01634 return 0;
01635 }
01636
01637
01638
01639
01640
01641
01642
01643
01644 void USBD_HAL_Suspend(void)
01645 {
01646
01647 UDP_DisableTransceiver();
01648 UDP_DisableUsbClock();
01649 UDP_DisablePeripheralClock();
01650 }
01651
01652
01653
01654
01655
01656
01657
01658 void USBD_HAL_Activate(void)
01659 {
01660 UDP_EnablePeripheralClock();
01661 UDP_EnableUsbClock();
01662 UDP_EnableTransceiver();
01663 }
01664
01665
01666
01667
01668
01669 void USBD_HAL_Test( uint8_t bIndex )
01670 {
01671 bIndex = bIndex;
01672 }
01673
01674
01675