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

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