* @param[in] LINUARTx can be only LINUART.
  * @param[in] LINUART_WordLength can be LINUART_WordLength_8D or LINUART_WordLength_9D to select the lenght of data frame.
  * @param[in] LINUART_StopBits can 0.5, 1, 1.5 or 2 stopbits,
  * @param[in] LINUART_Parity can be LINUART_Parity_No, LINUART_Parity_Odd or LINUART_Parity_Even,
  * @param[in] LINUART_BaudRate  the baudrate,
  * @param[in] MasterFrequency can be obtained using the CLK_GetClocksFreq function,
  * @param[in] LINUART_Mode LINUART_Mode_TypeDef,
  * @retval void None
  * @par Required preconditions:
  * None
  * @par Called functions:
  * None
  * @par Example:
  * @code
  * LINUART_Init(LINUART, LINUART_InitStruct)
  * @endcode
  */
void LINUART_Init(LINUART_TypeDef* LINUARTx,
                  LINUART_WordLength_TypeDef LINUART_WordLength,
                  LINUART_StopBits_TypeDef LINUART_StopBits,
                  LINUART_Parity_TypeDef LINUART_Parity,
                  u32 LINUART_BaudRate,
                  u32 MasterFrequency,
                  LINUART_Mode_TypeDef LINUART_Mode)
{

    u32 BaudRate_Mantissa, BaudRate_Mantissa100;

    assert(IS_LINUART_WordLength_VALUE_OK(LINUART_WordLength));

    assert(IS_LINUART_StopBits_VALUE_OK(LINUART_StopBits));

    assert(IS_LINUART_Parity_VALUE_OK(LINUART_Parity));

    /* Assert: BaudRate value should be <= 625000 bps */
    assert(IS_LINUART_BAUDRATE_OK(LINUART_BaudRate));

    /* Assert: USART_Mode value should exclude values such as  USART_ModeTx_Enable|USART_ModeTx_Disable */
    assert(IS_LINUART_MODE_VALUE_OK((u8)LINUART_Mode));

    /* Wait for no Transmition before modifying the M bit */
    /* while(!(LINUARTx->SR&LINUART_SR_TC));      */

    LINUARTx->CR1 &= (u8)(~LINUART_CR1_M);     /**< Clear the word length bit */
    LINUARTx->CR1 |= (u8)LINUART_WordLength; /**< Set the word length bit according to LINUART_WordLength value */

    LINUARTx->CR3 &= (u8)(~LINUART_CR3_STOP);  /**< Clear the STOP bits */
    LINUARTx->CR3 |= (u8)LINUART_StopBits;  /**< Set the STOP bits number according to LINUART_StopBits value  */

    LINUARTx->CR1 &= (u8)(~(LINUART_CR1_PCEN|LINUART_CR1_PS));  /**< Clear the Parity Control bit */
    LINUARTx->CR1 |= (u8)LINUART_Parity;     /**< Set the Parity Control bit to LINUART_Parity value */

    LINUARTx->BRR1 &= (u8)(~LINUART_BRR1_DIVM);  /**< Clear the LSB mantissa of LINUARTDIV  */
    LINUARTx->BRR2 &= (u8)(~LINUART_BRR2_DIVM);  /**< Clear the MSB mantissa of LINUARTDIV  */
    LINUARTx->BRR2 &= (u8)(~LINUART_BRR2_DIVF);  /**< Clear the Fraction bits of LINUARTDIV */

    /**< Set the LINUART BaudRates in BRR1 and BRR2 registers according to LINUART_BaudRate value */
    BaudRate_Mantissa    = (MasterFrequency / (LINUART_BaudRate << 4));
    BaudRate_Mantissa100 = ((MasterFrequency * 100) / (LINUART_BaudRate << 4));
    LINUARTx->BRR2 |= (u8)((u8)((u8)((u8)(BaudRate_Mantissa100 - (BaudRate_Mantissa * 100)) << 4) / 100) & (u8)0x0F); /**< Set the fraction of LINUARTDIV  */
    LINUARTx->BRR2 |= (u8)((BaudRate_Mantissa >> 4) & (u8)0xF0); /**< Set the MSB mantissa of LINUARTDIV  */
    LINUARTx->BRR1 |= (u8)BaudRate_Mantissa;           /**< Set the LSB mantissa of LINUARTDIV  */


    if ((u8)LINUART_Mode&(u8)LINUART_Mode_Tx_Enable)
    {
        LINUARTx->CR2 |= LINUART_CR2_TEN;  /**< Set the Transmitter Enable bit */
    }
    else
    {
        LINUARTx->CR2 &= (u8)(~LINUART_CR2_TEN);  /**< Clear the Transmitter Disable bit */
    }
    if ((u8)LINUART_Mode & (u8)LINUART_Mode_Rx_Enable)
    {
        LINUARTx->CR2 |= LINUART_CR2_REN;  /**< Set the Receiver Enable bit */
    }
    else
    {
        LINUARTx->CR2 &= (u8)(~LINUART_CR2_REN);  /**< Clear the Receiver Disable bit */
    }
}


