lib/main/STM32F1/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_cec.c

   1 /**
   2   ******************************************************************************
   3   * @file    stm32f1xx_hal_cec.c
   4   * @author  MCD Application Team
   5   * @version V1.1.1
   6   * @date    12-May-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 function
  12   *           + IO operation function
  13   *           + Peripheral Control function
  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 Bit Timing Error Mode and the Bit Period Error Mode in the hcec Init structure.
  39
  40     (#) Initialize the CEC registers by calling the HAL_CEC_Init() API.
  41
  42   [..]
  43     (@) This API (HAL_CEC_Init()) configures also the low level Hardware (GPIO, CLOCK, CORTEX...etc)
  44         by calling the customed HAL_CEC_MspInit() API.
  45
  46   @endverbatim
  47   ******************************************************************************
  48   * @attention
  49   *
  50   * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
  51   *
  52   * Redistribution and use in source and binary forms, with or without modification,
  53   * are permitted provided that the following conditions are met:
  54   *   1. Redistributions of source code must retain the above copyright notice,
  55   *      this list of conditions and the following disclaimer.
  56   *   2. Redistributions in binary form must reproduce the above copyright notice,
  57   *      this list of conditions and the following disclaimer in the documentation
  58   *      and/or other materials provided with the distribution.
  59   *   3. Neither the name of STMicroelectronics nor the names of its contributors
  60   *      may be used to endorse or promote products derived from this software
  61   *      without specific prior written permission.
  62   *
  63   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  64   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  65   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  66   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  67   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  68   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  69   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  70   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  71   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  72   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  73   *
  74   ******************************************************************************
  75   */
  76
  77 /* Includes ------------------------------------------------------------------*/
  78 #include "stm32f1xx_hal.h"
  79
  80 #ifdef HAL_CEC_MODULE_ENABLED
  81
  82 #if defined(STM32F100xB) || defined(STM32F100xE)
  83
  84 /** @addtogroup STM32F1xx_HAL_Driver
  85   * @{
  86   */
  87
  88 /** @defgroup CEC CEC
  89   * @brief HAL CEC module driver
  90   * @{
  91   */
  92
  93 /* Private typedef -----------------------------------------------------------*/
  94 /* Private define ------------------------------------------------------------*/
  95 /** @defgroup CEC_Private_Constants CEC Private Constants
  96   * @{
  97   */
  98 #define CEC_CFGR_FIELDS (CEC_CFGR_BTEM | CEC_CFGR_BPEM )
  99 #define CEC_FLAG_TRANSMIT_MASK (CEC_FLAG_TSOM|CEC_FLAG_TEOM|CEC_FLAG_TBTRF)
 100 #define CEC_FLAG_RECEIVE_MASK (CEC_FLAG_RSOM|CEC_FLAG_REOM|CEC_FLAG_RBTF)
 101 #define CEC_ESR_ALL_ERROR (CEC_ESR_BTE|CEC_ESR_BPE|CEC_ESR_RBTFE|CEC_ESR_SBE|CEC_ESR_ACKE|CEC_ESR_LINE|CEC_ESR_TBTFE)
 102 #define CEC_RXXFERSIZE_INITIALIZE 0xFFFF /*!< Value used to initialise the RxXferSize of the handle */
 103 /**
 104   * @}
 105   */
 106
 107 /* Private macro -------------------------------------------------------------*/
 108 /* Private variables ---------------------------------------------------------*/
 109 /* Private function prototypes -----------------------------------------------*/
 110 /** @defgroup CEC_Private_Functions CEC Private Functions
 111   * @{
 112   */
 113 static HAL_StatusTypeDef CEC_Transmit_IT(CEC_HandleTypeDef *hcec);
 114 static HAL_StatusTypeDef CEC_Receive_IT(CEC_HandleTypeDef *hcec);
 115 /**
 116   * @}
 117   */
 118
 119 /* Exported functions ---------------------------------------------------------*/
 120
 121 /** @defgroup CEC_Exported_Functions CEC Exported Functions
 122   * @{
 123   */
 124
 125 /** @defgroup CEC_Exported_Functions_Group1 Initialization and de-initialization functions
 126   *  @brief    Initialization and Configuration functions
 127   *
 128 @verbatim
 129 ===============================================================================
 130             ##### Initialization and Configuration functions #####
 131  ===============================================================================
 132     [..]
 133     This subsection provides a set of functions allowing to initialize the CEC
 134       (+) The following parameters need to be configured:
 135         (++) TimingErrorFree
 136         (++) PeriodErrorFree
 137         (++) InitiatorAddress
 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_BIT_TIMING_ERROR_MODE(hcec->Init.TimingErrorFree));
 160   assert_param(IS_CEC_BIT_PERIOD_ERROR_MODE(hcec->Init.PeriodErrorFree));
 161   assert_param(IS_CEC_ADDRESS(hcec->Init.OwnAddress));
 162
 163   if(hcec->gState == HAL_CEC_STATE_RESET)
 164   {
 165     /* Allocate lock resource and initialize it */
 166     hcec->Lock = HAL_UNLOCKED;
 167     /* Init the low level hardware : GPIO, CLOCK */
 168     HAL_CEC_MspInit(hcec);
 169   }
 170   hcec->gState = HAL_CEC_STATE_BUSY;
 171
 172   /* Disable the Peripheral */
 173   __HAL_CEC_DISABLE(hcec);
 174
 175   /* Write to CEC Control Register */
 176   MODIFY_REG(hcec->Instance->CFGR, CEC_CFGR_FIELDS, hcec->Init.TimingErrorFree | hcec->Init.PeriodErrorFree);
 177
 178   /* Write to CEC Own Address Register */
 179   MODIFY_REG(hcec->Instance->OAR, CEC_OAR_OA, hcec->Init.OwnAddress);
 180
 181   /* Configure the prescaler to generate the required 50 microseconds time base.*/
 182   MODIFY_REG(hcec->Instance->PRES, CEC_PRES_PRES, 50U * (HAL_RCC_GetPCLK1Freq()/1000000U) - 1U);
 183
 184   /* Enable the following CEC Interrupt */
 185   __HAL_CEC_ENABLE_IT(hcec, CEC_IT_IE);
 186
 187   /* Enable the CEC Peripheral */
 188   __HAL_CEC_ENABLE(hcec);
 189
 190   hcec->ErrorCode = HAL_CEC_ERROR_NONE;
 191   hcec->gState = HAL_CEC_STATE_READY;
 192   hcec->RxState = HAL_CEC_STATE_READY;
 193
 194   return HAL_OK;
 195 }
 196
 197 /**
 198   * @brief DeInitializes the CEC peripheral
 199   * @param hcec: CEC handle
 200   * @retval HAL status
 201   */
 202 HAL_StatusTypeDef HAL_CEC_DeInit(CEC_HandleTypeDef *hcec)
 203 {
 204   /* Check the CEC handle allocation */
 205   if(hcec == NULL)
 206   {
 207     return HAL_ERROR;
 208   }
 209
 210   /* Check the parameters */
 211   assert_param(IS_CEC_ALL_INSTANCE(hcec->Instance));
 212
 213   hcec->gState = HAL_CEC_STATE_BUSY;
 214
 215   /* DeInit the low level hardware */
 216   HAL_CEC_MspDeInit(hcec);
 217
 218   __HAL_RCC_CEC_FORCE_RESET();
 219   __HAL_RCC_CEC_RELEASE_RESET();
 220
 221   hcec->ErrorCode = HAL_CEC_ERROR_NONE;
 222   hcec->gState = HAL_CEC_STATE_RESET;
 223   hcec->RxState = HAL_CEC_STATE_RESET;
 224
 225   /* Process Unlock */
 226   __HAL_UNLOCK(hcec);
 227
 228   return HAL_OK;
 229 }
 230
 231 /**
 232   * @brief Initializes the Own Address of the CEC device
 233   * @param hcec: CEC handle
 234   * @param  CEC_OwnAddress: The CEC own address.
 235   * @retval HAL status
 236   */
 237 HAL_StatusTypeDef HAL_CEC_SetDeviceAddress(CEC_HandleTypeDef *hcec, uint16_t CEC_OwnAddress)
 238 {
 239   /* Check the parameters */
 240   assert_param(IS_CEC_OWN_ADDRESS(CEC_OwnAddress));
 241
 242   if ((hcec->gState == HAL_CEC_STATE_READY) && (hcec->RxState == HAL_CEC_STATE_READY))
 243   {
 244     /* Process Locked */
 245     __HAL_LOCK(hcec);
 246
 247     hcec->gState = HAL_CEC_STATE_BUSY;
 248
 249     /* Disable the Peripheral */
 250     __HAL_CEC_DISABLE(hcec);
 251
 252     if(CEC_OwnAddress != CEC_OWN_ADDRESS_NONE)
 253     {
 254        MODIFY_REG(hcec->Instance->OAR, CEC_OAR_OA, hcec->Init.OwnAddress);
 255     }
 256     else
 257     {
 258        CLEAR_BIT(hcec->Instance->OAR, CEC_OAR_OA);
 259     }
 260
 261     hcec->gState = HAL_CEC_STATE_READY;
 262     hcec->ErrorCode = HAL_CEC_ERROR_NONE;
 263
 264     /* Process Unlocked */
 265     __HAL_UNLOCK(hcec);
 266
 267     /* Enable the Peripheral */
 268     __HAL_CEC_ENABLE(hcec);
 269
 270     return  HAL_OK;
 271   }
 272   else
 273   {
 274     return HAL_BUSY;
 275   }
 276 }
 277
 278 /**
 279   * @brief CEC MSP Init
 280   * @param hcec: CEC handle
 281   * @retval None
 282   */
 283  __weak void HAL_CEC_MspInit(CEC_HandleTypeDef *hcec)
 284 {
 285   /* Prevent unused argument(s) compilation warning */
 286   UNUSED(hcec);
 287   /* NOTE : This function should not be modified, when the callback is needed,
 288             the HAL_CEC_MspInit can be implemented in the user file
 289    */
 290 }
 291
 292 /**
 293   * @brief CEC MSP DeInit
 294   * @param hcec: CEC handle
 295   * @retval None
 296   */
 297  __weak void HAL_CEC_MspDeInit(CEC_HandleTypeDef *hcec)
 298 {
 299   /* Prevent unused argument(s) compilation warning */
 300   UNUSED(hcec);
 301   /* NOTE : This function should not be modified, when the callback is needed,
 302             the HAL_CEC_MspDeInit can be implemented in the user file
 303    */
 304 }
 305
 306 /**
 307   * @}
 308   */
 309
 310 /** @defgroup CEC_Exported_Functions_Group2 Input and Output operation functions
 311   *  @brief CEC Transmit/Receive functions
 312   *
 313 @verbatim
 314  ===============================================================================
 315                       ##### IO operation functions #####
 316  ===============================================================================
 317     [..]
 318     This subsection provides a set of functions allowing to manage the CEC data transfers.
 319
 320     (#) The CEC handle must contain the initiator (TX side) and the destination (RX side)
 321         logical addresses (4-bit long addresses, 0xF for broadcast messages destination)
 322
 323     (#) The communication is performed using Interrupts.
 324            These API's return the HAL status.
 325            The end of the data processing will be indicated through the
 326            dedicated CEC IRQ when using Interrupt mode.
 327            The HAL_CEC_TxCpltCallback(), HAL_CEC_RxCpltCallback() user callbacks
 328            will be executed respectively at the end of the transmit or Receive process
 329            The HAL_CEC_ErrorCallback() user callback will be executed when a communication
 330            error is detected
 331
 332     (#) API's with Interrupt are :
 333          (+) HAL_CEC_Transmit_IT()
 334          (+) HAL_CEC_IRQHandler()
 335
 336     (#) A set of User Callbacks are provided:
 337          (+) HAL_CEC_TxCpltCallback()
 338          (+) HAL_CEC_RxCpltCallback()
 339          (+) HAL_CEC_ErrorCallback()
 340
 341 @endverbatim
 342   * @{
 343   */
 344
 345 /**
 346   * @brief Send data in interrupt mode
 347   * @param hcec: CEC handle
 348   * @param InitiatorAddress: Initiator address
 349   * @param DestinationAddress: destination logical address
 350   * @param pData: pointer to input byte data buffer
 351   * @param Size: amount of data to be sent in bytes (without counting the header).
 352   *              0 means only the header is sent (ping operation).
 353   *              Maximum TX size is 15 bytes (1 opcode and up to 14 operands).
 354   * @retval HAL status
 355   */
 356 HAL_StatusTypeDef HAL_CEC_Transmit_IT(CEC_HandleTypeDef *hcec, uint8_t InitiatorAddress,uint8_t DestinationAddress, uint8_t *pData, uint32_t Size)
 357 {
 358   /* if the IP isn't already busy and if there is no previous transmission
 359      already pending due to arbitration lost */
 360   if(hcec->gState == HAL_CEC_STATE_READY)
 361   {
 362     if((pData == NULL ) && (Size > 0U))
 363     {
 364       return  HAL_ERROR;
 365     }
 366
 367     assert_param(IS_CEC_ADDRESS(DestinationAddress));
 368     assert_param(IS_CEC_ADDRESS(InitiatorAddress));
 369     assert_param(IS_CEC_MSGSIZE(Size));
 370
 371     /* Process Locked */
 372     __HAL_LOCK(hcec);
 373     hcec->pTxBuffPtr = pData;
 374     hcec->gState = HAL_CEC_STATE_BUSY_TX;
 375     hcec->ErrorCode = HAL_CEC_ERROR_NONE;
 376
 377     /* initialize the number of bytes to send,
 378      * 0 means only one header is sent (ping operation) */
 379     hcec->TxXferCount = Size;
 380
 381     /* send header block */
 382     hcec->Instance->TXD = (uint8_t)((uint32_t)InitiatorAddress << CEC_INITIATOR_LSB_POS) | DestinationAddress;
 383
 384     /* Process Unlocked */
 385     __HAL_UNLOCK(hcec);
 386
 387     /* case no data to be sent, sender is only pinging the system */
 388     if (Size != 0)
 389     {
 390       /* Set TX Start of Message (TXSOM) bit */
 391       MODIFY_REG(hcec->Instance->CSR, CEC_FLAG_TRANSMIT_MASK, CEC_FLAG_TSOM);
 392     }
 393     else
 394     {
 395       /* Send a ping command */
 396       MODIFY_REG(hcec->Instance->CSR, CEC_FLAG_TRANSMIT_MASK, CEC_FLAG_TEOM|CEC_FLAG_TSOM);
 397     }
 398     return HAL_OK;
 399
 400   }
 401   else
 402   {
 403     return HAL_BUSY;
 404   }
 405 }
 406
 407 /**
 408   * @brief Get size of the received frame.
 409   * @param hcec: CEC handle
 410   * @retval Frame size
 411   */
 412 uint32_t HAL_CEC_GetLastReceivedFrameSize(CEC_HandleTypeDef *hcec)
 413 {
 414   return hcec->RxXferSize;
 415 }
 416
 417 /**
 418   * @brief Change Rx Buffer.
 419   * @param hcec: CEC handle
 420   * @param Rxbuffer: Rx Buffer
 421   * @note  This function can be called only inside the HAL_CEC_RxCpltCallback()
 422   * @retval Frame size
 423   */
 424 void HAL_CEC_ChangeRxBuffer(CEC_HandleTypeDef *hcec, uint8_t* Rxbuffer)
 425 {
 426   hcec->Init.RxBuffer = Rxbuffer;
 427 }
 428
 429 /**
 430   * @brief This function handles CEC interrupt requests.
 431   * @param hcec: CEC handle
 432   * @retval None
 433   */
 434 void HAL_CEC_IRQHandler(CEC_HandleTypeDef *hcec)
 435 {
 436   /* Save error status register for further error handling purposes */
 437   hcec->ErrorCode = READ_BIT(hcec->Instance->ESR, CEC_ESR_ALL_ERROR);
 438
 439   /* Transmit error */
 440   if(__HAL_CEC_GET_FLAG(hcec, CEC_FLAG_TERR) != RESET)
 441   {
 442     /* Acknowledgement of the error */
 443     __HAL_CEC_CLEAR_FLAG(hcec, CEC_FLAG_TERR);
 444
 445     hcec->gState = HAL_CEC_STATE_READY;
 446   }
 447
 448   /* Receive error */
 449   if(__HAL_CEC_GET_FLAG(hcec, CEC_FLAG_RERR) != RESET)
 450   {
 451     /* Acknowledgement of the error */
 452     __HAL_CEC_CLEAR_FLAG(hcec, CEC_FLAG_RERR);
 453     hcec->Init.RxBuffer-=hcec->RxXferSize;
 454     hcec->RxXferSize = 0U;
 455     hcec->RxState = HAL_CEC_STATE_READY;
 456   }
 457
 458   if((hcec->ErrorCode & CEC_ESR_ALL_ERROR) != 0U)
 459   {
 460     /* Error  Call Back */
 461     HAL_CEC_ErrorCallback(hcec);
 462   }
 463
 464   /* Transmit byte request or block transfer finished */
 465   if(__HAL_CEC_GET_FLAG(hcec, CEC_FLAG_TBTRF) != RESET)
 466   {
 467     CEC_Transmit_IT(hcec);
 468   }
 469
 470   /* Receive byte or block transfer finished */
 471   if(__HAL_CEC_GET_FLAG(hcec, CEC_FLAG_RBTF) != RESET)
 472   {
 473     if(hcec->RxXferSize == 0U)
 474     {
 475       /* reception is starting */
 476       hcec->RxState = HAL_CEC_STATE_BUSY_RX;
 477     }
 478     CEC_Receive_IT(hcec);
 479   }
 480 }
 481
 482
 483 /**
 484   * @brief Tx Transfer completed callback
 485   * @param hcec: CEC handle
 486   * @retval None
 487   */
 488  __weak void HAL_CEC_TxCpltCallback(CEC_HandleTypeDef *hcec)
 489 {
 490   /* Prevent unused argument(s) compilation warning */
 491   UNUSED(hcec);
 492   /* NOTE : This function should not be modified, when the callback is needed,
 493             the HAL_CEC_TxCpltCallback can be implemented in the user file
 494    */
 495 }
 496
 497 /**
 498   * @brief Rx Transfer completed callback
 499   * @param hcec: CEC handle
 500   * @param RxFrameSize: Size of frame
 501   * @retval None
 502   */
 503 __weak void HAL_CEC_RxCpltCallback(CEC_HandleTypeDef *hcec, uint32_t RxFrameSize)
 504 {
 505   /* Prevent unused argument(s) compilation warning */
 506   UNUSED(hcec);
 507   UNUSED(RxFrameSize);
 508   /* NOTE : This function should not be modified, when the callback is needed,
 509             the HAL_CEC_RxCpltCallback can be implemented in the user file
 510    */
 511 }
 512
 513 /**
 514   * @brief CEC error callbacks
 515   * @param hcec: CEC handle
 516   * @retval None
 517   */
 518  __weak void HAL_CEC_ErrorCallback(CEC_HandleTypeDef *hcec)
 519 {
 520   /* Prevent unused argument(s) compilation warning */
 521   UNUSED(hcec);
 522   /* NOTE : This function should not be modified, when the callback is needed,
 523             the HAL_CEC_ErrorCallback can be implemented in the user file
 524    */
 525 }
 526 /**
 527   * @}
 528   */
 529
 530 /** @defgroup CEC_Exported_Functions_Group3 Peripheral Control functions
 531   *  @brief   CEC control functions
 532   *
 533 @verbatim
 534  ===============================================================================
 535                       ##### Peripheral Control function #####
 536  ===============================================================================
 537     [..]
 538     This subsection provides a set of functions allowing to control the CEC.
 539      (+) HAL_CEC_GetState() API can be helpful to check in run-time the state of the CEC peripheral.
 540          (+) HAL_CEC_GetError() API can be helpful to check in run-time the error of the CEC peripheral.
 541 @endverbatim
 542   * @{
 543   */
 544 /**
 545   * @brief return the CEC state
 546   * @param hcec: pointer to a CEC_HandleTypeDef structure that contains
 547   *              the configuration information for the specified CEC module.
 548   * @retval HAL state
 549   */
 550 HAL_CEC_StateTypeDef HAL_CEC_GetState(CEC_HandleTypeDef *hcec)
 551 {
 552   uint32_t temp1= 0x00U, temp2 = 0x00U;
 553   temp1 = hcec->gState;
 554   temp2 = hcec->RxState;
 555
 556   return (HAL_CEC_StateTypeDef)(temp1 | temp2);
 557 }
 558
 559 /**
 560 * @brief  Return the CEC error code
 561 * @param  hcec : pointer to a CEC_HandleTypeDef structure that contains
 562   *              the configuration information for the specified CEC.
 563 * @retval CEC Error Code
 564 */
 565 uint32_t HAL_CEC_GetError(CEC_HandleTypeDef *hcec)
 566 {
 567   return hcec->ErrorCode;
 568 }
 569
 570 /**
 571   * @}
 572   */
 573
 574 /**
 575   * @}
 576   */
 577
 578 /** @addtogroup CEC_Private_Functions
 579   * @{
 580   */
 581
 582  /**
 583   * @brief Send data in interrupt mode
 584   * @param hcec: CEC handle.
 585   *         Function called under interruption only, once
 586   *         interruptions have been enabled by HAL_CEC_Transmit_IT()
 587   * @retval HAL status
 588   */
 589 static HAL_StatusTypeDef CEC_Transmit_IT(CEC_HandleTypeDef *hcec)
 590 {
 591   /* if the IP is already busy or if there is a previous transmission
 592      already pending due to arbitration loss */
 593   if((hcec->gState == HAL_CEC_STATE_BUSY_TX) || (__HAL_CEC_GET_TRANSMISSION_START_FLAG(hcec) != RESET))
 594   {
 595     /* if all data have been sent */
 596     if(hcec->TxXferCount == 0U)
 597     {
 598       /* Acknowledge successful completion by writing 0x00 */
 599       MODIFY_REG(hcec->Instance->CSR, CEC_FLAG_TRANSMIT_MASK, 0x00U);
 600
 601       hcec->gState = HAL_CEC_STATE_READY;
 602
 603       HAL_CEC_TxCpltCallback(hcec);
 604
 605       return HAL_OK;
 606     }
 607     else
 608     {
 609       /* Reduce the number of bytes to transfer by one */
 610       hcec->TxXferCount--;
 611
 612       /* Write data to TX buffer*/
 613       hcec->Instance->TXD = *hcec->pTxBuffPtr++;
 614
 615       /* If this is the last byte of the ongoing transmission */
 616       if(hcec->TxXferCount == 0U)
 617       {
 618         /* Acknowledge byte request and signal end of message */
 619         MODIFY_REG(hcec->Instance->CSR, CEC_FLAG_TRANSMIT_MASK, CEC_FLAG_TEOM);
 620       }
 621       else
 622       {
 623         /* Acknowledge byte request by writing 0x00 */
 624         MODIFY_REG(hcec->Instance->CSR, CEC_FLAG_TRANSMIT_MASK, 0x00U);
 625       }
 626
 627       return HAL_OK;
 628     }
 629   }
 630   else
 631   {
 632     return HAL_BUSY;
 633   }
 634 }
 635
 636 /**
 637   * @brief Receive data in interrupt mode.
 638   * @param hcec: CEC handle.
 639   *         Function called under interruption only, once
 640   *         interruptions have been enabled by HAL_CEC_Receive_IT()
 641   * @retval HAL status
 642   */
 643 static HAL_StatusTypeDef CEC_Receive_IT(CEC_HandleTypeDef *hcec)
 644 {
 645   static uint32_t temp;
 646
 647   if(hcec->RxState == HAL_CEC_STATE_BUSY_RX)
 648   {
 649     temp = hcec->Instance->CSR;
 650
 651     /* Store received data */
 652     hcec->RxXferSize++;
 653     *hcec->Init.RxBuffer++ = hcec->Instance->RXD;
 654
 655     /* Acknowledge received byte by writing 0x00 */
 656     MODIFY_REG(hcec->Instance->CSR, CEC_FLAG_RECEIVE_MASK, 0x00U);
 657
 658     /* If the End Of Message is reached */
 659     if(HAL_IS_BIT_SET(temp, CEC_FLAG_REOM))
 660     {
 661       /* Interrupts are not disabled due to transmission still ongoing */
 662       hcec->RxState = HAL_CEC_STATE_READY;
 663
 664       HAL_CEC_RxCpltCallback(hcec, hcec->RxXferSize);
 665
 666       return HAL_OK;
 667     }
 668     else
 669     {
 670       return HAL_BUSY;
 671     }
 672   }
 673   else
 674   {
 675     return HAL_BUSY;
 676   }
 677 }
 678
 679 /**
 680  * @}
 681  */
 682
 683 /**
 684   * @}
 685   */
 686
 687 #endif /* defined(STM32F100xB) || defined(STM32F100xE) */
 688
 689 #endif /* HAL_CEC_MODULE_ENABLED */
 690 /**
 691   * @}
 692   */
 693
 694 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/