source/sci.c

   1 /** @file sci.c \r
   2 *   @brief SCI Driver Implementation File\r
   3 *   @date 15.Mar.2012\r
   4 *   @version 03.01.00\r
   5 *\r
   6 */\r
   7 \r
   8 /* (c) Texas Instruments 2009-2012, All rights reserved. */\r
   9 \r
  10 /* USER CODE BEGIN (0) */\r
  11 /* USER CODE END */\r
  12 \r
  13 #include "sci.h"\r
  14 \r
  15 /* USER CODE BEGIN (1) */\r
  16 #include "cmdio_tisci.h"\r
  17 #include "os_queue.h"\r
  18 \r
  19 extern tBuffer outBuffer;\r
  20 extern tBuffer inBuffer;\r
  21 static uint32_t receiveError;\r
  22 /* USER CODE END */\r
  23 /** @struct g_sciTransfer\r
  24 *   @brief Interrupt mode globals\r
  25 *\r
  26 */\r
  27 struct g_sciTransfer\r
  28 {\r
  29     uint32_t       mode;\r
  30     uint32_t       length;\r
  31     uint8_t *data;\r
  32 } g_sciTransfer[2];\r
  33 \r
  34 \r
  35 /** @fn void sciInit(void)\r
  36 *   @brief Initializes the SCI Driver\r
  37 *\r
  38 *   This function initializes the SCI module.\r
  39 */\r
  40 void sciInit(void)\r
  41 {\r
  42 /* USER CODE BEGIN (2) */\r
  43 /* USER CODE END */\r
  44 \r
  45     /** @b intalise @b SCI */\r
  46 \r
  47     /** - bring SCI out of reset */\r
  48     sciREG->GCR0 = 1U;\r
  49 \r
  50     /** - Disable all interrupts */\r
  51     sciREG->CLRINT    = 0xFFFFFFFFU;\r
  52     sciREG->CLRINTLVL = 0xFFFFFFFFU;\r
  53 \r
  54     /** - global control 1 */\r
  55     sciREG->GCR1 = (1 << 25)  /* enable transmit */\r
  56                   | (1 << 24)  /* enable receive */\r
  57                   | (1 << 5)   /* internal clock (device has no clock pin) */\r
  58                   | ((2-1) << 4)  /* number of stop bits */\r
  59                   | (0 << 3)  /* even parity, otherwise odd */\r
  60                   | (0 << 2)  /* enable parity */\r
  61                   | (1 << 1);  /* asynchronous timing mode */\r
  62 \r
  63     /** - set baudrate */\r
  64     sciREG->BAUD = 520;  /* baudrate */\r
  65 \r
  66     /** - tranmision length */\r
  67     sciREG->LENGTH = 8 - 1;  /* length */\r
  68 \r
  69     /** - set SCI pins functional mode */\r
  70     sciREG->FUN = (1 << 2)  /* tx pin */\r
  71                  | (1 << 1)  /* rx pin */\r
  72                  | (0);  /* clk pin */\r
  73 \r
  74     /** - set SCI pins default output value */\r
  75     sciREG->DOUT = (0 << 2)  /* tx pin */\r
  76                   | (0 << 1)  /* rx pin */\r
  77                   | (0);  /* clk pin */\r
  78 \r
  79     /** - set SCI pins output direction */\r
  80     sciREG->DIR = (1 << 2)  /* tx pin */\r
  81                  | (0 << 1)  /* rx pin */\r
  82                  | (0);  /* clk pin */\r
  83 \r
  84     /** - set SCI pins open drain enable */\r
  85     sciREG->ODR = (0 << 2)  /* tx pin */\r
  86                  | (0 << 1)  /* rx pin */\r
  87                  | (0);  /* clk pin */\r
  88 \r
  89     /** - set SCI pins pullup/pulldown enable */\r
  90     sciREG->PD = (0 << 2)  /* tx pin */\r
  91                 | (0 << 1)  /* rx pin */\r
  92                 | (0);  /* clk pin */\r
  93 \r
  94     /** - set SCI pins pullup/pulldown select */\r
  95     sciREG->PSL = (1 << 2)  /* tx pin */\r
  96                  | (1 << 1)  /* rx pin */\r
  97                  | (1);  /* clk pin */\r
  98 \r
  99     /** - set interrupt level */\r
 100     sciREG->SETINTLVL = (0 << 26)  /* Framing error */\r
 101                        | (0 << 25)  /* Overrun error */\r
 102                        | (0 << 24)  /* Pariry error */\r
 103                        | (0 << 9)  /* Receive */\r
 104                        | (0 << 8)  /* Transmit */\r
 105                        | (0 << 1)  /* Wakeup */\r
 106                        | (0);  /* Break detect */\r
 107 \r
 108     /** - set interrupt enable */\r
 109     sciREG->SETINT = (0 << 26)  /* Framing error */\r
 110                     | (0 << 25)  /* Overrun error */\r
 111                     | (0 << 24)  /* Pariry error */\r
 112                     | (1 << 9)  /* Receive */\r
 113                     | (0 << 1)  /* Wakeup */\r
 114                     | (0);  /* Break detect */\r
 115 \r
 116     /** - inialise global transfer variables */\r
 117     g_sciTransfer[0].mode   = 0 << 8;\r
 118     g_sciTransfer[0].length = 0;\r
 119 \r
 120     /** - Finaly start SCI */\r
 121     sciREG->GCR1 |= (1 << 7);\r
 122 \r
 123 \r
 124 /* USER CODE BEGIN (3) */\r
 125 /* USER CODE END */\r
 126 }\r
 127 \r
 128 \r
 129 /** @fn void sciSetFunctional(sciBASE_t *sci, uint32_t port)\r
 130 *   @brief Change functional behavoiur of pins at runtime.\r
 131 *   @param[in] sci   - sci module base address\r
 132 *   @param[in] port  - Value to write to FUN register\r
 133 *\r
 134 *   Change the value of the PCFUN register at runtime, this allows to\r
 135 *   dynaimcaly change the functionality of the SCI pins between functional\r
 136 *   and GIO mode.\r
 137 */\r
 138 void sciSetFunctional(sciBASE_t *sci, uint32_t port)\r
 139 {\r
 140 /* USER CODE BEGIN (4) */\r
 141 /* USER CODE END */\r
 142 \r
 143     sci->FUN = port;\r
 144 \r
 145 /* USER CODE BEGIN (5) */\r
 146 /* USER CODE END */\r
 147 }\r
 148 \r
 149 \r
 150 /** @fn void sciSetBaudrate(sciBASE_t *sci, uint32_t baud)\r
 151 *   @brief Change baudrate at runtime.\r
 152 *   @param[in] sci  - sci module base address\r
 153 *   @param[in] baud - baudrate in Hz\r
 154 *\r
 155 *   Change the SCI baudrate at runtime.\r
 156 */\r
 157 void sciSetBaudrate(sciBASE_t *sci, uint32_t baud)\r
 158 {\r
 159     double   vclk = 80.000 * 1000000.0;\r
 160     uint32_t f    = sci->GCR1 & 2 ? 16 : 1;\r
 161 \r
 162 /* USER CODE BEGIN (6) */\r
 163 /* USER CODE END */\r
 164 \r
 165     sci->BAUD = ((uint32_t)((vclk /(f*baud) + 0.5)) - 1) & 0x00FFFFFF;\r
 166 \r
 167 /* USER CODE BEGIN (7) */\r
 168 /* USER CODE END */\r
 169 }\r
 170 \r
 171 \r
 172 /** @fn int sciIsTxReady(sciBASE_t *sci)\r
 173 *   @brief Check if Tx buffer empty\r
 174 *   @param[in] sci - sci module base address\r
 175 *\r
 176 *   @return The TX ready flag\r
 177 *\r
 178 *   Checks to see if the Tx buffer ready flag is set, returns\r
 179 *   0 is flags not set otherwise will return the Tx flag itself.\r
 180 */\r
 181 int sciIsTxReady(sciBASE_t *sci)\r
 182 {\r
 183 /* USER CODE BEGIN (8) */\r
 184 /* USER CODE END */\r
 185 \r
 186     return sci->FLR & SCI_TX_INT;\r
 187 }\r
 188 \r
 189 \r
 190 /** @fn void sciSendByte(sciBASE_t *sci, uint8_t byte)\r
 191 *   @brief Send Byte\r
 192 *   @param[in] sci  - sci module base address\r
 193 *   @param[in] byte - byte to transfer\r
 194 *\r
 195 *   Sends a single byte in polling mode, will wait in the\r
 196 *   routine until the transmit buffer is empty before sending\r
 197 *   the byte.  Use sciIsTxReady to check for Tx buffer empty\r
 198 *   before calling sciSendByte to avoid waiting.\r
 199 */\r
 200 void sciSendByte(sciBASE_t *sci, uint8_t byte)\r
 201 {\r
 202 /* USER CODE BEGIN (9) */\r
 203 /* USER CODE END */\r
 204 \r
 205     while ((sci->FLR & SCI_TX_INT) == 0) { /* wait */ };\r
 206     sci->TD = byte;\r
 207 \r
 208 /* USER CODE BEGIN (10) */\r
 209 /* USER CODE END */\r
 210 }\r
 211 \r
 212 \r
 213 /** @fn void sciSend(sciBASE_t *sci, uint32_t length, uint8_t *data)\r
 214 *   @brief Send Data\r
 215 *   @param[in] sci    - sci module base address\r
 216 *   @param[in] length - number of data words to transfer\r
 217 *   @param[in] data   - pointer to data to send\r
 218 *\r
 219 *   Send a block of data pointed to by 'data' and 'length' bytes\r
 220 *   long.  If interrupts have been enabled the data is sent using\r
 221 *   interrupt mode, otherwise polling mode is used.  In interrupt\r
 222 *   mode transmition of the first byte is started and the routine\r
 223 *   returns imediatly, sciSend must not be called again until the\r
 224 *   transfer is complete, when the sciNotification callback will\r
 225 *   be called.  In polling mode, sciSend will not return  until \r
 226 *   the transfer is complete.\r
 227 *\r
 228 *   @note if data word is less than 8 bits, then the data must be left\r
 229 *         aligned in the data byte.\r
 230 */\r
 231 void sciSend(sciBASE_t *sci, uint32_t length, uint8_t *data)\r
 232 {\r
 233     int index = sci == sciREG ? 0 : 1;\r
 234 \r
 235 /* USER CODE BEGIN (11) */\r
 236     /* Using interrupt, does not work. Sometimes a character is lost */\r
 237 //    if ((g_sciTransfer[index].mode & SCI_TX_INT) != 0)\r
 238 //    {\r
 239         /* start transmit by sending first byte */\r
 240 //      uint8_t byte = 0;\r
 241 //      if (xQueueReceiveFromISR(outBuffer.buf, (uint8_t *)&byte, NULL) == pdPASS) {\r
 242 //            sci->TD     = byte;\r
 243 //            sci->SETINT = SCI_TX_INT;\r
 244 //      }\r
 245 //    }\r
 246 //   else\r
 247 //    {\r
 248         /* send the data *///\r
 249 //    while (length-- > 0)\r
 250 //        {\r
 251 //            while ((sci->FLR & SCI_TX_INT) == 0) { /* wait */ };\r
 252 //            sci->TD = *data++;\r
 253 //        }\r
 254 //    }\r
 255 /* USER CODE END */\r
 256 \r
 257     if ((g_sciTransfer[index].mode & SCI_TX_INT) != 0)\r
 258     {\r
 259         /* we are in interrupt mode */\r
 260         \r
 261         g_sciTransfer[index].length = length;\r
 262         g_sciTransfer[index].data   = data;\r
 263 \r
 264         /* start transmit by sending first byte */        \r
 265         sci->TD     = *g_sciTransfer[index].data++;\r
 266         sci->SETINT = SCI_TX_INT;\r
 267     }\r
 268     else\r
 269     {\r
 270         /* send the data */\r
 271         while (xQueueIsQueueEmptyFromISR(outBuffer.buf) != pdTRUE)\r
 272         {\r
 273             while ((sci->FLR & SCI_TX_INT) == 0) { /* wait */ };\r
 274             uint8_t byte;\r
 275             xQueueReceiveFromISR(outBuffer.buf, (void *)&byte, NULL);\r
 276             sci->TD = byte;\r
 277         }\r
 278     }\r
 279 \r
 280 /* USER CODE BEGIN (12) */\r
 281 /* USER CODE END */\r
 282 }\r
 283 \r
 284 \r
 285 /** @fn int sciIsRxReady(sciBASE_t *sci)\r
 286 *   @brief Check if Rx buffer full\r
 287 *   @param[in] sci - sci module base address\r
 288 *\r
 289 *   @return The Rx ready flag\r
 290 *\r
 291 *   Checks to see if the Rx buffer full flag is set, returns\r
 292 *   0 is flags not set otherwise will return the Rx flag itself.\r
 293 */\r
 294 int sciIsRxReady(sciBASE_t *sci)\r
 295 {\r
 296 /* USER CODE BEGIN (13) */\r
 297 /* USER CODE END */\r
 298 \r
 299     return sci->FLR & SCI_RX_INT;\r
 300 }\r
 301 \r
 302 \r
 303 /** @fn int sciRxError(sciBASE_t *sci)\r
 304 *   @brief Return Rx Error flags\r
 305 *   @param[in] sci - sci module base address\r
 306 *\r
 307 *   @return The Rx error flags\r
 308 *\r
 309 *   Returns the Rx framing, overun and parity errors flags,\r
 310 *   also clears the error flags before returning.\r
 311 */\r
 312 int sciRxError(sciBASE_t *sci)\r
 313 {\r
 314     int status = sci->FLR & (SCI_FE_INT | SCI_OE_INT |SCI_PE_INT);\r
 315 \r
 316 /* USER CODE BEGIN (14) */\r
 317 /* USER CODE END */\r
 318 \r
 319     sci->FLR = SCI_FE_INT | SCI_OE_INT | SCI_PE_INT;\r
 320     return status;\r
 321 }\r
 322 \r
 323 \r
 324 /** @fn uint32_t sciReceiveByte(sciBASE_t *sci)\r
 325 *   @brief Receive Byte\r
 326 *   @param[in] sci - sci module base address\r
 327 *\r
 328 *   @return Received byte\r
 329 *\r
 330 *    Recieves a single byte in polling mode.  If there is\r
 331 *    not a byte in the receive buffer the routine will wait\r
 332 *    until one is received.   Use sciIsRxReady to check to\r
 333 *    see if the buffer is full to avoid waiting.\r
 334 */\r
 335 int sciReceiveByte(sciBASE_t *sci)\r
 336 {\r
 337 /* USER CODE BEGIN (15) */\r
 338 /* USER CODE END */\r
 339 \r
 340     while ((sci->FLR & SCI_RX_INT) == 0) { /* wait */ };\r
 341 \r
 342     return sci->RD;\r
 343 }\r
 344 \r
 345 \r
 346 /** @fn void sciReceive(sciBASE_t *sci, uint32_t length, uint8_t *data)\r
 347 *   @brief Receive Data\r
 348 *   @param[in] sci    - sci module base address\r
 349 *   @param[in] length - number of data words to transfer\r
 350 *   @param[in] data   - pointer to data buffer\r
 351 *\r
 352 *   Receive a block of 'length' bytes long and place it into the \r
 353 *   data buffer pointed to by 'data'.  If interrupts have been \r
 354 *   enabled the data is received using interrupt mode, otherwise\r
 355 *   polling mode is used.  In interrupt mode receive is setup and\r
 356 *   the routine returns imediatly, sciReceive must not be called \r
 357 *   again until the transfer is complete, when the sciNotification \r
 358 *   callback will be called.  In polling mode, sciReceive will not\r
 359 *   return  until the transfer is complete.\r
 360 */\r
 361 void sciReceive(sciBASE_t *sci, uint32_t length, uint8_t *data)\r
 362 {\r
 363 /* USER CODE BEGIN (16) */\r
 364     if (sci->SETINT & SCI_RX_INT)\r
 365     {\r
 366         /* clear error flags */\r
 367         sci->FLR = SCI_FE_INT | SCI_OE_INT | SCI_PE_INT;\r
 368 \r
 369     }\r
 370     else\r
 371     {   \r
 372         while (length-- > 0)\r
 373         {\r
 374             while ((sci->FLR & SCI_RX_INT) == 0) { /* wait */ };\r
 375             *data++ = sci->RD;\r
 376         }\r
 377     }\r
 378 /* USER CODE END */\r
 379 \r
 380     if (sci->SETINT & SCI_RX_INT)\r
 381     {\r
 382         /* we are in interrupt mode */\r
 383         int index = sci == sciREG ? 0 : 1;\r
 384         \r
 385         /* clear error flags */\r
 386         sci->FLR = SCI_FE_INT | SCI_OE_INT | SCI_PE_INT;\r
 387 \r
 388         g_sciTransfer[index].length = length;\r
 389         g_sciTransfer[index].data   = data;\r
 390     }\r
 391     else\r
 392     {   \r
 393         while (length-- > 0)\r
 394         {\r
 395             while ((sci->FLR & SCI_RX_INT) == 0) { /* wait */ };\r
 396             *data++ = sci->RD;\r
 397         }\r
 398     }\r
 399 /* USER CODE BEGIN (17) */\r
 400 /* USER CODE END */\r
 401 }\r
 402 \r
 403 /** @fn void sciEnableLoopback(sciBASE_t *sci, Loopbacktype_t Loopbacktype)\r
 404 *   @brief Enable Loopback mode for self test\r
 405 *   @param[in] sci        - sci module base address\r
 406 *   @param[in] Loopbacktype  - Digital or Analog\r
 407 *\r
 408 *   This function enables the Loopback mode for self test.\r
 409 */\r
 410 void sciEnableLoopback(sciBASE_t *sci, Loopbacktype_t Loopbacktype)\r
 411 {\r
 412 /* USER CODE BEGIN (18) */\r
 413 /* USER CODE END */\r
 414     \r
 415         /* Clear Loopback incase enbaled already */\r
 416         sci->IODFTCTRL = 0;\r
 417         \r
 418         /* Enable Loopback either in Analog or Digital Mode */\r
 419     sci->IODFTCTRL = 0x00000A00\r
 420                    | Loopbacktype << 1;\r
 421         \r
 422 /* USER CODE BEGIN (19) */\r
 423 /* USER CODE END */\r
 424 }\r
 425 \r
 426 /** @fn void sciDisableLoopback(sciBASE_t *sci)\r
 427 *   @brief Enable Loopback mode for self test\r
 428 *   @param[in] sci        - sci module base address\r
 429 *\r
 430 *   This function disable the Loopback mode.\r
 431 */\r
 432 void sciDisableLoopback(sciBASE_t *sci)\r
 433 {\r
 434 /* USER CODE BEGIN (20) */\r
 435 /* USER CODE END */\r
 436     \r
 437         /* Disable Loopback Mode */\r
 438     sci->IODFTCTRL = 0x000005000;\r
 439         \r
 440 /* USER CODE BEGIN (21) */\r
 441 /* USER CODE END */\r
 442 }\r
 443 \r
 444 /** @fn sciEnableNotification(sciBASE_t *sci, uint32_t flags)\r
 445 *   @brief Enable interrupts\r
 446 *   @param[in] sci   - sci module base address\r
 447 *   @param[in] flags - Interrupts to be enabled, can be ored value of:\r
 448 *                      SCI_FE_INT    - framming error,\r
 449 *                      SCI_OE_INT    - overrun error,\r
 450 *                      SCI_PE_INT    - parity error,\r
 451 *                      SCI_RX_INT    - receive buffer ready,\r
 452 *                      SCI_TX_INT    - transmit buffer ready,\r
 453 *                      SCI_WAKE_INT  - wakeup,\r
 454 *                      SCI_BREAK_INT - break detect\r
 455 */\r
 456 void sciEnableNotification(sciBASE_t *sci, uint32_t flags)\r
 457 {\r
 458     int index = sci == sciREG ? 0 : 1;\r
 459 \r
 460 /* USER CODE BEGIN (22) */\r
 461 /* USER CODE END */\r
 462 \r
 463     g_sciTransfer[index].mode |= (flags & SCI_TX_INT);\r
 464     sci->SETINT                = (flags & ~SCI_TX_INT);\r
 465 \r
 466 /* USER CODE BEGIN (23) */\r
 467 /* USER CODE END */\r
 468 }\r
 469 \r
 470 \r
 471 /** @fn sciDisableNotification(sciBASE_t *sci, uint32_t flags)\r
 472 *   @brief Disable interrupts\r
 473 *   @param[in] sci   - sci module base address\r
 474 *   @param[in] flags - Interrupts to be disabled, can be ored value of:\r
 475 *                      SCI_FE_INT    - framming error,\r
 476 *                      SCI_OE_INT    - overrun error,\r
 477 *                      SCI_PE_INT    - parity error,\r
 478 *                      SCI_RX_INT    - receive buffer ready,\r
 479 *                      SCI_TX_INT    - transmit buffer ready,\r
 480 *                      SCI_WAKE_INT  - wakeup,\r
 481 *                      SCI_BREAK_INT - break detect\r
 482 */\r
 483 void sciDisableNotification(sciBASE_t *sci, uint32_t flags)\r
 484 {\r
 485     int index = sci == sciREG ? 0 : 1;\r
 486 \r
 487 /* USER CODE BEGIN (24) */\r
 488 /* USER CODE END */\r
 489 \r
 490     g_sciTransfer[index].mode &= ~(flags & SCI_TX_INT);\r
 491     sci->CLRINT                = (flags & ~SCI_TX_INT);\r
 492 \r
 493 /* USER CODE BEGIN (25) */\r
 494 /* USER CODE END */\r
 495 }\r
 496 \r
 497 \r
 498 /** @fn void sciHighLevelInterrupt(void)\r
 499 *   @brief Level 0 Interrupt for SCI\r
 500 */\r
 501 #pragma INTERRUPT(sciHighLevelInterrupt, IRQ)\r
 502 \r
 503 void sciHighLevelInterrupt(void)\r
 504 {\r
 505     uint32_t vec = sciREG->INTVECT0;\r
 506 \r
 507 /* USER CODE BEGIN (26) */\r
 508     switch (vec)\r
 509     {\r
 510     case 1:\r
 511         sciNotification(sciREG, SCI_WAKE_INT);\r
 512         break;\r
 513     case 3:\r
 514         sciNotification(sciREG, SCI_PE_INT);\r
 515         break;\r
 516     case 6:\r
 517         sciNotification(sciREG, SCI_FE_INT);\r
 518         break;\r
 519     case 7:\r
 520         sciNotification(sciREG, SCI_BREAK_INT);\r
 521         break;\r
 522     case 9:\r
 523         sciNotification(sciREG, SCI_OE_INT);\r
 524         break;\r
 525 \r
 526     case 11:\r
 527         /* receive */\r
 528         {   uint8_t byte = sciREG->RD;\r
 529                 if (xQueueSendFromISR(inBuffer.buf, (void*)&byte, NULL) == errQUEUE_FULL)\r
 530                         receiveError++;\r
 531                 sciNotification(sciREG, SCI_RX_INT);\r
 532         }\r
 533         break;\r
 534 \r
 535     case 12:\r
 536         /* transmit */\r
 537         /* using interrupt, does not work properly, sometimes a character is lost */\r
 538  /*     if (xQueueIsQueueEmptyFromISR(outBuffer.buf) == pdTRUE) {\r
 539                 sciREG->CLRINT = SCI_TX_INT;\r
 540                 sciNotification(sciREG, SCI_TX_INT);\r
 541         }\r
 542         else {\r
 543                 uint8_t byte = 0;\r
 544                 xQueueReceiveFromISR(outBuffer.buf, (uint8_t *)&byte, NULL);\r
 545                 while (sciIsTxReady(sciREG) == 0)\r
 546                         ;\r
 547                         sciREG->TD     = byte;\r
 548         }\r
 549  */\r
 550         /* transmit */\r
 551         if (--g_sciTransfer[0].length > 0)\r
 552         {\r
 553             sciREG->TD = *g_sciTransfer[0].data++;\r
 554         }\r
 555         else\r
 556         {\r
 557             sciREG->CLRINT = SCI_TX_INT;\r
 558             sciNotification(sciREG, SCI_TX_INT);\r
 559         }\r
 560         break;\r
 561 \r
 562      default:\r
 563         /* phantom interrupt, clear flags and return */\r
 564         sciREG->FLR = ~sciREG->SETINTLVL & 0x07000303;\r
 565         break;\r
 566     }\r
 567 /* USER CODE END */\r
 568 \r
 569 /* USER CODE BEGIN (27) */\r
 570 /* USER CODE END */\r
 571 }\r
 572 \r
 573 /** @fn void sciLowLevelInterrupt(void)\r
 574 *   @brief Level 1 Interrupt for SCI\r
 575 */\r
 576 #pragma INTERRUPT(sciLowLevelInterrupt, IRQ)\r
 577 \r
 578 void sciLowLevelInterrupt(void)\r
 579 {\r
 580     uint32_t vec = sciREG->INTVECT1;\r
 581 /* USER CODE BEGIN (28) */\r
 582 /* USER CODE END */\r
 583 \r
 584     switch (vec)\r
 585     {\r
 586     case 1:\r
 587         sciNotification(sciREG, SCI_WAKE_INT);\r
 588         break;\r
 589     case 3:\r
 590         sciNotification(sciREG, SCI_PE_INT);\r
 591         break;\r
 592     case 6:\r
 593         sciNotification(sciREG, SCI_FE_INT);\r
 594         break;\r
 595     case 7:\r
 596         sciNotification(sciREG, SCI_BREAK_INT);\r
 597         break;\r
 598     case 9:\r
 599         sciNotification(sciREG, SCI_OE_INT);\r
 600         break;\r
 601 \r
 602     case 11:\r
 603         /* receive */\r
 604         {   uint32_t byte = sciREG->RD;\r
 605 \r
 606             if (g_sciTransfer[0].length > 0)\r
 607             {\r
 608                 *g_sciTransfer[0].data++ = byte;\r
 609                 g_sciTransfer[0].length--;\r
 610                 if (g_sciTransfer[0].length == 0)\r
 611                 {\r
 612                     sciNotification(sciREG, SCI_RX_INT);\r
 613                 }\r
 614             }\r
 615         }\r
 616         break;\r
 617 \r
 618     case 12:\r
 619         /* transmit */\r
 620         if (--g_sciTransfer[0].length > 0)\r
 621         {\r
 622             sciREG->TD = *g_sciTransfer[0].data++;\r
 623         }\r
 624         else\r
 625         {\r
 626             sciREG->CLRINT = SCI_TX_INT;\r
 627             sciNotification(sciREG, SCI_TX_INT);\r
 628         }\r
 629         break;\r
 630 \r
 631     default:\r
 632         /* phantom interrupt, clear flags and return */\r
 633         sciREG->FLR = sciREG->SETINTLVL & 0x07000303;\r
 634          break;\r
 635     }\r
 636 /* USER CODE BEGIN (29) */\r
 637 /* USER CODE END */\r
 638 }\r
 639 \r
 640 \r
 641 \r