/**
  * @brief Enables or disables the specified LINUART interrupts.
  * @par Full description:
  * Enables or disables the specified LINUART interrupts.
  * @param[in] LINUARTx can be only LINUART.
  * @param[in] LINUART_IT specifies the LINUART interrupt sources to be
  *                    enabled or disabled.
  *                    This parameter can be one of the following values:
  *                       - LINUART_IT_PIEN
  *                       - LINUART_IT_TCIEN
  *                       - LINUART_IT_RIEN
  *                       - LINUART_IT_ILIEN
  *                       - LINUART_IT_RIEN
   *                      - LINUART_IT_LBDIEN
   *		        - LINUART_IT_LHDIEN
  * @param[in] NewState new state of the specified LINUART interrupts.
 *                    This parameter can be: ENABLE or DISABLE.
  * @retval void None
  * @par Required preconditions:
  * None
  * @par Called functions:
  * None
  * @par Example:
  * @code
  * LINUART_ITConfig(LINUART, LINUART_IT_PIEN, ENABLE)
  * @endcode
  */
void LINUART_ITConfig(LINUART_TypeDef* LINUARTx, LINUART_IT_TypeDef LINUART_IT, FunctionalState NewState)
{
    assert(IS_LINUART_IT_VALUE_OK(LINUART_IT));
    assert(IS_STATE_VALUE_OK(NewState));

    if (NewState)
    {
        /**< Enable the Interrupt bits according to LINUART_IT mask */
        LINUARTx->CR2 |= (u8)(((u8)LINUART_IT) & (u8)(LINUART_CR2_TIEN | LINUART_CR2_TCIEN | LINUART_CR2_RIEN | LINUART_CR2_ILIEN));
        LINUARTx->CR1 |= (u8)((u8)LINUART_IT & LINUART_CR1_PIEN);
        LINUARTx->CR4 |= (u8)((u8)((u8)LINUART_IT << 4) & LINUART_CR4_LBDIEN);
#ifdef HW_PLATFORM_CUT10
        LINUARTx->CR5 |= (u8)((u8)LINUART_IT  & LINUART_CR5_LHDIEN);
#endif
    }
    else
    {
        /**< Disable the interrupt bits according to LINUART_IT mask */

        LINUARTx->CR2 &= (u8)(~(((u8)LINUART_IT) & (u8)(LINUART_CR2_TIEN | LINUART_CR2_TCIEN | LINUART_CR2_RIEN | LINUART_CR2_ILIEN)));
        LINUARTx->CR1 &= (u8)(~((u8)LINUART_IT & LINUART_CR1_PIEN));
        LINUARTx->CR4 &= (u8)(~((u8)((u8)LINUART_IT << 4) & LINUART_CR4_LBDIEN));
#ifdef HW_PLATFORM_CUT10
        LINUARTx->CR5 &= (u8)(~((u8)LINUART_IT  & LINUART_CR5_LHDIEN));
#endif
    }

}


