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