git.sur5r.net Git - freertos/blob

   1 /******************************************************************************
   2 *
   3 * Copyright (C) 2010 - 2014 Xilinx, Inc.  All rights reserved.
   4 *
   5 * Permission is hereby granted, free of charge, to any person obtaining a copy
   6 * of this software and associated documentation files (the "Software"), to deal
   7 * in the Software without restriction, including without limitation the rights
   8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 * copies of the Software, and to permit persons to whom the Software is
  10 * furnished to do so, subject to the following conditions:
  11 *
  12 * The above copyright notice and this permission notice shall be included in
  13 * all copies or substantial portions of the Software.
  14 *
  15 * Use of the Software is limited solely to applications:
  16 * (a) running on a Xilinx device, or
  17 * (b) that interact with a Xilinx device through a bus or interconnect.
  18 *
  19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  22 * XILINX  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  23 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  24 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  25 * SOFTWARE.
  26 *
  27 * Except as contained in this notice, the name of the Xilinx shall not be used
  28 * in advertising or otherwise to promote the sale, use or other dealings in
  29 * this Software without prior written authorization from Xilinx.
  30 *
  31 ******************************************************************************/
  32 /****************************************************************************/
  33 /**
  34 *
  35 * @file xuartps_options.c
  36 *
  37 * The implementation of the options functions for the XUartPs driver.
  38 *
  39 * <pre>
  40 * MODIFICATION HISTORY:
  41 *
  42 * Ver   Who    Date     Changes
  43 * ----- ------ -------- -----------------------------------------------
  44 * 1.00  drg/jz 01/13/10 First Release
  45 * 1.00  sdm    09/27/11 Fixed a bug in XUartPs_SetFlowDelay where the input
  46 *                       value was not being written to the register.
  47 *
  48 * </pre>
  49 *
  50 *****************************************************************************/
  51
  52 /***************************** Include Files ********************************/
  53
  54 #include "xuartps.h"
  55
  56 /************************** Constant Definitions ****************************/
  57
  58 /**************************** Type Definitions ******************************/
  59
  60 /***************** Macros (Inline Functions) Definitions ********************/
  61
  62 /************************** Variable Definitions ****************************/
  63 /*
  64  * The following data type is a map from an option to the offset in the
  65  * register to which it belongs as well as its bit mask in that register.
  66  */
  67 typedef struct {
  68         u16 Option;
  69         u16 RegisterOffset;
  70         u32 Mask;
  71 } Mapping;
  72
  73 /*
  74  * Create the table which contains options which are to be processed to get/set
  75  * the options. These options are table driven to allow easy maintenance and
  76  * expansion of the options.
  77  */
  78
  79 static Mapping OptionsTable[] = {
  80         {XUARTPS_OPTION_SET_BREAK, XUARTPS_CR_OFFSET, XUARTPS_CR_STARTBRK},
  81         {XUARTPS_OPTION_STOP_BREAK, XUARTPS_CR_OFFSET, XUARTPS_CR_STOPBRK},
  82         {XUARTPS_OPTION_RESET_TMOUT, XUARTPS_CR_OFFSET, XUARTPS_CR_TORST},
  83         {XUARTPS_OPTION_RESET_TX, XUARTPS_CR_OFFSET, XUARTPS_CR_TXRST},
  84         {XUARTPS_OPTION_RESET_RX, XUARTPS_CR_OFFSET, XUARTPS_CR_RXRST},
  85         {XUARTPS_OPTION_ASSERT_RTS, XUARTPS_MODEMCR_OFFSET,
  86          XUARTPS_MODEMCR_RTS},
  87         {XUARTPS_OPTION_ASSERT_DTR, XUARTPS_MODEMCR_OFFSET,
  88          XUARTPS_MODEMCR_DTR},
  89         {XUARTPS_OPTION_SET_FCM, XUARTPS_MODEMCR_OFFSET, XUARTPS_MODEMCR_FCM}
  90 };
  91
  92 /* Create a constant for the number of entries in the table */
  93
  94 #define XUARTPS_NUM_OPTIONS       (sizeof(OptionsTable) / sizeof(Mapping))
  95
  96 /************************** Function Prototypes *****************************/
  97
  98 /****************************************************************************/
  99 /**
 100 *
 101 * Gets the options for the specified driver instance. The options are
 102 * implemented as bit masks such that multiple options may be enabled or
 103 * disabled simulataneously.
 104 *
 105 * @param        InstancePtr is a pointer to the XUartPs instance.
 106 *
 107 * @return
 108 *
 109 * The current options for the UART. The optionss are bit masks that are
 110 * contained in the file xuartps.h and named XUARTPS_OPTION_*.
 111 *
 112 * @note         None.
 113 *
 114 *****************************************************************************/
 115 u16 XUartPs_GetOptions(XUartPs *InstancePtr)
 116 {
 117         u16 Options = 0;
 118         u32 Register;
 119         unsigned int Index;
 120
 121         /*
 122          * Assert validates the input arguments
 123          */
 124         Xil_AssertNonvoid(InstancePtr != NULL);
 125         Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 126
 127         /*
 128          * Loop thru the options table to map the physical options in the
 129          * registers of the UART to the logical options to be returned
 130          */
 131         for (Index = 0; Index < XUARTPS_NUM_OPTIONS; Index++) {
 132                 Register = XUartPs_ReadReg(InstancePtr->Config.BaseAddress,
 133                                                  OptionsTable[Index].
 134                                                  RegisterOffset);
 135
 136                 /*
 137                  * If the bit in the register which correlates to the option
 138                  * is set, then set the corresponding bit in the options,
 139                  * ignoring any bits which are zero since the options variable
 140                  * is initialized to zero
 141                  */
 142                 if (Register & OptionsTable[Index].Mask) {
 143                         Options |= OptionsTable[Index].Option;
 144                 }
 145         }
 146
 147         return Options;
 148 }
 149
 150 /****************************************************************************/
 151 /**
 152 *
 153 * Sets the options for the specified driver instance. The options are
 154 * implemented as bit masks such that multiple options may be enabled or
 155 * disabled simultaneously.
 156 *
 157 * The GetOptions function may be called to retrieve the currently enabled
 158 * options. The result is ORed in the desired new settings to be enabled and
 159 * ANDed with the inverse to clear the settings to be disabled. The resulting
 160 * value is then used as the options for the SetOption function call.
 161 *
 162 * @param        InstancePtr is a pointer to the XUartPs instance.
 163 * @param        Options contains the options to be set which are bit masks
 164 *               contained in the file xuartps.h and named XUARTPS_OPTION_*.
 165 *
 166 * @return       None.
 167 *
 168 * @note         None.
 169 *
 170 *****************************************************************************/
 171 void XUartPs_SetOptions(XUartPs *InstancePtr, u16 Options)
 172 {
 173         unsigned int Index;
 174         u32 Register;
 175
 176         /*
 177          * Assert validates the input arguments
 178          */
 179         Xil_AssertVoid(InstancePtr != NULL);
 180         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 181
 182         /*
 183          * Loop thru the options table to map the logical options to the
 184          * physical options in the registers of the UART.
 185          */
 186         for (Index = 0; Index < XUARTPS_NUM_OPTIONS; Index++) {
 187
 188                 /*
 189                  * Read the register which contains option so that the register
 190                  * can be changed without destoying any other bits of the
 191                  * register.
 192                  */
 193                 Register = XUartPs_ReadReg(InstancePtr->Config.BaseAddress,
 194                                                  OptionsTable[Index].
 195                                                  RegisterOffset);
 196
 197                 /*
 198                  * If the option is set in the input, then set the corresponding
 199                  * bit in the specified register, otherwise clear the bit in
 200                  * the register.
 201                  */
 202                 if (Options & OptionsTable[Index].Option) {
 203                         Register |= OptionsTable[Index].Mask;
 204                 }
 205                 else {
 206                         Register &= ~OptionsTable[Index].Mask;
 207                 }
 208
 209                 /* Write the new value to the register to set the option */
 210                 XUartPs_WriteReg(InstancePtr->Config.BaseAddress,
 211                                    OptionsTable[Index].RegisterOffset,
 212                                    Register);
 213         }
 214
 215 }
 216
 217 /****************************************************************************/
 218 /**
 219 *
 220 * This function gets the receive FIFO trigger level. The receive trigger
 221 * level indicates the number of bytes in the receive FIFO that cause a receive
 222 * data event (interrupt) to be generated.
 223 *
 224 * @param        InstancePtr is a pointer to the XUartPs instance.
 225 *
 226 * @return       The current receive FIFO trigger level. This is a value
 227 *               from 0-31.
 228 *
 229 * @note         None.
 230 *
 231 *****************************************************************************/
 232 u8 XUartPs_GetFifoThreshold(XUartPs *InstancePtr)
 233 {
 234         u8 RtrigRegister;
 235
 236         /*
 237          * Assert validates the input arguments
 238          */
 239         Xil_AssertNonvoid(InstancePtr != NULL);
 240         Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 241
 242         /*
 243          * Read the value of the FIFO control register so that the threshold
 244          * can be retrieved, this read takes special register processing
 245          */
 246         RtrigRegister = (u8) XUartPs_ReadReg(InstancePtr->Config.BaseAddress,
 247                                                    XUARTPS_RXWM_OFFSET);
 248
 249         /* Return only the trigger level from the register value */
 250
 251         return (RtrigRegister & XUARTPS_RXWM_MASK);
 252 }
 253
 254 /****************************************************************************/
 255 /**
 256 *
 257 * This functions sets the receive FIFO trigger level. The receive trigger
 258 * level specifies the number of bytes in the receive FIFO that cause a receive
 259 * data event (interrupt) to be generated.
 260 *
 261 * @param        InstancePtr is a pointer to the XUartPs instance.
 262 * @param        TriggerLevel contains the trigger level to set.
 263 *
 264 * @return       None
 265 *
 266 * @note         None.
 267 *
 268 *****************************************************************************/
 269 void XUartPs_SetFifoThreshold(XUartPs *InstancePtr, u8 TriggerLevel)
 270 {
 271         u32 RtrigRegister;
 272
 273         /*
 274          * Assert validates the input arguments
 275          */
 276         Xil_AssertVoid(InstancePtr != NULL);
 277         Xil_AssertVoid(TriggerLevel <= XUARTPS_RXWM_MASK);
 278         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 279
 280         RtrigRegister = TriggerLevel & XUARTPS_RXWM_MASK;
 281
 282         /*
 283          * Write the new value for the FIFO control register to it such that the
 284          * threshold is changed
 285          */
 286         XUartPs_WriteReg(InstancePtr->Config.BaseAddress,
 287                            XUARTPS_RXWM_OFFSET, RtrigRegister);
 288
 289 }
 290
 291 /****************************************************************************/
 292 /**
 293 *
 294 * This function gets the modem status from the specified UART. The modem
 295 * status indicates any changes of the modem signals. This function allows
 296 * the modem status to be read in a polled mode. The modem status is updated
 297 * whenever it is read such that reading it twice may not yield the same
 298 * results.
 299 *
 300 * @param        InstancePtr is a pointer to the XUartPs instance.
 301 *
 302 * @return
 303 *
 304 * The modem status which are bit masks that are contained in the file
 305 * xuartps.h and named XUARTPS_MODEM_*.
 306 *
 307 * @note
 308 *
 309 * The bit masks used for the modem status are the exact bits of the modem
 310 * status register with no abstraction.
 311 *
 312 *****************************************************************************/
 313 u16 XUartPs_GetModemStatus(XUartPs *InstancePtr)
 314 {
 315         u32 ModemStatusRegister;
 316
 317         /*
 318          * Assert validates the input arguments
 319          */
 320         Xil_AssertNonvoid(InstancePtr != NULL);
 321         Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 322
 323         /* Read the modem status register to return
 324          */
 325         ModemStatusRegister = XUartPs_ReadReg(InstancePtr->Config.BaseAddress,
 326                                                 XUARTPS_MODEMSR_OFFSET);
 327         return ModemStatusRegister;
 328 }
 329
 330 /****************************************************************************/
 331 /**
 332 *
 333 * This function determines if the specified UART is sending data.
 334 *
 335 * @param        InstancePtr is a pointer to the XUartPs instance.
 336 *
 337 * @return
 338 *               - TRUE if the UART is sending data
 339 *               - FALSE if UART is not sending data
 340 *
 341 * @note         None.
 342 *
 343 *****************************************************************************/
 344 u32 XUartPs_IsSending(XUartPs *InstancePtr)
 345 {
 346         u32 ChanStatRegister;
 347
 348         /*
 349          * Assert validates the input arguments
 350          */
 351         Xil_AssertNonvoid(InstancePtr != NULL);
 352         Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 353
 354         /*
 355          * Read the channel status register to determine if the transmitter is
 356          * active
 357          */
 358         ChanStatRegister = XUartPs_ReadReg(InstancePtr->Config.BaseAddress,
 359                                                  XUARTPS_SR_OFFSET);
 360
 361         /*
 362          * If the transmitter is active, or the TX FIFO is not empty, then indicate
 363          * that the UART is still sending some data
 364          */
 365         return ((XUARTPS_SR_TACTIVE == (ChanStatRegister &
 366                                          XUARTPS_SR_TACTIVE)) ||
 367                 (XUARTPS_SR_TXEMPTY != (ChanStatRegister &
 368                                          XUARTPS_SR_TXEMPTY)));
 369 }
 370
 371 /****************************************************************************/
 372 /**
 373 *
 374 * This function gets the operational mode of the UART. The UART can operate
 375 * in one of four modes: Normal, Local Loopback, Remote Loopback, or automatic
 376 * echo.
 377 *
 378 * @param        InstancePtr is a pointer to the XUartPs instance.
 379 *
 380 * @return
 381 *
 382 * The operational mode is specified by constants defined in xuartps.h. The
 383 * constants are named XUARTPS_OPER_MODE_*
 384 *
 385 * @note         None.
 386 *
 387 *****************************************************************************/
 388 u8 XUartPs_GetOperMode(XUartPs *InstancePtr)
 389 {
 390         u32 ModeRegister;
 391         u8 OperMode;
 392
 393         /*
 394          * Assert validates the input arguments
 395          */
 396         Xil_AssertNonvoid(InstancePtr != NULL);
 397         Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 398
 399         /*
 400          * Read the Mode register.
 401          */
 402         ModeRegister =
 403                 XUartPs_ReadReg(InstancePtr->Config.BaseAddress,
 404                                   XUARTPS_MR_OFFSET);
 405
 406         ModeRegister &= XUARTPS_MR_CHMODE_MASK;
 407         /*
 408          * Return the constant
 409          */
 410         switch (ModeRegister) {
 411         case XUARTPS_MR_CHMODE_NORM:
 412                 OperMode = XUARTPS_OPER_MODE_NORMAL;
 413                 break;
 414         case XUARTPS_MR_CHMODE_ECHO:
 415                 OperMode = XUARTPS_OPER_MODE_AUTO_ECHO;
 416                 break;
 417         case XUARTPS_MR_CHMODE_L_LOOP:
 418                 OperMode = XUARTPS_OPER_MODE_LOCAL_LOOP;
 419                 break;
 420         case XUARTPS_MR_CHMODE_R_LOOP:
 421                 OperMode = XUARTPS_OPER_MODE_REMOTE_LOOP;
 422                 break;
 423         default:
 424                 OperMode = (u8) ((ModeRegister & XUARTPS_MR_CHMODE_MASK) >>
 425                         XUARTPS_MR_CHMODE_SHIFT);
 426         }
 427
 428         return OperMode;
 429 }
 430
 431 /****************************************************************************/
 432 /**
 433 *
 434 * This function sets the operational mode of the UART. The UART can operate
 435 * in one of four modes: Normal, Local Loopback, Remote Loopback, or automatic
 436 * echo.
 437 *
 438 * @param        InstancePtr is a pointer to the XUartPs instance.
 439 * @param        OperationMode is the mode of the UART.
 440 *
 441 * @return       None.
 442 *
 443 * @note         None.
 444 *
 445 *****************************************************************************/
 446 void XUartPs_SetOperMode(XUartPs *InstancePtr, u8 OperationMode)
 447 {
 448         u32 ModeRegister;
 449
 450         /*
 451          * Assert validates the input arguments.
 452          */
 453         Xil_AssertVoid(InstancePtr != NULL);
 454         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 455         Xil_AssertVoid(OperationMode <= XUARTPS_OPER_MODE_REMOTE_LOOP);
 456
 457         /*
 458          * Read the Mode register.
 459          */
 460         ModeRegister =
 461                 XUartPs_ReadReg(InstancePtr->Config.BaseAddress,
 462                                   XUARTPS_MR_OFFSET);
 463
 464         /*
 465          * Set the correct value by masking the bits, then ORing the const.
 466          */
 467         ModeRegister &= ~XUARTPS_MR_CHMODE_MASK;
 468
 469         switch (OperationMode) {
 470         case XUARTPS_OPER_MODE_NORMAL:
 471                 ModeRegister |= XUARTPS_MR_CHMODE_NORM;
 472                 break;
 473         case XUARTPS_OPER_MODE_AUTO_ECHO:
 474                 ModeRegister |= XUARTPS_MR_CHMODE_ECHO;
 475                 break;
 476         case XUARTPS_OPER_MODE_LOCAL_LOOP:
 477                 ModeRegister |= XUARTPS_MR_CHMODE_L_LOOP;
 478                 break;
 479         case XUARTPS_OPER_MODE_REMOTE_LOOP:
 480                 ModeRegister |= XUARTPS_MR_CHMODE_R_LOOP;
 481                 break;
 482         }
 483
 484         XUartPs_WriteReg(InstancePtr->Config.BaseAddress, XUARTPS_MR_OFFSET,
 485                            ModeRegister);
 486
 487 }
 488
 489 /****************************************************************************/
 490 /**
 491 *
 492 * This function sets the Flow Delay.
 493 * 0 - 3: Flow delay inactive
 494 * 4 - 32: If Flow Control mode is enabled, UART_rtsN is deactivated when the
 495 * receive FIFO fills to this level.
 496 *
 497 * @param        InstancePtr is a pointer to the XUartPs instance.
 498 *
 499 * @return
 500 *
 501 * The Flow Delay is specified by constants defined in xuartps_hw.h. The
 502 * constants are named XUARTPS_FLOWDEL*
 503 *
 504 * @note         None.
 505 *
 506 *****************************************************************************/
 507 u8 XUartPs_GetFlowDelay(XUartPs *InstancePtr)
 508 {
 509         u32 FdelRegister;
 510
 511         /*
 512          * Assert validates the input arguments
 513          */
 514         Xil_AssertNonvoid(InstancePtr != NULL);
 515         Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 516
 517         /*
 518          * Read the Mode register.
 519          */
 520         FdelRegister = XUartPs_ReadReg(InstancePtr->Config.BaseAddress,
 521                                          XUARTPS_FLOWDEL_OFFSET);
 522
 523         /*
 524          * Return the contents of the flow delay register
 525          */
 526         return (u8) (FdelRegister & XUARTPS_FLOWDEL_MASK);
 527 }
 528
 529 /****************************************************************************/
 530 /**
 531 *
 532 * This function sets the Flow Delay.
 533 * 0 - 3: Flow delay inactive
 534 * 4 - 63: If Flow Control mode is enabled, UART_rtsN is deactivated when the
 535 * receive FIFO fills to this level.
 536 *
 537 * @param        InstancePtr is a pointer to the XUartPs instance.
 538 * @param        FlowDelayValue is the Setting for the flow delay.
 539 *
 540 * @return       None.
 541 *
 542 * @note         None.
 543 *
 544 *****************************************************************************/
 545 void XUartPs_SetFlowDelay(XUartPs *InstancePtr, u8 FlowDelayValue)
 546 {
 547         u32 FdelRegister;
 548
 549         /*
 550          * Assert validates the input arguments
 551          */
 552         Xil_AssertVoid(InstancePtr != NULL);
 553         Xil_AssertVoid(FlowDelayValue > XUARTPS_FLOWDEL_MASK);
 554         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 555
 556         /*
 557          * Set the correct value by shifting the input constant, then masking
 558          * the bits
 559          */
 560         FdelRegister = (FlowDelayValue & XUARTPS_FLOWDEL_MASK);
 561
 562         XUartPs_WriteReg(InstancePtr->Config.BaseAddress,
 563                            XUARTPS_FLOWDEL_OFFSET, FdelRegister);
 564
 565 }
 566
 567 /****************************************************************************/
 568 /**
 569 *
 570 * This function gets the Receive Timeout of the UART.
 571 *
 572 * @param        InstancePtr is a pointer to the XUartPs instance.
 573 *
 574 * @return       The current setting for receive time out.
 575 *
 576 * @note         None.
 577 *
 578 *****************************************************************************/
 579 u8 XUartPs_GetRecvTimeout(XUartPs *InstancePtr)
 580 {
 581         u32 RtoRegister;
 582
 583         /*
 584          * Assert validates the input arguments
 585          */
 586         Xil_AssertNonvoid(InstancePtr != NULL);
 587         Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 588
 589         /*
 590          * Read the Recieve Timeout register.
 591          */
 592         RtoRegister = XUartPs_ReadReg(InstancePtr->Config.BaseAddress,
 593                                         XUARTPS_RXTOUT_OFFSET);
 594
 595         /*
 596          * Return the contents of the mode register shifted appropriately
 597          */
 598         return (RtoRegister & XUARTPS_RXTOUT_MASK);
 599 }
 600
 601 /****************************************************************************/
 602 /**
 603 *
 604 * This function sets the Receive Timeout of the UART.
 605 *
 606 * @param        InstancePtr is a pointer to the XUartPs instance.
 607 * @param        RecvTimeout setting allows the UART to detect an idle connection
 608 *               on the reciever data line.
 609 *               Timeout duration = RecvTimeout x 4 x Bit Period. 0 disables the
 610 *               timeout function.
 611 *
 612 * @return       None.
 613 *
 614 * @note         None.
 615 *
 616 *****************************************************************************/
 617 void XUartPs_SetRecvTimeout(XUartPs *InstancePtr, u8 RecvTimeout)
 618 {
 619         u32 RtoRegister;
 620
 621         /*
 622          * Assert validates the input arguments
 623          */
 624         Xil_AssertVoid(InstancePtr != NULL);
 625         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 626
 627         /*
 628          * Set the correct value by masking the bits
 629          */
 630         RtoRegister = (RecvTimeout & XUARTPS_RXTOUT_MASK);
 631
 632         XUartPs_WriteReg(InstancePtr->Config.BaseAddress,
 633                            XUARTPS_RXTOUT_OFFSET, RtoRegister);
 634
 635         /*
 636          * Configure CR to restart the receiver timeout counter
 637          */
 638         RtoRegister =
 639                 XUartPs_ReadReg(InstancePtr->Config.BaseAddress,
 640                                   XUARTPS_CR_OFFSET);
 641         XUartPs_WriteReg(InstancePtr->Config.BaseAddress, XUARTPS_CR_OFFSET,
 642                            (RtoRegister | XUARTPS_CR_TORST));
 643
 644 }
 645 /****************************************************************************/
 646 /**
 647 *
 648 * Sets the data format for the device. The data format includes the
 649 * baud rate, number of data bits, number of stop bits, and parity. It is the
 650 * caller's responsibility to ensure that the UART is not sending or receiving
 651 * data when this function is called.
 652 *
 653 * @param        InstancePtr is a pointer to the XUartPs instance.
 654 * @param        FormatPtr is a pointer to a format structure containing the data
 655 *               format to be set.
 656 *
 657 * @return
 658 *               - XST_SUCCESS if the data format was successfully set.
 659 *               - XST_UART_BAUD_ERROR indicates the baud rate could not be
 660 *               set because of the amount of error with the baud rate and
 661 *               the input clock frequency.
 662 *               - XST_INVALID_PARAM if one of the parameters was not valid.
 663 *
 664 * @note
 665 *
 666 * The data types in the format type, data bits and parity, are 32 bit fields
 667 * to prevent a compiler warning.
 668 * The asserts in this function will cause a warning if these fields are
 669 * bytes.
 670 * <br><br>
 671 *
 672 *****************************************************************************/
 673 int XUartPs_SetDataFormat(XUartPs *InstancePtr,
 674                         XUartPsFormat * FormatPtr)
 675 {
 676         int Status;
 677         u32 ModeRegister;
 678
 679         Xil_AssertNonvoid(InstancePtr != NULL);
 680         Xil_AssertNonvoid(FormatPtr != NULL);
 681         Xil_AssertNonvoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 682
 683         /*
 684          * Verify the inputs specified are valid
 685          */
 686         if ((FormatPtr->DataBits > XUARTPS_FORMAT_6_BITS) ||
 687                 (FormatPtr->StopBits > XUARTPS_FORMAT_2_STOP_BIT) ||
 688                 (FormatPtr->Parity > XUARTPS_FORMAT_NO_PARITY)) {
 689                 return XST_INVALID_PARAM;
 690         }
 691
 692         /*
 693          * Try to set the baud rate and if it's not successful then don't
 694          * continue altering the data format, this is done first to avoid the
 695          * format from being altered when an error occurs
 696          */
 697         Status = XUartPs_SetBaudRate(InstancePtr, FormatPtr->BaudRate);
 698         if (Status != XST_SUCCESS) {
 699                 return Status;
 700         }
 701
 702         ModeRegister =
 703                 XUartPs_ReadReg(InstancePtr->Config.BaseAddress,
 704                                   XUARTPS_MR_OFFSET);
 705
 706         /*
 707          * Set the length of data (8,7,6) by first clearing out the bits
 708          * that control it in the register, then set the length in the register
 709          */
 710         ModeRegister &= ~XUARTPS_MR_CHARLEN_MASK;
 711         ModeRegister |= (FormatPtr->DataBits << XUARTPS_MR_CHARLEN_SHIFT);
 712
 713         /*
 714          * Set the number of stop bits in the mode register by first clearing
 715          * out the bits that control it in the register, then set the number
 716          * of stop bits in the register.
 717          */
 718         ModeRegister &= ~XUARTPS_MR_STOPMODE_MASK;
 719         ModeRegister |= (FormatPtr->StopBits << XUARTPS_MR_STOPMODE_SHIFT);
 720
 721         /*
 722          * Set the parity by first clearing out the bits that control it in the
 723          * register, then set the bits in the register, the default is no parity
 724          * after clearing the register bits
 725          */
 726         ModeRegister &= ~XUARTPS_MR_PARITY_MASK;
 727         ModeRegister |= (FormatPtr->Parity << XUARTPS_MR_PARITY_SHIFT);
 728
 729         /*
 730          * Update the mode register
 731          */
 732         XUartPs_WriteReg(InstancePtr->Config.BaseAddress, XUARTPS_MR_OFFSET,
 733                            ModeRegister);
 734
 735         return XST_SUCCESS;
 736 }
 737
 738 /****************************************************************************/
 739 /**
 740 *
 741 * Gets the data format for the specified UART. The data format includes the
 742 * baud rate, number of data bits, number of stop bits, and parity.
 743 *
 744 * @param        InstancePtr is a pointer to the XUartPs instance.
 745 * @param        FormatPtr is a pointer to a format structure that will contain
 746 *               the data format after this call completes.
 747 *
 748 * @return       None.
 749 *
 750 * @note         None.
 751 *
 752 *
 753 *****************************************************************************/
 754 void XUartPs_GetDataFormat(XUartPs *InstancePtr, XUartPsFormat * FormatPtr)
 755 {
 756         u32 ModeRegister;
 757
 758
 759         /*
 760          * Assert validates the input arguments
 761          */
 762         Xil_AssertVoid(InstancePtr != NULL);
 763         Xil_AssertVoid(FormatPtr != NULL);
 764         Xil_AssertVoid(InstancePtr->IsReady == XIL_COMPONENT_IS_READY);
 765
 766         /*
 767          * Get the baud rate from the instance, this is not retrieved from the
 768          * hardware because it is only kept as a divisor such that it is more
 769          * difficult to get back to the baud rate
 770          */
 771         FormatPtr->BaudRate = InstancePtr->BaudRate;
 772
 773         ModeRegister = XUartPs_ReadReg(InstancePtr->Config.BaseAddress,
 774                                   XUARTPS_MR_OFFSET);
 775
 776         /*
 777          * Get the length of data (8,7,6,5)
 778          */
 779         FormatPtr->DataBits =
 780                 (ModeRegister & XUARTPS_MR_CHARLEN_MASK) >>
 781                 XUARTPS_MR_CHARLEN_SHIFT;
 782
 783         /*
 784          * Get the number of stop bits
 785          */
 786         FormatPtr->StopBits =
 787                 (ModeRegister & XUARTPS_MR_STOPMODE_MASK) >>
 788                 XUARTPS_MR_STOPMODE_SHIFT;
 789
 790         /*
 791          * Determine what parity is
 792          */
 793         FormatPtr->Parity =
 794                 (ModeRegister & XUARTPS_MR_PARITY_MASK) >>
 795                 XUARTPS_MR_PARITY_SHIFT;
 796 }