/**
  * @brief Sets the LINUART LIN Break detection length.
  * @par Full description:
  * Sets the LINUART LIN Break detection length.
  * @param[in] LINUARTx can be only LINUART.
  * @param[in] LINUART_LINBreakDetectionLength specifies the LIN break
  *                    detection length.
  *                    This parameter can be one of the following values:
  *                       - LINUART_LINBreakDetectionLength10
  *                       - LINUART_LINBreakDetectionLength11
  * @retval void None
  * @par Required preconditions:
  * None
  * @par Called functions:
  * None
  * @par Example:
  * @code
  * LINUART_LINBreakDetectionConfig(LINUART, LINUART_LINBreakDetectionLength11)
  * @endcode
  */
void LINUART_LINBreakDetectionConfig(LINUART_TypeDef* LINUARTx, LINUART_LINBreakDetectionLength_TypeDef LINUART_LINBreakDetectionLength)
{
    assert(IS_LINUART_LINBreakDetectionLength_VALUE_OK(LINUART_LINBreakDetectionLength));

    if (LINUART_LINBreakDetectionLength == LINUART_LINBreakDetectionLength10)
    {
        LINUARTx->CR4 &= ((u8)~LINUART_CR4_LBDL);
    }
    else
    {
        LINUARTx->CR4 |= LINUART_CR4_LBDL;
    }
}

#ifdef HW_PLATFORM_CUT10
void LINUART_LINConfig(LINUART_TypeDef* LINUARTx, LINUART_Slave_TypeDef LINUART_Slave, LINUART_Autosync_TypeDef LINUART_Autosync, LINUART_DivUp_TypeDef LINUART_DivUp)
{
    assert(IS_LINUART_Slave_VALUE_OK(LINUART_Slave));

    assert(IS_LINUART_Autosync_VALUE_OK(LINUART_Autosync));

    assert(IS_LINUART_DivUp_VALUE_OK(LINUART_DivUp));

    if (LINUART_Slave==LINUART_LIN_Master_Mode)
        LINUARTx->CR5 &= ((u8)~ LINUART_CR5_LSLV);
    else
        LINUARTx->CR5 |=  LINUART_CR5_LSLV;

    if (LINUART_Autosync==LINUART_LIN_Autosync_Disable)
        LINUARTx->CR5 &= ((u8)~ LINUART_CR5_LASE );
    else
        LINUARTx->CR5 |=  LINUART_CR5_LASE ;

    if (LINUART_DivUp==LINUART_LIN_DivUp_LBRR1)
        LINUARTx->CR5 &= ((u8)~ LINUART_CR5_LDUM);
    else
        LINUARTx->CR5 |=  LINUART_CR5_LDUM;

}
#endif

/**
  * @brief Enables or disables the LINUART抯 LIN mode.
  * @par Full description:
  * Enables or disables the LINUART抯 LIN mode.
  * @param[in] LINUARTx can be only LINUART.
  * @param[in] NewState is new state of the LINUART LIN mode.
  *                    This parameter can be: ENABLE or DISABLE.
  * @retval void None
  * @par Required preconditions:
  * None
  * @par Called functions:
  * None
  * @par Example:
  * @code
  * LINUART_LINCmd(LINUART, ENABLE)
  * @endcode
  */
void LINUART_LINCmd(LINUART_TypeDef* LINUARTx, FunctionalState NewState)
{
    assert(IS_STATE_VALUE_OK(NewState));

    if (NewState)
    {
        /* Enable the LIN mode by setting the LINE bit in the CR2 register */
        LINUARTx->CR3 |= LINUART_CR3_LINEN;
    }
    else
    {
        /* Disable the LIN mode by clearing the LINE bit in the CR2 register */
        LINUARTx->CR3 &= ((u8)~LINUART_CR3_LINEN);
    }
}


