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

   1 /*\r
   2         This serial port driver is borrowed heavily from DZComm.  I have\r
   3         simplified it by removing a lot of the functionality (hardware \r
   4         flow control, etc.).  For more details and the full version see\r
   5         http://dzcomm.sourceforge.net\r
   6 \r
   7 \r
   8         FreeRTOS.org V4.6.1 - Copyright (C) 2003-2007 Richard Barry.\r
   9 \r
  10         This file is part of the FreeRTOS.org distribution.\r
  11 \r
  12         FreeRTOS.org is free software; you can redistribute it and/or modify\r
  13         it under the terms of the GNU General Public License as published by\r
  14         the Free Software Foundation; either version 2 of the License, or\r
  15         (at your option) any later version.\r
  16 \r
  17         FreeRTOS.org is distributed in the hope that it will be useful,\r
  18         but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  19         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  20         GNU General Public License for more details.\r
  21 \r
  22         You should have received a copy of the GNU General Public License\r
  23         along with FreeRTOS.org; if not, write to the Free Software\r
  24         Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\r
  25 \r
  26         A special exception to the GPL can be applied should you wish to distribute\r
  27         a combined work that includes FreeRTOS.org, without being obliged to provide\r
  28         the source code for any proprietary components.  See the licensing section \r
  29         of http://www.FreeRTOS.org for full details of how and when the exception\r
  30         can be applied.\r
  31 \r
  32         ***************************************************************************\r
  33         See http://www.FreeRTOS.org for documentation, latest information, license \r
  34         and contact details.  Please ensure to read the configuration and relevant \r
  35         port sections of the online documentation.\r
  36 \r
  37         Also see http://www.SafeRTOS.com a version that has been certified for use\r
  38         in safety critical systems, plus commercial licensing, development and\r
  39         support options.\r
  40         ***************************************************************************\r
  41 */\r
  42 \r
  43 /*\r
  44 Changes from V1.00:\r
  45         \r
  46         + Call to the more efficient portSWITCH_CONTEXT() replaces the call to \r
  47           taskYIELD() in the ISR.\r
  48 \r
  49 Changes from V1.2.0:\r
  50 \r
  51         + Added vSerialPutString().\r
  52 \r
  53 Changes from V1.2.3\r
  54 \r
  55         + The function xPortInitMinimal() has been renamed to \r
  56           xSerialPortInitMinimal() and the function xPortInit() has been renamed\r
  57           to xSerialPortInit().\r
  58 \r
  59 Changes From V2.0.0\r
  60 \r
  61         + Use portTickType in place of unsigned pdLONG for delay periods.\r
  62         + cQueueReieveFromISR() used in place of xQueueReceive() in ISR.\r
  63 */\r
  64 \r
  65 \r
  66 #include <stdlib.h>\r
  67 #include <dos.h>\r
  68 #include "FreeRTOS.h"\r
  69 #include "queue.h"\r
  70 #include "task.h"\r
  71 #include "semphr.h"\r
  72 #include "portasm.h"\r
  73 \r
  74 #define serMAX_IRQs                                             ( 16 )\r
  75 #define serTRANSMIT_HOLD_EMPTY_INT              ( 0x02 )\r
  76 #define serCOM1_STANDARD_IRQ                    ( ( unsigned portCHAR ) 4 )\r
  77 #define serCOM2_STANDARD_IRQ                    ( ( unsigned portCHAR ) 3 )\r
  78 \r
  79 \r
  80 #define serIMR_8259_0                                   ( ( unsigned portCHAR ) 0x21 )\r
  81 #define serIMR_8259_1                                   ( ( unsigned portCHAR ) 0xa1 )\r
  82 #define serISR_8259_0                                   ( ( unsigned portCHAR ) 0x20 )\r
  83 #define serISR_8259_1                                   ( ( unsigned portCHAR ) 0xa0 )\r
  84 #define serALL_COMS_INTERRUPTS                  ( ( unsigned portCHAR ) 0x0f )\r
  85 #define serALL_MODEM_CTRL_INTERRUPTS    ( ( unsigned portCHAR ) 0x0f )\r
  86 \r
  87 #define serTRANSMIT_HOLD_OFFSET                                 ( 0 )\r
  88 #define serRECEIVE_DATA_OFFSET                                  ( 0 )\r
  89 #define serBAUD_RATE_DIVISOR_LOW_OFFSET                 ( 0 )\r
  90 #define serBAUD_RATE_DIVISOR_HIGH_OFFSET                ( 1 )\r
  91 #define serINTERRUPT_ENABLE_OFFSET                              ( 1 )\r
  92 #define serINTERRUPT_ID_OFFSET                                  ( 2 )\r
  93 #define serFIFO_CTRL_OFFSET                                             ( 2 )\r
  94 #define serLINE_CTRL_OFFSET                                             ( 3 )\r
  95 #define serMODEM_CTRL_OFFSET                                    ( 4 )\r
  96 #define serLINE_STATUS_OFFSET                                   ( 5 )\r
  97 #define serMODEM_STATUS_OFFSET                                  ( 6 )\r
  98 #define serSCR_OFFSET                                                   ( 7 )\r
  99 \r
 100 #define serMAX_BAUD                     ( ( unsigned portLONG ) 115200UL )\r
 101 \r
 102 #define serNO_INTERRUPTS        ( 0x00 )\r
 103 \r
 104 #define vInterruptOn( pxPort, ucInterrupt )                                                                             \\r
 105 {                                                                                                                                                               \\r
 106         unsigned portCHAR ucIn = portINPUT_BYTE( pxPort->usInterruptEnableReg );        \\r
 107         if( !( ucIn & ucInterrupt ) )                                                                                           \\r
 108         {                                                                                                                                                       \\r
 109                 portOUTPUT_BYTE( pxPort->usInterruptEnableReg, ucIn | ucInterrupt );    \\r
 110         }                                                                                                                                                       \\r
 111 }                                                                                                                                                               \r
 112 /*-----------------------------------------------------------*/\r
 113 \r
 114 #define vInterruptOff( pxPort, ucInterrupt )                                                                    \\r
 115 {                                                                                                                                                               \\r
 116         unsigned portCHAR ucIn = portINPUT_BYTE( pxPort->usInterruptEnableReg );        \\r
 117         if( ucIn & ucInterrupt )                                                                                                        \\r
 118         {                                                                                                                                                       \\r
 119                 portOUTPUT_BYTE( pxPort->usInterruptEnableReg, ucIn & ~ucInterrupt);    \\r
 120         }                                                                                                                                                       \\r
 121 }\r
 122 /*-----------------------------------------------------------*/\r
 123 \r
 124 typedef enum\r
 125 { \r
 126         serCOM1, \r
 127         serCOM2, \r
 128         serCOM3, \r
 129         serCOM4, \r
 130         serCOM5, \r
 131         serCOM6, \r
 132         serCOM7, \r
 133         serCOM8 \r
 134 } eCOMPort;\r
 135 \r
 136 typedef enum \r
 137 { \r
 138         serNO_PARITY, \r
 139         serODD_PARITY, \r
 140         serEVEN_PARITY, \r
 141         serMARK_PARITY, \r
 142         serSPACE_PARITY \r
 143 } eParity;\r
 144 \r
 145 typedef enum \r
 146 { \r
 147         serSTOP_1, \r
 148         serSTOP_2 \r
 149 } eStopBits;\r
 150 \r
 151 typedef enum \r
 152 { \r
 153         serBITS_5, \r
 154         serBITS_6, \r
 155         serBITS_7, \r
 156         serBITS_8 \r
 157 } eDataBits;\r
 158 \r
 159 typedef enum \r
 160 { \r
 161         ser50,          \r
 162         ser75,          \r
 163         ser110,         \r
 164         ser134,         \r
 165         ser150,    \r
 166         ser200,\r
 167         ser300,         \r
 168         ser600,         \r
 169         ser1200,        \r
 170         ser1800,        \r
 171         ser2400,   \r
 172         ser4800,\r
 173         ser9600,                \r
 174         ser19200,       \r
 175         ser38400,       \r
 176         ser57600,       \r
 177         ser115200\r
 178 } eBaud;\r
 179 \r
 180 /* This *MUST* match the order in the eBaud definition. */\r
 181 unsigned portLONG ulBaudFromEnum[] = \r
 182 { \r
 183         ( unsigned portLONG ) 50, \r
 184         ( unsigned portLONG ) 75, \r
 185         ( unsigned portLONG ) 110, \r
 186         ( unsigned portLONG ) 134, \r
 187         ( unsigned portLONG ) 150,      \r
 188         ( unsigned portLONG ) 200, \r
 189         ( unsigned portLONG ) 300, \r
 190         ( unsigned portLONG ) 600, \r
 191         ( unsigned portLONG ) 1200, \r
 192         ( unsigned portLONG ) 1800, \r
 193         ( unsigned portLONG ) 2400,   \r
 194         ( unsigned portLONG ) 4800,   \r
 195         ( unsigned portLONG ) 9600,  \r
 196         ( unsigned portLONG ) 19200,  \r
 197         ( unsigned portLONG ) 38400UL,\r
 198         ( unsigned portLONG ) 57600UL,\r
 199         ( unsigned portLONG ) 115200UL\r
 200 };\r
 201 \r
 202 typedef struct xCOM_PORT\r
 203 { \r
 204         unsigned portSHORT sPort;   /* comm port address eg. 0x3f8    */\r
 205         unsigned portCHAR ucIRQ;    /* comm IRQ eg. 3                 */\r
 206 \r
 207         /* Next two fields used for setting up the IRQ routine and\r
 208         * (un)masking the interrupt in certain circumstances.\r
 209         */\r
 210         unsigned portSHORT usIRQVector;\r
 211         unsigned portCHAR ucInterruptEnableMast;\r
 212 \r
 213         /* Read/Write buffers. */\r
 214         xQueueHandle xRxedChars; \r
 215         xQueueHandle xCharsForTx;\r
 216 \r
 217         /* This lot are set up to minimise CPU time where accessing the comm\r
 218         * port's registers.\r
 219         */\r
 220         unsigned portSHORT usTransmitHoldReg; \r
 221         unsigned portSHORT usReceiveDataRegister;\r
 222         unsigned portSHORT usBaudRateDivisorLow; \r
 223         unsigned portSHORT usBaudRateDivisorHigh;\r
 224         unsigned portSHORT usInterruptEnableReg;\r
 225         unsigned portSHORT usInterruptIDReg;\r
 226         unsigned portSHORT usFIFOCtrlReg;\r
 227         unsigned portSHORT usLineCtrlReg;\r
 228         unsigned portSHORT usModemCtrlReg;\r
 229         unsigned portSHORT usLineStatusReg;\r
 230         unsigned portSHORT usModemStatusReg;\r
 231         unsigned portSHORT usSCRReg;\r
 232         unsigned portSHORT us8259InterruptServiceReg;\r
 233         unsigned portSHORT us8259InterruptMaskReg;\r
 234 \r
 235         /* This semaphore does nothing useful except test a feature of the\r
 236         scheduler. */\r
 237         xSemaphoreHandle xTestSem;\r
 238 \r
 239 } xComPort;\r
 240 \r
 241 typedef xComPort *xComPortHandle;\r
 242 \r
 243 /* A xComPort structure can be associated with each IRQ.  Initially none\r
 244 are create/installed. */\r
 245 xComPort *xPortStatus[ serMAX_IRQs ] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };\r
 246 \r
 247 /*-----------------------------------------------------------*/\r
 248 \r
 249 /* These prototypes are repeated here so we don't have to include the serial header.  This allows\r
 250 the xComPortHandle structure details to be private to this file. */\r
 251 xComPortHandle xSerialPortInit( eCOMPort ePort, eBaud eWantedBaud, eParity eWantedParity, eDataBits eWantedDataBits, eStopBits eWantedStopBits, unsigned portBASE_TYPE uxBufferLength );\r
 252 portBASE_TYPE xSerialGetChar( xComPortHandle pxPort, portCHAR *pcRxedChar, portTickType xBlockTime );\r
 253 portBASE_TYPE xSerialPutChar( xComPortHandle pxPort, portCHAR cOutChar, portTickType xBlockTime );\r
 254 portBASE_TYPE xSerialWaitForSemaphore( xComPortHandle xPort );\r
 255 \r
 256 static void prvSetupPortHardware( xComPort *pxPort, eCOMPort ePort, eBaud eWantedBaud, eParity eWantedParity, eDataBits eWantedDataBits, eStopBits eWantedStopBits );\r
 257 static portSHORT sComPortISR( const xComPort * const pxPort );\r
 258 \r
 259 /*-----------------------------------------------------------*/\r
 260 \r
 261 /* Define an interrupt handler for each slot in the xPortStatus array. */\r
 262 \r
 263 #define COM_IRQ_WRAPPER(N)                                                                              \\r
 264         static void __interrupt COM_IRQ##N##_WRAPPER( void )            \\r
 265         {                                                                                                                       \\r
 266                 portDISABLE_INTERRUPTS();                                                               \\r
 267                 if( sComPortISR( xPortStatus[##N##] ) )                                 \\r
 268                 {                                                                                                               \\r
 269                         portSWITCH_CONTEXT();                                                           \\r
 270                 }                                                                                                               \\r
 271         } \r
 272 \r
 273 COM_IRQ_WRAPPER( 0 )\r
 274 COM_IRQ_WRAPPER( 1 )\r
 275 COM_IRQ_WRAPPER( 2 )\r
 276 COM_IRQ_WRAPPER( 3 )\r
 277 COM_IRQ_WRAPPER( 4 )\r
 278 COM_IRQ_WRAPPER( 5 )\r
 279 COM_IRQ_WRAPPER( 6 )\r
 280 COM_IRQ_WRAPPER( 7 )\r
 281 COM_IRQ_WRAPPER( 8 )\r
 282 COM_IRQ_WRAPPER( 9 )\r
 283 COM_IRQ_WRAPPER( 10 )\r
 284 COM_IRQ_WRAPPER( 11 )\r
 285 COM_IRQ_WRAPPER( 12 )\r
 286 COM_IRQ_WRAPPER( 13 )\r
 287 COM_IRQ_WRAPPER( 14 )\r
 288 COM_IRQ_WRAPPER( 15 )\r
 289 \r
 290 static pxISR xISRs[ serMAX_IRQs ] = \r
 291 {\r
 292         COM_IRQ0_WRAPPER, \r
 293         COM_IRQ1_WRAPPER, \r
 294         COM_IRQ2_WRAPPER, \r
 295         COM_IRQ3_WRAPPER, \r
 296         COM_IRQ4_WRAPPER, \r
 297         COM_IRQ5_WRAPPER, \r
 298         COM_IRQ6_WRAPPER, \r
 299         COM_IRQ7_WRAPPER, \r
 300         COM_IRQ8_WRAPPER, \r
 301         COM_IRQ9_WRAPPER, \r
 302         COM_IRQ10_WRAPPER, \r
 303         COM_IRQ11_WRAPPER, \r
 304         COM_IRQ12_WRAPPER, \r
 305         COM_IRQ13_WRAPPER, \r
 306         COM_IRQ14_WRAPPER,\r
 307         COM_IRQ15_WRAPPER\r
 308 };\r
 309 \r
 310 static pxISR xOldISRs[ serMAX_IRQs ] = { NULL };\r
 311 \r
 312 /*-----------------------------------------------------------*/\r
 313 \r
 314 \r
 315 xComPortHandle xSerialPortInit( eCOMPort ePort, eBaud eWantedBaud, eParity eWantedParity, eDataBits eWantedDataBits, eStopBits eWantedStopBits, unsigned portBASE_TYPE uxBufferLength )\r
 316 {\r
 317 xComPort *pxPort;\r
 318 \r
 319         /* Create a structure to handle this port. */\r
 320         pxPort = ( xComPort * ) pvPortMalloc( sizeof( xComPort ) );\r
 321         \r
 322         if( pxPort != NULL )\r
 323         {\r
 324                 /* Create the queues used by the comtest task. */\r
 325                 pxPort->xRxedChars = xQueueCreate( uxBufferLength, ( unsigned portBASE_TYPE ) sizeof( portCHAR ) );\r
 326                 pxPort->xCharsForTx = xQueueCreate( uxBufferLength, ( unsigned portBASE_TYPE ) sizeof( portCHAR ) );\r
 327 \r
 328                 /* Create the test semaphore.  This does nothing useful except test a feature of the scheduler. */\r
 329                 vSemaphoreCreateBinary( pxPort->xTestSem );\r
 330 \r
 331                 prvSetupPortHardware( pxPort, ePort, eWantedBaud, eWantedParity, eWantedDataBits, eWantedStopBits );\r
 332 \r
 333                 return pxPort;\r
 334         }\r
 335 \r
 336         return NULL;\r
 337 }\r
 338 /*-----------------------------------------------------------*/\r
 339 \r
 340 static void prvSetupPortHardware( xComPort *pxPort, eCOMPort ePort, eBaud eWantedBaud, eParity eWantedParity, eDataBits eWantedDataBits, eStopBits eWantedStopBits )\r
 341 {\r
 342 portSHORT sIn;\r
 343 unsigned portLONG ulDivisor;\r
 344 unsigned portCHAR ucDivisorLow;\r
 345 unsigned portCHAR ucDivisorHigh;\r
 346 unsigned portCHAR ucCommParam;\r
 347 \r
 348         /* IRQ numbers - standard */\r
 349         if( ( ePort == serCOM1 ) || ( ePort == serCOM3 ) || ( ePort == serCOM5 ) || ( ePort == serCOM7 ) )\r
 350         {\r
 351                 pxPort->ucIRQ = serCOM1_STANDARD_IRQ;\r
 352                 pxPort->sPort = 0x3f8;\r
 353         }\r
 354         else\r
 355         {\r
 356                 pxPort->ucIRQ = serCOM2_STANDARD_IRQ;\r
 357                 pxPort->sPort = 0x2f8;\r
 358         }\r
 359 \r
 360         /* Set up variables in port making it easy to see which sIn/o address is which */\r
 361         pxPort->usTransmitHoldReg = pxPort->sPort + serTRANSMIT_HOLD_OFFSET;\r
 362         pxPort->usReceiveDataRegister = pxPort->sPort + serRECEIVE_DATA_OFFSET;\r
 363         pxPort->usBaudRateDivisorLow = pxPort->sPort + serBAUD_RATE_DIVISOR_LOW_OFFSET;\r
 364         pxPort->usBaudRateDivisorHigh = pxPort->sPort + serBAUD_RATE_DIVISOR_HIGH_OFFSET;\r
 365         pxPort->usInterruptEnableReg = pxPort->sPort + serINTERRUPT_ENABLE_OFFSET;\r
 366         pxPort->usInterruptIDReg = pxPort->sPort + serINTERRUPT_ID_OFFSET;\r
 367         pxPort->usFIFOCtrlReg = pxPort->sPort + serFIFO_CTRL_OFFSET;\r
 368         pxPort->usLineCtrlReg = pxPort->sPort + serLINE_CTRL_OFFSET;\r
 369         pxPort->usModemCtrlReg = pxPort->sPort + serMODEM_CTRL_OFFSET;\r
 370         pxPort->usLineStatusReg = pxPort->sPort + serLINE_STATUS_OFFSET;\r
 371         pxPort->usModemStatusReg = pxPort->sPort + serMODEM_STATUS_OFFSET;\r
 372         pxPort->usSCRReg = pxPort->sPort + serSCR_OFFSET;\r
 373 \r
 374         /* Set communication parameters. */\r
 375         ulDivisor = serMAX_BAUD / ulBaudFromEnum[ eWantedBaud ];\r
 376         ucDivisorLow = ( unsigned portCHAR ) ulDivisor & ( unsigned portCHAR ) 0xff;\r
 377         ucDivisorHigh = ( unsigned portCHAR ) ( ( ( unsigned portSHORT ) ulDivisor >> 8 ) & 0xff );\r
 378         \r
 379         switch( eWantedParity )\r
 380         {       \r
 381                 case serNO_PARITY:              ucCommParam = 0x00;\r
 382                                                                 break;\r
 383                 case serODD_PARITY:             ucCommParam = 0x08;\r
 384                                                                 break;\r
 385                 case serEVEN_PARITY:    ucCommParam = 0x18;\r
 386                                                                 break;\r
 387                 case serMARK_PARITY:    ucCommParam = 0x28;\r
 388                                                                 break;\r
 389                 case serSPACE_PARITY:   ucCommParam = 0x38;\r
 390                                                                 break;\r
 391                 default:                                ucCommParam = 0x00;\r
 392                                                                 break;\r
 393         }\r
 394 \r
 395         switch ( eWantedDataBits )\r
 396         {\r
 397                 case serBITS_5: ucCommParam |= 0x00;\r
 398                                                 break;\r
 399                 case serBITS_6: ucCommParam |= 0x01;\r
 400                                                 break;\r
 401                 case serBITS_7: ucCommParam |= 0x02;\r
 402                                                 break;\r
 403                 case serBITS_8: ucCommParam |= 0x03;\r
 404                                                 break;\r
 405                 default:                ucCommParam |= 0x03;\r
 406                                                 break;\r
 407         }\r
 408 \r
 409         if( eWantedStopBits == serSTOP_2 ) \r
 410         {\r
 411                 ucCommParam |= 0x04;\r
 412         }\r
 413 \r
 414         /* Reset UART into known state - Thanks to Bradley Town */\r
 415         portOUTPUT_BYTE( pxPort->usLineCtrlReg, 0x00 );                 /* Access usTransmitHoldReg/RBR/usInterruptEnableReg */\r
 416         portOUTPUT_BYTE( pxPort->usInterruptEnableReg, 0x00 );  /* Disable interrupts from UART */\r
 417         portOUTPUT_BYTE( pxPort->usModemCtrlReg, 0x04 );                /* Enable some multi-port cards */\r
 418 \r
 419         /* Code based on stuff from SVAsync lib. Clear UART Status and data registers\r
 420         setting up FIFO if possible */\r
 421         sIn = portINPUT_BYTE( pxPort->usSCRReg );\r
 422         portOUTPUT_BYTE( pxPort->usSCRReg, 0x55 );\r
 423 \r
 424         if( portINPUT_BYTE( pxPort->usSCRReg ) == 0x55 )\r
 425         {\r
 426                 /* The chip is better than an 8250 */\r
 427                 portOUTPUT_BYTE( pxPort->usSCRReg, sIn );       /* Set usSCRReg back to what it was before */\r
 428                 portINPUT_BYTE( pxPort->usSCRReg);                      /* Give slow motherboards a chance */\r
 429 \r
 430                 /* Try and start the FIFO. It appears that some chips need a two call \r
 431                 protocol, but those that don't seem to work even if you do start it twice. \r
 432                 The first call is simply to start it, the second starts it and sets an 8 \r
 433                 byte FIFO trigger level. */\r
 434                 portOUTPUT_BYTE( pxPort->usFIFOCtrlReg, 0x01 );\r
 435                 portINPUT_BYTE( pxPort->usFIFOCtrlReg );                        /* Give slow motherboards a chance to catch up */\r
 436                 portOUTPUT_BYTE( pxPort->usFIFOCtrlReg, 0x87 );\r
 437 \r
 438                 /* Check that the FIFO initialised */\r
 439                 if( ( portINPUT_BYTE( pxPort->usInterruptIDReg ) & 0xc0 ) != 0xc0 )\r
 440                 {\r
 441                         /* It didn't so we assume it isn't there but disable it to be on the \r
 442                         safe side. */\r
 443                         portOUTPUT_BYTE( pxPort->usInterruptIDReg, 0xfe );\r
 444                 }\r
 445         }\r
 446 \r
 447         /* End of (modified) SVAsync code.  \r
 448         Set interrupt parameters calculating mask for 8259 controller's \r
 449         IMR and number of interrupt handler for given irq level  */\r
 450         if (pxPort->ucIRQ <= 7)\r
 451         {       \r
 452                 /* if 0<=irq<=7 first IMR address used */\r
 453                 pxPort->ucInterruptEnableMast = ~(0x01 << pxPort->ucIRQ);\r
 454                 pxPort->usIRQVector = pxPort->ucIRQ + 8;\r
 455                 pxPort->us8259InterruptMaskReg = serIMR_8259_0;\r
 456                 pxPort->us8259InterruptServiceReg = serISR_8259_0;\r
 457         }\r
 458         else\r
 459         {\r
 460                 pxPort->ucInterruptEnableMast = ~( 0x01 << ( pxPort->ucIRQ % 8 ) );\r
 461                 pxPort->usIRQVector = 0x70 + ( pxPort->ucIRQ - 8) ;\r
 462                 pxPort->us8259InterruptMaskReg = serIMR_8259_1;\r
 463                 pxPort->us8259InterruptServiceReg = serISR_8259_1;\r
 464         }\r
 465 \r
 466         /* Set Port Toggle to usBaudRateDivisorLow/usBaudRateDivisorHigh registers \r
 467         to set baud rate */\r
 468         portOUTPUT_BYTE( pxPort->usLineCtrlReg, ucCommParam | 0x80 );\r
 469         portOUTPUT_BYTE( pxPort->usBaudRateDivisorLow, ucDivisorLow );\r
 470         portOUTPUT_BYTE( pxPort->usBaudRateDivisorHigh, ucDivisorHigh );\r
 471 \r
 472         /* reset usLineCtrlReg and Port Toggleout */\r
 473         portOUTPUT_BYTE( pxPort->usLineCtrlReg, ucCommParam & 0x7F );\r
 474 \r
 475         portENTER_CRITICAL();\r
 476 \r
 477         if( xPortStatus[ pxPort->ucIRQ ] == NULL )\r
 478         {       \r
 479                 xPortStatus[ pxPort->ucIRQ ] = pxPort;\r
 480         }\r
 481         \r
 482         xOldISRs[ pxPort->ucIRQ ] = _dos_getvect( pxPort->usIRQVector );\r
 483         _dos_setvect( pxPort->usIRQVector, xISRs[ pxPort->ucIRQ ] );\r
 484 \r
 485         /* enable interrupt pxPort->ucIRQ level */\r
 486         portOUTPUT_BYTE( pxPort->us8259InterruptMaskReg, portINPUT_BYTE( pxPort->us8259InterruptMaskReg ) & pxPort->ucInterruptEnableMast );\r
 487 \r
 488         /* And allow interrupts again now the hairy bit's done */\r
 489         portEXIT_CRITICAL();            \r
 490 \r
 491         /* This version does not allow flow control. */\r
 492         portOUTPUT_BYTE( pxPort->usModemCtrlReg, serALL_MODEM_CTRL_INTERRUPTS );\r
 493 \r
 494         /* enable all communication's interrupts */\r
 495         portOUTPUT_BYTE( pxPort->usInterruptEnableReg, serALL_COMS_INTERRUPTS );\r
 496 }\r
 497 /*-----------------------------------------------------------*/\r
 498 \r
 499 static portSHORT sComPortISR( const xComPort * const pxPort )\r
 500 {\r
 501 portSHORT sInterruptID;\r
 502 portCHAR cIn, cOut;\r
 503 portBASE_TYPE xTaskWokenByPost = pdFALSE, xAnotherTaskWokenByPost = pdFALSE, xTaskWokenByTx = pdFALSE;\r
 504 extern void vComTestUnsuspendTask( void );\r
 505 \r
 506         portOUTPUT_BYTE( pxPort->us8259InterruptMaskReg, ( portINPUT_BYTE( pxPort->us8259InterruptMaskReg) | ~pxPort->ucInterruptEnableMast ) );\r
 507 \r
 508         /* Decide which UART has issued the interrupt */\r
 509         sInterruptID = portINPUT_BYTE( pxPort->usInterruptIDReg );\r
 510 \r
 511         /* service whatever requests the calling UART may have. The top 4 bits are\r
 512         either unused or indicate the presence of a functioning FIFO, which we don't\r
 513         need to know. So trim them off to simplify the switch statement below. */\r
 514         sInterruptID &= 0x0f;\r
 515         do\r
 516         {\r
 517                 switch( sInterruptID )\r
 518                 {\r
 519                         case 0x0c:      /* Timeout\r
 520                                                 Called when FIFO not up to trigger level but no activity for \r
 521                                                 a while. Handled exactly as RDAINT, see below for \r
 522                                                 description. */\r
 523                                                 do\r
 524                                                 {\r
 525                                                         cIn = ( portCHAR ) portINPUT_BYTE( pxPort->usReceiveDataRegister );                                             \r
 526                                                         xTaskWokenByPost = xQueueSendFromISR( pxPort->xRxedChars, &cIn, xTaskWokenByPost );\r
 527 \r
 528                                                         /* Also release the semaphore - this does nothing interesting and is just a test.\r
 529                                                         We first attempt to unsuspend the task to check the scheduler correctely detects\r
 530                                                         this as an invalid call, then give the semaphore for real. */\r
 531                                                         vComTestUnsuspendTask();\r
 532                                                         xAnotherTaskWokenByPost = xSemaphoreGiveFromISR( pxPort->xTestSem, xAnotherTaskWokenByPost );\r
 533 \r
 534                                                 } while( portINPUT_BYTE( pxPort->usLineStatusReg ) & 0x01 );\r
 535                                                 break;\r
 536 \r
 537                         case 0x06:      /* LSINT */\r
 538                                                 portINPUT_BYTE( pxPort->usLineStatusReg );\r
 539                                                 break;\r
 540 \r
 541                         case 0x04:      /* RDAINT */\r
 542                                                 /* The usInterruptIDReg flag tested above stops when the \r
 543                                                 FIFO is below the trigger level rather than empty, whereas \r
 544                                                 this flag allows one to empty it: (do loop because there \r
 545                                                 must be at least one to read by virtue of having got here.) */\r
 546                                                 do\r
 547                                                 {\r
 548                                                         cIn = ( portCHAR ) portINPUT_BYTE( pxPort->usReceiveDataRegister );                                             \r
 549                                                         xTaskWokenByPost = xQueueSendFromISR( pxPort->xRxedChars, &cIn, xTaskWokenByPost );\r
 550 \r
 551                                                         /* Also release the semaphore - this does nothing interesting and is just a test.\r
 552                                                         We first attempt to unsuspend the task to check the scheduler correctely detects\r
 553                                                         this as an invalid call, then give the semaphore for real. */\r
 554                                                         vComTestUnsuspendTask();\r
 555                                                         xAnotherTaskWokenByPost = xSemaphoreGiveFromISR( pxPort->xTestSem, xAnotherTaskWokenByPost );\r
 556 \r
 557                                                 } while( portINPUT_BYTE( pxPort->usLineStatusReg ) & 0x01 );\r
 558                                                 break;\r
 559 \r
 560                         case 0x02:      /* serTRANSMIT_HOLD_EMPTY_INT */\r
 561                                                 if( xQueueReceiveFromISR( pxPort->xCharsForTx, &cOut, &xTaskWokenByTx ) != pdTRUE )                                             \r
 562                                                 {                                                                                                                                                                               \r
 563                                                         /* Queue empty, nothing to send */                                                                                                      \r
 564                                                         vInterruptOff( pxPort, serTRANSMIT_HOLD_EMPTY_INT);                                                                     \r
 565                                                 }                                                                                                                                                                               \r
 566                                                 else                                                                                                                                                                    \r
 567                                                 {                                                                                                                                                                               \r
 568                                                         portOUTPUT_BYTE( pxPort->usTransmitHoldReg, ( portSHORT ) cOut );                                       \r
 569                                                 }\r
 570                                                 break;\r
 571 \r
 572                         case 0x00:      /* MSINT */\r
 573                                                 portINPUT_BYTE( pxPort->usModemStatusReg );\r
 574                                                 break;\r
 575                 }               \r
 576 \r
 577                 /* Get the next instruction, trimming as above */\r
 578                 sInterruptID = portINPUT_BYTE( pxPort->usInterruptIDReg ) & 0x0f;\r
 579 \r
 580         } while( !( sInterruptID & 0x01 ) );\r
 581 \r
 582         if( pxPort->ucIRQ > 7 )\r
 583         {\r
 584                 portOUTPUT_BYTE( 0xA0, 0x60 + ( pxPort->ucIRQ & 0x07 ) );\r
 585                 portOUTPUT_BYTE( 0x20, 0x62);\r
 586         }\r
 587         else\r
 588         {\r
 589                 portOUTPUT_BYTE( 0x20, 0x60 + pxPort->ucIRQ );\r
 590         }\r
 591 \r
 592         portOUTPUT_BYTE( pxPort->us8259InterruptMaskReg, portINPUT_BYTE( pxPort->us8259InterruptMaskReg ) & pxPort->ucInterruptEnableMast );\r
 593 \r
 594         /* If posting any of the characters to a queue woke a task that was blocked on\r
 595         the queue we may want to return to the task just woken (depending on its \r
 596         priority relative to the task this ISR interrupted. */\r
 597         if( xTaskWokenByPost || xAnotherTaskWokenByPost || xTaskWokenByTx )\r
 598         {\r
 599                 return pdTRUE;\r
 600         }\r
 601         else\r
 602         {\r
 603                 return pdFALSE;\r
 604         }\r
 605 }\r
 606 /*-----------------------------------------------------------*/\r
 607 \r
 608 portBASE_TYPE xSerialGetChar( xComPortHandle pxPort, portCHAR *pcRxedChar, portTickType xBlockTime )\r
 609 {\r
 610         /* Get the next character from the buffer, note that this routine is only \r
 611         called having checked that the is (at least) one to get */\r
 612         if( xQueueReceive( pxPort->xRxedChars, pcRxedChar, xBlockTime ) )\r
 613         {\r
 614                 return pdTRUE;\r
 615         }\r
 616         else\r
 617         {\r
 618                 return pdFALSE;\r
 619         }\r
 620 }\r
 621 /*-----------------------------------------------------------*/\r
 622 \r
 623 portBASE_TYPE xSerialPutChar( xComPortHandle pxPort, portCHAR cOutChar, portTickType xBlockTime )\r
 624 {\r
 625         if( xQueueSend( pxPort->xCharsForTx, &cOutChar, xBlockTime ) != pdPASS )\r
 626         {\r
 627                 return pdFAIL;\r
 628         }\r
 629 \r
 630         vInterruptOn( pxPort, serTRANSMIT_HOLD_EMPTY_INT );\r
 631 \r
 632         return pdPASS;\r
 633 }\r
 634 /*-----------------------------------------------------------*/\r
 635 \r
 636 void vSerialPutString( xComPortHandle pxPort, const portCHAR * const pcString, unsigned portSHORT usStringLength )\r
 637 {\r
 638 portCHAR * pcNextChar;\r
 639 const portTickType xNoBlock = ( portTickType ) 0;\r
 640 \r
 641         /* Stop warnings. */\r
 642         ( void ) usStringLength;\r
 643 \r
 644         pcNextChar = ( portCHAR * ) pcString;\r
 645         while( *pcNextChar )\r
 646         {\r
 647                 xSerialPutChar( pxPort, *pcNextChar, xNoBlock );\r
 648                 pcNextChar++;\r
 649         }\r
 650 }\r
 651 /*-----------------------------------------------------------*/\r
 652 \r
 653 portBASE_TYPE xSerialWaitForSemaphore( xComPortHandle xPort )\r
 654 {\r
 655 const portTickType xBlockTime = ( portTickType ) 0xffff;\r
 656 \r
 657         /* This function does nothing interesting, but test the \r
 658         semaphore from ISR mechanism. */\r
 659         return xSemaphoreTake( xPort->xTestSem, xBlockTime );   \r
 660 }\r
 661 /*-----------------------------------------------------------*/\r
 662 \r
 663 void vSerialClose( xComPortHandle xPort )\r
 664 {\r
 665         portENTER_CRITICAL();\r
 666 \r
 667         /* Turn off the interrupts. */\r
 668         portOUTPUT_BYTE( xPort->usModemCtrlReg, serNO_INTERRUPTS );\r
 669         portOUTPUT_BYTE( xPort->usInterruptEnableReg, serNO_INTERRUPTS );\r
 670 \r
 671         /* Put back the original ISR. */\r
 672         _dos_setvect( xPort->usIRQVector, xOldISRs[ xPort->ucIRQ ] );\r
 673 \r
 674         /* Remove the reference in the array of xComPort structures. */\r
 675         xPortStatus[ xPort->ucIRQ ] = NULL;\r
 676 \r
 677         /* Delete the queues. */\r
 678         vQueueDelete( xPort->xRxedChars );\r
 679         vQueueDelete( xPort->xCharsForTx );\r
 680 \r
 681         vPortFree( ( void * ) xPort );\r
 682 \r
 683         portEXIT_CRITICAL();\r
 684 }\r
 685 \r