git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M0+_LPC51U68_LPCXpresso/drivers/fsl_pint.c

   1 /*\r
   2  * Copyright (c) 2016, Freescale Semiconductor, Inc.\r
   3  * Copyright 2016-2017 NXP\r
   4  * All rights reserved.\r
   5  *\r
   6  * SPDX-License-Identifier: BSD-3-Clause\r
   7  */\r
   8 \r
   9 #include "fsl_pint.h"\r
  10 \r
  11 /* Component ID definition, used by tools. */\r
  12 #ifndef FSL_COMPONENT_ID\r
  13 #define FSL_COMPONENT_ID "platform.drivers.pint"\r
  14 #endif\r
  15 \r
  16 /*******************************************************************************\r
  17  * Variables\r
  18  ******************************************************************************/\r
  19 \r
  20 #if defined(FSL_FEATURE_SECPINT_NUMBER_OF_CONNECTED_OUTPUTS)\r
  21 /*! @brief Irq number array */\r
  22 static const IRQn_Type s_pintIRQ[FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS +\r
  23                                  FSL_FEATURE_SECPINT_NUMBER_OF_CONNECTED_OUTPUTS] = PINT_IRQS;\r
  24 \r
  25 /*! @brief Callback function array for PINT(s). */\r
  26 static pint_cb_t\r
  27     s_pintCallback[FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS + FSL_FEATURE_SECPINT_NUMBER_OF_CONNECTED_OUTPUTS];\r
  28 #else\r
  29 /*! @brief Irq number array */\r
  30 static const IRQn_Type s_pintIRQ[FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS] = PINT_IRQS;\r
  31 \r
  32 /*! @brief Callback function array for PINT(s). */\r
  33 static pint_cb_t s_pintCallback[FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS];\r
  34 #endif /* FSL_FEATURE_SECPINT_NUMBER_OF_CONNECTED_OUTPUTS */\r
  35 \r
  36 /*******************************************************************************\r
  37  * Code\r
  38  ******************************************************************************/\r
  39 \r
  40 /*!\r
  41  * brief        Initialize PINT peripheral.\r
  42 \r
  43  * This function initializes the PINT peripheral and enables the clock.\r
  44  *\r
  45  * param base Base address of the PINT peripheral.\r
  46  *\r
  47  * retval None.\r
  48  */\r
  49 void PINT_Init(PINT_Type *base)\r
  50 {\r
  51     uint32_t i;\r
  52     uint32_t pmcfg;\r
  53     uint8_t pintcount;\r
  54     assert(base);\r
  55     pmcfg = 0;\r
  56 \r
  57 #if defined(SECPINT)\r
  58     pintcount = SEC_PINT_PIN_INT_COUNT;\r
  59 #else\r
  60     pintcount = PINT_PIN_INT_COUNT;\r
  61 #endif /* SECPINT */\r
  62 \r
  63     for (i = 0; i < FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS; i++)\r
  64     {\r
  65         s_pintCallback[i] = NULL;\r
  66     }\r
  67 \r
  68     /* Disable all bit slices for pint*/\r
  69     for (i = 0; i < pintcount; i++)\r
  70     {\r
  71         pmcfg = pmcfg | (kPINT_PatternMatchNever << (PININT_BITSLICE_CFG_START + (i * 3U)));\r
  72     }\r
  73 \r
  74 #if defined(FSL_FEATURE_CLOCK_HAS_GPIOINT_CLOCK_SOURCE) && (FSL_FEATURE_CLOCK_HAS_GPIOINT_CLOCK_SOURCE == 1)\r
  75 #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)\r
  76     /* Enable the clock. */\r
  77     CLOCK_EnableClock(kCLOCK_GpioInt);\r
  78 #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */\r
  79 \r
  80 #if !(defined(FSL_SDK_DISABLE_DRIVER_RESET_CONTROL) && FSL_SDK_DISABLE_DRIVER_RESET_CONTROL)\r
  81     /* Reset the module. */\r
  82     RESET_PeripheralReset(kGPIOINT_RST_N_SHIFT_RSTn);\r
  83 #endif /* FSL_SDK_DISABLE_DRIVER_RESET_CONTROL */\r
  84 \r
  85 #elif defined(FSL_FEATURE_CLOCK_HAS_GPIOINT_CLOCK_SOURCE) && (FSL_FEATURE_CLOCK_HAS_GPIOINT_CLOCK_SOURCE == 0)\r
  86 #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)\r
  87     /* Enable the clock. */\r
  88     CLOCK_EnableClock(kCLOCK_Gpio0);\r
  89 #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */\r
  90 \r
  91 #if !(defined(FSL_SDK_DISABLE_DRIVER_RESET_CONTROL) && FSL_SDK_DISABLE_DRIVER_RESET_CONTROL)\r
  92     /* Reset the module. */\r
  93     RESET_PeripheralReset(kGPIO0_RST_N_SHIFT_RSTn);\r
  94 #endif /* FSL_SDK_DISABLE_DRIVER_RESET_CONTROL */\r
  95 \r
  96 #if defined(SECPINT)\r
  97 #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)\r
  98     /* Enable the clock. */\r
  99     CLOCK_EnableClock(kCLOCK_Gpio_Sec);\r
 100 #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */\r
 101 \r
 102 #if !(defined(FSL_SDK_DISABLE_DRIVER_RESET_CONTROL) && FSL_SDK_DISABLE_DRIVER_RESET_CONTROL)\r
 103     /* Reset the module. */\r
 104     RESET_PeripheralReset(kGPIOSEC_RST_SHIFT_RSTn);\r
 105 #endif /* FSL_SDK_DISABLE_DRIVER_RESET_CONTROL */\r
 106 #endif /* SECPINT */\r
 107 #else\r
 108     /* if need config SECURE PINT device,then enable secure pint interrupt clock */\r
 109     if (base == PINT)\r
 110     {\r
 111 #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)\r
 112         /* Enable the clock. */\r
 113         CLOCK_EnableClock(kCLOCK_Pint);\r
 114 #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */\r
 115 \r
 116 #if !(defined(FSL_SDK_DISABLE_DRIVER_RESET_CONTROL) && FSL_SDK_DISABLE_DRIVER_RESET_CONTROL)\r
 117         /* Reset the module. */\r
 118         RESET_PeripheralReset(kPINT_RST_SHIFT_RSTn);\r
 119 #endif /* FSL_SDK_DISABLE_DRIVER_RESET_CONTROL */\r
 120     }\r
 121 #if defined(SECPINT)\r
 122     else if (base == SECPINT)\r
 123     {\r
 124 #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)\r
 125         /* Enable the clock. */\r
 126         CLOCK_EnableClock(kCLOCK_Gpio_sec_Int);\r
 127 #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */\r
 128 \r
 129 #if !(defined(FSL_SDK_DISABLE_DRIVER_RESET_CONTROL) && FSL_SDK_DISABLE_DRIVER_RESET_CONTROL)\r
 130         /* Reset the module. */\r
 131         RESET_PeripheralReset(kGPIOSECINT_RST_SHIFT_RSTn);\r
 132 #endif /* FSL_SDK_DISABLE_DRIVER_RESET_CONTROL */\r
 133     }\r
 134 #endif /* SECPINT */\r
 135 #endif /* FSL_FEATURE_CLOCK_HAS_GPIOINT_CLOCK_SOURCE */\r
 136 \r
 137     /* Disable all pattern match bit slices */\r
 138     base->PMCFG = pmcfg;\r
 139 }\r
 140 \r
 141 /*!\r
 142  * brief        Configure PINT peripheral pin interrupt.\r
 143 \r
 144  * This function configures a given pin interrupt.\r
 145  *\r
 146  * param base Base address of the PINT peripheral.\r
 147  * param intr Pin interrupt.\r
 148  * param enable Selects detection logic.\r
 149  * param callback Callback.\r
 150  *\r
 151  * retval None.\r
 152  */\r
 153 void PINT_PinInterruptConfig(PINT_Type *base, pint_pin_int_t intr, pint_pin_enable_t enable, pint_cb_t callback)\r
 154 {\r
 155     assert(base);\r
 156 \r
 157     /* Clear Rise and Fall flags first */\r
 158     PINT_PinInterruptClrRiseFlag(base, intr);\r
 159     PINT_PinInterruptClrFallFlag(base, intr);\r
 160 \r
 161     /* select level or edge sensitive */\r
 162     base->ISEL =\r
 163         (base->ISEL & ~(1UL << (uint32_t)intr)) | ((enable & PINT_PIN_INT_LEVEL) ? (1UL << (uint32_t)intr) : 0U);\r
 164 \r
 165     /* enable rising or level interrupt */\r
 166     if (enable & (PINT_PIN_INT_LEVEL | PINT_PIN_INT_RISE))\r
 167     {\r
 168         base->SIENR = 1UL << (uint32_t)intr;\r
 169     }\r
 170     else\r
 171     {\r
 172         base->CIENR = 1UL << (uint32_t)intr;\r
 173     }\r
 174 \r
 175     /* Enable falling or select high level */\r
 176     if (enable & PINT_PIN_INT_FALL_OR_HIGH_LEVEL)\r
 177     {\r
 178         base->SIENF = 1UL << (uint32_t)intr;\r
 179     }\r
 180     else\r
 181     {\r
 182         base->CIENF = 1UL << (uint32_t)intr;\r
 183     }\r
 184 \r
 185     s_pintCallback[intr] = callback;\r
 186 }\r
 187 \r
 188 /*!\r
 189  * brief        Get PINT peripheral pin interrupt configuration.\r
 190 \r
 191  * This function returns the configuration of a given pin interrupt.\r
 192  *\r
 193  * param base Base address of the PINT peripheral.\r
 194  * param pintr Pin interrupt.\r
 195  * param enable Pointer to store the detection logic.\r
 196  * param callback Callback.\r
 197  *\r
 198  * retval None.\r
 199  */\r
 200 void PINT_PinInterruptGetConfig(PINT_Type *base, pint_pin_int_t pintr, pint_pin_enable_t *enable, pint_cb_t *callback)\r
 201 {\r
 202     uint32_t mask;\r
 203     bool level;\r
 204 \r
 205     assert(base);\r
 206 \r
 207     *enable = kPINT_PinIntEnableNone;\r
 208     level   = false;\r
 209 \r
 210     mask = 1UL << (uint32_t)pintr;\r
 211     if ((base->ISEL & mask) != 0U)\r
 212     {\r
 213         /* Pin interrupt is level sensitive */\r
 214         level = true;\r
 215     }\r
 216 \r
 217     if ((base->IENR & mask) != 0U)\r
 218     {\r
 219         if (level)\r
 220         {\r
 221             /* Level interrupt is enabled */\r
 222             *enable = kPINT_PinIntEnableLowLevel;\r
 223         }\r
 224         else\r
 225         {\r
 226             /* Rising edge interrupt */\r
 227             *enable = kPINT_PinIntEnableRiseEdge;\r
 228         }\r
 229     }\r
 230 \r
 231     if ((base->IENF & mask) != 0U)\r
 232     {\r
 233         if (level)\r
 234         {\r
 235             /* Level interrupt is active high */\r
 236             *enable = kPINT_PinIntEnableHighLevel;\r
 237         }\r
 238         else\r
 239         {\r
 240             /* Either falling or both edge */\r
 241             if (*enable == kPINT_PinIntEnableRiseEdge)\r
 242             {\r
 243                 /* Rising and faling edge */\r
 244                 *enable = kPINT_PinIntEnableBothEdges;\r
 245             }\r
 246             else\r
 247             {\r
 248                 /* Falling edge */\r
 249                 *enable = kPINT_PinIntEnableFallEdge;\r
 250             }\r
 251         }\r
 252     }\r
 253 \r
 254     *callback = s_pintCallback[pintr];\r
 255 }\r
 256 \r
 257 /*!\r
 258  * brief        Configure PINT pattern match.\r
 259 \r
 260  * This function configures a given pattern match bit slice.\r
 261  *\r
 262  * param base Base address of the PINT peripheral.\r
 263  * param bslice Pattern match bit slice number.\r
 264  * param cfg Pointer to bit slice configuration.\r
 265  *\r
 266  * retval None.\r
 267  */\r
 268 void PINT_PatternMatchConfig(PINT_Type *base, pint_pmatch_bslice_t bslice, pint_pmatch_cfg_t *cfg)\r
 269 {\r
 270     uint32_t src_shift;\r
 271     uint32_t cfg_shift;\r
 272     uint32_t pmcfg;\r
 273     uint32_t tmp_src_shift = PININT_BITSLICE_SRC_MASK;\r
 274     uint32_t tmp_cfg_shift = PININT_BITSLICE_CFG_MASK;\r
 275 \r
 276     assert(base);\r
 277 \r
 278     src_shift = PININT_BITSLICE_SRC_START + ((uint32_t)bslice * 3UL);\r
 279     cfg_shift = PININT_BITSLICE_CFG_START + ((uint32_t)bslice * 3UL);\r
 280 \r
 281     /* Input source selection for selected bit slice */\r
 282     base->PMSRC = (base->PMSRC & ~(tmp_src_shift << src_shift)) | (cfg->bs_src << src_shift);\r
 283 \r
 284     /* Bit slice configuration */\r
 285     pmcfg = base->PMCFG;\r
 286     pmcfg = (pmcfg & ~(tmp_cfg_shift << cfg_shift)) | (cfg->bs_cfg << cfg_shift);\r
 287 \r
 288     /* If end point is true, enable the bits */\r
 289     if ((uint32_t)bslice != 7UL)\r
 290     {\r
 291         if (cfg->end_point)\r
 292         {\r
 293             pmcfg |= (1UL << (uint32_t)bslice);\r
 294         }\r
 295         else\r
 296         {\r
 297             pmcfg &= ~(1UL << (uint32_t)bslice);\r
 298         }\r
 299     }\r
 300 \r
 301     base->PMCFG = pmcfg;\r
 302 \r
 303     /* Save callback pointer */\r
 304     s_pintCallback[bslice] = cfg->callback;\r
 305 }\r
 306 \r
 307 /*!\r
 308  * brief        Get PINT pattern match configuration.\r
 309 \r
 310  * This function returns the configuration of a given pattern match bit slice.\r
 311  *\r
 312  * param base Base address of the PINT peripheral.\r
 313  * param bslice Pattern match bit slice number.\r
 314  * param cfg Pointer to bit slice configuration.\r
 315  *\r
 316  * retval None.\r
 317  */\r
 318 void PINT_PatternMatchGetConfig(PINT_Type *base, pint_pmatch_bslice_t bslice, pint_pmatch_cfg_t *cfg)\r
 319 {\r
 320     uint32_t src_shift;\r
 321     uint32_t cfg_shift;\r
 322     uint32_t tmp_src_shift = PININT_BITSLICE_SRC_MASK;\r
 323     uint32_t tmp_cfg_shift = PININT_BITSLICE_CFG_MASK;\r
 324 \r
 325     assert(base);\r
 326 \r
 327     src_shift = PININT_BITSLICE_SRC_START + ((uint32_t)bslice * 3UL);\r
 328     cfg_shift = PININT_BITSLICE_CFG_START + ((uint32_t)bslice * 3UL);\r
 329 \r
 330     cfg->bs_src = (pint_pmatch_input_src_t)((base->PMSRC & (tmp_src_shift << src_shift)) >> src_shift);\r
 331     cfg->bs_cfg = (pint_pmatch_bslice_cfg_t)((base->PMCFG & (tmp_cfg_shift << cfg_shift)) >> cfg_shift);\r
 332 \r
 333     if ((uint32_t)bslice == 7U)\r
 334     {\r
 335         cfg->end_point = true;\r
 336     }\r
 337     else\r
 338     {\r
 339         cfg->end_point = ((base->PMCFG & (1UL << (uint32_t)bslice)) >> (uint32_t)bslice);\r
 340     }\r
 341     cfg->callback = s_pintCallback[bslice];\r
 342 }\r
 343 \r
 344 /*!\r
 345  * brief        Reset pattern match detection logic.\r
 346 \r
 347  * This function resets the pattern match detection logic if any of the product term is matching.\r
 348  *\r
 349  * param base Base address of the PINT peripheral.\r
 350  *\r
 351  * retval pmstatus Each bit position indicates the match status of corresponding bit slice.\r
 352  * = 0 Match was detected.  = 1 Match was not detected.\r
 353  */\r
 354 uint32_t PINT_PatternMatchResetDetectLogic(PINT_Type *base)\r
 355 {\r
 356     uint32_t pmctrl;\r
 357     uint32_t pmstatus;\r
 358     uint32_t pmsrc;\r
 359 \r
 360     pmctrl   = base->PMCTRL;\r
 361     pmstatus = pmctrl >> PINT_PMCTRL_PMAT_SHIFT;\r
 362     if (pmstatus != 0UL)\r
 363     {\r
 364         /* Reset Pattern match engine detection logic */\r
 365         pmsrc       = base->PMSRC;\r
 366         base->PMSRC = pmsrc;\r
 367     }\r
 368     return (pmstatus);\r
 369 }\r
 370 \r
 371 /*!\r
 372  * @brief       Clear Selected pin interrupt status only when the pin was triggered by edge-sensitive.\r
 373 \r
 374  * This function clears the selected pin interrupt status.\r
 375  *\r
 376  * @param base Base address of the PINT peripheral.\r
 377  * @param pintr Pin interrupt.\r
 378  *\r
 379  * @retval None.\r
 380  */\r
 381 void PINT_PinInterruptClrStatus(PINT_Type *base, pint_pin_int_t pintr)\r
 382 {\r
 383     uint32_t pinIntMode   = base->ISEL & (1UL << (uint32_t)pintr);\r
 384     uint32_t pinIntStatus = base->IST & (1UL << (uint32_t)pintr);\r
 385 \r
 386     /* Edge sensitive and pin interrupt that is currently requesting an interrupt. */\r
 387     if ((pinIntMode == 0x0UL) && (pinIntStatus != 0x0UL))\r
 388     {\r
 389         base->IST = (1UL << (uint32_t)pintr);\r
 390     }\r
 391 }\r
 392 \r
 393 /*!\r
 394  * @brief       Clear all pin interrupts status only when pins were triggered by edge-sensitive.\r
 395 \r
 396  * This function clears the status of all pin interrupts.\r
 397  *\r
 398  * @param base Base address of the PINT peripheral.\r
 399  *\r
 400  * @retval None.\r
 401  */\r
 402 void PINT_PinInterruptClrStatusAll(PINT_Type *base)\r
 403 {\r
 404     uint32_t pinIntMode   = 0;\r
 405     uint32_t pinIntStatus = 0;\r
 406     uint32_t mask         = 0;\r
 407     uint32_t i;\r
 408 \r
 409     for (i = 0; i < FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS; i++)\r
 410     {\r
 411         pinIntMode   = base->ISEL & (1UL << i);\r
 412         pinIntStatus = base->IST & (1UL << i);\r
 413 \r
 414         /* Edge sensitive and pin interrupt that is currently requesting an interrupt. */\r
 415         if ((pinIntMode == 0x0UL) && (pinIntStatus != 0x0UL))\r
 416         {\r
 417             mask |= 1UL << i;\r
 418         }\r
 419     }\r
 420 \r
 421     base->IST = mask;\r
 422 }\r
 423 \r
 424 /*!\r
 425  * brief        Enable callback.\r
 426 \r
 427  * This function enables the interrupt for the selected PINT peripheral. Although the pin(s) are monitored\r
 428  * as soon as they are enabled, the callback function is not enabled until this function is called.\r
 429  *\r
 430  * param base Base address of the PINT peripheral.\r
 431  *\r
 432  * retval None.\r
 433  */\r
 434 void PINT_EnableCallback(PINT_Type *base)\r
 435 {\r
 436     uint32_t i;\r
 437 \r
 438     assert(base);\r
 439 \r
 440     for (i = 0; i < FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS; i++)\r
 441     {\r
 442         NVIC_ClearPendingIRQ(s_pintIRQ[i]);\r
 443         PINT_PinInterruptClrStatus(base, (pint_pin_int_t)i);\r
 444         (void)EnableIRQ(s_pintIRQ[i]);\r
 445     }\r
 446 }\r
 447 \r
 448 /*!\r
 449  * brief        enable callback by pin index.\r
 450 \r
 451  * This function  enables callback by pin index instead of enabling all pins.\r
 452  *\r
 453  * param base Base address of the peripheral.\r
 454  * param pinIdx pin index.\r
 455  *\r
 456  * retval None.\r
 457  */\r
 458 void PINT_EnableCallbackByIndex(PINT_Type *base, pint_pin_int_t pintIdx)\r
 459 {\r
 460     assert(base);\r
 461 \r
 462     NVIC_ClearPendingIRQ(s_pintIRQ[pintIdx]);\r
 463     PINT_PinInterruptClrStatus(base, (pint_pin_int_t)pintIdx);\r
 464     (void)EnableIRQ(s_pintIRQ[pintIdx]);\r
 465 }\r
 466 \r
 467 /*!\r
 468  * brief        Disable callback.\r
 469 \r
 470  * This function disables the interrupt for the selected PINT peripheral. Although the pins are still\r
 471  * being monitored but the callback function is not called.\r
 472  *\r
 473  * param base Base address of the peripheral.\r
 474  *\r
 475  * retval None.\r
 476  */\r
 477 void PINT_DisableCallback(PINT_Type *base)\r
 478 {\r
 479     uint32_t i;\r
 480 \r
 481     assert(base);\r
 482 \r
 483     for (i = 0; i < FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS; i++)\r
 484     {\r
 485         (void)DisableIRQ(s_pintIRQ[i]);\r
 486         PINT_PinInterruptClrStatus(base, (pint_pin_int_t)i);\r
 487         NVIC_ClearPendingIRQ(s_pintIRQ[i]);\r
 488     }\r
 489 }\r
 490 \r
 491 /*!\r
 492  * brief disable callback by pin index.\r
 493 \r
 494  * This function disables callback by pin index instead of disabling all pins.\r
 495  *\r
 496  * param base Base address of the peripheral.\r
 497  * param pinIdx pin index.\r
 498  *\r
 499  * retval None.\r
 500  */\r
 501 void PINT_DisableCallbackByIndex(PINT_Type *base, pint_pin_int_t pintIdx)\r
 502 {\r
 503     assert(base);\r
 504 \r
 505     (void)DisableIRQ(s_pintIRQ[pintIdx]);\r
 506     PINT_PinInterruptClrStatus(base, (pint_pin_int_t)pintIdx);\r
 507     NVIC_ClearPendingIRQ(s_pintIRQ[pintIdx]);\r
 508 }\r
 509 \r
 510 /*!\r
 511  * brief        Deinitialize PINT peripheral.\r
 512 \r
 513  * This function disables the PINT clock.\r
 514  *\r
 515  * param base Base address of the PINT peripheral.\r
 516  *\r
 517  * retval None.\r
 518  */\r
 519 void PINT_Deinit(PINT_Type *base)\r
 520 {\r
 521     uint32_t i;\r
 522 \r
 523     assert(base);\r
 524 \r
 525     /* Cleanup */\r
 526     PINT_DisableCallback(base);\r
 527     for (i = 0; i < FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS; i++)\r
 528     {\r
 529         s_pintCallback[i] = NULL;\r
 530     }\r
 531 \r
 532 #if defined(FSL_FEATURE_CLOCK_HAS_GPIOINT_CLOCK_SOURCE) && (FSL_FEATURE_CLOCK_HAS_GPIOINT_CLOCK_SOURCE == 1)\r
 533 #if !(defined(FSL_SDK_DISABLE_DRIVER_RESET_CONTROL) && FSL_SDK_DISABLE_DRIVER_RESET_CONTROL)\r
 534     /* Reset the module. */\r
 535     RESET_PeripheralReset(kGPIOINT_RST_N_SHIFT_RSTn);\r
 536 #endif /* FSL_SDK_DISABLE_DRIVER_RESET_CONTROL */\r
 537 \r
 538 #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)\r
 539     /* Disable the clock. */\r
 540     CLOCK_DisableClock(kCLOCK_GpioInt);\r
 541 #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */\r
 542 \r
 543 #elif defined(FSL_FEATURE_CLOCK_HAS_GPIOINT_CLOCK_SOURCE) && (FSL_FEATURE_CLOCK_HAS_GPIOINT_CLOCK_SOURCE == 0)\r
 544 #if !(defined(FSL_SDK_DISABLE_DRIVER_RESET_CONTROL) && FSL_SDK_DISABLE_DRIVER_RESET_CONTROL)\r
 545     /* Reset the module. */\r
 546     RESET_PeripheralReset(kGPIO0_RST_N_SHIFT_RSTn);\r
 547 #endif /* FSL_SDK_DISABLE_DRIVER_RESET_CONTROL */\r
 548 \r
 549 #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)\r
 550     /* Disable the clock. */\r
 551     CLOCK_DisableClock(kCLOCK_Gpio0);\r
 552 #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */\r
 553 \r
 554 #if defined(SECPINT)\r
 555 #if !(defined(FSL_SDK_DISABLE_DRIVER_RESET_CONTROL) && FSL_SDK_DISABLE_DRIVER_RESET_CONTROL)\r
 556     /* Reset the module. */\r
 557     RESET_PeripheralReset(kGPIOSEC_RST_SHIFT_RSTn);\r
 558 #endif /* FSL_SDK_DISABLE_DRIVER_RESET_CONTROL */\r
 559 \r
 560 #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)\r
 561     /* Enable the clock. */\r
 562     CLOCK_DisableClock(kCLOCK_Gpio_Sec);\r
 563 #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */\r
 564 #endif /* SECPINT */\r
 565 #else\r
 566     if (base == PINT)\r
 567     {\r
 568 #if !(defined(FSL_SDK_DISABLE_DRIVER_RESET_CONTROL) && FSL_SDK_DISABLE_DRIVER_RESET_CONTROL)\r
 569         /* Reset the module. */\r
 570         RESET_PeripheralReset(kPINT_RST_SHIFT_RSTn);\r
 571 #endif /* FSL_SDK_DISABLE_DRIVER_RESET_CONTROL */\r
 572 \r
 573 #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)\r
 574         /* Disable the clock. */\r
 575         CLOCK_DisableClock(kCLOCK_Pint);\r
 576 #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */\r
 577     }\r
 578 #if defined(SECPINT)\r
 579     else if (base == SECPINT)\r
 580     {\r
 581 #if !(defined(FSL_SDK_DISABLE_DRIVER_RESET_CONTROL) && FSL_SDK_DISABLE_DRIVER_RESET_CONTROL)\r
 582         /* Reset the module. */\r
 583         RESET_PeripheralReset(kGPIOSECINT_RST_SHIFT_RSTn);\r
 584 #endif /* FSL_SDK_DISABLE_DRIVER_RESET_CONTROL */\r
 585 \r
 586 #if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL)\r
 587         /* Disable the clock. */\r
 588         CLOCK_DisableClock(kCLOCK_Gpio_sec_Int);\r
 589 #endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */\r
 590     }\r
 591 #endif /* SECPINT */\r
 592 #endif /* FSL_FEATURE_CLOCK_HAS_GPIOINT_CLOCK_SOURCE */\r
 593 }\r
 594 #if defined(SECPINT)\r
 595 /* IRQ handler functions overloading weak symbols in the startup */\r
 596 void SEC_GPIO_INT0_IRQ0_DriverIRQHandler(void)\r
 597 {\r
 598     uint32_t pmstatus = 0;\r
 599 \r
 600     /* Reset pattern match detection */\r
 601     pmstatus = PINT_PatternMatchResetDetectLogic(SECPINT);\r
 602     /* Call user function */\r
 603     if (s_pintCallback[kPINT_SecPinInt0] != NULL)\r
 604     {\r
 605         s_pintCallback[kPINT_SecPinInt0](kPINT_SecPinInt0, pmstatus);\r
 606     }\r
 607     if ((SECPINT->ISEL & 0x1U) == 0x0U)\r
 608     {\r
 609         /* Edge sensitive: clear Pin interrupt after callback */\r
 610         PINT_PinInterruptClrStatus(SECPINT, kPINT_PinInt0);\r
 611     }\r
 612 /* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping\r
 613   exception return operation might vector to incorrect interrupt */\r
 614 #if defined __CORTEX_M && (__CORTEX_M == 4U)\r
 615     __DSB();\r
 616 #endif\r
 617 }\r
 618 \r
 619 #if (FSL_FEATURE_SECPINT_NUMBER_OF_CONNECTED_OUTPUTS > 1U)\r
 620 /* IRQ handler functions overloading weak symbols in the startup */\r
 621 void SEC_GPIO_INT0_IRQ1_DriverIRQHandler(void)\r
 622 {\r
 623     uint32_t pmstatus;\r
 624 \r
 625     /* Reset pattern match detection */\r
 626     pmstatus = PINT_PatternMatchResetDetectLogic(SECPINT);\r
 627     /* Call user function */\r
 628     if (s_pintCallback[kPINT_SecPinInt1] != NULL)\r
 629     {\r
 630         s_pintCallback[kPINT_SecPinInt1](kPINT_SecPinInt1, pmstatus);\r
 631     }\r
 632     if ((SECPINT->ISEL & 0x1U) == 0x0U)\r
 633     {\r
 634         /* Edge sensitive: clear Pin interrupt after callback */\r
 635         PINT_PinInterruptClrStatus(SECPINT, kPINT_PinInt1);\r
 636     }\r
 637 /* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping\r
 638   exception return operation might vector to incorrect interrupt */\r
 639 #if defined __CORTEX_M && (__CORTEX_M == 4U)\r
 640     __DSB();\r
 641 #endif\r
 642 }\r
 643 #endif /* FSL_FEATURE_SECPINT_NUMBER_OF_CONNECTED_OUTPUTS */\r
 644 #endif /* SECPINT */\r
 645 \r
 646 /* IRQ handler functions overloading weak symbols in the startup */\r
 647 void PIN_INT0_DriverIRQHandler(void)\r
 648 {\r
 649     uint32_t pmstatus;\r
 650 \r
 651     /* Reset pattern match detection */\r
 652     pmstatus = PINT_PatternMatchResetDetectLogic(PINT);\r
 653     /* Call user function */\r
 654     if (s_pintCallback[kPINT_PinInt0] != NULL)\r
 655     {\r
 656         s_pintCallback[kPINT_PinInt0](kPINT_PinInt0, pmstatus);\r
 657     }\r
 658     if ((PINT->ISEL & 0x1U) == 0x0U)\r
 659     {\r
 660         /* Edge sensitive: clear Pin interrupt after callback */\r
 661         PINT_PinInterruptClrStatus(PINT, kPINT_PinInt0);\r
 662     }\r
 663 /* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping\r
 664   exception return operation might vector to incorrect interrupt */\r
 665 #if defined __CORTEX_M && (__CORTEX_M == 4U)\r
 666     __DSB();\r
 667 #endif\r
 668 }\r
 669 \r
 670 #if (FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS > 1U)\r
 671 void PIN_INT1_DriverIRQHandler(void)\r
 672 {\r
 673     uint32_t pmstatus;\r
 674 \r
 675     /* Reset pattern match detection */\r
 676     pmstatus = PINT_PatternMatchResetDetectLogic(PINT);\r
 677     /* Call user function */\r
 678     if (s_pintCallback[kPINT_PinInt1] != NULL)\r
 679     {\r
 680         s_pintCallback[kPINT_PinInt1](kPINT_PinInt1, pmstatus);\r
 681     }\r
 682     if ((PINT->ISEL & 0x2U) == 0x0U)\r
 683     {\r
 684         /* Edge sensitive: clear Pin interrupt after callback */\r
 685         PINT_PinInterruptClrStatus(PINT, kPINT_PinInt1);\r
 686     }\r
 687 /* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping\r
 688   exception return operation might vector to incorrect interrupt */\r
 689 #if defined __CORTEX_M && (__CORTEX_M == 4U)\r
 690     __DSB();\r
 691 #endif\r
 692 }\r
 693 #endif\r
 694 \r
 695 #if (FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS > 2U)\r
 696 void PIN_INT2_DriverIRQHandler(void)\r
 697 {\r
 698     uint32_t pmstatus;\r
 699 \r
 700     /* Reset pattern match detection */\r
 701     pmstatus = PINT_PatternMatchResetDetectLogic(PINT);\r
 702     /* Call user function */\r
 703     if (s_pintCallback[kPINT_PinInt2] != NULL)\r
 704     {\r
 705         s_pintCallback[kPINT_PinInt2](kPINT_PinInt2, pmstatus);\r
 706     }\r
 707     if ((PINT->ISEL & 0x4U) == 0x0U)\r
 708     {\r
 709         /* Edge sensitive: clear Pin interrupt after callback */\r
 710         PINT_PinInterruptClrStatus(PINT, kPINT_PinInt2);\r
 711     }\r
 712 /* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping\r
 713   exception return operation might vector to incorrect interrupt */\r
 714 #if defined __CORTEX_M && (__CORTEX_M == 4U)\r
 715     __DSB();\r
 716 #endif\r
 717 }\r
 718 #endif\r
 719 \r
 720 #if (FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS > 3U)\r
 721 void PIN_INT3_DriverIRQHandler(void)\r
 722 {\r
 723     uint32_t pmstatus;\r
 724 \r
 725     /* Reset pattern match detection */\r
 726     pmstatus = PINT_PatternMatchResetDetectLogic(PINT);\r
 727     /* Call user function */\r
 728     if (s_pintCallback[kPINT_PinInt3] != NULL)\r
 729     {\r
 730         s_pintCallback[kPINT_PinInt3](kPINT_PinInt3, pmstatus);\r
 731     }\r
 732     if ((PINT->ISEL & 0x8U) == 0x0U)\r
 733     {\r
 734         /* Edge sensitive: clear Pin interrupt after callback */\r
 735         PINT_PinInterruptClrStatus(PINT, kPINT_PinInt3);\r
 736     }\r
 737 /* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping\r
 738   exception return operation might vector to incorrect interrupt */\r
 739 #if defined __CORTEX_M && (__CORTEX_M == 4U)\r
 740     __DSB();\r
 741 #endif\r
 742 }\r
 743 #endif\r
 744 \r
 745 #if (FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS > 4U)\r
 746 void PIN_INT4_DriverIRQHandler(void)\r
 747 {\r
 748     uint32_t pmstatus;\r
 749 \r
 750     /* Reset pattern match detection */\r
 751     pmstatus = PINT_PatternMatchResetDetectLogic(PINT);\r
 752     /* Call user function */\r
 753     if (s_pintCallback[kPINT_PinInt4] != NULL)\r
 754     {\r
 755         s_pintCallback[kPINT_PinInt4](kPINT_PinInt4, pmstatus);\r
 756     }\r
 757     if ((PINT->ISEL & 0x10U) == 0x0U)\r
 758     {\r
 759         /* Edge sensitive: clear Pin interrupt after callback */\r
 760         PINT_PinInterruptClrStatus(PINT, kPINT_PinInt4);\r
 761     }\r
 762 /* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping\r
 763   exception return operation might vector to incorrect interrupt */\r
 764 #if defined __CORTEX_M && (__CORTEX_M == 4U)\r
 765     __DSB();\r
 766 #endif\r
 767 }\r
 768 #endif\r
 769 \r
 770 #if (FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS > 5U)\r
 771 #if defined(FSL_FEATURE_NVIC_HAS_SHARED_INTERTTUPT_NUMBER) && FSL_FEATURE_NVIC_HAS_SHARED_INTERTTUPT_NUMBER\r
 772 void PIN_INT5_DAC1_IRQHandler(void)\r
 773 #else\r
 774 void PIN_INT5_DriverIRQHandler(void)\r
 775 #endif /* FSL_FEATURE_NVIC_HAS_SHARED_INTERTTUPT_NUMBER */\r
 776 {\r
 777     uint32_t pmstatus;\r
 778 \r
 779     /* Reset pattern match detection */\r
 780     pmstatus = PINT_PatternMatchResetDetectLogic(PINT);\r
 781     /* Call user function */\r
 782     if (s_pintCallback[kPINT_PinInt5] != NULL)\r
 783     {\r
 784         s_pintCallback[kPINT_PinInt5](kPINT_PinInt5, pmstatus);\r
 785     }\r
 786     if ((PINT->ISEL & 0x20U) == 0x0U)\r
 787     {\r
 788         /* Edge sensitive: clear Pin interrupt after callback */\r
 789         PINT_PinInterruptClrStatus(PINT, kPINT_PinInt5);\r
 790     }\r
 791 /* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping\r
 792   exception return operation might vector to incorrect interrupt */\r
 793 #if defined __CORTEX_M && (__CORTEX_M == 4U)\r
 794     __DSB();\r
 795 #endif\r
 796 }\r
 797 #endif\r
 798 \r
 799 #if (FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS > 6U)\r
 800 #if defined(FSL_FEATURE_NVIC_HAS_SHARED_INTERTTUPT_NUMBER) && FSL_FEATURE_NVIC_HAS_SHARED_INTERTTUPT_NUMBER\r
 801 void PIN_INT6_USART3_IRQHandler(void)\r
 802 #else\r
 803 void PIN_INT6_DriverIRQHandler(void)\r
 804 #endif /* FSL_FEATURE_NVIC_HAS_SHARED_INTERTTUPT_NUMBER */\r
 805 {\r
 806     uint32_t pmstatus;\r
 807 \r
 808     /* Reset pattern match detection */\r
 809     pmstatus = PINT_PatternMatchResetDetectLogic(PINT);\r
 810     /* Call user function */\r
 811     if (s_pintCallback[kPINT_PinInt6] != NULL)\r
 812     {\r
 813         s_pintCallback[kPINT_PinInt6](kPINT_PinInt6, pmstatus);\r
 814     }\r
 815     if ((PINT->ISEL & 0x40U) == 0x0U)\r
 816     {\r
 817         /* Edge sensitive: clear Pin interrupt after callback */\r
 818         PINT_PinInterruptClrStatus(PINT, kPINT_PinInt6);\r
 819     }\r
 820 /* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping\r
 821   exception return operation might vector to incorrect interrupt */\r
 822 #if defined __CORTEX_M && (__CORTEX_M == 4U)\r
 823     __DSB();\r
 824 #endif\r
 825 }\r
 826 #endif\r
 827 \r
 828 #if (FSL_FEATURE_PINT_NUMBER_OF_CONNECTED_OUTPUTS > 7U)\r
 829 #if defined(FSL_FEATURE_NVIC_HAS_SHARED_INTERTTUPT_NUMBER) && FSL_FEATURE_NVIC_HAS_SHARED_INTERTTUPT_NUMBER\r
 830 void PIN_INT7_USART4_IRQHandler(void)\r
 831 #else\r
 832 void PIN_INT7_DriverIRQHandler(void)\r
 833 #endif /* FSL_FEATURE_NVIC_HAS_SHARED_INTERTTUPT_NUMBER */\r
 834 {\r
 835     uint32_t pmstatus;\r
 836 \r
 837     /* Reset pattern match detection */\r
 838     pmstatus = PINT_PatternMatchResetDetectLogic(PINT);\r
 839     /* Call user function */\r
 840     if (s_pintCallback[kPINT_PinInt7] != NULL)\r
 841     {\r
 842         s_pintCallback[kPINT_PinInt7](kPINT_PinInt7, pmstatus);\r
 843     }\r
 844     if ((PINT->ISEL & 0x80U) == 0x0U)\r
 845     {\r
 846         /* Edge sensitive: clear Pin interrupt after callback */\r
 847         PINT_PinInterruptClrStatus(PINT, kPINT_PinInt7);\r
 848     }\r
 849 /* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping\r
 850   exception return operation might vector to incorrect interrupt */\r
 851 #if defined __CORTEX_M && (__CORTEX_M == 4U)\r
 852     __DSB();\r
 853 #endif\r
 854 }\r
 855 #endif\r