Subversion Repositories AFRtranscoder

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /**
  2.   ******************************************************************************
  3.   * @file    stm32f1xx_hal_exti.c
  4.   * @author  MCD Application Team
  5.   * @brief   EXTI HAL module driver.
  6.   *          This file provides firmware functions to manage the following
  7.   *          functionalities of the Extended Interrupts and events controller (EXTI) peripheral:
  8.   *           + Initialization and de-initialization functions
  9.   *           + IO operation functions
  10.   *
  11.   ******************************************************************************
  12.   * @attention
  13.   *
  14.   * Copyright (c) 2019 STMicroelectronics.
  15.   * All rights reserved.
  16.   *
  17.   * This software is licensed under terms that can be found in the LICENSE file
  18.   * in the root directory of this software component.
  19.   * If no LICENSE file comes with this software, it is provided AS-IS.
  20.   *
  21.   ******************************************************************************
  22.   @verbatim
  23.   ==============================================================================
  24.                     ##### EXTI Peripheral features #####
  25.   ==============================================================================
  26.   [..]
  27.     (+) Each Exti line can be configured within this driver.
  28.  
  29.     (+) Exti line can be configured in 3 different modes
  30.         (++) Interrupt
  31.         (++) Event
  32.         (++) Both of them
  33.  
  34.     (+) Configurable Exti lines can be configured with 3 different triggers
  35.         (++) Rising
  36.         (++) Falling
  37.         (++) Both of them
  38.  
  39.     (+) When set in interrupt mode, configurable Exti lines have two different
  40.         interrupts pending registers which allow to distinguish which transition
  41.         occurs:
  42.         (++) Rising edge pending interrupt
  43.         (++) Falling
  44.  
  45.     (+) Exti lines 0 to 15 are linked to gpio pin number 0 to 15. Gpio port can
  46.         be selected through multiplexer.
  47.  
  48.                      ##### How to use this driver #####
  49.   ==============================================================================
  50.   [..]
  51.  
  52.     (#) Configure the EXTI line using HAL_EXTI_SetConfigLine().
  53.         (++) Choose the interrupt line number by setting "Line" member from
  54.              EXTI_ConfigTypeDef structure.
  55.         (++) Configure the interrupt and/or event mode using "Mode" member from
  56.              EXTI_ConfigTypeDef structure.
  57.         (++) For configurable lines, configure rising and/or falling trigger
  58.              "Trigger" member from EXTI_ConfigTypeDef structure.
  59.         (++) For Exti lines linked to gpio, choose gpio port using "GPIOSel"
  60.              member from GPIO_InitTypeDef structure.
  61.  
  62.     (#) Get current Exti configuration of a dedicated line using
  63.         HAL_EXTI_GetConfigLine().
  64.         (++) Provide exiting handle as parameter.
  65.         (++) Provide pointer on EXTI_ConfigTypeDef structure as second parameter.
  66.  
  67.     (#) Clear Exti configuration of a dedicated line using HAL_EXTI_ClearConfigLine().
  68.         (++) Provide exiting handle as parameter.
  69.  
  70.     (#) Register callback to treat Exti interrupts using HAL_EXTI_RegisterCallback().
  71.         (++) Provide exiting handle as first parameter.
  72.         (++) Provide which callback will be registered using one value from
  73.              EXTI_CallbackIDTypeDef.
  74.         (++) Provide callback function pointer.
  75.  
  76.     (#) Get interrupt pending bit using HAL_EXTI_GetPending().
  77.  
  78.     (#) Clear interrupt pending bit using HAL_EXTI_ClearPending().
  79.  
  80.     (#) Generate software interrupt using HAL_EXTI_GenerateSWI().
  81.  
  82.   @endverbatim
  83.   */
  84.  
  85. /* Includes ------------------------------------------------------------------*/
  86. #include "stm32f1xx_hal.h"
  87.  
  88. /** @addtogroup STM32F1xx_HAL_Driver
  89.   * @{
  90.   */
  91.  
  92. /** @addtogroup EXTI
  93.   * @{
  94.   */
  95. /** MISRA C:2012 deviation rule has been granted for following rule:
  96.   * Rule-18.1_b - Medium: Array `EXTICR' 1st subscript interval [0,7] may be out
  97.   * of bounds [0,3] in following API :
  98.   * HAL_EXTI_SetConfigLine
  99.   * HAL_EXTI_GetConfigLine
  100.   * HAL_EXTI_ClearConfigLine
  101.   */
  102.  
  103. #ifdef HAL_EXTI_MODULE_ENABLED
  104.  
  105. /* Private typedef -----------------------------------------------------------*/
  106. /* Private defines -----------------------------------------------------------*/
  107. /** @defgroup EXTI_Private_Constants EXTI Private Constants
  108.   * @{
  109.   */
  110.  
  111. /**
  112.   * @}
  113.   */
  114.  
  115. /* Private macros ------------------------------------------------------------*/
  116. /* Private variables ---------------------------------------------------------*/
  117. /* Private function prototypes -----------------------------------------------*/
  118. /* Exported functions --------------------------------------------------------*/
  119.  
  120. /** @addtogroup EXTI_Exported_Functions
  121.   * @{
  122.   */
  123.  
  124. /** @addtogroup EXTI_Exported_Functions_Group1
  125.   *  @brief    Configuration functions
  126.   *
  127. @verbatim
  128.  ===============================================================================
  129.               ##### Configuration functions #####
  130.  ===============================================================================
  131.  
  132. @endverbatim
  133.   * @{
  134.   */
  135.  
  136. /**
  137.   * @brief  Set configuration of a dedicated Exti line.
  138.   * @param  hexti Exti handle.
  139.   * @param  pExtiConfig Pointer on EXTI configuration to be set.
  140.   * @retval HAL Status.
  141.   */
  142. HAL_StatusTypeDef HAL_EXTI_SetConfigLine(EXTI_HandleTypeDef *hexti, EXTI_ConfigTypeDef *pExtiConfig)
  143. {
  144.   uint32_t regval;
  145.   uint32_t linepos;
  146.   uint32_t maskline;
  147.  
  148.   /* Check null pointer */
  149.   if ((hexti == NULL) || (pExtiConfig == NULL))
  150.   {
  151.     return HAL_ERROR;
  152.   }
  153.  
  154.   /* Check parameters */
  155.   assert_param(IS_EXTI_LINE(pExtiConfig->Line));
  156.   assert_param(IS_EXTI_MODE(pExtiConfig->Mode));
  157.  
  158.   /* Assign line number to handle */
  159.   hexti->Line = pExtiConfig->Line;
  160.  
  161.   /* Compute line mask */
  162.   linepos = (pExtiConfig->Line & EXTI_PIN_MASK);
  163.   maskline = (1uL << linepos);
  164.  
  165.   /* Configure triggers for configurable lines */
  166.   if ((pExtiConfig->Line & EXTI_CONFIG) != 0x00u)
  167.   {
  168.     assert_param(IS_EXTI_TRIGGER(pExtiConfig->Trigger));
  169.  
  170.     /* Configure rising trigger */
  171.     /* Mask or set line */
  172.     if ((pExtiConfig->Trigger & EXTI_TRIGGER_RISING) != 0x00u)
  173.     {
  174.       EXTI->RTSR |= maskline;
  175.     }
  176.     else
  177.     {
  178.       EXTI->RTSR &= ~maskline;
  179.     }
  180.  
  181.     /* Configure falling trigger */
  182.     /* Mask or set line */
  183.     if ((pExtiConfig->Trigger & EXTI_TRIGGER_FALLING) != 0x00u)
  184.     {
  185.       EXTI->FTSR |= maskline;
  186.     }
  187.     else
  188.     {
  189.       EXTI->FTSR &= ~maskline;
  190.     }
  191.  
  192.  
  193.     /* Configure gpio port selection in case of gpio exti line */
  194.     if ((pExtiConfig->Line & EXTI_GPIO) == EXTI_GPIO)
  195.     {
  196.       assert_param(IS_EXTI_GPIO_PORT(pExtiConfig->GPIOSel));
  197.       assert_param(IS_EXTI_GPIO_PIN(linepos));
  198.      
  199.       regval = AFIO->EXTICR[linepos >> 2u];
  200.       regval &= ~(AFIO_EXTICR1_EXTI0 << (AFIO_EXTICR1_EXTI1_Pos * (linepos & 0x03u)));
  201.       regval |= (pExtiConfig->GPIOSel << (AFIO_EXTICR1_EXTI1_Pos * (linepos & 0x03u)));
  202.       AFIO->EXTICR[linepos >> 2u] = regval;
  203.     }
  204.   }
  205.  
  206.   /* Configure interrupt mode : read current mode */
  207.   /* Mask or set line */
  208.   if ((pExtiConfig->Mode & EXTI_MODE_INTERRUPT) != 0x00u)
  209.   {
  210.     EXTI->IMR |= maskline;
  211.   }
  212.   else
  213.   {
  214.     EXTI->IMR &= ~maskline;
  215.   }
  216.  
  217.   /* Configure event mode : read current mode */
  218.   /* Mask or set line */
  219.   if ((pExtiConfig->Mode & EXTI_MODE_EVENT) != 0x00u)
  220.   {
  221.     EXTI->EMR |= maskline;
  222.   }
  223.   else
  224.   {
  225.     EXTI->EMR &= ~maskline;
  226.   }
  227.  
  228.   return HAL_OK;
  229. }
  230.  
  231. /**
  232.   * @brief  Get configuration of a dedicated Exti line.
  233.   * @param  hexti Exti handle.
  234.   * @param  pExtiConfig Pointer on structure to store Exti configuration.
  235.   * @retval HAL Status.
  236.   */
  237. HAL_StatusTypeDef HAL_EXTI_GetConfigLine(EXTI_HandleTypeDef *hexti, EXTI_ConfigTypeDef *pExtiConfig)
  238. {
  239.   uint32_t regval;
  240.   uint32_t linepos;
  241.   uint32_t maskline;
  242.  
  243.   /* Check null pointer */
  244.   if ((hexti == NULL) || (pExtiConfig == NULL))
  245.   {
  246.     return HAL_ERROR;
  247.   }
  248.  
  249.   /* Check the parameter */
  250.   assert_param(IS_EXTI_LINE(hexti->Line));
  251.  
  252.   /* Store handle line number to configuration structure */
  253.   pExtiConfig->Line = hexti->Line;
  254.  
  255.   /* Compute line mask */
  256.   linepos = (pExtiConfig->Line & EXTI_PIN_MASK);
  257.   maskline = (1uL << linepos);
  258.  
  259.   /* 1] Get core mode : interrupt */
  260.  
  261.   /* Check if selected line is enable */
  262.   if ((EXTI->IMR & maskline) != 0x00u)
  263.   {
  264.     pExtiConfig->Mode = EXTI_MODE_INTERRUPT;
  265.   }
  266.   else
  267.   {
  268.     pExtiConfig->Mode = EXTI_MODE_NONE;
  269.   }
  270.  
  271.   /* Get event mode */
  272.   /* Check if selected line is enable */
  273.   if ((EXTI->EMR & maskline) != 0x00u)
  274.   {
  275.     pExtiConfig->Mode |= EXTI_MODE_EVENT;
  276.   }
  277.  
  278.   /* Get default Trigger and GPIOSel configuration */
  279.   pExtiConfig->Trigger = EXTI_TRIGGER_NONE;
  280.   pExtiConfig->GPIOSel = 0x00u;
  281.  
  282.   /* 2] Get trigger for configurable lines : rising */
  283.   if ((pExtiConfig->Line & EXTI_CONFIG) != 0x00u)
  284.   {
  285.     /* Check if configuration of selected line is enable */
  286.     if ((EXTI->RTSR & maskline) != 0x00u)
  287.     {
  288.       pExtiConfig->Trigger = EXTI_TRIGGER_RISING;
  289.     }
  290.  
  291.     /* Get falling configuration */
  292.     /* Check if configuration of selected line is enable */
  293.     if ((EXTI->FTSR & maskline) != 0x00u)
  294.     {
  295.       pExtiConfig->Trigger |= EXTI_TRIGGER_FALLING;
  296.     }
  297.  
  298.     /* Get Gpio port selection for gpio lines */
  299.     if ((pExtiConfig->Line & EXTI_GPIO) == EXTI_GPIO)
  300.     {
  301.       assert_param(IS_EXTI_GPIO_PIN(linepos));
  302.  
  303.       regval = AFIO->EXTICR[linepos >> 2u];
  304.       pExtiConfig->GPIOSel = (regval >> (AFIO_EXTICR1_EXTI1_Pos * (linepos & 0x03u))) & AFIO_EXTICR1_EXTI0;
  305.     }
  306.   }
  307.  
  308.   return HAL_OK;
  309. }
  310.  
  311. /**
  312.   * @brief  Clear whole configuration of a dedicated Exti line.
  313.   * @param  hexti Exti handle.
  314.   * @retval HAL Status.
  315.   */
  316. HAL_StatusTypeDef HAL_EXTI_ClearConfigLine(EXTI_HandleTypeDef *hexti)
  317. {
  318.   uint32_t regval;
  319.   uint32_t linepos;
  320.   uint32_t maskline;
  321.  
  322.   /* Check null pointer */
  323.   if (hexti == NULL)
  324.   {
  325.     return HAL_ERROR;
  326.   }
  327.  
  328.   /* Check the parameter */
  329.   assert_param(IS_EXTI_LINE(hexti->Line));
  330.  
  331.   /* compute line mask */
  332.   linepos = (hexti->Line & EXTI_PIN_MASK);
  333.   maskline = (1uL << linepos);
  334.  
  335.   /* 1] Clear interrupt mode */
  336.   EXTI->IMR = (EXTI->IMR & ~maskline);
  337.  
  338.   /* 2] Clear event mode */
  339.   EXTI->EMR = (EXTI->EMR & ~maskline);
  340.  
  341.   /* 3] Clear triggers in case of configurable lines */
  342.   if ((hexti->Line & EXTI_CONFIG) != 0x00u)
  343.   {
  344.     EXTI->RTSR = (EXTI->RTSR & ~maskline);
  345.     EXTI->FTSR = (EXTI->FTSR & ~maskline);
  346.  
  347.     /* Get Gpio port selection for gpio lines */
  348.     if ((hexti->Line & EXTI_GPIO) == EXTI_GPIO)
  349.     {
  350.       assert_param(IS_EXTI_GPIO_PIN(linepos));
  351.  
  352.       regval = AFIO->EXTICR[linepos >> 2u];
  353.       regval &= ~(AFIO_EXTICR1_EXTI0 << (AFIO_EXTICR1_EXTI1_Pos * (linepos & 0x03u)));
  354.       AFIO->EXTICR[linepos >> 2u] = regval;
  355.     }
  356.   }
  357.  
  358.   return HAL_OK;
  359. }
  360.  
  361. /**
  362.   * @brief  Register callback for a dedicated Exti line.
  363.   * @param  hexti Exti handle.
  364.   * @param  CallbackID User callback identifier.
  365.   *         This parameter can be one of @arg @ref EXTI_CallbackIDTypeDef values.
  366.   * @param  pPendingCbfn function pointer to be stored as callback.
  367.   * @retval HAL Status.
  368.   */
  369. HAL_StatusTypeDef HAL_EXTI_RegisterCallback(EXTI_HandleTypeDef *hexti, EXTI_CallbackIDTypeDef CallbackID, void (*pPendingCbfn)(void))
  370. {
  371.   HAL_StatusTypeDef status = HAL_OK;
  372.  
  373.   switch (CallbackID)
  374.   {
  375.     case  HAL_EXTI_COMMON_CB_ID:
  376.       hexti->PendingCallback = pPendingCbfn;
  377.       break;
  378.  
  379.     default:
  380.       status = HAL_ERROR;
  381.       break;
  382.   }
  383.  
  384.   return status;
  385. }
  386.  
  387. /**
  388.   * @brief  Store line number as handle private field.
  389.   * @param  hexti Exti handle.
  390.   * @param  ExtiLine Exti line number.
  391.   *         This parameter can be from 0 to @ref EXTI_LINE_NB.
  392.   * @retval HAL Status.
  393.   */
  394. HAL_StatusTypeDef HAL_EXTI_GetHandle(EXTI_HandleTypeDef *hexti, uint32_t ExtiLine)
  395. {
  396.   /* Check the parameters */
  397.   assert_param(IS_EXTI_LINE(ExtiLine));
  398.  
  399.   /* Check null pointer */
  400.   if (hexti == NULL)
  401.   {
  402.     return HAL_ERROR;
  403.   }
  404.   else
  405.   {
  406.     /* Store line number as handle private field */
  407.     hexti->Line = ExtiLine;
  408.  
  409.     return HAL_OK;
  410.   }
  411. }
  412.  
  413. /**
  414.   * @}
  415.   */
  416.  
  417. /** @addtogroup EXTI_Exported_Functions_Group2
  418.   *  @brief EXTI IO functions.
  419.   *
  420. @verbatim
  421.  ===============================================================================
  422.                        ##### IO operation functions #####
  423.  ===============================================================================
  424.  
  425. @endverbatim
  426.   * @{
  427.   */
  428.  
  429. /**
  430.   * @brief  Handle EXTI interrupt request.
  431.   * @param  hexti Exti handle.
  432.   * @retval none.
  433.   */
  434. void HAL_EXTI_IRQHandler(EXTI_HandleTypeDef *hexti)
  435. {
  436.   uint32_t regval;
  437.   uint32_t maskline;
  438.  
  439.   /* Compute line mask */
  440.   maskline = (1uL << (hexti->Line & EXTI_PIN_MASK));
  441.  
  442.   /* Get pending bit  */
  443.   regval = (EXTI->PR & maskline);
  444.   if (regval != 0x00u)
  445.   {
  446.     /* Clear pending bit */
  447.     EXTI->PR = maskline;
  448.  
  449.     /* Call callback */
  450.     if (hexti->PendingCallback != NULL)
  451.     {
  452.       hexti->PendingCallback();
  453.     }
  454.   }
  455. }
  456.  
  457. /**
  458.   * @brief  Get interrupt pending bit of a dedicated line.
  459.   * @param  hexti Exti handle.
  460.   * @param  Edge Specify which pending edge as to be checked.
  461.   *         This parameter can be one of the following values:
  462.   *           @arg @ref EXTI_TRIGGER_RISING_FALLING
  463.   *         This parameter is kept for compatibility with other series.
  464.   * @retval 1 if interrupt is pending else 0.
  465.   */
  466. uint32_t HAL_EXTI_GetPending(EXTI_HandleTypeDef *hexti, uint32_t Edge)
  467. {
  468.   uint32_t regval;
  469.   uint32_t maskline;
  470.   uint32_t linepos;
  471.  
  472.   /* Check parameters */
  473.   assert_param(IS_EXTI_LINE(hexti->Line));
  474.   assert_param(IS_EXTI_CONFIG_LINE(hexti->Line));
  475.   assert_param(IS_EXTI_PENDING_EDGE(Edge));
  476.  
  477.   /* Prevent unused argument compilation warning */
  478.   UNUSED(Edge);
  479.  
  480.   /* Compute line mask */
  481.   linepos = (hexti->Line & EXTI_PIN_MASK);
  482.   maskline = (1uL << linepos);
  483.  
  484.   /* return 1 if bit is set else 0 */
  485.   regval = ((EXTI->PR & maskline) >> linepos);
  486.   return regval;
  487. }
  488.  
  489. /**
  490.   * @brief  Clear interrupt pending bit of a dedicated line.
  491.   * @param  hexti Exti handle.
  492.   * @param  Edge Specify which pending edge as to be clear.
  493.   *         This parameter can be one of the following values:
  494.   *           @arg @ref EXTI_TRIGGER_RISING_FALLING
  495.   *         This parameter is kept for compatibility with other series.
  496.   * @retval None.
  497.   */
  498. void HAL_EXTI_ClearPending(EXTI_HandleTypeDef *hexti, uint32_t Edge)
  499. {
  500.   uint32_t maskline;
  501.  
  502.   /* Check parameters */
  503.   assert_param(IS_EXTI_LINE(hexti->Line));
  504.   assert_param(IS_EXTI_CONFIG_LINE(hexti->Line));
  505.   assert_param(IS_EXTI_PENDING_EDGE(Edge));
  506.  
  507.   /* Prevent unused argument compilation warning */
  508.   UNUSED(Edge);
  509.  
  510.   /* Compute line mask */
  511.   maskline = (1uL << (hexti->Line & EXTI_PIN_MASK));
  512.  
  513.   /* Clear Pending bit */
  514.   EXTI->PR =  maskline;
  515. }
  516.  
  517. /**
  518.   * @brief  Generate a software interrupt for a dedicated line.
  519.   * @param  hexti Exti handle.
  520.   * @retval None.
  521.   */
  522. void HAL_EXTI_GenerateSWI(EXTI_HandleTypeDef *hexti)
  523. {
  524.   uint32_t maskline;
  525.  
  526.   /* Check parameters */
  527.   assert_param(IS_EXTI_LINE(hexti->Line));
  528.   assert_param(IS_EXTI_CONFIG_LINE(hexti->Line));
  529.  
  530.   /* Compute line mask */
  531.   maskline = (1uL << (hexti->Line & EXTI_PIN_MASK));
  532.  
  533.   /* Generate Software interrupt */
  534.   EXTI->SWIER = maskline;
  535. }
  536.  
  537. /**
  538.   * @}
  539.   */
  540.  
  541. /**
  542.   * @}
  543.   */
  544.  
  545. #endif /* HAL_EXTI_MODULE_ENABLED */
  546. /**
  547.   * @}
  548.   */
  549.  
  550. /**
  551.   * @}
  552.   */
  553.  
  554.