/**
  * @brief Returns the most recent received data by the LINUART peripheral.
  * @par Full description:
  * Returns the most recent received data by the LINUART peripheral.
  * @param[in] LINUARTx can be only LINUART.
  * @retval u16 Received Data
  * @par Required preconditions:
  * LINUART_Cmd(LINUART, ENABLE);
  * @par Called functions:
  * None
  * @par Example:
  * @code
  * u8 my_data;
  * my_data = LINUART_ReceiveData8(LINUART);
  * @endcode
  */
u8 LINUART_ReceiveData8(LINUART_TypeDef* LINUARTx)
{
    /*!< Wait until reception completed  */
    /*! while(!(LINUARTx->SR&LINUART_SR_RXNE)); */
    return LINUARTx->DR;
}


/**
  * @brief Returns the most recent received data by the LINUART peripheral.
  * @par Full description:
  * Returns the most recent received data by the LINUART peripheral.
  * @param[in] LINUARTx can be only LINUART.
  * @retval u16 Received Data
  * @par Required preconditions:
  * LINUART_Cmd(LINUART, ENABLE);
  * @par Called functions:
  * None
  * @par Example:
  * @code
  * u16 my_data;
  * my_data = LINUART_ReceiveData9(LINUART);
  * @endcode
  */
u16 LINUART_ReceiveData9(LINUART_TypeDef* LINUARTx)
{
    /*!< Wait until reception completed  */
    /*! while(!(LINUARTx->SR&LINUART_SR_RXNE)); */
    return (u16)((((u16)LINUARTx->DR) | ((u16)(((u16)((u16)LINUARTx->CR1 & (u16)LINUART_CR1_R8)) << 1))) & ((u16)0x01FF));
}

/**
  * @brief Determines if the LINUART is in mute mode or not.
  * @par Full description:
  * Determines if the LINUART is in mute mode or not.
  * @param[in] LINUARTx can be only LINUART.
  * @param[in] NewState: new state of the LINUART mode.
  *                    This parameter can be: ENABLE or DISABLE.
  * @retval void None
  * @par Required preconditions:
  * None
  * @par Called functions:
  * None
  * @par Example:
  * @code
  * LINUART_ReceiverWakeUpCmd(LINUART, DISABLE);
  * @endcode
  */
void LINUART_ReceiverWakeUpCmd(LINUART_TypeDef* LINUARTx, FunctionalState NewState)
{
    assert(IS_STATE_VALUE_OK(NewState));

    if (NewState)
    {
        /* Enable the mute mode LINUART by setting the RWU bit in the CR2 register */
        LINUARTx->CR2 |= LINUART_CR2_RWU;
    }
    else
    {
        /* Disable the mute mode LINUART by clearing the RWU bit in the CR1 register */
        LINUARTx->CR2 &= ((u8)~LINUART_CR2_RWU);
    }
}

/**
  * @brief Transmits break characters.
  * @par Full description:
  * Transmits break characters on the LINUART peripheral.
  * @param[in] LINUARTx can be only LINUART.
  * @retval void None
  * @par Required preconditions:
  * None
  * @par Called functions:
  * None
  * @par Example:
  * @code
  * LINUART_SendBreak(LINUART);
  * @endcode
  */
void LINUART_SendBreak(LINUART_TypeDef* LINUARTx)
{
    LINUARTx->CR2 |= LINUART_CR2_SBK;
}

/**
  * @brief Transmits 8 bit data through the LINUART peripheral.
  * @par Full description:
  * Transmits 8 bit data through the LINUART peripheral.
  * @param[in] LINUARTx can be only LINUART.
  * @param[in] Data: the data to transmit.
  * @retval void None
  * @par Required preconditions:
  * LINUART_Cmd(LINUART, ENABLE);
  * @par Called functions:
  * None
  * @par Example:
  * Send 0x55 using LINUART
  * @code
  * u8 my_data = 0x55;
  * LINUART_SendData8(LINUART, my_data);
  * @endcode
  */
void LINUART_SendData8(LINUART_TypeDef* LINUARTx, u8 Data)
{

    /*! Send data only if Transmitter Enabled and if the LINUART is Enabled   */
    /*! if((LINUARTx->CR2&LINUART_CR2_TEN)&(~(LINUARTx->CR1&LINUART_CR1_LINUARTDD)))      */
    /*! Wait until previous transmission completed                          */
    /*! while(!(LINUARTx->SR&LINUART_SR_TC));                                     */
    /* Transmit Data */
    LINUARTx->DR = Data;
}

