lib/main/STM32F4/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_cec.c

   1 /**
   2   ******************************************************************************
   3   * @file    stm32f4xx_hal_cec.c
   4   * @author  MCD Application Team
   5   * @version V1.7.1
   6   * @date    14-April-2017
   7   * @brief   CEC HAL module driver.
   8   *          This file provides firmware functions to manage the following
   9   *          functionalities of the High Definition Multimedia Interface
  10   *          Consumer Electronics Control Peripheral (CEC).
  11   *           + Initialization and de-initialization functions
  12   *           + IO operation functions
  13   *           + Peripheral Control functions
  14   *
  15   *
  16   @verbatim
  17  ===============================================================================
  18                         ##### How to use this driver #####
  19  ===============================================================================
  20     [..]
  21     The CEC HAL driver can be used as follow:
  22
  23     (#) Declare a CEC_HandleTypeDef handle structure.
  24     (#) Initialize the CEC low level resources by implementing the HAL_CEC_MspInit ()API:
  25         (##) Enable the CEC interface clock.
  26         (##) CEC pins configuration:
  27             (+++) Enable the clock for the CEC GPIOs.
  28             (+++) Configure these CEC pins as alternate function pull-up.
  29         (##) NVIC configuration if you need to use interrupt process (HAL_CEC_Transmit_IT()
  30              and HAL_CEC_Receive_IT() APIs):
  31             (+++) Configure the CEC interrupt priority.
  32             (+++) Enable the NVIC CEC IRQ handle.
  33             (+++) The specific CEC interrupts (Transmission complete interrupt,
  34                   RXNE interrupt and Error Interrupts) will be managed using the macros
  35                   __HAL_CEC_ENABLE_IT() and __HAL_CEC_DISABLE_IT() inside the transmit
  36                   and receive process.
  37
  38     (#) Program the Signal Free Time (SFT) and SFT option, Tolerance, reception stop in
  39         in case of Bit Rising Error, Error-Bit generation conditions, device logical
  40         address and Listen mode in the hcec Init structure.
  41
  42     (#) Initialize the CEC registers by calling the HAL_CEC_Init() API.
  43
  44   [..]
  45     (@) This API (HAL_CEC_Init()) configures also the low level Hardware (GPIO, CLOCK, CORTEX...)
  46         by calling the customed HAL_CEC_MspInit() API.
  47
  48   @endverbatim
  49   ******************************************************************************
  50   * @attention
  51   *
  52   * <h2><center>&copy; COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
  53   *
  54   * Redistribution and use in source and binary forms, with or without modification,
  55   * are permitted provided that the following conditions are met:
  56   *   1. Redistributions of source code must retain the above copyright notice,
  57   *      this list of conditions and the following disclaimer.
  58   *   2. Redistributions in binary form must reproduce the above copyright notice,
  59   *      this list of conditions and the following disclaimer in the documentation
  60   *      and/or other materials provided with the distribution.
  61   *   3. Neither the name of STMicroelectronics nor the names of its contributors
  62   *      may be used to endorse or promote products derived from this software
  63   *      without specific prior written permission.
  64   *
  65   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  66   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  67   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  68   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  69   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  70   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  71   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  72   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  73   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  74   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  75   *
  76   ******************************************************************************
  77   */
  78
  79 /* Includes ------------------------------------------------------------------*/
  80 #include "stm32f4xx_hal.h"
  81
  82 /** @addtogroup STM32F4xx_HAL_Driver
  83   * @{
  84   */
  85
  86 /** @defgroup CEC CEC
  87   * @brief HAL CEC module driver
  88   * @{
  89   */
  90 #ifdef HAL_CEC_MODULE_ENABLED
  91
  92 #if defined(STM32F446xx)
  93
  94 /* Private typedef -----------------------------------------------------------*/
  95 /* Private define ------------------------------------------------------------*/
  96 /** @defgroup CEC_Private_Constants CEC Private Constants
  97   * @{
  98   */
  99 /**
 100   * @}
 101   */
 102
 103 /* Private macro -------------------------------------------------------------*/
 104 /* Private variables ---------------------------------------------------------*/
 105 /* Private function prototypes -----------------------------------------------*/
 106 /** @defgroup CEC_Private_Functions CEC Private Functions
 107   * @{
 108   */
 109 /**
 110   * @}
 111   */
 112
 113 /* Exported functions ---------------------------------------------------------*/
 114
 115 /** @defgroup CEC_Exported_Functions CEC Exported Functions
 116   * @{
 117   */
 118
 119 /** @defgroup CEC_Exported_Functions_Group1 Initialization and de-initialization functions
 120   *  @brief    Initialization and Configuration functions
 121   *
 122 @verbatim
 123 ===============================================================================
 124             ##### Initialization and Configuration functions #####
 125  ===============================================================================
 126     [..]
 127     This subsection provides a set of functions allowing to initialize the CEC
 128       (+) The following parameters need to be configured:
 129         (++) SignalFreeTime
 130         (++) Tolerance
 131         (++) BRERxStop                 (RX stopped or not upon Bit Rising Error)
 132         (++) BREErrorBitGen            (Error-Bit generation in case of Bit Rising Error)
 133         (++) LBPEErrorBitGen           (Error-Bit generation in case of Long Bit Period Error)
 134         (++) BroadcastMsgNoErrorBitGen (Error-bit generation in case of broadcast message error)
 135         (++) SignalFreeTimeOption      (SFT Timer start definition)
 136         (++) OwnAddress                (CEC device address)
 137         (++) ListenMode
 138
 139 @endverbatim
 140   * @{
 141   */
 142
 143 /**
 144   * @brief Initializes the CEC mode according to the specified
 145   *         parameters in the CEC_InitTypeDef and creates the associated handle .
 146   * @param hcec: CEC handle
 147   * @retval HAL status
 148   */
 149 HAL_StatusTypeDef HAL_CEC_Init(CEC_HandleTypeDef *hcec)
 150 {
 151   /* Check the CEC handle allocation */
 152   if((hcec == NULL) ||(hcec->Init.RxBuffer == NULL))
 153   {
 154     return HAL_ERROR;
 155   }
 156
 157   /* Check the parameters */
 158   assert_param(IS_CEC_ALL_INSTANCE(hcec->Instance));
 159   assert_param(IS_CEC_SIGNALFREETIME(hcec->Init.SignalFreeTime));
 160   assert_param(IS_CEC_TOLERANCE(hcec->Init.Tolerance));
 161   assert_param(IS_CEC_BRERXSTOP(hcec->Init.BRERxStop));
 162   assert_param(IS_CEC_BREERRORBITGEN(hcec->Init.BREErrorBitGen));
 163   assert_param(IS_CEC_LBPEERRORBITGEN(hcec->Init.LBPEErrorBitGen));
 164   assert_param(IS_CEC_BROADCASTERROR_NO_ERRORBIT_GENERATION(hcec->Init.BroadcastMsgNoErrorBitGen));
 165   assert_param(IS_CEC_SFTOP(hcec->Init.SignalFreeTimeOption));
 166   assert_param(IS_CEC_LISTENING_MODE(hcec->Init.ListenMode));
 167   assert_param(IS_CEC_OWN_ADDRESS(hcec->Init.OwnAddress));
 168
 169   if(hcec->gState == HAL_CEC_STATE_RESET)
 170   {
 171     /* Allocate lock resource and initialize it */
 172     hcec->Lock = HAL_UNLOCKED;
 173     /* Init the low level hardware : GPIO, CLOCK */
 174     HAL_CEC_MspInit(hcec);
 175   }
 176   hcec->gState = HAL_CEC_STATE_BUSY;
 177
 178   /* Disable the Peripheral */
 179   __HAL_CEC_DISABLE(hcec);
 180
 181   /* Write to CEC Control Register */
 182   hcec->Instance->CFGR = hcec->Init.SignalFreeTime | hcec->Init.Tolerance | hcec->Init.BRERxStop|\
 183                          hcec->Init.BREErrorBitGen | hcec->Init.LBPEErrorBitGen | hcec->Init.BroadcastMsgNoErrorBitGen |\
 184                          hcec->Init.SignalFreeTimeOption |((uint32_t)(hcec->Init.OwnAddress)<<16U) |\
 185                          hcec->Init.ListenMode;
 186
 187   /* Enable the following CEC Transmission/Reception interrupts as
 188    * well as the following CEC Transmission/Reception Errors interrupts
 189    * Rx Byte Received IT
 190    * End of Reception IT
 191    * Rx overrun
 192    * Rx bit rising error
 193    * Rx short bit period error
 194    * Rx long bit period error
 195    * Rx missing acknowledge
 196    * Tx Byte Request IT
 197    * End of Transmission IT
 198    * Tx Missing Acknowledge IT
 199    * Tx-Error IT
 200    * Tx-Buffer Underrun IT
 201    * Tx arbitration lost   */
 202  __HAL_CEC_ENABLE_IT(hcec, CEC_IT_RXBR|CEC_IT_RXEND|CEC_IER_RX_ALL_ERR|CEC_IT_TXBR|CEC_IT_TXEND|CEC_IER_TX_ALL_ERR);
 203
 204   /* Enable the CEC Peripheral */
 205   __HAL_CEC_ENABLE(hcec);
 206
 207   hcec->ErrorCode = HAL_CEC_ERROR_NONE;
 208   hcec->gState = HAL_CEC_STATE_READY;
 209   hcec->RxState = HAL_CEC_STATE_READY;
 210
 211   return HAL_OK;
 212 }
 213
 214 /**
 215   * @brief DeInitializes the CEC peripheral
 216   * @param hcec: CEC handle
 217   * @retval HAL status
 218   */
 219 HAL_StatusTypeDef HAL_CEC_DeInit(CEC_HandleTypeDef *hcec)
 220 {
 221   /* Check the CEC handle allocation */
 222   if(hcec == NULL)
 223   {
 224     return HAL_ERROR;
 225   }
 226
 227   /* Check the parameters */
 228   assert_param(IS_CEC_ALL_INSTANCE(hcec->Instance));
 229
 230   hcec->gState = HAL_CEC_STATE_BUSY;
 231
 232   /* DeInit the low level hardware */
 233   HAL_CEC_MspDeInit(hcec);
 234   /* Disable the Peripheral */
 235   __HAL_CEC_DISABLE(hcec);
 236
 237   /* Clear Flags */
 238   __HAL_CEC_CLEAR_FLAG(hcec,CEC_FLAG_TXEND|CEC_FLAG_TXBR|CEC_FLAG_RXBR|CEC_FLAG_RXEND|CEC_ISR_ALL_ERROR);
 239
 240   /* Disable the following CEC Transmission/Reception interrupts as
 241    * well as the following CEC Transmission/Reception Errors interrupts
 242    * Rx Byte Received IT
 243    * End of Reception IT
 244    * Rx overrun
 245    * Rx bit rising error
 246    * Rx short bit period error
 247    * Rx long bit period error
 248    * Rx missing acknowledge
 249    * Tx Byte Request IT
 250    * End of Transmission IT
 251    * Tx Missing Acknowledge IT
 252    * Tx-Error IT
 253    * Tx-Buffer Underrun IT
 254    * Tx arbitration lost   */
 255   __HAL_CEC_DISABLE_IT(hcec, CEC_IT_RXBR|CEC_IT_RXEND|CEC_IER_RX_ALL_ERR|CEC_IT_TXBR|CEC_IT_TXEND|CEC_IER_TX_ALL_ERR);
 256
 257   hcec->ErrorCode = HAL_CEC_ERROR_NONE;
 258   hcec->gState = HAL_CEC_STATE_RESET;
 259   hcec->RxState = HAL_CEC_STATE_RESET;
 260
 261   /* Process Unlock */
 262   __HAL_UNLOCK(hcec);
 263
 264   return HAL_OK;
 265 }
 266
 267 /**
 268   * @brief Initializes the Own Address of the CEC device
 269   * @param hcec: CEC handle
 270   * @param  CEC_OwnAddress: The CEC own address.
 271   * @retval HAL status
 272   */
 273 HAL_StatusTypeDef HAL_CEC_SetDeviceAddress(CEC_HandleTypeDef *hcec, uint16_t CEC_OwnAddress)
 274 {
 275   /* Check the parameters */
 276   assert_param(IS_CEC_OWN_ADDRESS(CEC_OwnAddress));
 277
 278   if ((hcec->gState == HAL_CEC_STATE_READY) && (hcec->RxState == HAL_CEC_STATE_READY))
 279   {
 280     /* Process Locked */
 281     __HAL_LOCK(hcec);
 282
 283     hcec->gState = HAL_CEC_STATE_BUSY;
 284
 285     /* Disable the Peripheral */
 286     __HAL_CEC_DISABLE(hcec);
 287
 288     if(CEC_OwnAddress != CEC_OWN_ADDRESS_NONE)
 289     {
 290       hcec->Instance->CFGR |= ((uint32_t)CEC_OwnAddress<<16U);
 291     }
 292     else
 293     {
 294       hcec->Instance->CFGR &= ~(CEC_CFGR_OAR);
 295     }
 296
 297     hcec->gState = HAL_CEC_STATE_READY;
 298     hcec->ErrorCode = HAL_CEC_ERROR_NONE;
 299
 300     /* Process Unlocked */
 301     __HAL_UNLOCK(hcec);
 302
 303     /* Enable the Peripheral */
 304     __HAL_CEC_ENABLE(hcec);
 305
 306     return  HAL_OK;
 307   }
 308   else
 309   {
 310     return HAL_BUSY;
 311   }
 312 }
 313
 314 /**
 315   * @brief CEC MSP Init
 316   * @param hcec: CEC handle
 317   * @retval None
 318   */
 319  __weak void HAL_CEC_MspInit(CEC_HandleTypeDef *hcec)
 320 {
 321   /* Prevent unused argument(s) compilation warning */
 322   UNUSED(hcec);
 323   /* NOTE : This function should not be modified, when the callback is needed,
 324             the HAL_CEC_MspInit can be implemented in the user file
 325    */
 326 }
 327
 328 /**
 329   * @brief CEC MSP DeInit
 330   * @param hcec: CEC handle
 331   * @retval None
 332   */
 333  __weak void HAL_CEC_MspDeInit(CEC_HandleTypeDef *hcec)
 334 {
 335   /* Prevent unused argument(s) compilation warning */
 336   UNUSED(hcec);
 337   /* NOTE : This function should not be modified, when the callback is needed,
 338             the HAL_CEC_MspDeInit can be implemented in the user file
 339    */
 340 }
 341
 342 /**
 343   * @}
 344   */
 345
 346 /** @defgroup CEC_Exported_Functions_Group2 Input and Output operation functions
 347   *  @brief CEC Transmit/Receive functions
 348   *
 349 @verbatim
 350  ===============================================================================
 351                       ##### IO operation functions #####
 352  ===============================================================================
 353     This subsection provides a set of functions allowing to manage the CEC data transfers.
 354
 355     (#) The CEC handle must contain the initiator (TX side) and the destination (RX side)
 356         logical addresses (4-bit long addresses, 0x0F for broadcast messages destination)
 357
 358     (#) The communication is performed using Interrupts.
 359            These API's return the HAL status.
 360            The end of the data processing will be indicated through the
 361            dedicated CEC IRQ when using Interrupt mode.
 362            The HAL_CEC_TxCpltCallback(), HAL_CEC_RxCpltCallback() user callbacks
 363            will be executed respectivelly at the end of the transmit or Receive process
 364            The HAL_CEC_ErrorCallback()user callback will be executed when a communication
 365            error is detected
 366
 367     (#) API's with Interrupt are :
 368          (+) HAL_CEC_Transmit_IT()
 369          (+) HAL_CEC_IRQHandler()
 370
 371     (#) A set of User Callbacks are provided:
 372          (+) HAL_CEC_TxCpltCallback()
 373          (+) HAL_CEC_RxCpltCallback()
 374          (+) HAL_CEC_ErrorCallback()
 375
 376 @endverbatim
 377   * @{
 378   */
 379
 380 /**
 381   * @brief Send data in interrupt mode
 382   * @param hcec: CEC handle
 383   * @param InitiatorAddress: Initiator logical address
 384   * @param DestinationAddress: destination logical address
 385   * @param pData: pointer to input byte data buffer
 386   * @param Size: amount of data to be sent in bytes (without counting the header).
 387   *              0 means only the header is sent (ping operation).
 388   *              Maximum TX size is 15 bytes (1 opcode and up to 14 operands).
 389   * @retval HAL status
 390   */
 391 HAL_StatusTypeDef HAL_CEC_Transmit_IT(CEC_HandleTypeDef *hcec, uint8_t InitiatorAddress, uint8_t DestinationAddress, uint8_t *pData, uint32_t Size)
 392 {
 393   /* if the IP isn't already busy and if there is no previous transmission
 394      already pending due to arbitration lost */
 395   if (hcec->gState == HAL_CEC_STATE_READY)
 396   {
 397     if((pData == NULL ) && (Size > 0U))
 398     {
 399       return  HAL_ERROR;
 400     }
 401
 402     assert_param(IS_CEC_ADDRESS(DestinationAddress));
 403     assert_param(IS_CEC_ADDRESS(InitiatorAddress));
 404     assert_param(IS_CEC_MSGSIZE(Size));
 405
 406     /* Process Locked */
 407     __HAL_LOCK(hcec);
 408     hcec->pTxBuffPtr = pData;
 409     hcec->gState = HAL_CEC_STATE_BUSY_TX;
 410     hcec->ErrorCode = HAL_CEC_ERROR_NONE;
 411
 412     /* initialize the number of bytes to send,
 413      * 0 means only one header is sent (ping operation) */
 414     hcec->TxXferCount = Size;
 415
 416     /* in case of no payload (Size = 0), sender is only pinging the system;
 417        Set TX End of Message (TXEOM) bit, must be set before writing data to TXDR */
 418     if (Size == 0U)
 419     {
 420       __HAL_CEC_LAST_BYTE_TX_SET(hcec);
 421     }
 422
 423     /* send header block */
 424     hcec->Instance->TXDR = ((uint8_t)(InitiatorAddress << CEC_INITIATOR_LSB_POS) |(uint8_t) DestinationAddress);
 425     /* Set TX Start of Message  (TXSOM) bit */
 426     __HAL_CEC_FIRST_BYTE_TX_SET(hcec);
 427
 428     /* Process Unlocked */
 429     __HAL_UNLOCK(hcec);
 430
 431     return HAL_OK;
 432
 433   }
 434   else
 435   {
 436     return HAL_BUSY;
 437   }
 438 }
 439
 440 /**
 441   * @brief Get size of the received frame.
 442   * @param hcec: CEC handle
 443   * @retval Frame size
 444   */
 445 uint32_t HAL_CEC_GetLastReceivedFrameSize(CEC_HandleTypeDef *hcec)
 446 {
 447   return hcec->RxXferSize;
 448 }
 449
 450 /**
 451   * @brief Change Rx Buffer.
 452   * @param hcec: CEC handle
 453   * @param Rxbuffer: Rx Buffer
 454   * @note  This function can be called only inside the HAL_CEC_RxCpltCallback()
 455   * @retval Frame size
 456   */
 457 void HAL_CEC_ChangeRxBuffer(CEC_HandleTypeDef *hcec, uint8_t* Rxbuffer)
 458 {
 459   hcec->Init.RxBuffer = Rxbuffer;
 460 }
 461
 462 /**
 463   * @brief This function handles CEC interrupt requests.
 464   * @param hcec: CEC handle
 465   * @retval None
 466   */
 467 void HAL_CEC_IRQHandler(CEC_HandleTypeDef *hcec)
 468 {
 469
 470   /* save interrupts register for further error or interrupts handling purposes */
 471   uint32_t reg = 0U;
 472   reg = hcec->Instance->ISR;
 473
 474
 475   /* ----------------------------Arbitration Lost Management----------------------------------*/
 476   /* CEC TX arbitration error interrupt occurred --------------------------------------*/
 477   if((reg & CEC_FLAG_ARBLST) != RESET)
 478   {
 479     hcec->ErrorCode = HAL_CEC_ERROR_ARBLST;
 480     __HAL_CEC_CLEAR_FLAG(hcec, CEC_FLAG_ARBLST);
 481   }
 482
 483   /* ----------------------------Rx Management----------------------------------*/
 484   /* CEC RX byte received interrupt  ---------------------------------------------------*/
 485   if((reg & CEC_FLAG_RXBR) != RESET)
 486   {
 487     /* reception is starting */
 488     hcec->RxState = HAL_CEC_STATE_BUSY_RX;
 489     hcec->RxXferSize++;
 490     /* read received byte */
 491     *hcec->Init.RxBuffer++ = hcec->Instance->RXDR;
 492     __HAL_CEC_CLEAR_FLAG(hcec, CEC_FLAG_RXBR);
 493   }
 494
 495   /* CEC RX end received interrupt  ---------------------------------------------------*/
 496   if((reg & CEC_FLAG_RXEND) != RESET)
 497   {
 498     /* clear IT */
 499     __HAL_CEC_CLEAR_FLAG(hcec, CEC_FLAG_RXEND);
 500
 501     /* Rx process is completed, restore hcec->RxState to Ready */
 502     hcec->RxState = HAL_CEC_STATE_READY;
 503     hcec->ErrorCode = HAL_CEC_ERROR_NONE;
 504     hcec->Init.RxBuffer -= hcec->RxXferSize;
 505     HAL_CEC_RxCpltCallback(hcec, hcec->RxXferSize);
 506     hcec->RxXferSize = 0U;
 507   }
 508
 509   /* ----------------------------Tx Management----------------------------------*/
 510   /* CEC TX byte request interrupt ------------------------------------------------*/
 511   if((reg & CEC_FLAG_TXBR) != RESET)
 512   {
 513     if (hcec->TxXferCount == 0U)
 514     {
 515       /* if this is the last byte transmission, set TX End of Message (TXEOM) bit */
 516       __HAL_CEC_LAST_BYTE_TX_SET(hcec);
 517       hcec->Instance->TXDR = *hcec->pTxBuffPtr++;
 518     }
 519     else
 520     {
 521       hcec->Instance->TXDR = *hcec->pTxBuffPtr++;
 522       hcec->TxXferCount--;
 523     }
 524     /* clear Tx-Byte request flag */
 525     __HAL_CEC_CLEAR_FLAG(hcec,CEC_FLAG_TXBR);
 526   }
 527
 528   /* CEC TX end interrupt ------------------------------------------------*/
 529   if((reg & CEC_FLAG_TXEND) != RESET)
 530   {
 531     __HAL_CEC_CLEAR_FLAG(hcec, CEC_FLAG_TXEND);
 532
 533     /* Tx process is ended, restore hcec->gState to Ready */
 534     hcec->gState = HAL_CEC_STATE_READY;
 535     /* Call the Process Unlocked before calling the Tx call back API to give the possibility to
 536     start again the Transmission under the Tx call back API */
 537     __HAL_UNLOCK(hcec);
 538     hcec->ErrorCode = HAL_CEC_ERROR_NONE;
 539     HAL_CEC_TxCpltCallback(hcec);
 540   }
 541
 542   /* ----------------------------Rx/Tx Error Management----------------------------------*/
 543   if ((reg & (CEC_ISR_RXOVR|CEC_ISR_BRE|CEC_ISR_SBPE|CEC_ISR_LBPE|CEC_ISR_RXACKE|CEC_ISR_TXUDR|CEC_ISR_TXERR|CEC_ISR_TXACKE)) != 0U)
 544   {
 545     hcec->ErrorCode = reg;
 546     __HAL_CEC_CLEAR_FLAG(hcec, HAL_CEC_ERROR_RXOVR|HAL_CEC_ERROR_BRE|CEC_FLAG_LBPE|CEC_FLAG_SBPE|HAL_CEC_ERROR_RXACKE|HAL_CEC_ERROR_TXUDR|HAL_CEC_ERROR_TXERR|HAL_CEC_ERROR_TXACKE);
 547
 548
 549     if((reg & (CEC_ISR_RXOVR|CEC_ISR_BRE|CEC_ISR_SBPE|CEC_ISR_LBPE|CEC_ISR_RXACKE)) != RESET)
 550     {
 551       hcec->Init.RxBuffer-=hcec->RxXferSize;
 552       hcec->RxXferSize = 0U;
 553       hcec->RxState = HAL_CEC_STATE_READY;
 554     }
 555     else if (((reg & (CEC_ISR_TXUDR|CEC_ISR_TXERR|CEC_ISR_TXACKE)) != RESET) && ((reg & CEC_ISR_ARBLST) == RESET))
 556     {
 557       /* Set the CEC state ready to be able to start again the process */
 558       hcec->gState = HAL_CEC_STATE_READY;
 559     }
 560
 561     /* Error  Call Back */
 562     HAL_CEC_ErrorCallback(hcec);
 563   }
 564
 565 }
 566
 567 /**
 568   * @brief Tx Transfer completed callback
 569   * @param hcec: CEC handle
 570   * @retval None
 571   */
 572  __weak void HAL_CEC_TxCpltCallback(CEC_HandleTypeDef *hcec)
 573 {
 574   /* Prevent unused argument(s) compilation warning */
 575   UNUSED(hcec);
 576   /* NOTE : This function should not be modified, when the callback is needed,
 577             the HAL_CEC_TxCpltCallback can be implemented in the user file
 578    */
 579 }
 580
 581 /**
 582   * @brief Rx Transfer completed callback
 583   * @param hcec: CEC handle
 584   * @param RxFrameSize: Size of frame
 585   * @retval None
 586   */
 587 __weak void HAL_CEC_RxCpltCallback(CEC_HandleTypeDef *hcec, uint32_t RxFrameSize)
 588 {
 589   /* Prevent unused argument(s) compilation warning */
 590   UNUSED(hcec);
 591   UNUSED(RxFrameSize);
 592   /* NOTE : This function should not be modified, when the callback is needed,
 593             the HAL_CEC_RxCpltCallback can be implemented in the user file
 594    */
 595 }
 596
 597 /**
 598   * @brief CEC error callbacks
 599   * @param hcec: CEC handle
 600   * @retval None
 601   */
 602  __weak void HAL_CEC_ErrorCallback(CEC_HandleTypeDef *hcec)
 603 {
 604   /* Prevent unused argument(s) compilation warning */
 605   UNUSED(hcec);
 606   /* NOTE : This function should not be modified, when the callback is needed,
 607             the HAL_CEC_ErrorCallback can be implemented in the user file
 608    */
 609 }
 610 /**
 611   * @}
 612   */
 613
 614 /** @defgroup CEC_Exported_Functions_Group3 Peripheral Control function
 615   *  @brief   CEC control functions
 616   *
 617 @verbatim
 618  ===============================================================================
 619                       ##### Peripheral Control function #####
 620  ===============================================================================
 621     [..]
 622     This subsection provides a set of functions allowing to control the CEC.
 623      (+) HAL_CEC_GetState() API can be helpful to check in run-time the state of the CEC peripheral.
 624          (+) HAL_CEC_GetError() API can be helpful to check in run-time the error of the CEC peripheral.
 625 @endverbatim
 626   * @{
 627   */
 628 /**
 629   * @brief return the CEC state
 630   * @param hcec: pointer to a CEC_HandleTypeDef structure that contains
 631   *              the configuration information for the specified CEC module.
 632   * @retval HAL state
 633   */
 634 HAL_CEC_StateTypeDef HAL_CEC_GetState(CEC_HandleTypeDef *hcec)
 635 {
 636   uint32_t temp1 = 0x00U, temp2 = 0x00U;
 637   temp1 = hcec->gState;
 638   temp2 = hcec->RxState;
 639
 640   return (HAL_CEC_StateTypeDef)(temp1 | temp2);
 641 }
 642
 643 /**
 644   * @brief  Return the CEC error code
 645   * @param  hcec : pointer to a CEC_HandleTypeDef structure that contains
 646   *              the configuration information for the specified CEC.
 647   * @retval CEC Error Code
 648   */
 649 uint32_t HAL_CEC_GetError(CEC_HandleTypeDef *hcec)
 650 {
 651   return hcec->ErrorCode;
 652 }
 653
 654 /**
 655   * @}
 656   */
 657
 658 /**
 659   * @}
 660   */
 661
 662 #endif /* STM32F446xx */
 663
 664 #endif /* HAL_CEC_MODULE_ENABLED */
 665 /**
 666   * @}
 667   */
 668
 669 /**
 670   * @}
 671   */
 672
 673 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/