lib/main/STM32H7/Drivers/STM32H7xx_HAL_Driver/Src/stm32h7xx_hal_hsem.c

   1 /**
   2   ******************************************************************************
   3   * @file    stm32h7xx_hal_hsem.c
   4   * @author  MCD Application Team
   5   * @brief   HSEM HAL module driver.
   6   *          This file provides firmware functions to manage the following
   7   *          functionalities of the semaphore peripheral:
   8   *           + Semaphore Take function (2-Step Procedure) , non blocking
   9   *           + Semaphore FastTake function (1-Step Procedure) , non blocking
  10   *           + Semaphore Status check
  11   *           + Semaphore Clear Key Set and Get
  12   *           + Release and release all functions
  13   *           + Semaphore notification enabling and disabling and callnack functions
  14   *           + IRQ handler management
  15   *
  16   *
  17   @verbatim
  18   ==============================================================================
  19                      ##### How to use this driver #####
  20   ==============================================================================
  21   [..]
  22       (#)Take a semaphore In 2-Step mode Using function HAL_HSEM_Take. This function takes as parameters :
  23            (++) the semaphore ID from 0 to 31
  24            (++) the process ID from 0 to 255
  25       (#) Fast Take semaphore In 1-Step mode Using function HAL_HSEM_FastTake. This function takes as parameter :
  26            (++) the semaphore ID from 0_ID to 31. Note that the process ID value is implicitly assumed as zero
  27       (#) Check if a semaphore is Taken using function HAL_HSEM_IsSemTaken. This function takes as parameter :
  28           (++) the semaphore ID from 0_ID to 31
  29           (++) It returns 1 if the given semaphore is taken otherwise (Free) zero
  30       (#)Release a semaphore using function with HAL_HSEM_Release. This function takes as parameters :
  31            (++) the semaphore ID from 0 to 31
  32            (++) the process ID from 0 to 255:
  33            (++) Note: If ProcessID and MasterID match, semaphore is freed, and an interrupt
  34          may be generated when enabled (notification activated). If ProcessID or MasterID does not match,
  35          semaphore remains taken (locked)
  36
  37       (#)Release all semaphores at once taken by a given Master using function HAL_HSEM_Release_All
  38           This function takes as parameters :
  39            (++) the Release Key (value from 0 to 0xFFFF) can be Set or Get respectively by
  40               HAL_HSEM_SetClearKey() or HAL_HSEM_GetClearKey functions
  41            (++) the Master ID:
  42            (++) Note: If the Key and MasterID match, all semaphores taken by the given CPU that corresponds
  43            to MasterID  will be freed, and an interrupt may be generated when enabled (notification activated). If the
  44            Key or the MasterID doesn't match, semaphores remains taken (locked)
  45
  46       (#)Semaphores Release all key functions:
  47          (++)  HAL_HSEM_SetClearKey() to set semaphore release all Key
  48          (++)  HAL_HSEM_GetClearKey() to get release all Key
  49       (#)Semaphores notification functions :
  50          (++)  HAL_HSEM_ActivateNotification to activate a notification callback on
  51                a given semaphores Mask (bitfield). When one or more semaphores defined by the mask are released
  52                the callback HAL_HSEM_FreeCallback will be asserted giving as parameters a mask of the released
  53                semaphores (bitfield).
  54
  55          (++)  HAL_HSEM_DeactivateNotification to deactivate the notification of a given semaphores Mask (bitfield).
  56          (++) See the description of the macro __HAL_HSEM_SEMID_TO_MASK to check how to calculate a semaphore mask
  57                 Used by the notification functions
  58      *** HSEM HAL driver macros list ***
  59      =============================================
  60      [..] Below the list of most used macros in HSEM HAL driver.
  61
  62       (+) __HAL_HSEM_SEMID_TO_MASK: Helper macro to convert a Semaphore ID to a Mask.
  63       [..] Example of use :
  64       [..] mask = __HAL_HSEM_SEMID_TO_MASK(8)  |  __HAL_HSEM_SEMID_TO_MASK(21) | __HAL_HSEM_SEMID_TO_MASK(25).
  65       [..] All next macros take as parameter a semaphore Mask (bitfiled) that can be constructed using  __HAL_HSEM_SEMID_TO_MASK as the above example.
  66       (+) __HAL_HSEM_ENABLE_IT: Enable the specified semaphores Mask interrupts.
  67       (+) __HAL_HSEM_DISABLE_IT: Disable the specified semaphores Mask interrupts.
  68       (+) __HAL_HSEM_GET_IT: Checks whether the specified semaphore interrupt has occurred or not.
  69       (+) __HAL_HSEM_GET_FLAG: Get the semaphores status release flags.
  70       (+) __HAL_HSEM_CLEAR_FLAG: Clear the semaphores status release flags.
  71
  72   @endverbatim
  73   ******************************************************************************
  74   * @attention
  75   *
  76   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
  77   * All rights reserved.</center></h2>
  78   *
  79   * This software component is licensed by ST under BSD 3-Clause license,
  80   * the "License"; You may not use this file except in compliance with the
  81   * License. You may obtain a copy of the License at:
  82   *                        opensource.org/licenses/BSD-3-Clause
  83   *
  84   ******************************************************************************
  85   */
  86
  87 /* Includes ------------------------------------------------------------------*/
  88 #include "stm32h7xx_hal.h"
  89
  90 /** @addtogroup STM32H7xx_HAL_Driver
  91   * @{
  92   */
  93
  94 /** @defgroup HSEM HSEM
  95   * @brief HSEM HAL module driver
  96   * @{
  97   */
  98
  99 #ifdef HAL_HSEM_MODULE_ENABLED
 100
 101 /* Private typedef -----------------------------------------------------------*/
 102 /* Private define ------------------------------------------------------------*/
 103 #if defined(DUAL_CORE)
 104 #ifndef HSEM_R_MASTERID
 105 #define HSEM_R_MASTERID HSEM_R_COREID
 106 #endif
 107
 108 #ifndef HSEM_RLR_MASTERID
 109 #define HSEM_RLR_MASTERID HSEM_RLR_COREID
 110 #endif
 111
 112 #ifndef HSEM_CR_MASTERID
 113 #define HSEM_CR_MASTERID HSEM_CR_COREID
 114 #endif
 115 #endif /* DUAL_CORE */
 116 /* Private macro -------------------------------------------------------------*/
 117 /* Private variables ---------------------------------------------------------*/
 118 /* Private function prototypes -----------------------------------------------*/
 119 /* Private functions ---------------------------------------------------------*/
 120 /* Exported functions --------------------------------------------------------*/
 121
 122 /** @defgroup HSEM_Exported_Functions  HSEM Exported Functions
 123   * @{
 124   */
 125
 126 /** @defgroup HSEM_Exported_Functions_Group1 Take and Release functions
 127   *  @brief    HSEM Take and Release functions
 128   *
 129 @verbatim
 130  ==============================================================================
 131               ##### HSEM Take and Release functions #####
 132  ==============================================================================
 133 [..] This section provides functions allowing to:
 134       (+) Take a semaphore with 2 Step method
 135       (+) Fast Take a semaphore with 1 Step method
 136       (+) Check semaphore state Taken or not
 137       (+) Release a semaphore
 138       (+) Release all semaphore at once
 139
 140 @endverbatim
 141   * @{
 142   */
 143
 144
 145 /**
 146   * @brief  Take a semaphore in 2 Step mode.
 147   * @param  SemID: semaphore ID from 0 to 31
 148   * @param  ProcessID: Process ID from 0 to 255
 149   * @retval HAL status
 150   */
 151 HAL_StatusTypeDef  HAL_HSEM_Take(uint32_t SemID, uint32_t ProcessID)
 152 {
 153   /* Check the parameters */
 154   assert_param(IS_HSEM_SEMID(SemID));
 155   assert_param(IS_HSEM_PROCESSID(ProcessID));
 156
 157 #if  USE_MULTI_CORE_SHARED_CODE != 0U
 158   /* First step  write R register with MasterID, processID and take bit=1*/
 159   HSEM->R[SemID] = ((ProcessID & HSEM_R_PROCID) | ((HAL_GetCurrentCPUID() << POSITION_VAL(HSEM_R_MASTERID)) & HSEM_R_MASTERID) | HSEM_R_LOCK);
 160
 161   /* second step : read the R register . Take achieved if MasterID and processID match and take bit set to 1 */
 162   if (HSEM->R[SemID] == ((ProcessID & HSEM_R_PROCID) | ((HAL_GetCurrentCPUID() << POSITION_VAL(HSEM_R_MASTERID)) & HSEM_R_MASTERID) | HSEM_R_LOCK))
 163   {
 164     /*take success when MasterID and ProcessID match and take bit set*/
 165     return HAL_OK;
 166   }
 167 #else
 168   /* First step  write R register with MasterID, processID and take bit=1*/
 169   HSEM->R[SemID] = (ProcessID | HSEM_CR_COREID_CURRENT | HSEM_R_LOCK);
 170
 171   /* second step : read the R register . Take achieved if MasterID and processID match and take bit set to 1 */
 172   if (HSEM->R[SemID] == (ProcessID | HSEM_CR_COREID_CURRENT | HSEM_R_LOCK))
 173   {
 174     /*take success when MasterID and ProcessID match and take bit set*/
 175     return HAL_OK;
 176   }
 177 #endif
 178
 179   /* Semaphore take fails*/
 180   return HAL_ERROR;
 181 }
 182
 183 /**
 184   * @brief  Fast Take a semaphore with 1 Step mode.
 185   * @param  SemID: semaphore ID from 0 to 31
 186   * @retval HAL status
 187   */
 188 HAL_StatusTypeDef HAL_HSEM_FastTake(uint32_t SemID)
 189 {
 190   /* Check the parameters */
 191   assert_param(IS_HSEM_SEMID(SemID));
 192
 193 #if  USE_MULTI_CORE_SHARED_CODE != 0U
 194   /* Read the RLR register to take the semaphore */
 195   if (HSEM->RLR[SemID] == (((HAL_GetCurrentCPUID() << POSITION_VAL(HSEM_R_MASTERID)) & HSEM_RLR_MASTERID) | HSEM_RLR_LOCK))
 196   {
 197     /*take success when MasterID match and take bit set*/
 198     return HAL_OK;
 199   }
 200 #else
 201   /* Read the RLR register to take the semaphore */
 202   if (HSEM->RLR[SemID] == (HSEM_CR_COREID_CURRENT | HSEM_RLR_LOCK))
 203   {
 204     /*take success when MasterID match and take bit set*/
 205     return HAL_OK;
 206   }
 207 #endif
 208
 209   /* Semaphore take fails */
 210   return HAL_ERROR;
 211 }
 212 /**
 213   * @brief  Check semaphore state Taken or not.
 214   * @param  SemID: semaphore ID
 215   * @retval HAL HSEM state
 216   */
 217 uint32_t HAL_HSEM_IsSemTaken(uint32_t SemID)
 218 {
 219   return (((HSEM->R[SemID] & HSEM_R_LOCK) != 0U) ? 1UL : 0UL);
 220 }
 221
 222
 223 /**
 224   * @brief  Release a semaphore.
 225   * @param  SemID: semaphore ID from 0 to 31
 226   * @param  ProcessID: Process ID from 0 to 255
 227   * @retval None
 228   */
 229 void  HAL_HSEM_Release(uint32_t SemID, uint32_t ProcessID)
 230 {
 231   /* Check the parameters */
 232   assert_param(IS_HSEM_SEMID(SemID));
 233   assert_param(IS_HSEM_PROCESSID(ProcessID));
 234
 235   /* Clear the semaphore by writing to the R register : the MasterID , the processID and take bit = 0  */
 236 #if  USE_MULTI_CORE_SHARED_CODE != 0U
 237   HSEM->R[SemID] = (ProcessID | ((HAL_GetCurrentCPUID() << POSITION_VAL(HSEM_R_MASTERID)) & HSEM_R_MASTERID));
 238 #else
 239   HSEM->R[SemID] = (ProcessID | HSEM_CR_COREID_CURRENT);
 240 #endif
 241
 242 }
 243
 244 /**
 245   * @brief  Release All semaphore used by a given Master .
 246   * @param  Key: Semaphore Key , value from 0 to 0xFFFF
 247   * @param  CoreID: CoreID of the CPU that is using semaphores to be released
 248   * @retval None
 249   */
 250 void HAL_HSEM_ReleaseAll(uint32_t Key, uint32_t CoreID)
 251 {
 252   assert_param(IS_HSEM_KEY(Key));
 253   assert_param(IS_HSEM_COREID(CoreID));
 254
 255   HSEM->CR = ((Key << HSEM_CR_KEY_Pos) | (CoreID << HSEM_CR_COREID_Pos));
 256 }
 257
 258 /**
 259   * @}
 260   */
 261
 262 /** @defgroup HSEM_Exported_Functions_Group2 HSEM Set and Get Key functions
 263   *  @brief    HSEM Set and Get Key functions.
 264   *
 265 @verbatim
 266   ==============================================================================
 267               ##### HSEM Set and Get Key functions #####
 268   ==============================================================================
 269     [..]  This section provides functions allowing to:
 270       (+) Set semaphore Key
 271       (+) Get semaphore Key
 272 @endverbatim
 273
 274   * @{
 275   */
 276
 277 /**
 278   * @brief  Set semaphore Key .
 279   * @param  Key: Semaphore Key , value from 0 to 0xFFFF
 280   * @retval None
 281   */
 282 void  HAL_HSEM_SetClearKey(uint32_t Key)
 283 {
 284   assert_param(IS_HSEM_KEY(Key));
 285
 286   MODIFY_REG(HSEM->KEYR, HSEM_KEYR_KEY, (Key << HSEM_KEYR_KEY_Pos));
 287
 288 }
 289
 290 /**
 291   * @brief  Get semaphore Key .
 292   * @retval Semaphore Key , value from 0 to 0xFFFF
 293   */
 294 uint32_t HAL_HSEM_GetClearKey(void)
 295 {
 296   return (HSEM->KEYR >> HSEM_KEYR_KEY_Pos);
 297 }
 298
 299 /**
 300   * @}
 301   */
 302
 303 /** @defgroup HSEM_Exported_Functions_Group3 HSEM IRQ handler management
 304   *  @brief    HSEM Notification functions.
 305   *
 306 @verbatim
 307   ==============================================================================
 308       ##### HSEM IRQ handler management and Notification functions #####
 309   ==============================================================================
 310 [..]  This section provides HSEM IRQ handler and Notification function.
 311
 312 @endverbatim
 313   * @{
 314   */
 315
 316 /**
 317   * @brief  Activate Semaphore release Notification for a given Semaphores Mask .
 318   * @param  SemMask: Mask of Released semaphores
 319   * @retval Semaphore Key
 320   */
 321 void HAL_HSEM_ActivateNotification(uint32_t SemMask)
 322 {
 323 #if  USE_MULTI_CORE_SHARED_CODE != 0U
 324   /*enable the semaphore mask interrupts */
 325   if (HAL_GetCurrentCPUID() == HSEM_CPU1_COREID)
 326   {
 327     /*Use interrupt line 0 for CPU1 Master */
 328     HSEM->C1IER |= SemMask;
 329   }
 330   else /* HSEM_CPU2_COREID */
 331   {
 332     /*Use interrupt line 1 for CPU2 Master*/
 333     HSEM->C2IER |= SemMask;
 334   }
 335 #else
 336   HSEM_COMMON->IER |= SemMask;
 337 #endif
 338 }
 339
 340 /**
 341   * @brief  Deactivate Semaphore release Notification for a given Semaphores Mask .
 342   * @param  SemMask: Mask of Released semaphores
 343   * @retval Semaphore Key
 344   */
 345 void HAL_HSEM_DeactivateNotification(uint32_t SemMask)
 346 {
 347 #if  USE_MULTI_CORE_SHARED_CODE != 0U
 348   /*enable the semaphore mask interrupts */
 349   if (HAL_GetCurrentCPUID() == HSEM_CPU1_COREID)
 350   {
 351     /*Use interrupt line 0 for CPU1 Master */
 352     HSEM->C1IER &= ~SemMask;
 353   }
 354   else /* HSEM_CPU2_COREID */
 355   {
 356     /*Use interrupt line 1 for CPU2 Master*/
 357     HSEM->C2IER &= ~SemMask;
 358   }
 359 #else
 360   HSEM_COMMON->IER &= ~SemMask;
 361 #endif
 362 }
 363
 364 /**
 365   * @brief  This function handles HSEM interrupt request
 366   * @retval None
 367   */
 368 void HAL_HSEM_IRQHandler(void)
 369 {
 370   uint32_t statusreg;
 371 #if  USE_MULTI_CORE_SHARED_CODE != 0U
 372   if (HAL_GetCurrentCPUID() == HSEM_CPU1_COREID)
 373   {
 374     /* Get the list of masked freed semaphores*/
 375     statusreg = HSEM->C1MISR; /*Use interrupt line 0 for CPU1 Master*/
 376
 377     /*Disable Interrupts*/
 378     HSEM->C1IER &= ~((uint32_t)statusreg);
 379
 380     /*Clear Flags*/
 381     HSEM->C1ICR = ((uint32_t)statusreg);
 382   }
 383   else /* HSEM_CPU2_COREID */
 384   {
 385     /* Get the list of masked freed semaphores*/
 386     statusreg = HSEM->C2MISR;/*Use interrupt line 1 for CPU2 Master*/
 387
 388     /*Disable Interrupts*/
 389     HSEM->C2IER &= ~((uint32_t)statusreg);
 390
 391     /*Clear Flags*/
 392     HSEM->C2ICR = ((uint32_t)statusreg);
 393   }
 394 #else
 395   /* Get the list of masked freed semaphores*/
 396   statusreg = HSEM_COMMON->MISR;
 397
 398   /*Disable Interrupts*/
 399   HSEM_COMMON->IER &= ~((uint32_t)statusreg);
 400
 401   /*Clear Flags*/
 402   HSEM_COMMON->ICR = ((uint32_t)statusreg);
 403
 404 #endif
 405   /* Call FreeCallback */
 406   HAL_HSEM_FreeCallback(statusreg);
 407 }
 408
 409 /**
 410   * @brief Semaphore Released Callback.
 411   * @param SemMask: Mask of Released semaphores
 412   * @retval None
 413   */
 414 __weak void HAL_HSEM_FreeCallback(uint32_t SemMask)
 415 {
 416   /* Prevent unused argument(s) compilation warning */
 417   UNUSED(SemMask);
 418
 419   /* NOTE : This function should not be modified, when the callback is needed,
 420   the HAL_HSEM_FreeCallback can be implemented in the user file
 421     */
 422 }
 423
 424 /**
 425   * @}
 426   */
 427
 428 /**
 429   * @}
 430   */
 431
 432 #endif /* HAL_HSEM_MODULE_ENABLED */
 433 /**
 434   * @}
 435   */
 436
 437 /**
 438   * @}
 439   */
 440
 441 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/