/**
  * @brief Transmits 9 bit data through the LINUART peripheral.
  * @par Full description:
  * Transmits 9 bit data through the LINUART peripheral.
  * @param[in] LINUARTx can be only LINUART.
  * @param[in] Data: the data to transmit.
  * @retval void None
  * @par Required preconditions:
  * LINUART_Cmd(LINUART, ENABLE);
  * @par Called functions:
  * None
  * @par Example:
  * Send 0x103 using LINUART
   * @code
  * u16 my_data = 0x103;
  * LINUART_SendData9(LINUART, my_data);
  * @endcode
  */
void LINUART_SendData9(LINUART_TypeDef* LINUARTx, u16 Data)
{
    /*! Send data only if Transmitter Enabled and if the LINUART is Enabled   */
    /*! if((LINUART.CR2&LINUART_CR2_TEN)&(~(LINUART.CR1&LINUART_CR1_LINUARTDD)))      */
    /*! Wait until previous transmission completed                          */
    /*! while(!(LINUARTx->SR&LINUART_SR_TC));                                     */

    LINUARTx->CR1 &= ((u8)~LINUART_CR1_T8);                  /**< Clear the transmit data bit 8     */
    LINUARTx->CR1 |= (u8)(((u8)(Data >> 2)) & LINUART_CR1_T8); /**< Write the transmit data bit [8]   */
    LINUARTx->DR   = (u8)(Data);                    /**< Write the transmit data bit [0:7] */

}



/**
  * @brief Sets the address of the LINUART node.
  * @par Full description:
  * Sets the address of the LINUART node.
  * @param[in] LINUARTx can be only LINUART.
  * @param[in] LINUART_Address: Indicates the address of the LINUART node.
  * @retval void None
  * @par Required preconditions:
  * None
  * @par Called functions:
  * None
  * @par Example:
  * Set the address of the LINUART node at 0x04
  * @code
  * u8 my_LINUART_Address = 0x04;
  * LINUART_SetAddress(LINUART, my_LINUART_Address);
  * @endcode
  */
void LINUART_SetAddress(LINUART_TypeDef* LINUARTx, u8 LINUART_Address)
{
    /*Assert for x LINUART_Address*/
    assert(IS_LINUART_LINUART_Address_VALUE_OK(LINUART_Address));

    /* Clear the LINUART address */
    LINUARTx->CR4 &= ((u8)~LINUART_CR4_ADD);
    /* Set the LINUART address node */
    LINUARTx->CR4 |= LINUART_Address;
}


/**
  * @brief Selects the USART WakeUp method.
  * @par Full description:
  * Selects the USART WakeUp method.
  * @param[in] LINUARTx can be only LINUART.
  * @param[in] LINUART_WakeUp: specifies the LINUART wakeup method.
  *                    This parameter can be one of the following values:
  *                        - LINUART_WakeUp_IdleLine
  *                        - LINUART_WakeUp_AddressMark
  * @retval void None
  * @par Required preconditions:
  * None
  * @par Called functions:
  * None
  * @par Example:
  * LINUART WakeUp Idle line .
  * @code
    * LINUART_WakeUpConfig(LINUART,LINUART_WakeUp_IdleLine);
  * @endcode
  */
void LINUART_WakeUpConfig(LINUART_TypeDef* LINUARTx, LINUART_WakeUp_TypeDef LINUART_WakeUp)
{
    assert(IS_LINUART_WakeUp_VALUE_OK(LINUART_WakeUp));

    LINUARTx->CR1 &= ((u8)~LINUART_CR1_WAKE);
    LINUARTx->CR1 |= (u8)LINUART_WakeUp;
}

/**
  * @}
  */

/******************* (C) COPYRIGHT 2007 STMicroelectronics *****END OF FILE****/