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
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120 #include "board.h"
00121 #include "..\..\..\..\utils\utility.h"
00122 #include <string.h>
00123 #include <stdio.h>
00124 #include <stdlib.h>
00125 #include "..\..\..\..\utils\md5\md5.h"
00126
00127
00128
00129
00130
00131 #define FULL_DUPLEX
00132
00133 #define BUFFER_SIZE 128
00134
00135
00136 #define PINS_USART PIN_USART0_TXD, PIN_USART0_RXD, PIN_USART0_RTS, PIN_USART0_CTS
00137
00138
00139 #define BASE_USART USART0
00140
00141
00142 #define BASE_USART_IRQ USART0_IRQn
00143
00144
00145 #define ID_USART ID_USART0
00146
00147 #define USART_Interrupt USART0_Handler
00148
00149 #define USART_TX_TIMEOUT 5000 // 5 seconds
00150
00151
00152
00153 #define USART_DMA_LLI 10
00154
00155 #define APP_BUFFER ( 100*1024) // 100 KB
00156 #define RX_BUFFER ( BUFFER_SIZE * USART_DMA_LLI ) // RingBuffer's Size
00157 #define MIN_FREE_BYTES ( BUFFER_SIZE * (USART_DMA_LLI-1) ) // min free bytes in ring buffer
00158 #define MAX_FREE_BYTES ( BUFFER_SIZE * (USART_DMA_LLI-2) ) // min free bytes in ring buffer
00159
00160 #define XDMA_NVIC_PRIO 1
00161 #define USART_NVIC_PRIO 3
00162 #define TC_NVIC_PRIO 4
00163
00164 #ifdef USE_MD5_CHECK
00165 static md5_state_t pms;
00166 static uint8_t md5[16];
00167 #endif
00168
00169
00170
00171
00172
00173 COMPILER_PACK_SET(4)
00174 typedef struct
00175 {
00176 uint8_t *pBuffer;
00177 const uint8_t reserved[3];
00178 uint32_t BuffSize;
00179 volatile uint32_t Count;
00180 volatile uint32_t *pHead;
00181 uint32_t pTail;
00182 }RignBuffer_t;
00183 COMPILER_PACK_RESET()
00184
00185
00186
00187
00188
00189 static sXdmad ChDma;
00190
00191 static UsartDma Usartd;
00192 static UsartChannel UsartTx, UsartRx;
00193
00194
00195
00196 const Pin pins[] = {PINS_USART};
00197
00198
00199 volatile uint32_t mutexTimeout;
00200 volatile uint8_t semaphore = 0;
00201 volatile uint32_t dmaflush = 0;
00202 static uint32_t TotalbytesReceived = 0;
00203 static uint8_t PingPongBufferFlag = 0;
00204 volatile uint32_t TimeOutTimer = 0;
00205
00206
00207
00208
00209
00210 COMPILER_ALIGNED(32) uint8_t pRxBuffer[RX_BUFFER];
00211
00212
00213 COMPILER_ALIGNED(32) uint8_t FirstAppBuff[APP_BUFFER];
00214 COMPILER_ALIGNED(32) uint8_t SecondAppBuff[APP_BUFFER];
00215
00216 COMPILER_WORD_ALIGNED RignBuffer_t *pUsartBuffer;
00217
00218 static void _DmaRxCallback(uint8_t status, void* pArg);
00219
00220
00221
00222
00223 #ifdef FULL_DUPLEX
00224 __STATIC_INLINE void _UpdateTxConfig(uint32_t Source, uint32_t size)
00225 {
00226 XDMAC_SetSourceAddr(ChDma.pXdmacs, UsartTx.ChNum, Source);
00227 XDMAC_SetMicroblockControl(ChDma.pXdmacs, UsartTx.ChNum, size);
00228 }
00229
00230
00231
00232
00233 static void _DmaTxCallback(uint8_t status, void* pArg)
00234 {
00235
00236 status = status;
00237 pArg = pArg;
00238
00239 UsartTx.dmaProgress = 1;
00240 if (PingPongBufferFlag)
00241 _UpdateTxConfig((uint32_t)&SecondAppBuff[0], APP_BUFFER);
00242 else
00243 _UpdateTxConfig((uint32_t)&FirstAppBuff[0], APP_BUFFER);
00244 }
00245
00246
00247
00248
00249 __STATIC_INLINE void FlushTxBuffer(uint32_t TxBytesLeft)
00250 {
00251 if (PingPongBufferFlag)
00252 _UpdateTxConfig((uint32_t)&SecondAppBuff[0], TxBytesLeft);
00253 else
00254 _UpdateTxConfig((uint32_t)&FirstAppBuff[0], TxBytesLeft);
00255 USARTD_SendData(&Usartd);
00256 while (!UsartTx.dmaProgress);
00257 }
00258
00259 #endif
00260
00261
00262
00263 __STATIC_INLINE void _UpdateCount(void)
00264 {
00265
00266 if (pUsartBuffer->pTail != *pUsartBuffer->pHead) {
00267 if (pUsartBuffer->pTail > *pUsartBuffer->pHead)
00268 pUsartBuffer->Count = (pUsartBuffer->BuffSize -
00269 (pUsartBuffer->pTail % *pUsartBuffer->pHead));
00270 else
00271 pUsartBuffer->Count = (*pUsartBuffer->pHead % pUsartBuffer->pTail);
00272 }
00273 memory_barrier();
00274 TRACE_DEBUG("COUNT is %d \n\r",pUsartBuffer->Count);
00275 }
00276
00277
00278
00279
00280 void XDMAC_Handler(void)
00281 {
00282 XDMAD_Handler(&ChDma);
00283 }
00284
00285
00286
00287
00288 void USART_Interrupt(void)
00289 {
00290 if (BASE_USART->US_CSR & US_CSR_TIMEOUT) {
00291
00292 USART_AcknowledgeRxTimeOut(BASE_USART, 0);
00293
00294 BASE_USART->US_CR = US_CR_RTSEN;
00295 XDMAC_SoftwareFlushReq(ChDma.pXdmacs, UsartRx.ChNum);
00296 dmaflush++;
00297 TRACE_DEBUG(" Time out \n\r");
00298 }
00299 }
00300
00301
00302
00303
00304 static void _DmaRxCallback( uint8_t status, void* pArg )
00305 {
00306
00307 status = status;
00308 pArg = pArg;
00309
00310 mutexTimeout = 0x7FF;
00311 while (LockMutex(semaphore, mutexTimeout));
00312 _UpdateCount();
00313 SCB_InvalidateDCache_by_Addr((uint32_t *)pRxBuffer,sizeof(pRxBuffer));
00314 if (__LDREXW(&pUsartBuffer->Count) >= MAX_FREE_BYTES) {
00315
00316
00317
00318 BASE_USART->US_CR = US_CR_RTSEN;
00319 }
00320 ReleaseMutex(semaphore);
00321 }
00322
00323
00324
00325
00326 __STATIC_INLINE void _initCircularBuffer(RignBuffer_t *pBuff)
00327 {
00328 pBuff->pBuffer = &pRxBuffer[0];
00329 pBuff->BuffSize = RX_BUFFER;
00330 pBuff->pTail = (uint32_t )pRxBuffer;
00331
00332 pBuff->pHead = &ChDma.pXdmacs->XDMAC_CHID[UsartRx.ChNum].XDMAC_CDA;
00333 pBuff->Count = 0;
00334 }
00335
00336
00337
00338
00339
00340
00341
00342 __STATIC_INLINE void _ConfigureUsart(uint32_t baudrate, uint32_t rxTimeout)
00343 {
00344 uint32_t mode = 0
00345 | US_MR_USART_MODE_HW_HANDSHAKING
00346 | US_MR_USCLKS_MCK
00347 | US_MR_CHRL_8_BIT
00348 | US_MR_PAR_NO
00349 | US_MR_NBSTOP_1_BIT
00350 | US_MR_CHMODE_NORMAL;
00351
00352
00353 memset(&UsartTx, 0, sizeof(UsartChannel));
00354 memset(&UsartRx, 0, sizeof(UsartChannel));
00355
00356
00357 UsartRx.BuffSize= BUFFER_SIZE;
00358 UsartRx.pBuff = pRxBuffer;
00359 UsartRx.callback = _DmaRxCallback;
00360 UsartRx.dmaProgrammingMode = XDMAD_LLI;
00361 UsartRx.dmaBlockSize = USART_DMA_LLI;
00362 UsartRx.dmaRingBuffer = 1;
00363 UsartRx.dmaProgress = 1;
00364
00365
00366 #ifdef FULL_DUPLEX
00367 UsartTx.BuffSize= APP_BUFFER;
00368 UsartTx.pBuff = FirstAppBuff;
00369 UsartTx.callback = _DmaTxCallback;
00370 UsartTx.dmaProgrammingMode = XDMAD_SINGLE;
00371 UsartTx.dmaBlockSize = 0;
00372 UsartTx.dmaRingBuffer = 0;
00373 #endif
00374 UsartTx.dmaProgress = 1;
00375
00376 Usartd.pXdmad = &ChDma;
00377 Usartd.pRxChannel = &UsartRx;
00378 Usartd.pTxChannel = &UsartTx;
00379 USARTD_Configure(&Usartd, ID_USART, mode, baudrate, BOARD_MCK);
00380
00381 NVIC_ClearPendingIRQ(BASE_USART_IRQ);
00382 NVIC_SetPriority( BASE_USART_IRQ , USART_NVIC_PRIO);
00383
00384 USART_EnableIt(BASE_USART, US_IER_TIMEOUT);
00385
00386 NVIC_EnableIRQ(BASE_USART_IRQ);
00387 USART_EnableRecvTimeOut( BASE_USART, rxTimeout);
00388 TRACE_INFO("Baudrate is set to %u and TimeOut is %f Sec",
00389 (unsigned)baudrate, (float)((float)rxTimeout / baudrate));
00390 }
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401 static uint32_t RingBufferRead(RignBuffer_t *pBuff, uint8_t *pDestination, uint32_t Len)
00402 {
00403 uint32_t EndAddrs = ((uint32_t)pBuff->pBuffer + pBuff->BuffSize);
00404 uint32_t UnreadCount = 0;
00405 uint32_t EnableRTS = 0;
00406 uint32_t TotalLen = 0;
00407 uint32_t TailAddrs, BytesLeft;
00408
00409
00410 if (dmaflush) {
00411 mutexTimeout = 0x7FF;
00412 BASE_USART->US_CR = US_CR_RTSEN;
00413 __disable_irq();
00414 while (LockMutex(semaphore, mutexTimeout));
00415 _UpdateCount();
00416
00417 if (pBuff->Count < MAX_FREE_BYTES)
00418 EnableRTS = US_CR_RTSDIS;
00419 dmaflush = 0;
00420 memory_sync();
00421 ReleaseMutex(semaphore);
00422 BASE_USART->US_CR = EnableRTS;
00423 __enable_irq();
00424 }
00425
00426
00427
00428 if (pBuff->Count) {
00429 UnreadCount = __LDREXW(&pBuff->Count);
00430 memory_barrier();
00431 TotalLen = (Len > UnreadCount) ? UnreadCount : Len;
00432
00433
00434 if ((pBuff->pTail + TotalLen) >= EndAddrs) {
00435 BytesLeft = (EndAddrs - pBuff->pTail);
00436 memcpy( pDestination , (uint32_t *)pBuff->pTail, BytesLeft );
00437
00438 memcpy( (pDestination +(EndAddrs - pBuff->pTail)),
00439 (uint32_t *)(pBuff->pBuffer), TotalLen - BytesLeft);
00440 TailAddrs = ( (uint32_t)pBuff->pBuffer + (TotalLen - BytesLeft));
00441 } else {
00442 memcpy( pDestination , (uint32_t *)pBuff->pTail, TotalLen);
00443 TailAddrs = pBuff->pTail + TotalLen;
00444 }
00445
00446
00447
00448
00449
00450 BASE_USART->US_CR = US_CR_RTSEN;
00451 __disable_irq();
00452 mutexTimeout = 0x7FF;
00453 while (LockMutex(semaphore, mutexTimeout));
00454 pBuff->pTail = TailAddrs;
00455 pBuff->Count -=TotalLen;
00456 TotalbytesReceived +=TotalLen;
00457 memory_sync();
00458 #ifdef FULL_DUPLEX
00459 TimeOutTimer = GetTicks();
00460 #endif
00461
00462 if (pUsartBuffer->Count < MAX_FREE_BYTES)
00463 EnableRTS = US_CR_RTSDIS;
00464 ReleaseMutex(semaphore);
00465 BASE_USART->US_CR = EnableRTS;
00466 __enable_irq();
00467
00468 printf("\r Total bytes received 0x%x (%u)", \
00469 (unsigned)TotalbytesReceived, (unsigned)TotalbytesReceived);
00470
00471 return TotalLen;
00472 } else
00473 return 0;
00474 }
00475
00476
00477
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490 int main( void )
00491 {
00492 char pbaud_time[8];
00493 uint32_t BytesRead, BytesToRead, baudrate, timeout, TxBytesLeft;
00494 uint8_t AppBufferRollOver = 0;
00495 uint8_t *pTxBuff;
00496
00497
00498 WDT_Disable(WDT);
00499
00500 printf("-- USART Hardware Handshaking Example %s --\n\r", SOFTPACK_VERSION);
00501 printf("-- %s\n\r", BOARD_NAME);
00502 printf("-- Compiled: %s %s With %s--\n\r", __DATE__, __TIME__, COMPILER_NAME);
00503
00504
00505 SCB_EnableICache();
00506 SCB_EnableDCache();
00507
00508
00509 PIO_Configure(pins, PIO_LISTSIZE(pins));
00510
00511
00512 TimeTick_Configure();
00513
00514 NVIC_SetPriority(XDMAC_IRQn , XDMA_NVIC_PRIO);
00515
00516
00517 printf("\n\rEnter required baudrate:");
00518 gets(pbaud_time);
00519 baudrate = (atoi(pbaud_time)) ? (atoi(pbaud_time)): 921600;
00520 printf("\n\rEnter required timeout (in microsec):");
00521 gets(pbaud_time);
00522
00523 timeout = atoi(pbaud_time);
00524 if (timeout > 1000) {
00525 timeout /= 1000;
00526 timeout = ((timeout * baudrate) / 1000);
00527 } else {
00528 timeout = (timeout * baudrate) / 1000000;
00529 }
00530 timeout = (timeout) ? ((timeout > MAX_RX_TIMEOUT) ? MAX_RX_TIMEOUT : timeout) \
00531 : MAX_RX_TIMEOUT;
00532 printf("\n\r");
00533
00534 _ConfigureUsart(baudrate, timeout);
00535 printf("\n\r");
00536
00537
00538 USARTD_EnableRxChannels(&Usartd, &UsartRx);
00539
00540 #ifdef FULL_DUPLEX
00541
00542 USARTD_EnableTxChannels(&Usartd, &UsartTx);
00543 #endif
00544
00545
00546 USARTD_RcvData(&Usartd);
00547
00548
00549 pUsartBuffer = (RignBuffer_t *)malloc(sizeof(RignBuffer_t));
00550 _initCircularBuffer(pUsartBuffer);
00551
00552 pTxBuff = &FirstAppBuff[0];
00553
00554 TxBytesLeft = 0;
00555
00556 #ifdef USE_MD5_CHECK
00557 md5_init(&pms);
00558 #endif //USE_MD5_CHECK
00559
00560 #ifdef FULL_DUPLEX
00561 printf( "\n\r-I- USART is in Full Duplex mode \n\r");
00562 #else
00563 printf( "\n\r-I- USART is in Half Duplex mode \n\r");
00564 #endif
00565 printf( "\n\r-I- Please send a file to serial port (USART0) \n\r");
00566 BytesToRead = MIN_FREE_BYTES;
00567
00568 while (1) {
00569 #ifdef USE_MD5_CHECK
00570 if (DBG_IsRxReady()) {
00571 ch = DBG_GetChar();
00572 if (ch == 'm') {
00573 uint8_t i;
00574 md5_finish(&pms, md5);
00575 printf("\r\nmd5:");
00576 for (i = 0; i < sizeof(md5);i++)
00577 printf("%.2x",md5[i]);
00578 printf("\r\n");
00579 md5_init(&pms);
00580 TotalbytesReceived = 0;
00581 }
00582 }
00583 #endif
00584
00585 if (((PingPongBufferFlag == 0) &&
00586 (pTxBuff+BytesToRead) >= &FirstAppBuff[APP_BUFFER]) ||
00587 (( PingPongBufferFlag == 1) && (pTxBuff+BytesToRead) >=
00588 &SecondAppBuff[APP_BUFFER])) {
00589 AppBufferRollOver = 1;
00590
00591 if (PingPongBufferFlag)
00592 BytesToRead = (&SecondAppBuff[APP_BUFFER] - pTxBuff);
00593 else
00594 BytesToRead = (&FirstAppBuff[APP_BUFFER] - pTxBuff);
00595 memory_barrier();
00596 }
00597
00598 BytesRead = RingBufferRead(pUsartBuffer, pTxBuff, BytesToRead);
00599 memory_sync();
00600 TxBytesLeft += BytesRead;
00601
00602 #ifdef USE_MD5_CHECK
00603 if (BytesRead > 0)
00604 md5_append(&pms,pTxBuff,BytesRead);
00605 #endif
00606
00607
00608 if (AppBufferRollOver && (TxBytesLeft == APP_BUFFER)) {
00609 AppBufferRollOver = 0;
00610 TxBytesLeft = 0;
00611 BytesRead = 0;
00612 BytesToRead = MIN_FREE_BYTES;
00613 while (!UsartTx.dmaProgress);
00614 if (PingPongBufferFlag) {
00615 PingPongBufferFlag = 0;
00616 pTxBuff = &FirstAppBuff[0];
00617 } else {
00618 PingPongBufferFlag = 1;
00619 pTxBuff = &SecondAppBuff[0];
00620 }
00621 memory_sync();
00622 #ifdef FULL_DUPLEX
00623 USARTD_SendData(&Usartd);
00624 #endif
00625 }
00626
00627
00628 else {
00629 BytesToRead = MIN_FREE_BYTES;
00630 pTxBuff += BytesRead;
00631
00632 #ifdef FULL_DUPLEX
00633
00634
00635 if ((GetDelayInTicks(TimeOutTimer, GetTicks()) == USART_TX_TIMEOUT)
00636 && TxBytesLeft) {
00637
00638 while (!UsartTx.dmaProgress);
00639 FlushTxBuffer(TxBytesLeft);
00640 TimeOutTimer = GetTicks();
00641 PingPongBufferFlag = 0;
00642 TxBytesLeft = 0;
00643 BytesRead = 0;
00644 BytesToRead = MIN_FREE_BYTES;
00645 pTxBuff = &FirstAppBuff[0];
00646 _UpdateTxConfig((uint32_t)&FirstAppBuff[0], APP_BUFFER);
00647 TRACE_INFO_WP(" TX Tiemout \n\r");
00648 }
00649 #endif
00650 }
00651 }
00652 }
00653