lib/main/STM32G4/Drivers/STM32G4xx_HAL_Driver/Src/stm32g4xx_hal_opamp.c

   1 /**
   2   ******************************************************************************
   3   * @file    stm32g4xx_hal_opamp.c
   4   * @author  MCD Application Team
   5   * @brief   OPAMP HAL module driver.
   6   *          This file provides firmware functions to manage the following
   7   *          functionalities of the operational amplifiers (OPAMP1,...OPAMP6)
   8   *          peripheral:
   9   *           + OPAMP Configuration
  10   *           + OPAMP calibration
  11   *          Thanks to
  12   *           + Initialization/de-initialization functions
  13   *           + I/O operation functions
  14   *           + Peripheral Control functions
  15   *           + Peripheral State functions
  16   *
  17   @verbatim
  18 ================================================================================
  19           ##### OPAMP Peripheral Features #####
  20 ================================================================================
  21
  22   [..] The device integrates up to 6 operational amplifiers OPAMP1, OPAMP2,
  23        OPAMP3, OPAMP4, OPAMP5 and OPAMP6:
  24
  25        (#) The OPAMP(s) provides several exclusive running modes.
  26        (++) Standalone mode
  27        (++) Programmable Gain Amplifier (PGA) mode (Resistor feedback output)
  28        (++) Follower mode
  29
  30        (#) The OPAMP(s) provide(s) calibration capabilities.
  31        (++) Calibration aims at correcting some offset for running mode.
  32        (++) The OPAMP uses either factory calibration settings OR user defined
  33            calibration (trimming) settings (i.e. trimming mode).
  34        (++) The user defined settings can be figured out using self calibration
  35            handled by HAL_OPAMP_SelfCalibrate, HAL_OPAMPEx_SelfCalibrateAll
  36        (++) HAL_OPAMP_SelfCalibrate:
  37        (++) Runs automatically the calibration in 2 steps.
  38             (90% of VDDA for NMOS transistors, 10% of VDDA for PMOS transistors).
  39             (As OPAMP is Rail-to-rail input/output, these 2 steps calibration is
  40             appropriate and enough in most cases).
  41        (++) Enables the user trimming mode
  42        (++) Updates the init structure with trimming values with fresh calibration
  43             results.
  44             The user may store the calibration results for larger
  45             (ex monitoring the trimming as a function of temperature
  46             for instance)
  47        (++) for STM32G4 devices having 6 OPAMPs
  48             HAL_OPAMPEx_SelfCalibrateAll
  49             runs calibration of 6 OPAMPs in parallel.
  50
  51        (#) For any running mode, an additional Timer-controlled Mux (multiplexer)
  52            mode can be set on top.
  53        (++) Timer-controlled Mux mode allows Automatic switching of inputs
  54            configuration (inverting and non inverting).
  55        (++) Hence on top of defaults (primary) inverting and non-inverting inputs,
  56            the user shall select secondary inverting and non inverting inputs.
  57        (++) TIM1 OC6, TIM8 OC6 and TIM20 OC6 provides the alternate switching
  58            tempo between defaults (primary) and secondary inputs.
  59        (++) These 3 timers (TIM1, TIM8 and TIM20) can be combined to design a more
  60            complex switching scheme. So that any of the selected channel can initiate
  61            the configuration switch.
  62
  63        (#) Running mode: Standalone mode
  64        (++) Gain is set externally (gain depends on external loads).
  65        (++) Follower mode also possible externally by connecting the inverting input to
  66            the output.
  67
  68        (#) Running mode: Follower mode
  69        (++) Inverting Input is not connected.
  70
  71        (#) Running mode: Programmable Gain Amplifier (PGA) mode
  72            (Resistor feedback output)
  73        (++) The OPAMP(s) output(s) can be internally connected to resistor feedback
  74            output.
  75        (++) The OPAMP inverting input can be "not" connected, signal to amplify is
  76            connected to non inverting input and gain is positive (2,4,8,16,32 or 64)
  77        (++) The OPAMP inverting input can be connected to VINM0:
  78            If signal is applied to non inverting input, gain is positive (2,4,8,16,32 or 64).
  79            If signal is applied to inverting input, gain is negative (-1,-3,-7,-15-,31 or -63).
  80            In both cases, the other input can be used as bias.
  81
  82
  83             ##### How to use this driver #####
  84 ================================================================================
  85   [..]
  86
  87     *** High speed / normal power mode ***
  88     ============================================
  89     [..]  To run in high speed mode:
  90
  91       (#) Configure the OPAMP using HAL_OPAMP_Init() function:
  92       (++) Select OPAMP_POWERMODE_HIGHSPEED
  93       (++) Otherwise select OPAMP_POWERMODE_NORMAL
  94
  95     *** Calibration ***
  96     ============================================
  97     [..]  To run the OPAMP calibration self calibration:
  98
  99       (#) Start calibration using HAL_OPAMP_SelfCalibrate.
 100            Store the calibration results.
 101
 102     *** Running mode ***
 103     ============================================
 104     [..]  To use the OPAMP, perform the following steps:
 105
 106       (#) Fill in the HAL_OPAMP_MspInit() to
 107       (++) Configure the OPAMP input AND output in analog mode using
 108           HAL_GPIO_Init() to map the OPAMP output to the GPIO pin.
 109
 110       (#) Registrate Callbacks
 111       (++) The compilation define  USE_HAL_OPAMP_REGISTER_CALLBACKS when set to 1
 112            allows the user to configure dynamically the driver callbacks.
 113
 114       (++) Use Functions @ref HAL_OPAMP_RegisterCallback() to register a user callback,
 115            it allows to register following callbacks:
 116       (+++) MspInitCallback         : OPAMP MspInit.
 117       (+++) MspDeInitCallback       : OPAMP MspDeInit.
 118            This function takes as parameters the HAL peripheral handle, the Callback ID
 119            and a pointer to the user callback function.
 120
 121       (++) Use function @ref HAL_OPAMP_UnRegisterCallback() to reset a callback to the default
 122            weak (surcharged) function. It allows to reset following callbacks:
 123       (+++) MspInitCallback         : OPAMP MspInit.
 124       (+++) MspDeInitCallback       : OPAMP MspDeInit.
 125       (+++) All Callbacks
 126
 127       (#) Configure the OPAMP using HAL_OPAMP_Init() function:
 128       (++) Select the mode
 129       (++) Select the inverting input
 130       (++) Select the non-inverting input
 131       (++) Select if the internal ouput should be enabled/disabled (if enabled, regular I/O output is disabled)
 132       (++) Select if the Timer controlled Mux is disabled or enabled and controlled by specified timer(s)
 133       (++) If the Timer controlled Mux mode is enabled, select the secondary inverting input
 134       (++) If the Timer controlled Mux mode is enabled, Select the secondary non-inverting input
 135       (++) If PGA mode is enabled, Select if inverting input is connected.
 136       (++) If PGA mode is enabled, Select PGA gain to be used.
 137       (++) Select either factory or user defined trimming mode.
 138       (++) If the user defined trimming mode is enabled, select PMOS & NMOS trimming values
 139           (typ. settings returned by HAL_OPAMP_SelfCalibrate function).
 140
 141       (#) Enable the OPAMP using HAL_OPAMP_Start() function.
 142
 143       (#) Disable the OPAMP using HAL_OPAMP_Stop() function.
 144
 145       (#) Lock the OPAMP in running mode using HAL_OPAMP_Lock() & HAL_OPAMP_TimerMuxLock functions.
 146           From then the configuration can only be modified
 147       (++) After HW reset
 148       (++) OR thanks to HAL_OPAMP_MspDeInit called (user defined) from HAL_OPAMP_DeInit.
 149
 150     *** Running mode: change of configuration while OPAMP ON  ***
 151     ============================================
 152     [..]    To Re-configure OPAMP when OPAMP is ON (change on the fly)
 153       (#) If needed, fill in the HAL_OPAMP_MspInit()
 154       (++) This is the case for instance if you wish to use new OPAMP I/O
 155
 156       (#) Configure the OPAMP using HAL_OPAMP_Init() function:
 157       (++) As in configure case, selects first the parameters you wish to modify.
 158       (++) If OPAMP control register is locked, it is not possible to modify any values
 159           on the fly (even the timer controlled mux parameters).
 160       (++) If OPAMP timer controlled mux mode register is locked, it is possible to modify any values
 161           of the control register but none on the timer controlled mux mode one.
 162
 163       (#) Change from high speed mode to normal power mode (& vice versa) requires
 164           first HAL_OPAMP_DeInit() (force OPAMP OFF) and then HAL_OPAMP_Init().
 165           In other words, of OPAMP is ON, HAL_OPAMP_Init can NOT change power mode
 166           alone.
 167
 168   @endverbatim
 169   ******************************************************************************
 170   * @attention
 171   *
 172   * <h2><center>&copy; Copyright (c) 2018 STMicroelectronics.
 173   * All rights reserved.</center></h2>
 174   *
 175   * This software component is licensed by ST under BSD 3-Clause license,
 176   * the "License"; You may not use this file except in compliance with the
 177   * License. You may obtain a copy of the License at:
 178   *                        opensource.org/licenses/BSD-3-Clause
 179   *
 180   ******************************************************************************
 181   */
 182
 183 /*
 184   Additional Tables:
 185     The OPAMPs non inverting input (both default and secondary) can be
 186     selected among the list shown by table below.
 187
 188     The OPAMPs non inverting input (both default and secondary) can be
 189     selected among the list shown by table below.
 190
 191     Table 1.  OPAMPs inverting/non-inverting inputs for the STM32G4 devices:
 192     +--------------------------------------------------------------------------------------------+
 193     |                 |        | OPAMP1   | OPAMP2   | OPAMP3   | OPAMP4   | OPAMP5   | OPAMP6   |
 194     |-----------------|--------|----------|----------|----------|----------|----------|----------|
 195     |                 | No conn|  X       |  X       |  X       |  X       |  X       |  X       |
 196     | Inverting Input | VM0    | PA3      | PA5      | PB2      | PB10     | PB15     | PA1      |
 197     | (1)             | VM1    | PC5      | PC5      | PB10     | PD8      | PA3      | PB1      |
 198     |-----------------|--------|----------|----------|----------|----------|----------|----------|
 199     |                 | VP0    | PA1      | PA7      | PB0      | PB13     | PB14     | PB12     |
 200     |  Non Inverting  | VP1    | PA3      | PB14     | PB13     | PD11     | PD12     | PD9      |
 201     |    Input        | VP2    | PA7      | PB0      | PA1      | PB11     | PC3      | PB13     |
 202     |                 | VP3    | DAC3_CH1 | PD14     | DAC3_CH2 | DAC4_CH1 | DAC4_CH2 | DAC3_CH1 |
 203     +--------------------------------------------------------------------------------------------+
 204     (1): No connection in follower mode.
 205
 206     Table 2.  OPAMPs outputs for the STM32G4 devices:
 207     +--------------------------------------------------------------------------------+
 208     |                 |        | OPAMP1 | OPAMP2 | OPAMP3 | OPAMP4 | OPAMP5 | OPAMP6 |
 209     |-----------------|--------|--------|--------|--------|--------|--------|--------|
 210     | Output          |        |  PA2   |  PA6   |  PB1   |  PB12  |  PA8   |  PB11  |
 211     |-----------------|--------|--------|--------|--------|--------|--------|--------+
 212     | Internal output |        |  ADC1  |  ADC2  |  ADC2  |  ADC5  |  ADC5  |  ADC4  |
 213     | to ADCs         |        |  CH13  |  CH16  |  CH18  |  CH5   |  CH3   |  CH17  |
 214     |                 |        |        |        |  ADC3  |        |        |        |
 215     |                 |        |        |        |  CH13  |        |        |        |
 216     |-----------------|--------|--------|--------|--------|--------|--------|--------+
 217
 218 */
 219
 220 /* Includes ------------------------------------------------------------------*/
 221 #include "stm32g4xx_hal.h"
 222
 223 /** @addtogroup STM32G4xx_HAL_Driver
 224   * @{
 225   */
 226
 227 #ifdef HAL_OPAMP_MODULE_ENABLED
 228
 229 /** @defgroup OPAMP OPAMP
 230   * @brief OPAMP HAL module driver
 231   * @{
 232   */
 233
 234 /* Private typedef -----------------------------------------------------------*/
 235 /* Private define ------------------------------------------------------------*/
 236 /** @defgroup OPAMP_Private_Define OPAMP Private Define
 237   * @{
 238   */
 239 /* CSR register reset value */
 240 #define OPAMP_CSR_RESET_VALUE             (0x00000000UL)
 241 /* CSR register TRIM value upon reset are factory ones, filter them out from CSR register check */
 242 #define OPAMP_CSR_RESET_CHECK_MASK        (~(OPAMP_CSR_TRIMOFFSETN | OPAMP_CSR_TRIMOFFSETP))
 243 /* CSR init register Mask */
 244 #define OPAMP_CSR_UPDATE_PARAMETERS_INIT_MASK (OPAMP_CSR_TRIMOFFSETN | OPAMP_CSR_TRIMOFFSETP \
 245                                                | OPAMP_CSR_HIGHSPEEDEN | OPAMP_CSR_OPAMPINTEN \
 246                                                | OPAMP_CSR_PGGAIN | OPAMP_CSR_VPSEL \
 247                                                | OPAMP_CSR_VMSEL | OPAMP_CSR_FORCEVP)
 248 /* TCMR init register Mask */
 249 #define OPAMP_TCMR_UPDATE_PARAMETERS_INIT_MASK (OPAMP_TCMR_T20CMEN | OPAMP_TCMR_T8CMEN \
 250                                                 | OPAMP_TCMR_T1CMEN | OPAMP_TCMR_VPSSEL \
 251                                                 | OPAMP_TCMR_VMSSEL)
 252 /**
 253   * @}
 254   */
 255
 256 /* Private macro -------------------------------------------------------------*/
 257 /* Private variables ---------------------------------------------------------*/
 258 /* Private function prototypes -----------------------------------------------*/
 259 /* Exported functions ---------------------------------------------------------*/
 260
 261 /** @defgroup OPAMP_Exported_Functions OPAMP Exported Functions
 262   * @{
 263   */
 264
 265 /** @defgroup OPAMP_Exported_Functions_Group1 Initialization and de-initialization functions
 266   *  @brief    Initialization and Configuration functions
 267   *
 268 @verbatim
 269  ===============================================================================
 270               ##### Initialization and de-initialization  functions #####
 271  ===============================================================================
 272     [..]  This section provides functions allowing to:
 273
 274 @endverbatim
 275   * @{
 276   */
 277
 278 /**
 279   * @brief  Initializes the OPAMP according to the specified
 280   *         parameters in the OPAMP_InitTypeDef and initialize the associated handle.
 281   * @note   If the selected opamp is locked, initialization can't be performed.
 282   *         To unlock the configuration, perform a system reset.
 283   * @param  hopamp OPAMP handle
 284   * @retval HAL status
 285   */
 286 HAL_StatusTypeDef HAL_OPAMP_Init(OPAMP_HandleTypeDef *hopamp)
 287 {
 288   HAL_StatusTypeDef status = HAL_OK;
 289
 290   /* Check the OPAMP handle allocation and lock status */
 291   /* Init not allowed if calibration is ongoing */
 292   if (hopamp == NULL)
 293   {
 294     return HAL_ERROR;
 295   }
 296   else if (hopamp->State == HAL_OPAMP_STATE_BUSYLOCKED)
 297   {
 298     return HAL_ERROR;
 299   }
 300   else if (hopamp->State == HAL_OPAMP_STATE_CALIBBUSY)
 301   {
 302     return HAL_ERROR;
 303   }
 304   else
 305   {
 306
 307     /* Check the parameter */
 308     assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
 309
 310     /* Set OPAMP parameters */
 311     assert_param(IS_OPAMP_POWERMODE(hopamp->Init.PowerMode));
 312     assert_param(IS_OPAMP_FUNCTIONAL_NORMALMODE(hopamp->Init.Mode));
 313     assert_param(IS_OPAMP_NONINVERTING_INPUT(hopamp->Init.NonInvertingInput));
 314
 315 #if (USE_HAL_OPAMP_REGISTER_CALLBACKS == 1)
 316     if (hopamp->State == HAL_OPAMP_STATE_RESET)
 317     {
 318       if (hopamp->MspInitCallback == NULL)
 319       {
 320         hopamp->MspInitCallback               = HAL_OPAMP_MspInit;
 321       }
 322     }
 323 #endif /* USE_HAL_OPAMP_REGISTER_CALLBACKS */
 324
 325     if ((hopamp->Init.Mode) == OPAMP_STANDALONE_MODE)
 326     {
 327       assert_param(IS_OPAMP_INVERTING_INPUT(hopamp->Init.InvertingInput));
 328     }
 329     assert_param(IS_FUNCTIONAL_STATE(hopamp->Init.InternalOutput));
 330
 331     assert_param(IS_OPAMP_TIMERCONTROLLED_MUXMODE(hopamp->Init.TimerControlledMuxmode));
 332
 333     if ((hopamp->Init.TimerControlledMuxmode) != OPAMP_TIMERCONTROLLEDMUXMODE_DISABLE)
 334     {
 335       assert_param(IS_OPAMP_SEC_NONINVERTING_INPUT(hopamp->Init.NonInvertingInputSecondary));
 336       assert_param(IS_OPAMP_SEC_INVERTING_INPUT(hopamp->Init.InvertingInputSecondary));
 337     }
 338
 339     if ((hopamp->Init.Mode) == OPAMP_PGA_MODE)
 340     {
 341       assert_param(IS_OPAMP_PGACONNECT(hopamp->Init.PgaConnect));
 342       assert_param(IS_OPAMP_PGA_GAIN(hopamp->Init.PgaGain));
 343     }
 344
 345     assert_param(IS_OPAMP_TRIMMING(hopamp->Init.UserTrimming));
 346     if ((hopamp->Init.UserTrimming) == OPAMP_TRIMMING_USER)
 347     {
 348       assert_param(IS_OPAMP_TRIMMINGVALUE(hopamp->Init.TrimmingValueP));
 349       assert_param(IS_OPAMP_TRIMMINGVALUE(hopamp->Init.TrimmingValueN));
 350     }
 351
 352     /* Init SYSCFG and the low level hardware to access opamp */
 353     __HAL_RCC_SYSCFG_CLK_ENABLE();
 354
 355     if (hopamp->State == HAL_OPAMP_STATE_RESET)
 356     {
 357       /* Allocate lock resource and initialize it */
 358       hopamp->Lock = HAL_UNLOCKED;
 359     }
 360
 361 #if (USE_HAL_OPAMP_REGISTER_CALLBACKS == 1)
 362     hopamp->MspInitCallback(hopamp);
 363 #else
 364     /* Call MSP init function */
 365     HAL_OPAMP_MspInit(hopamp);
 366 #endif /* USE_HAL_OPAMP_REGISTER_CALLBACKS */
 367
 368     /* Set OPAMP parameters */
 369     /*     Set  bits according to hopamp->hopamp->Init.Mode value                                 */
 370     /*     Set  bits according to hopamp->hopamp->Init.InvertingInput value                       */
 371     /*     Set  bits according to hopamp->hopamp->Init.NonInvertingInput value                    */
 372     /*     Set  bits according to hopamp->hopamp->Init.InternalOutput value                       */
 373     /*     Set  bits according to hopamp->hopamp->Init.TimerControlledMuxmode value               */
 374     /*     Set  bits according to hopamp->hopamp->Init.InvertingInputSecondary  value             */
 375     /*     Set  bits according to hopamp->hopamp->Init.NonInvertingInputSecondary value           */
 376     /*     Set  bits according to hopamp->hopamp->Init.PgaConnect value                           */
 377     /*     Set  bits according to hopamp->hopamp->Init.PgaGain value                              */
 378     /*     Set  bits according to hopamp->hopamp->Init.UserTrimming value                         */
 379     /*     Set  bits according to hopamp->hopamp->Init.TrimmingValueP value                       */
 380     /*     Set  bits according to hopamp->hopamp->Init.TrimmingValueN value                       */
 381
 382
 383     /* check if OPAMP_PGA_MODE & in Follower mode */
 384     /*   - InvertingInput                         */
 385     /* is Not Applicable                          */
 386
 387     if ((hopamp->Init.Mode == OPAMP_PGA_MODE) || (hopamp->Init.Mode == OPAMP_FOLLOWER_MODE))
 388     {
 389       /* Update User Trim config first to be able to modify trimming value afterwards */
 390       MODIFY_REG(hopamp->Instance->CSR,
 391                  OPAMP_CSR_USERTRIM,
 392                  hopamp->Init.UserTrimming);
 393       MODIFY_REG(hopamp->Instance->CSR,
 394                  OPAMP_CSR_UPDATE_PARAMETERS_INIT_MASK,
 395                  hopamp->Init.PowerMode |
 396                  hopamp->Init.Mode |
 397                  hopamp->Init.NonInvertingInput |
 398                  ((hopamp->Init.InternalOutput == ENABLE) ? OPAMP_CSR_OPAMPINTEN : 0UL) |
 399                  hopamp->Init.PgaConnect |
 400                  hopamp->Init.PgaGain |
 401                  (hopamp->Init.TrimmingValueP << OPAMP_INPUT_NONINVERTING) |
 402                  (hopamp->Init.TrimmingValueN << OPAMP_INPUT_INVERTING));
 403     }
 404     else /* OPAMP_STANDALONE_MODE */
 405     {
 406       /* Update User Trim config first to be able to modify trimming value afterwards */
 407       MODIFY_REG(hopamp->Instance->CSR,
 408                  OPAMP_CSR_USERTRIM,
 409                  hopamp->Init.UserTrimming);
 410       MODIFY_REG(hopamp->Instance->CSR,
 411                  OPAMP_CSR_UPDATE_PARAMETERS_INIT_MASK,
 412                  hopamp->Init.PowerMode |
 413                  hopamp->Init.Mode |
 414                  hopamp->Init.InvertingInput    |
 415                  hopamp->Init.NonInvertingInput |
 416                  ((hopamp->Init.InternalOutput == ENABLE) ? OPAMP_CSR_OPAMPINTEN : 0UL) |
 417                  hopamp->Init.PgaConnect |
 418                  hopamp->Init.PgaGain |
 419                  (hopamp->Init.TrimmingValueP << OPAMP_INPUT_NONINVERTING) |
 420                  (hopamp->Init.TrimmingValueN << OPAMP_INPUT_INVERTING));
 421     }
 422
 423     if ((READ_BIT(hopamp->Instance->TCMR, OPAMP_TCMR_LOCK)) == 0UL)
 424     {
 425       MODIFY_REG(hopamp->Instance->TCMR,
 426                  OPAMP_TCMR_UPDATE_PARAMETERS_INIT_MASK,
 427                  hopamp->Init.TimerControlledMuxmode |
 428                  hopamp->Init.InvertingInputSecondary  |
 429                  hopamp->Init.NonInvertingInputSecondary);
 430     }
 431
 432     /* Update the OPAMP state*/
 433     if (hopamp->State == HAL_OPAMP_STATE_RESET)
 434     {
 435       /* From RESET state to READY State */
 436       hopamp->State = HAL_OPAMP_STATE_READY;
 437     }
 438     /* else: remain in READY or BUSY state (no update) */
 439
 440     return status;
 441   }
 442 }
 443
 444
 445 /**
 446   * @brief  DeInitializes the OPAMP peripheral
 447   * @note   Deinitialization can't be performed if the OPAMP configuration is locked.
 448   *         To unlock the configuration, perform a system reset.
 449   * @param  hopamp OPAMP handle
 450   * @retval HAL status
 451   */
 452 HAL_StatusTypeDef HAL_OPAMP_DeInit(OPAMP_HandleTypeDef *hopamp)
 453 {
 454   HAL_StatusTypeDef status = HAL_OK;
 455
 456   /* Check the OPAMP handle allocation */
 457   /* DeInit not allowed if calibration is ongoing */
 458   if (hopamp == NULL)
 459   {
 460     status = HAL_ERROR;
 461   }
 462   else if (hopamp->State == HAL_OPAMP_STATE_CALIBBUSY)
 463   {
 464     status = HAL_ERROR;
 465   }
 466   else
 467   {
 468     /* Check the parameter */
 469     assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
 470
 471     /* Set OPAMP_CSR register to reset value */
 472     WRITE_REG(hopamp->Instance->CSR, OPAMP_CSR_RESET_VALUE);
 473
 474     /* DeInit the low level hardware: GPIO, CLOCK and NVIC */
 475     /* When OPAMP is locked, unlocking can be achieved thanks to */
 476     /* __HAL_RCC_SYSCFG_CLK_DISABLE() call within HAL_OPAMP_MspDeInit */
 477     /* Note that __HAL_RCC_SYSCFG_CLK_DISABLE() also disables comparator */
 478
 479 #if (USE_HAL_OPAMP_REGISTER_CALLBACKS == 1)
 480     if (hopamp->MspDeInitCallback == NULL)
 481     {
 482       hopamp->MspDeInitCallback = HAL_OPAMP_MspDeInit;
 483     }
 484     /* DeInit the low level hardware */
 485     hopamp->MspDeInitCallback(hopamp);
 486 #else
 487     HAL_OPAMP_MspDeInit(hopamp);
 488 #endif /* USE_HAL_OPAMP_REGISTER_CALLBACKS */
 489
 490     if (OPAMP_CSR_RESET_VALUE == (hopamp->Instance->CSR & OPAMP_CSR_RESET_CHECK_MASK))
 491     {
 492       /* Update the OPAMP state */
 493       hopamp->State = HAL_OPAMP_STATE_RESET;
 494     }
 495     else /* RESET STATE */
 496     {
 497       /* DeInit not complete */
 498       /* It can be the case if OPAMP was formerly locked */
 499       status = HAL_ERROR;
 500
 501       /* The OPAMP state is NOT updated */
 502     }
 503
 504     /* Process unlocked */
 505     __HAL_UNLOCK(hopamp);
 506   }
 507
 508   return status;
 509 }
 510
 511 /**
 512   * @brief  Initialize the OPAMP MSP.
 513   * @param  hopamp OPAMP handle
 514   * @retval None
 515   */
 516 __weak void HAL_OPAMP_MspInit(OPAMP_HandleTypeDef *hopamp)
 517 {
 518   /* Prevent unused argument(s) compilation warning */
 519   UNUSED(hopamp);
 520
 521   /* NOTE : This function should not be modified, when the callback is needed,
 522             the HAL_OPAMP_MspInit could be implemented in the user file
 523    */
 524
 525   /* Example */
 526 }
 527
 528 /**
 529   * @brief  DeInitialize OPAMP MSP.
 530   * @param  hopamp OPAMP handle
 531   * @retval None
 532   */
 533 __weak void HAL_OPAMP_MspDeInit(OPAMP_HandleTypeDef *hopamp)
 534 {
 535   /* Prevent unused argument(s) compilation warning */
 536   UNUSED(hopamp);
 537
 538   /* NOTE : This function should not be modified, when the callback is needed,
 539             the HAL_OPAMP_MspDeInit could be implemented in the user file
 540    */
 541
 542 }
 543
 544 /**
 545   * @}
 546   */
 547
 548
 549 /** @defgroup OPAMP_Exported_Functions_Group2 Input and Output operation functions
 550   *  @brief   Data transfers functions
 551   *
 552 @verbatim
 553  ===============================================================================
 554                       ##### IO operation functions #####
 555  ===============================================================================
 556     [..]
 557     This subsection provides a set of functions allowing to manage the OPAMP data
 558     transfers.
 559
 560 @endverbatim
 561   * @{
 562   */
 563
 564 /**
 565   * @brief  Start the opamp
 566   * @param  hopamp OPAMP handle
 567   * @retval HAL status
 568   */
 569
 570 HAL_StatusTypeDef HAL_OPAMP_Start(OPAMP_HandleTypeDef *hopamp)
 571 {
 572   HAL_StatusTypeDef status = HAL_OK;
 573
 574   /* Check the OPAMP handle allocation */
 575   /* Check if OPAMP locked */
 576   if (hopamp == NULL)
 577   {
 578     status = HAL_ERROR;
 579   }
 580   else if (hopamp->State == HAL_OPAMP_STATE_BUSYLOCKED)
 581   {
 582     status = HAL_ERROR;
 583   }
 584   else
 585   {
 586     /* Check the parameter */
 587     assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
 588
 589     if (hopamp->State == HAL_OPAMP_STATE_READY)
 590     {
 591       /* Enable the selected opamp */
 592       SET_BIT(hopamp->Instance->CSR, OPAMP_CSR_OPAMPxEN);
 593
 594       /* Update the OPAMP state*/
 595       /* From HAL_OPAMP_STATE_READY to HAL_OPAMP_STATE_BUSY */
 596       hopamp->State = HAL_OPAMP_STATE_BUSY;
 597     }
 598     else
 599     {
 600       status = HAL_ERROR;
 601     }
 602
 603
 604   }
 605   return status;
 606 }
 607
 608 /**
 609   * @brief  Stop the opamp
 610   * @param  hopamp OPAMP handle
 611   * @retval HAL status
 612   */
 613 HAL_StatusTypeDef HAL_OPAMP_Stop(OPAMP_HandleTypeDef *hopamp)
 614 {
 615   HAL_StatusTypeDef status = HAL_OK;
 616
 617   /* Check the OPAMP handle allocation */
 618   /* Check if OPAMP locked */
 619   /* Check if OPAMP calibration ongoing */
 620   if (hopamp == NULL)
 621   {
 622     status = HAL_ERROR;
 623   }
 624   else if (hopamp->State == HAL_OPAMP_STATE_BUSYLOCKED)
 625   {
 626     status = HAL_ERROR;
 627   }
 628   else if (hopamp->State == HAL_OPAMP_STATE_CALIBBUSY)
 629   {
 630     status = HAL_ERROR;
 631   }
 632   else
 633   {
 634     /* Check the parameter */
 635     assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
 636
 637     if (hopamp->State == HAL_OPAMP_STATE_BUSY)
 638     {
 639       /* Disable the selected opamp */
 640       CLEAR_BIT(hopamp->Instance->CSR, OPAMP_CSR_OPAMPxEN);
 641
 642       /* Update the OPAMP state*/
 643       /* From  HAL_OPAMP_STATE_BUSY to HAL_OPAMP_STATE_READY*/
 644       hopamp->State = HAL_OPAMP_STATE_READY;
 645     }
 646     else
 647     {
 648       status = HAL_ERROR;
 649     }
 650   }
 651   return status;
 652 }
 653
 654 /**
 655   * @brief  Run the self calibration of one OPAMP
 656   * @note   Calibration is performed in the mode specified in OPAMP init
 657   *         structure (mode normal or high-speed).
 658   * @param  hopamp handle
 659   * @retval Updated offset trimming values (PMOS & NMOS), user trimming is enabled
 660   * @retval HAL status
 661   * @note   Calibration runs about 25 ms.
 662   */
 663
 664 HAL_StatusTypeDef HAL_OPAMP_SelfCalibrate(OPAMP_HandleTypeDef *hopamp)
 665 {
 666
 667   HAL_StatusTypeDef status = HAL_OK;
 668
 669   uint32_t trimmingvaluen;
 670   uint32_t trimmingvaluep;
 671   uint32_t delta;
 672
 673   /* Check the OPAMP handle allocation */
 674   /* Check if OPAMP locked */
 675   if (hopamp == NULL)
 676   {
 677     status = HAL_ERROR;
 678   }
 679   else if (hopamp->State == HAL_OPAMP_STATE_BUSYLOCKED)
 680   {
 681     status = HAL_ERROR;
 682   }
 683   else
 684   {
 685
 686     /* Check if OPAMP in calibration mode and calibration not yet enable */
 687     if (hopamp->State ==  HAL_OPAMP_STATE_READY)
 688     {
 689       /* Check the parameter */
 690       assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
 691
 692       /* Set Calibration mode */
 693       /* Non-inverting input connected to calibration reference voltage. */
 694       SET_BIT(hopamp->Instance->CSR, OPAMP_CSR_FORCEVP);
 695
 696       /*  user trimming values are used for offset calibration */
 697       SET_BIT(hopamp->Instance->CSR, OPAMP_CSR_USERTRIM);
 698
 699       /* Enable calibration */
 700       SET_BIT(hopamp->Instance->CSR, OPAMP_CSR_CALON);
 701
 702       /* 1st calibration - N */
 703       /* Select 90% VREF */
 704       MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_CALSEL, OPAMP_VREF_90VDDA);
 705
 706       /* Enable the selected opamp */
 707       SET_BIT(hopamp->Instance->CSR, OPAMP_CSR_OPAMPxEN);
 708
 709       /* Init trimming counter */
 710       /* Medium value */
 711       trimmingvaluen = 16UL;
 712       delta = 8UL;
 713
 714       while (delta != 0UL)
 715       {
 716         /* Set candidate trimming */
 717         MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_TRIMOFFSETN, trimmingvaluen << OPAMP_INPUT_INVERTING);
 718
 719         /* OFFTRIMmax delay 2 ms as per datasheet (electrical characteristics */
 720         /* Offset trim time: during calibration, minimum time needed between */
 721         /* two steps to have 1 mV accuracy */
 722         HAL_Delay(2);
 723
 724         if ((hopamp->Instance->CSR & OPAMP_CSR_OUTCAL) != 0UL)
 725         {
 726           /* OPAMP_CSR_OUTCAL is HIGH try higher trimming */
 727           trimmingvaluen += delta;
 728         }
 729         else
 730         {
 731           /* OPAMP_CSR_OUTCAL is LOW try lower trimming */
 732           trimmingvaluen -= delta;
 733         }
 734
 735         delta >>= 1;
 736       }
 737
 738       /* Still need to check if righ calibration is current value or un step below */
 739       /* Indeed the first value that causes the OUTCAL bit to change from 1 to 0  */
 740       MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_TRIMOFFSETN, trimmingvaluen << OPAMP_INPUT_INVERTING);
 741
 742       /* OFFTRIMmax delay 2 ms as per datasheet (electrical characteristics */
 743       /* Offset trim time: during calibration, minimum time needed between */
 744       /* two steps to have 1 mV accuracy */
 745       HAL_Delay(2);
 746
 747       if ((hopamp->Instance->CSR & OPAMP_CSR_OUTCAL) != 0UL)
 748       {
 749         /* OPAMP_CSR_OUTCAL is actually one value more */
 750         trimmingvaluen++;
 751         /* Set right trimming */
 752         MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_TRIMOFFSETN, trimmingvaluen << OPAMP_INPUT_INVERTING);
 753       }
 754
 755       /* 2nd calibration - P */
 756       /* Select 10% VREF */
 757       MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_CALSEL, OPAMP_VREF_10VDDA);
 758
 759       /* Init trimming counter */
 760       /* Medium value */
 761       trimmingvaluep = 16UL;
 762       delta = 8UL;
 763
 764       while (delta != 0UL)
 765       {
 766         /* Set candidate trimming */
 767         MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_TRIMOFFSETP, trimmingvaluep << OPAMP_INPUT_NONINVERTING);
 768
 769         /* OFFTRIMmax delay 2 ms as per datasheet (electrical characteristics */
 770         /* Offset trim time: during calibration, minimum time needed between */
 771         /* two steps to have 1 mV accuracy */
 772         HAL_Delay(2);
 773
 774         if ((hopamp->Instance->CSR & OPAMP_CSR_OUTCAL) != 0UL)
 775         {
 776           /* OPAMP_CSR_OUTCAL is HIGH try higher trimming */
 777           trimmingvaluep += delta;
 778         }
 779         else
 780         {
 781           trimmingvaluep -= delta;
 782         }
 783
 784         delta >>= 1;
 785       }
 786
 787       /* Still need to check if righ calibration is current value or un step below */
 788       /* Indeed the first value that causes the OUTCAL bit to change from 1 to 0U */
 789       /* Set candidate trimming */
 790       MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_TRIMOFFSETP, trimmingvaluep << OPAMP_INPUT_NONINVERTING);
 791
 792       /* OFFTRIMmax delay 2 ms as per datasheet (electrical characteristics */
 793       /* Offset trim time: during calibration, minimum time needed between */
 794       /* two steps to have 1 mV accuracy */
 795       HAL_Delay(2);
 796
 797       if ((hopamp->Instance->CSR & OPAMP_CSR_OUTCAL) != 0UL)
 798       {
 799         /* OPAMP_CSR_OUTCAL is actually one value more */
 800         trimmingvaluep++;
 801         /* Set right trimming */
 802         MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_TRIMOFFSETP, trimmingvaluep << OPAMP_INPUT_NONINVERTING);
 803       }
 804
 805       /* Disable calibration */
 806       CLEAR_BIT(hopamp->Instance->CSR, OPAMP_CSR_CALON);
 807
 808       /* Disable the OPAMP */
 809       CLEAR_BIT(hopamp->Instance->CSR, OPAMP_CSR_OPAMPxEN);
 810
 811       /* Set operating mode  */
 812       /* Non-inverting input connected to calibration reference voltage. */
 813       CLEAR_BIT(hopamp->Instance->CSR, OPAMP_CSR_FORCEVP);
 814
 815       /* Self calibration is successful  */
 816       /* Store calibration(user timming) results in init structure. */
 817
 818       /* Write calibration result N */
 819       hopamp->Init.TrimmingValueN = trimmingvaluen;
 820
 821       /* Write calibration result P */
 822       hopamp->Init.TrimmingValueP = trimmingvaluep;
 823
 824       /* Select user timming mode */
 825       /* And updated with calibrated settings */
 826       hopamp->Init.UserTrimming = OPAMP_TRIMMING_USER;
 827       MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_TRIMOFFSETP, trimmingvaluep << OPAMP_INPUT_NONINVERTING);
 828       MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_TRIMOFFSETN, trimmingvaluen << OPAMP_INPUT_INVERTING);
 829     }
 830
 831     else
 832     {
 833       /* OPAMP can not be calibrated from this mode */
 834       status = HAL_ERROR;
 835     }
 836   }
 837   return status;
 838 }
 839
 840 /**
 841   * @}
 842   */
 843
 844 /** @defgroup OPAMP_Exported_Functions_Group3 Peripheral Control functions
 845   *  @brief   Peripheral Control functions
 846   *
 847 @verbatim
 848  ===============================================================================
 849                       ##### Peripheral Control functions #####
 850  ===============================================================================
 851     [..]
 852     This subsection provides a set of functions allowing to control the OPAMP data
 853     transfers.
 854
 855
 856
 857 @endverbatim
 858   * @{
 859   */
 860
 861 /**
 862   * @brief  Lock the selected opamp configuration.
 863   * @param  hopamp OPAMP handle
 864   * @retval HAL status
 865   */
 866 HAL_StatusTypeDef HAL_OPAMP_Lock(OPAMP_HandleTypeDef *hopamp)
 867 {
 868   HAL_StatusTypeDef status = HAL_OK;
 869
 870   /* Check the OPAMP handle allocation */
 871   /* Check if OPAMP locked */
 872   /* OPAMP can be locked when enabled and running in normal mode */
 873   /*   It is meaningless otherwise */
 874   if (hopamp == NULL)
 875   {
 876     status = HAL_ERROR;
 877   }
 878   else if (hopamp->State != HAL_OPAMP_STATE_BUSY)
 879   {
 880     status = HAL_ERROR;
 881   }
 882   else
 883   {
 884     /* Check the parameter */
 885     assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
 886
 887     /* Lock OPAMP */
 888     SET_BIT(hopamp->Instance->CSR, OPAMP_CSR_LOCK);
 889
 890     /* OPAMP state changed to locked */
 891     hopamp->State = HAL_OPAMP_STATE_BUSYLOCKED;
 892   }
 893   return status;
 894 }
 895
 896 /**
 897   * @}
 898   */
 899
 900 /**
 901   * @brief  Lock the selected opamp timer controlled mux configuration.
 902   * @param  hopamp OPAMP handle
 903   * @retval HAL status
 904   */
 905 HAL_StatusTypeDef HAL_OPAMP_LockTimerMux(OPAMP_HandleTypeDef *hopamp)
 906 {
 907   HAL_StatusTypeDef status = HAL_OK;
 908
 909   /* Check the OPAMP handle allocation                     */
 910   /* Check if OPAMP timer controlled mux is locked         */
 911   /* OPAMP timer controlled mux can be locked when enabled */
 912   /*   It is meaningless otherwise */
 913   if (hopamp == NULL)
 914   {
 915     status = HAL_ERROR;
 916   }
 917   else if (hopamp->State == HAL_OPAMP_STATE_RESET)
 918   {
 919     status = HAL_ERROR;
 920   }
 921   else if (READ_BIT(hopamp->Instance->TCMR, OPAMP_TCMR_LOCK) == OPAMP_TCMR_LOCK)
 922   {
 923     status = HAL_ERROR;
 924   }
 925   else
 926   {
 927     /* Check the parameter */
 928     assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
 929
 930     /* Lock OPAMP */
 931     SET_BIT(hopamp->Instance->TCMR, OPAMP_TCMR_LOCK);
 932   }
 933   return status;
 934 }
 935
 936 /**
 937   * @}
 938   */
 939
 940 /** @defgroup OPAMP_Exported_Functions_Group4 Peripheral State functions
 941   *  @brief   Peripheral State functions
 942   *
 943 @verbatim
 944  ===============================================================================
 945                       ##### Peripheral State functions #####
 946  ===============================================================================
 947     [..]
 948     This subsection permit to get in run-time the status of the peripheral
 949     and the data flow.
 950
 951 @endverbatim
 952   * @{
 953   */
 954
 955 /**
 956   * @brief  Return the OPAMP state
 957   * @param  hopamp OPAMP handle
 958   * @retval HAL state
 959   */
 960 HAL_OPAMP_StateTypeDef HAL_OPAMP_GetState(OPAMP_HandleTypeDef *hopamp)
 961 {
 962   /* Check the OPAMP handle allocation */
 963   if (hopamp == NULL)
 964   {
 965     return HAL_OPAMP_STATE_RESET;
 966   }
 967
 968   /* Check the parameter */
 969   assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
 970
 971   return hopamp->State;
 972 }
 973
 974 /**
 975   * @brief  Return the OPAMP factory trimming value
 976   * @param  hopamp OPAMP handle
 977   * @param  trimmingoffset Trimming offset (P or N)
 978   * @retval Trimming value (P or N): range: 0->31
 979   *         or OPAMP_FACTORYTRIMMING_DUMMY if trimming value is not available
 980  */
 981
 982 OPAMP_TrimmingValueTypeDef HAL_OPAMP_GetTrimOffset(OPAMP_HandleTypeDef *hopamp, uint32_t trimmingoffset)
 983 {
 984   uint32_t oldusertrimming = 0UL;
 985   OPAMP_TrimmingValueTypeDef  oldtrimmingvaluep = 0UL, oldtrimmingvaluen = 0UL, trimmingvalue;
 986
 987   /* Check the OPAMP handle allocation */
 988   /* Value can be retrieved in HAL_OPAMP_STATE_READY state */
 989   if (hopamp == NULL)
 990   {
 991     return OPAMP_FACTORYTRIMMING_DUMMY;
 992   }
 993   else if (hopamp->State != HAL_OPAMP_STATE_READY)
 994   {
 995     return OPAMP_FACTORYTRIMMING_DUMMY;
 996   }
 997   else
 998   {
 999     /* Check the parameter */
1000     assert_param(IS_OPAMP_ALL_INSTANCE(hopamp->Instance));
1001     assert_param(IS_OPAMP_FACTORYTRIMMING(trimmingoffset));
1002
1003     /* Check the trimming mode */
1004     if ((READ_BIT(hopamp->Instance->CSR, OPAMP_CSR_USERTRIM)) != 0UL)
1005     {
1006       /* User trimming is used */
1007       oldusertrimming = OPAMP_TRIMMING_USER;
1008       /* Store the TrimmingValueP & TrimmingValueN */
1009       oldtrimmingvaluep = (hopamp->Instance->CSR & OPAMP_CSR_TRIMOFFSETP) >> OPAMP_INPUT_NONINVERTING;
1010       oldtrimmingvaluen = (hopamp->Instance->CSR & OPAMP_CSR_TRIMOFFSETN) >> OPAMP_INPUT_INVERTING;
1011     }
1012
1013     /* Set factory timming mode */
1014     CLEAR_BIT(hopamp->Instance->CSR, OPAMP_CSR_USERTRIM);
1015
1016     /* Get factory trimming  */
1017     if (trimmingoffset == OPAMP_FACTORYTRIMMING_P)
1018     {
1019       /* Return TrimOffsetP */
1020       trimmingvalue = ((hopamp->Instance->CSR & OPAMP_CSR_TRIMOFFSETP) >> OPAMP_INPUT_NONINVERTING);
1021     }
1022     else
1023     {
1024       /* Return TrimOffsetN */
1025       trimmingvalue = ((hopamp->Instance->CSR & OPAMP_CSR_TRIMOFFSETN) >> OPAMP_INPUT_INVERTING);
1026     }
1027
1028     /* Restore user trimming configuration if it was formerly set */
1029     /* Check if user trimming was used */
1030     if (oldusertrimming == OPAMP_TRIMMING_USER)
1031     {
1032       /* Restore user trimming */
1033       SET_BIT(hopamp->Instance->CSR, OPAMP_CSR_USERTRIM);
1034       MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_TRIMOFFSETP, oldtrimmingvaluep << OPAMP_INPUT_NONINVERTING);
1035       MODIFY_REG(hopamp->Instance->CSR, OPAMP_CSR_TRIMOFFSETN, oldtrimmingvaluen << OPAMP_INPUT_INVERTING);
1036     }
1037   }
1038   return trimmingvalue;
1039 }
1040 /**
1041   * @}
1042   */
1043
1044 #if (USE_HAL_OPAMP_REGISTER_CALLBACKS == 1)
1045 /**
1046   * @brief  Register a User OPAMP Callback
1047   *         To be used instead of the weak (surcharged) predefined callback
1048   * @param hopamp : OPAMP handle
1049   * @param CallbackID : ID of the callback to be registered
1050   *        This parameter can be one of the following values:
1051   *          @arg @ref HAL_OPAMP_MSP_INIT_CB_ID       OPAMP MspInit callback ID
1052   *          @arg @ref HAL_OPAMP_MSP_DEINIT_CB_ID     OPAMP MspDeInit callback ID
1053   * @param pCallback : pointer to the Callback function
1054   * @retval status
1055   */
1056 HAL_StatusTypeDef HAL_OPAMP_RegisterCallback(OPAMP_HandleTypeDef *hopamp, HAL_OPAMP_CallbackIDTypeDef CallbackId,
1057                                              pOPAMP_CallbackTypeDef pCallback)
1058 {
1059   HAL_StatusTypeDef status = HAL_OK;
1060
1061   if (pCallback == NULL)
1062   {
1063     return HAL_ERROR;
1064   }
1065
1066   /* Process locked */
1067   __HAL_LOCK(hopamp);
1068
1069   if (hopamp->State == HAL_OPAMP_STATE_READY)
1070   {
1071     switch (CallbackId)
1072     {
1073       case HAL_OPAMP_MSP_INIT_CB_ID :
1074         hopamp->MspInitCallback = pCallback;
1075         break;
1076       case HAL_OPAMP_MSP_DEINIT_CB_ID :
1077         hopamp->MspDeInitCallback = pCallback;
1078         break;
1079       default :
1080         /* update return status */
1081         status =  HAL_ERROR;
1082         break;
1083     }
1084   }
1085   else if (hopamp->State == HAL_OPAMP_STATE_RESET)
1086   {
1087     switch (CallbackId)
1088     {
1089       case HAL_OPAMP_MSP_INIT_CB_ID :
1090         hopamp->MspInitCallback = pCallback;
1091         break;
1092       case HAL_OPAMP_MSP_DEINIT_CB_ID :
1093         hopamp->MspDeInitCallback = pCallback;
1094         break;
1095       default :
1096         /* update return status */
1097         status =  HAL_ERROR;
1098         break;
1099     }
1100   }
1101   else
1102   {
1103     /* update return status */
1104     status =  HAL_ERROR;
1105   }
1106
1107   /* Release Lock */
1108   __HAL_UNLOCK(hopamp);
1109   return status;
1110 }
1111
1112 /**
1113   * @brief  Unregister a User OPAMP Callback
1114   *         OPAMP Callback is redirected to the weak (surcharged) predefined callback
1115   * @param hopamp : OPAMP handle
1116   * @param CallbackID : ID of the callback to be unregistered
1117   *        This parameter can be one of the following values:
1118   *          @arg @ref HAL_OPAMP_MSP_INIT_CB_ID              OPAMP MSP Init Callback ID
1119   *          @arg @ref HAL_OPAMP_MSP_DEINIT_CB_ID            OPAMP MSP DeInit Callback ID
1120   *          @arg @ref HAL_OPAMP_ALL_CB_ID                   OPAMP All Callbacks
1121   * @retval status
1122   */
1123
1124 HAL_StatusTypeDef HAL_OPAMP_UnRegisterCallback(OPAMP_HandleTypeDef *hopamp, HAL_OPAMP_CallbackIDTypeDef CallbackId)
1125 {
1126   HAL_StatusTypeDef status = HAL_OK;
1127
1128   /* Process locked */
1129   __HAL_LOCK(hopamp);
1130
1131   if (hopamp->State == HAL_OPAMP_STATE_READY)
1132   {
1133     switch (CallbackId)
1134     {
1135       case HAL_OPAMP_MSP_INIT_CB_ID :
1136         hopamp->MspInitCallback = HAL_OPAMP_MspInit;
1137         break;
1138       case HAL_OPAMP_MSP_DEINIT_CB_ID :
1139         hopamp->MspDeInitCallback = HAL_OPAMP_MspDeInit;
1140         break;
1141       case HAL_OPAMP_ALL_CB_ID :
1142         hopamp->MspInitCallback = HAL_OPAMP_MspInit;
1143         hopamp->MspDeInitCallback = HAL_OPAMP_MspDeInit;
1144         break;
1145       default :
1146         /* update return status */
1147         status =  HAL_ERROR;
1148         break;
1149     }
1150   }
1151   else if (hopamp->State == HAL_OPAMP_STATE_RESET)
1152   {
1153     switch (CallbackId)
1154     {
1155       case HAL_OPAMP_MSP_INIT_CB_ID :
1156         hopamp->MspInitCallback = HAL_OPAMP_MspInit;
1157         break;
1158       case HAL_OPAMP_MSP_DEINIT_CB_ID :
1159         hopamp->MspDeInitCallback = HAL_OPAMP_MspDeInit;
1160         break;
1161       default :
1162         /* update return status */
1163         status =  HAL_ERROR;
1164         break;
1165     }
1166   }
1167   else
1168   {
1169     /* update return status */
1170     status =  HAL_ERROR;
1171   }
1172
1173   /* Release Lock */
1174   __HAL_UNLOCK(hopamp);
1175   return status;
1176 }
1177
1178 #endif /* USE_HAL_OPAMP_REGISTER_CALLBACKS */
1179
1180 /**
1181   * @}
1182   */
1183
1184 /**
1185   * @}
1186   */
1187
1188 #endif /* HAL_OPAMP_MODULE_ENABLED */
1189 /**
1190   * @}
1191   */
1192
1193
1194
1195 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/