1 /**
2 ******************************************************************************
3 * @file stm32f0xx_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_GetConfigLine().
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_GetPending().
79
80 (#) Generate software interrupt using HAL_EXTI_GenerateSWI().
81
82 @endverbatim
83 */
84
85 /* Includes ------------------------------------------------------------------*/
86 #include "stm32f0xx_hal.h"
87
88 /** @addtogroup STM32F0xx_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 */
HAL_EXTI_SetConfigLine(EXTI_HandleTypeDef * hexti,EXTI_ConfigTypeDef * pExtiConfig)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 = SYSCFG->EXTICR[linepos >> 2u];
200 regval &= ~(SYSCFG_EXTICR1_EXTI0 << (SYSCFG_EXTICR1_EXTI1_Pos * (linepos & 0x03u)));
201 regval |= (pExtiConfig->GPIOSel << (SYSCFG_EXTICR1_EXTI1_Pos * (linepos & 0x03u)));
202 SYSCFG->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 */
HAL_EXTI_GetConfigLine(EXTI_HandleTypeDef * hexti,EXTI_ConfigTypeDef * pExtiConfig)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 = SYSCFG->EXTICR[linepos >> 2u];
304 pExtiConfig->GPIOSel = (regval >> (SYSCFG_EXTICR1_EXTI1_Pos * (linepos & 0x03u))) & SYSCFG_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 */
HAL_EXTI_ClearConfigLine(EXTI_HandleTypeDef * hexti)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 = SYSCFG->EXTICR[linepos >> 2u];
353 regval &= ~(SYSCFG_EXTICR1_EXTI0 << (SYSCFG_EXTICR1_EXTI1_Pos * (linepos & 0x03u)));
354 SYSCFG->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 */
HAL_EXTI_RegisterCallback(EXTI_HandleTypeDef * hexti,EXTI_CallbackIDTypeDef CallbackID,void (* pPendingCbfn)(void))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 */
HAL_EXTI_GetHandle(EXTI_HandleTypeDef * hexti,uint32_t ExtiLine)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 */
HAL_EXTI_IRQHandler(EXTI_HandleTypeDef * hexti)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 */
HAL_EXTI_GetPending(EXTI_HandleTypeDef * hexti,uint32_t Edge)466 uint32_t HAL_EXTI_GetPending(EXTI_HandleTypeDef *hexti, uint32_t Edge)
467 {
468 uint32_t regval;
469 uint32_t linepos;
470 uint32_t maskline;
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 /* Compute line mask */
478 linepos = (hexti->Line & EXTI_PIN_MASK);
479 maskline = (1uL << linepos);
480
481 /* return 1 if bit is set else 0 */
482 regval = ((EXTI->PR & maskline) >> linepos);
483 return regval;
484 }
485
486 /**
487 * @brief Clear interrupt pending bit of a dedicated line.
488 * @param hexti Exti handle.
489 * @param Edge Specify which pending edge as to be clear.
490 * This parameter can be one of the following values:
491 * @arg @ref EXTI_TRIGGER_RISING_FALLING
492 * This parameter is kept for compatibility with other series.
493 * @retval None.
494 */
HAL_EXTI_ClearPending(EXTI_HandleTypeDef * hexti,uint32_t Edge)495 void HAL_EXTI_ClearPending(EXTI_HandleTypeDef *hexti, uint32_t Edge)
496 {
497 uint32_t maskline;
498
499 /* Check parameters */
500 assert_param(IS_EXTI_LINE(hexti->Line));
501 assert_param(IS_EXTI_CONFIG_LINE(hexti->Line));
502 assert_param(IS_EXTI_PENDING_EDGE(Edge));
503
504 /* Compute line mask */
505 maskline = (1uL << (hexti->Line & EXTI_PIN_MASK));
506
507 /* Clear Pending bit */
508 EXTI->PR = maskline;
509 }
510
511 /**
512 * @brief Generate a software interrupt for a dedicated line.
513 * @param hexti Exti handle.
514 * @retval None.
515 */
HAL_EXTI_GenerateSWI(EXTI_HandleTypeDef * hexti)516 void HAL_EXTI_GenerateSWI(EXTI_HandleTypeDef *hexti)
517 {
518 uint32_t maskline;
519
520 /* Check parameters */
521 assert_param(IS_EXTI_LINE(hexti->Line));
522 assert_param(IS_EXTI_CONFIG_LINE(hexti->Line));
523
524 /* Compute line mask */
525 maskline = (1uL << (hexti->Line & EXTI_PIN_MASK));
526
527 /* Generate Software interrupt */
528 EXTI->SWIER = maskline;
529 }
530
531 /**
532 * @}
533 */
534
535 /**
536 * @}
537 */
538
539 #endif /* HAL_EXTI_MODULE_ENABLED */
540 /**
541 * @}
542 */
543
544 /**
545 * @}
546 */
547
548
