git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/WizNET_DEMO_TERN_186/serial/serial.c

   1 /*\r
   2  * FreeRTOS Kernel V10.0.0\r
   3  * Copyright (C) 2017 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
   4  *\r
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
   6  * this software and associated documentation files (the "Software"), to deal in\r
   7  * the Software without restriction, including without limitation the rights to\r
   8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
   9  * the Software, and to permit persons to whom the Software is furnished to do so,\r
  10  * subject to the following conditions:\r
  11  *\r
  12  * The above copyright notice and this permission notice shall be included in all\r
  13  * copies or substantial portions of the Software. If you wish to use our Amazon\r
  14  * FreeRTOS name, please do so in a fair use way that does not cause confusion.\r
  15  *\r
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
  18  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
  19  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
  20  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  22  *\r
  23  * http://www.FreeRTOS.org\r
  24  * http://aws.amazon.com/freertos\r
  25  *\r
  26  * 1 tab == 4 spaces!\r
  27  */\r
  28 \r
  29 \r
  30 #include <stdlib.h>\r
  31 #include <embedded.h>\r
  32 #include "FreeRTOS.h"\r
  33 #include "portasm.h"\r
  34 #include "queue.h"\r
  35 #include "task.h"\r
  36 #include "semphr.h"\r
  37 \r
  38 #define serMAX_PORTS                    ( ( unsigned short ) 2 )\r
  39 \r
  40 #define serPORT_0_INT_REG               ( 0xff44 )\r
  41 #define serPORT_0_BAUD_REG              ( 0xff88 )\r
  42 #define serPORT_0_RX_REG                ( 0xff86 )\r
  43 #define serPORT_0_TX_REG                ( 0xff84 )\r
  44 #define serPORT_0_STATUS_REG    ( 0xff82 )\r
  45 #define serPORT_0_CTRL_REG              ( 0xff80 )\r
  46 #define serPORT_0_IRQ                   ( 0x14 )\r
  47 \r
  48 #define serPORT_1_INT_REG               ( 0xff42 )\r
  49 #define serPORT_1_BAUD_REG              ( 0xff18 )\r
  50 #define serPORT_1_RX_REG                ( 0xff16 )\r
  51 #define serPORT_1_TX_REG                ( 0xff14 )\r
  52 #define serPORT_1_STATUS_REG    ( 0xff12 )\r
  53 #define serPORT_1_CTRL_REG              ( 0xff10 )\r
  54 #define serPORT_1_IRQ                   ( 0x11 )\r
  55 \r
  56 #define serTX_EMPTY                             ( ( unsigned short ) 0x40 )\r
  57 #define serRX_READY                             ( ( unsigned short ) 0x80 )\r
  58 \r
  59 #define serRESET_PIC( usEOI_TYPE )      portOUTPUT_WORD( ( unsigned short ) 0xff22, usEOI_TYPE )\r
  60 #define serTX_HOLD_EMPTY_INT            ( ( unsigned short ) 0x100 )\r
  61 \r
  62 #define serENABLE_INTERRUPTS            ( ( unsigned short ) 0x80 )\r
  63 #define serMODE                                         ( ( unsigned short ) 0x01 )\r
  64 #define serENABLE_TX_MACHINES           ( ( unsigned short ) 0x40 )\r
  65 #define serENABLE_RX_MACHINES           ( ( unsigned short ) 0x20 )\r
  66 #define serINTERRUPT_MASK                       ( ( unsigned short ) 0x08 )\r
  67 #define serCLEAR_ALL_STATUS_BITS        ( ( unsigned short ) 0x00 )\r
  68 #define serINTERRUPT_PRIORITY           ( ( unsigned short ) 0x01 ) /*< Just below the scheduler priority. */\r
  69 \r
  70 #define serDONT_BLOCK                           ( ( TickType_t ) 0 )\r
  71 \r
  72 typedef enum\r
  73 { \r
  74         serCOM1 = 0, \r
  75         serCOM2, \r
  76         serCOM3, \r
  77         serCOM4, \r
  78         serCOM5, \r
  79         serCOM6, \r
  80         serCOM7, \r
  81         serCOM8 \r
  82 } eCOMPort;\r
  83 \r
  84 typedef enum \r
  85 { \r
  86         serNO_PARITY, \r
  87         serODD_PARITY, \r
  88         serEVEN_PARITY, \r
  89         serMARK_PARITY, \r
  90         serSPACE_PARITY \r
  91 } eParity;\r
  92 \r
  93 typedef enum \r
  94 { \r
  95         serSTOP_1, \r
  96         serSTOP_2 \r
  97 } eStopBits;\r
  98 \r
  99 typedef enum \r
 100 {\r
 101         serBITS_5,\r
 102         serBITS_6,\r
 103         serBITS_7,\r
 104         serBITS_8\r
 105 } eDataBits;\r
 106 \r
 107 typedef enum\r
 108 {\r
 109         ser50 = 0,\r
 110         ser75,\r
 111         ser110,\r
 112         ser134,\r
 113         ser150,\r
 114         ser200,\r
 115         ser300,\r
 116         ser600,\r
 117         ser1200,\r
 118         ser1800,\r
 119         ser2400,\r
 120         ser4800,\r
 121         ser9600,\r
 122         ser19200,\r
 123         ser38400,\r
 124         ser57600,\r
 125         ser115200\r
 126 } eBaud;\r
 127 \r
 128 typedef struct xCOM_PORT\r
 129 {\r
 130         /* Hardware parameters for this port. */\r
 131         short sTxInterruptOn;\r
 132         unsigned short usIntReg;\r
 133         unsigned short usBaudReg;\r
 134         unsigned short usRxReg;\r
 135         unsigned short usTxReg;\r
 136         unsigned short usStatusReg;\r
 137         unsigned short usCtrlReg;\r
 138 \r
 139         unsigned short usIRQVector;\r
 140 \r
 141         /* Queues used for communications with com test task. */\r
 142         QueueHandle_t xRxedChars; \r
 143         QueueHandle_t xCharsForTx;\r
 144 \r
 145         /* This semaphore does nothing useful except test a feature of the\r
 146         scheduler. */\r
 147         SemaphoreHandle_t xTestSem;\r
 148 \r
 149 } xComPort;\r
 150 \r
 151 static xComPort xPorts[ serMAX_PORTS ] = \r
 152 {\r
 153         { pdFALSE, serPORT_0_INT_REG, serPORT_0_BAUD_REG, serPORT_0_RX_REG, serPORT_0_TX_REG, serPORT_0_STATUS_REG, serPORT_0_CTRL_REG, serPORT_0_IRQ, NULL, NULL, NULL },\r
 154         { pdFALSE, serPORT_1_INT_REG, serPORT_1_BAUD_REG, serPORT_1_RX_REG, serPORT_1_TX_REG, serPORT_1_STATUS_REG, serPORT_1_CTRL_REG, serPORT_1_IRQ, NULL, NULL, NULL }\r
 155 };\r
 156 \r
 157 typedef xComPort * xComPortHandle;\r
 158 \r
 159 /**\r
 160  * Lookup the baud rate from the enum.\r
 161  */\r
 162 static unsigned long prvBaud( eBaud eWantedBaud ); \r
 163 \r
 164 /* These prototypes are repeated here so we don't have to include the serial header.  This allows\r
 165 the xComPortHandle structure details to be private to this file. */\r
 166 xComPortHandle xSerialPortInit( eCOMPort ePort, eBaud eWantedBaud, eParity eWantedParity, eDataBits eWantedDataBits, eStopBits eWantedStopBits, unsigned portBASE_TYPE uxBufferLength );\r
 167 portBASE_TYPE xSerialGetChar( xComPortHandle pxPort, char *pcRxedChar, TickType_t xBlockTime );\r
 168 portBASE_TYPE xSerialPutChar( xComPortHandle pxPort, char cOutChar, TickType_t xBlockTime );\r
 169 void vSerialClose( xComPortHandle xPort );\r
 170 short sSerialWaitForSemaphore( xComPortHandle xPort );\r
 171 /*-----------------------------------------------------------*/\r
 172 \r
 173 static short xComPortISR( xComPort * const pxPort );\r
 174 \r
 175 #define vInterruptOn( pxPort, usInterrupt )                                                                             \\r
 176 {                                                                                                                                                               \\r
 177 unsigned short usIn;                                                                                                            \\r
 178                                                                                                                                                                 \\r
 179         portENTER_CRITICAL();                                                                                                           \\r
 180         {                                                                                                                                                       \\r
 181                 if( pxPort->sTxInterruptOn == pdFALSE )                                                                 \\r
 182                 {                                                                                                                                               \\r
 183                         usIn = portINPUT_WORD( pxPort->usCtrlReg );                                                     \\r
 184                         portOUTPUT_WORD( pxPort->usCtrlReg, usIn | usInterrupt );                       \\r
 185                                                                                                                                                                 \\r
 186                         pxPort->sTxInterruptOn = pdTRUE;                                                                        \\r
 187                 }                                                                                                                                               \\r
 188         }                                                                                                                                                       \\r
 189         portEXIT_CRITICAL();                                                                                                            \\r
 190 }                                                                                                                                                               \r
 191 /*-----------------------------------------------------------*/\r
 192 \r
 193 #define vInterruptOff( pxPort, usInterrupt )                                                                    \\r
 194 {                                                                                                                                                               \\r
 195         unsigned short usIn = portINPUT_WORD( pxPort->usCtrlReg );                              \\r
 196         if( usIn & usInterrupt )                                                                                                        \\r
 197         {                                                                                                                                                       \\r
 198                 portOUTPUT_WORD( pxPort->usCtrlReg, usIn & ~usInterrupt);                               \\r
 199                 pxPort->sTxInterruptOn = pdFALSE;                                                                               \\r
 200         }                                                                                                                                                       \\r
 201 }\r
 202 /*-----------------------------------------------------------*/\r
 203 \r
 204 \r
 205 /* Define an interrupt handler for each port */\r
 206 #define COM_IRQ_WRAPPER(N)                                                                              \\r
 207         static void __interrupt COM_IRQ##N##_WRAPPER( void )            \\r
 208         {                                                                                                                       \\r
 209         if( xComPortISR( &( xPorts[##N##] ) ) )                 \\r
 210         {                                                       \\r
 211                         portEND_SWITCHING_ISR();                            \\r
 212                 }                                                       \\r
 213         }\r
 214 \r
 215   \r
 216 \r
 217 COM_IRQ_WRAPPER( 0 )\r
 218 COM_IRQ_WRAPPER( 1 )\r
 219 \r
 220 static pxISR xISRs[ serMAX_PORTS ] = \r
 221 {\r
 222         COM_IRQ0_WRAPPER, \r
 223         COM_IRQ1_WRAPPER\r
 224 };\r
 225 \r
 226 /*-----------------------------------------------------------*/\r
 227 \r
 228 static unsigned long prvBaud( eBaud eWantedBaud )\r
 229 {\r
 230         switch( eWantedBaud )\r
 231     {\r
 232                 case ser50                      :       return 50UL;\r
 233                 case ser75                      :       return 75UL;\r
 234                 case ser110                     :       return 110UL;\r
 235                 case ser134                     :       return 134UL;\r
 236                 case ser150                     :       return 150UL;\r
 237                 case ser200                     :       return 200UL;\r
 238                 case ser300                     :       return 300UL;\r
 239                 case ser600                     :       return 600UL;\r
 240                 case ser1200            :       return 1200UL;\r
 241                 case ser1800            :       return 1800UL;\r
 242                 case ser2400            :       return 2400UL;\r
 243                 case ser4800            :       return 4800UL;\r
 244                 case ser19200           :       return 19200UL;\r
 245                 case ser38400           :       return 38400UL;\r
 246                 case ser57600           :       return 57600UL;\r
 247                 case ser115200          :       return 115200UL;\r
 248                 default                         :       return 9600UL;\r
 249     }\r
 250 }\r
 251 \r
 252 /*-----------------------------------------------------------*/\r
 253 \r
 254 xComPortHandle xSerialPortInit( eCOMPort ePort, eBaud eWantedBaud, eParity eWantedParity, eDataBits eWantedDataBits, eStopBits eWantedStopBits, unsigned portBASE_TYPE uxBufferLength )\r
 255 {\r
 256 unsigned short usPort;\r
 257 xComPortHandle pxPort = NULL;\r
 258 unsigned long ulBaudDiv;\r
 259 \r
 260         /* BAUDDIV = ( Microprocessor Clock / Baud Rate ) / 16 */\r
 261     ulBaudDiv = ( configCPU_CLOCK_HZ / prvBaud( eWantedBaud ) ) / 16UL;\r
 262 \r
 263         /* Only n, 8, 1 is supported so these parameters are not required for this\r
 264         port. */\r
 265         ( void ) eWantedParity;\r
 266         ( void ) eWantedDataBits;\r
 267     ( void ) eWantedStopBits;\r
 268 \r
 269         /* Currently only n,8,1 is supported. */\r
 270 \r
 271         usPort = ( unsigned short ) ePort;\r
 272         \r
 273         if( usPort < serMAX_PORTS )\r
 274         {\r
 275                 pxPort = &( xPorts[ usPort ] );\r
 276 \r
 277                 portENTER_CRITICAL();\r
 278                 {\r
 279                         unsigned short usInWord;\r
 280 \r
 281                         /* Create the queues used by the com test task. */\r
 282                         pxPort->xRxedChars = xQueueCreate( uxBufferLength, ( unsigned portBASE_TYPE ) sizeof( char ) );\r
 283                         pxPort->xCharsForTx = xQueueCreate( uxBufferLength, ( unsigned portBASE_TYPE ) sizeof( char ) );\r
 284 \r
 285                         /* Create the test semaphore.  This does nothing useful except test a feature of the scheduler. */\r
 286                         vSemaphoreCreateBinary( pxPort->xTestSem );\r
 287 \r
 288                         /* There is no ISR here already to restore later. */\r
 289                         setvect( ( short ) pxPort->usIRQVector, xISRs[ usPort ] );\r
 290 \r
 291                         usInWord = portINPUT_WORD( pxPort->usIntReg );\r
 292                         usInWord &= ~serINTERRUPT_MASK;\r
 293                         usInWord |= serINTERRUPT_PRIORITY;\r
 294                         portOUTPUT_WORD( pxPort->usIntReg, usInWord );\r
 295 \r
 296                         portOUTPUT_WORD( pxPort->usBaudReg, ( unsigned short ) ulBaudDiv );\r
 297                         portOUTPUT_WORD( pxPort->usCtrlReg, serENABLE_INTERRUPTS | serMODE | serENABLE_TX_MACHINES | serENABLE_RX_MACHINES );\r
 298 \r
 299                         portOUTPUT_WORD( pxPort->usStatusReg, serCLEAR_ALL_STATUS_BITS );\r
 300                 }\r
 301                 portEXIT_CRITICAL();\r
 302         }\r
 303 \r
 304         return pxPort;\r
 305 } /*lint !e715 Some parameters are not used as only a subset of the serial port functionality is currently implemented. */\r
 306 /*-----------------------------------------------------------*/\r
 307 \r
 308 void vSerialPutString( xComPortHandle pxPort, const char * const pcString, unsigned short usStringLength )\r
 309 {\r
 310 unsigned short usByte;\r
 311 char *pcNextChar;\r
 312 \r
 313         pcNextChar = ( char * ) pcString;\r
 314 \r
 315         for( usByte = 0; usByte < usStringLength; usByte++ )\r
 316         {\r
 317                 xQueueSend( pxPort->xCharsForTx, pcNextChar, serDONT_BLOCK );\r
 318                 pcNextChar++;\r
 319         }\r
 320 \r
 321         vInterruptOn( pxPort, serTX_HOLD_EMPTY_INT );\r
 322 }\r
 323 /*-----------------------------------------------------------*/\r
 324 \r
 325 portBASE_TYPE xSerialGetChar( xComPortHandle pxPort, char *pcRxedChar, TickType_t xBlockTime )\r
 326 {\r
 327         /* Get the next character from the buffer, note that this routine is only \r
 328         called having checked that the is (at least) one to get */\r
 329         if( xQueueReceive( pxPort->xRxedChars, pcRxedChar, xBlockTime ) )\r
 330         {\r
 331                 return pdTRUE;\r
 332         }\r
 333         else\r
 334         {\r
 335                 return pdFALSE;\r
 336         }\r
 337 }\r
 338 /*-----------------------------------------------------------*/\r
 339 \r
 340 portBASE_TYPE xSerialPutChar( xComPortHandle pxPort, char cOutChar, TickType_t xBlockTime )\r
 341 {\r
 342         if( xQueueSend( pxPort->xCharsForTx, &cOutChar, xBlockTime ) != pdPASS )\r
 343         {\r
 344                 return pdFAIL;\r
 345         }\r
 346 \r
 347         vInterruptOn( pxPort, serTX_HOLD_EMPTY_INT );\r
 348 \r
 349         return pdPASS;\r
 350 }\r
 351 /*-----------------------------------------------------------*/\r
 352 \r
 353 portBASE_TYPE xSerialWaitForSemaphore( xComPortHandle xPort )\r
 354 {\r
 355 const TickType_t xBlockTime = ( TickType_t ) 0xffff;\r
 356 \r
 357         /* This function does nothing interesting, but test the \r
 358         semaphore from ISR mechanism. */\r
 359         return xSemaphoreTake( xPort->xTestSem, xBlockTime );\r
 360 }\r
 361 /*-----------------------------------------------------------*/\r
 362 \r
 363 void vSerialClose( xComPortHandle xPort )\r
 364 {\r
 365 unsigned short usOutput;\r
 366 \r
 367         /* Turn off the interrupts.  We may also want to delete the queues and/or\r
 368         re-install the original ISR. */\r
 369 \r
 370         portENTER_CRITICAL();\r
 371         {\r
 372                 usOutput = portINPUT_WORD( xPort->usCtrlReg );\r
 373 \r
 374                 usOutput &= ~serENABLE_INTERRUPTS;\r
 375                 usOutput &= ~serENABLE_TX_MACHINES;\r
 376                 usOutput &= ~serENABLE_RX_MACHINES;\r
 377                 portOUTPUT_WORD( xPort->usCtrlReg, usOutput );\r
 378 \r
 379                 usOutput = portINPUT_WORD( xPort->usIntReg );\r
 380                 usOutput |= serINTERRUPT_MASK;\r
 381                 portOUTPUT_WORD( xPort->usIntReg, usOutput );\r
 382         }\r
 383         portEXIT_CRITICAL();\r
 384 }\r
 385 /*-----------------------------------------------------------*/\r
 386 unsigned short usStatus;\r
 387 static portBASE_TYPE xComPortISR( xComPort * const pxPort )\r
 388 {\r
 389 unsigned short usStatusRegister;\r
 390 char cChar;\r
 391 portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
 392 \r
 393         /* NOTE:  THIS IS NOT AN EFFICIENT ISR AS IT IS DESIGNED SOLELY TO TEST\r
 394         THE SCHEDULER FUNCTIONALITY.  REAL APPLICATIONS SHOULD NOT USE THIS\r
 395         FUNCTION. */\r
 396 \r
 397         usStatusRegister = portINPUT_WORD( pxPort->usStatusReg );\r
 398 \r
 399         if( usStatusRegister & serRX_READY )\r
 400         {\r
 401                 cChar = ( char ) portINPUT_WORD( pxPort->usRxReg );\r
 402                 xQueueSendFromISR( pxPort->xRxedChars, &cChar, &xHigherPriorityTaskWoken );\r
 403 \r
 404                 /* Also release the semaphore - this does nothing interesting and is just a test. */\r
 405                 xSemaphoreGiveFromISR( pxPort->xTestSem, &xHigherPriorityTaskWoken );\r
 406         }\r
 407         else if( pxPort->sTxInterruptOn && ( usStatusRegister & serTX_EMPTY ) )\r
 408         {\r
 409                 if( xQueueReceiveFromISR( pxPort->xCharsForTx, &cChar, &xHigherPriorityTaskWoken ) == pdTRUE )\r
 410                 {\r
 411                         portOUTPUT_WORD( pxPort->usTxReg, ( unsigned short ) cChar );\r
 412                 }\r
 413                 else\r
 414                 {\r
 415                         /* Queue empty, nothing to send */\r
 416                         vInterruptOff( pxPort, serTX_HOLD_EMPTY_INT );\r
 417                 }\r
 418         }\r
 419 \r
 420     serRESET_PIC( pxPort->usIRQVector );\r
 421 \r
 422         /* If posting to the queue woke a task that was blocked on the queue we may\r
 423         want to switch to the woken task - depending on its priority relative to\r
 424         the task interrupted by this ISR. */\r
 425         return xHigherPriorityTaskWoken;\r
 426 }\r
 427 \r
 428 \r
 429 \r
 430 \r
 431 \r