git.sur5r.net Git - freertos/blob

   1 /***************************************************************************//**\r
   2  * @file em_gpio.h\r
   3  * @brief General Purpose IO (GPIO) peripheral API\r
   4  * @version 4.2.1\r
   5  *******************************************************************************\r
   6  * @section License\r
   7  * <b>(C) Copyright 2015 Silicon Labs, http://www.silabs.com</b>\r
   8  *******************************************************************************\r
   9  *\r
  10  * Permission is granted to anyone to use this software for any purpose,\r
  11  * including commercial applications, and to alter it and redistribute it\r
  12  * freely, subject to the following restrictions:\r
  13  *\r
  14  * 1. The origin of this software must not be misrepresented; you must not\r
  15  *    claim that you wrote the original software.\r
  16  * 2. Altered source versions must be plainly marked as such, and must not be\r
  17  *    misrepresented as being the original software.\r
  18  * 3. This notice may not be removed or altered from any source distribution.\r
  19  *\r
  20  * DISCLAIMER OF WARRANTY/LIMITATION OF REMEDIES: Silicon Labs has no\r
  21  * obligation to support this Software. Silicon Labs is providing the\r
  22  * Software "AS IS", with no express or implied warranties of any kind,\r
  23  * including, but not limited to, any implied warranties of merchantability\r
  24  * or fitness for any particular purpose or warranties against infringement\r
  25  * of any proprietary rights of a third party.\r
  26  *\r
  27  * Silicon Labs will not be liable for any consequential, incidental, or\r
  28  * special damages, or any other relief, or for any claim by any third party,\r
  29  * arising from your use of this Software.\r
  30  *\r
  31  ******************************************************************************/\r
  32 \r
  33 \r
  34 #ifndef __SILICON_LABS_EM_GPIO_H__\r
  35 #define __SILICON_LABS_EM_GPIO_H__\r
  36 \r
  37 #include "em_device.h"\r
  38 #if defined(GPIO_COUNT) && (GPIO_COUNT > 0)\r
  39 \r
  40 #include <stdbool.h>\r
  41 #include "em_bus.h"\r
  42 #include "em_assert.h"\r
  43 \r
  44 #ifdef __cplusplus\r
  45 extern "C" {\r
  46 #endif\r
  47 \r
  48 /***************************************************************************//**\r
  49  * @addtogroup EM_Library\r
  50  * @{\r
  51  ******************************************************************************/\r
  52 \r
  53 /***************************************************************************//**\r
  54  * @addtogroup GPIO\r
  55  * @{\r
  56  ******************************************************************************/\r
  57 \r
  58 /*******************************************************************************\r
  59  *******************************   DEFINES   ***********************************\r
  60  ******************************************************************************/\r
  61 \r
  62 /** @cond DO_NOT_INCLUDE_WITH_DOXYGEN */\r
  63 #if defined( _EFM32_TINY_FAMILY ) || defined( _EFM32_ZERO_FAMILY )\r
  64 \r
  65 #define _GPIO_PORT_A_PIN_COUNT 14\r
  66 #define _GPIO_PORT_B_PIN_COUNT 10\r
  67 #define _GPIO_PORT_C_PIN_COUNT 16\r
  68 #define _GPIO_PORT_D_PIN_COUNT 9\r
  69 #define _GPIO_PORT_E_PIN_COUNT 12\r
  70 #define _GPIO_PORT_F_PIN_COUNT 6\r
  71 \r
  72 #define _GPIO_PORT_A_PIN_MASK 0xF77F\r
  73 #define _GPIO_PORT_B_PIN_MASK 0x79F8\r
  74 #define _GPIO_PORT_C_PIN_MASK 0xFFFF\r
  75 #define _GPIO_PORT_D_PIN_MASK 0x01FF\r
  76 #define _GPIO_PORT_E_PIN_MASK 0xFFF0\r
  77 #define _GPIO_PORT_F_PIN_MASK 0x003F\r
  78 \r
  79 #elif defined( _EFM32_HAPPY_FAMILY )\r
  80 \r
  81 #define _GPIO_PORT_A_PIN_COUNT 6\r
  82 #define _GPIO_PORT_B_PIN_COUNT 5\r
  83 #define _GPIO_PORT_C_PIN_COUNT 12\r
  84 #define _GPIO_PORT_D_PIN_COUNT 4\r
  85 #define _GPIO_PORT_E_PIN_COUNT 4\r
  86 #define _GPIO_PORT_F_PIN_COUNT 6\r
  87 \r
  88 #define _GPIO_PORT_A_PIN_MASK 0x0707\r
  89 #define _GPIO_PORT_B_PIN_MASK 0x6980\r
  90 #define _GPIO_PORT_C_PIN_MASK 0xEF1F\r
  91 #define _GPIO_PORT_D_PIN_MASK 0x00F0\r
  92 #define _GPIO_PORT_E_PIN_MASK 0x3C00\r
  93 #define _GPIO_PORT_F_PIN_MASK 0x003F\r
  94 \r
  95 #elif defined( _EFM32_GIANT_FAMILY ) \\r
  96       || defined( _EFM32_WONDER_FAMILY )\r
  97 \r
  98 #define _GPIO_PORT_A_PIN_COUNT 16\r
  99 #define _GPIO_PORT_B_PIN_COUNT 16\r
 100 #define _GPIO_PORT_C_PIN_COUNT 16\r
 101 #define _GPIO_PORT_D_PIN_COUNT 16\r
 102 #define _GPIO_PORT_E_PIN_COUNT 16\r
 103 #define _GPIO_PORT_F_PIN_COUNT 13\r
 104 \r
 105 #define _GPIO_PORT_A_PIN_MASK 0xFFFF\r
 106 #define _GPIO_PORT_B_PIN_MASK 0xFFFF\r
 107 #define _GPIO_PORT_C_PIN_MASK 0xFFFF\r
 108 #define _GPIO_PORT_D_PIN_MASK 0xFFFF\r
 109 #define _GPIO_PORT_E_PIN_MASK 0xFFFF\r
 110 #define _GPIO_PORT_F_PIN_MASK 0x1FFF\r
 111 \r
 112 #elif defined( _EFM32_GECKO_FAMILY )\r
 113 \r
 114 #define _GPIO_PORT_A_PIN_COUNT 16\r
 115 #define _GPIO_PORT_B_PIN_COUNT 16\r
 116 #define _GPIO_PORT_C_PIN_COUNT 16\r
 117 #define _GPIO_PORT_D_PIN_COUNT 16\r
 118 #define _GPIO_PORT_E_PIN_COUNT 16\r
 119 #define _GPIO_PORT_F_PIN_COUNT 10\r
 120 \r
 121 #define _GPIO_PORT_A_PIN_MASK 0xFFFF\r
 122 #define _GPIO_PORT_B_PIN_MASK 0xFFFF\r
 123 #define _GPIO_PORT_C_PIN_MASK 0xFFFF\r
 124 #define _GPIO_PORT_D_PIN_MASK 0xFFFF\r
 125 #define _GPIO_PORT_E_PIN_MASK 0xFFFF\r
 126 #define _GPIO_PORT_F_PIN_MASK 0x03FF\r
 127 \r
 128 #elif defined( _EFR32_MIGHTY_FAMILY )    \\r
 129       || defined( _EFR32_BLUE_FAMILY )   \\r
 130       || defined( _EFR32_FLEX_FAMILY )   \\r
 131       || defined( _EFR32_ZAPPY_FAMILY )\r
 132 \r
 133 #define _GPIO_PORT_A_PIN_COUNT 6\r
 134 #define _GPIO_PORT_B_PIN_COUNT 5\r
 135 #define _GPIO_PORT_C_PIN_COUNT 6\r
 136 #define _GPIO_PORT_D_PIN_COUNT 3\r
 137 #define _GPIO_PORT_E_PIN_COUNT 0\r
 138 #define _GPIO_PORT_F_PIN_COUNT 8\r
 139 \r
 140 #define _GPIO_PORT_A_PIN_MASK 0x003F\r
 141 #define _GPIO_PORT_B_PIN_MASK 0xF800\r
 142 #define _GPIO_PORT_C_PIN_MASK 0x0FC0\r
 143 #define _GPIO_PORT_D_PIN_MASK 0xE000\r
 144 #define _GPIO_PORT_E_PIN_MASK 0x0000\r
 145 #define _GPIO_PORT_F_PIN_MASK 0x00FF\r
 146 \r
 147 #elif defined( _EFM32_PEARL_FAMILY )    \\r
 148       || defined( _EFM32_JADE_FAMILY )\r
 149 \r
 150 #define _GPIO_PORT_A_PIN_COUNT 6\r
 151 #define _GPIO_PORT_B_PIN_COUNT 5\r
 152 #define _GPIO_PORT_C_PIN_COUNT 6\r
 153 #define _GPIO_PORT_D_PIN_COUNT 7\r
 154 #define _GPIO_PORT_E_PIN_COUNT 0\r
 155 #define _GPIO_PORT_F_PIN_COUNT 8\r
 156 \r
 157 #define _GPIO_PORT_A_PIN_MASK 0x003F\r
 158 #define _GPIO_PORT_B_PIN_MASK 0xF800\r
 159 #define _GPIO_PORT_C_PIN_MASK 0x0FC0\r
 160 #define _GPIO_PORT_D_PIN_MASK 0xFE00\r
 161 #define _GPIO_PORT_E_PIN_MASK 0x0000\r
 162 #define _GPIO_PORT_F_PIN_MASK 0x00FF\r
 163 \r
 164 #else\r
 165 #warning "Port and pin masks are not defined for this family."\r
 166 #endif\r
 167 \r
 168 #if defined( _GPIO_PORT_G_PIN_COUNT ) && defined( _GPIO_PORT_H_PIN_COUNT )\r
 169 #define _GPIO_PORT_SIZE(port) (                \\r
 170         (port) == 0 ? _GPIO_PORT_A_PIN_COUNT : \\r
 171         (port) == 1 ? _GPIO_PORT_B_PIN_COUNT : \\r
 172         (port) == 2 ? _GPIO_PORT_C_PIN_COUNT : \\r
 173         (port) == 3 ? _GPIO_PORT_D_PIN_COUNT : \\r
 174         (port) == 4 ? _GPIO_PORT_E_PIN_COUNT : \\r
 175         (port) == 5 ? _GPIO_PORT_F_PIN_COUNT : \\r
 176         (port) == 6 ? _GPIO_PORT_G_PIN_COUNT : \\r
 177         (port) == 7 ? _GPIO_PORT_H_PIN_COUNT : \\r
 178         0)\r
 179 #else\r
 180 #define _GPIO_PORT_SIZE(port) (                \\r
 181         (port) == 0 ? _GPIO_PORT_A_PIN_COUNT : \\r
 182         (port) == 1 ? _GPIO_PORT_B_PIN_COUNT : \\r
 183         (port) == 2 ? _GPIO_PORT_C_PIN_COUNT : \\r
 184         (port) == 3 ? _GPIO_PORT_D_PIN_COUNT : \\r
 185         (port) == 4 ? _GPIO_PORT_E_PIN_COUNT : \\r
 186         (port) == 5 ? _GPIO_PORT_F_PIN_COUNT : \\r
 187         0)\r
 188 #endif\r
 189 \r
 190 #if defined( _GPIO_PORT_G_PIN_MASK ) && defined( _GPIO_PORT_H_PIN_MASK )\r
 191 #define _GPIO_PORT_MASK(port) ( \\r
 192         (port) == 0 ? _GPIO_PORT_A_PIN_MASK : \\r
 193         (port) == 1 ? _GPIO_PORT_B_PIN_MASK : \\r
 194         (port) == 2 ? _GPIO_PORT_C_PIN_MASK : \\r
 195         (port) == 3 ? _GPIO_PORT_D_PIN_MASK : \\r
 196         (port) == 4 ? _GPIO_PORT_E_PIN_MASK : \\r
 197         (port) == 5 ? _GPIO_PORT_F_PIN_MASK : \\r
 198         (port) == 6 ? _GPIO_PORT_G_PIN_MASK : \\r
 199         (port) == 7 ? _GPIO_PORT_H_PIN_MASK : \\r
 200         0)\r
 201 #else\r
 202 #define _GPIO_PORT_MASK(port) ( \\r
 203         (port) == 0 ? _GPIO_PORT_A_PIN_MASK : \\r
 204         (port) == 1 ? _GPIO_PORT_B_PIN_MASK : \\r
 205         (port) == 2 ? _GPIO_PORT_C_PIN_MASK : \\r
 206         (port) == 3 ? _GPIO_PORT_D_PIN_MASK : \\r
 207         (port) == 4 ? _GPIO_PORT_E_PIN_MASK : \\r
 208         (port) == 5 ? _GPIO_PORT_F_PIN_MASK : \\r
 209         0)\r
 210 #endif\r
 211 \r
 212 /** Validation of port and pin */\r
 213 #define GPIO_PORT_VALID(port)          ( _GPIO_PORT_MASK(port) )\r
 214 #define GPIO_PORT_PIN_VALID(port, pin) ((( _GPIO_PORT_MASK(port)) >> (pin)) & 0x1 )\r
 215 \r
 216 /** Highest GPIO pin number */\r
 217 #define GPIO_PIN_MAX  15\r
 218 \r
 219 /** Highest GPIO port number */\r
 220 #if defined( _GPIO_PORT_G_PIN_COUNT ) && defined( _GPIO_PORT_H_PIN_COUNT )\r
 221 #define GPIO_PORT_MAX  7\r
 222 #else\r
 223 #define GPIO_PORT_MAX  5\r
 224 #endif\r
 225 /** @endcond */\r
 226 \r
 227 /*******************************************************************************\r
 228  ********************************   ENUMS   ************************************\r
 229  ******************************************************************************/\r
 230 \r
 231 /** GPIO ports ids. */\r
 232 typedef enum\r
 233 {\r
 234 #if ( _GPIO_PORT_A_PIN_COUNT > 0 )\r
 235   gpioPortA = 0,\r
 236 #endif\r
 237 #if ( _GPIO_PORT_B_PIN_COUNT > 0 )\r
 238   gpioPortB = 1,\r
 239 #endif\r
 240 #if ( _GPIO_PORT_C_PIN_COUNT > 0 )\r
 241   gpioPortC = 2,\r
 242 #endif\r
 243 #if ( _GPIO_PORT_D_PIN_COUNT > 0 )\r
 244   gpioPortD = 3,\r
 245 #endif\r
 246 #if ( _GPIO_PORT_E_PIN_COUNT > 0 )\r
 247   gpioPortE = 4,\r
 248 #endif\r
 249 #if ( _GPIO_PORT_F_PIN_COUNT > 0 )\r
 250   gpioPortF = 5\r
 251 #endif\r
 252 #if defined( _GPIO_PORT_G_PIN_COUNT ) && ( _GPIO_PORT_G_PIN_COUNT > 0 )\r
 253   gpioPortG = 6\r
 254 #endif\r
 255 #if defined( _GPIO_PORT_H_PIN_COUNT ) && ( _GPIO_PORT_H_PIN_COUNT > 0 )\r
 256   gpioPortH = 7\r
 257 #endif\r
 258 } GPIO_Port_TypeDef;\r
 259 \r
 260 #if defined( _GPIO_P_CTRL_DRIVEMODE_MASK )\r
 261 /** GPIO drive mode. */\r
 262 typedef enum\r
 263 {\r
 264   /** Default 6mA */\r
 265   gpioDriveModeStandard = GPIO_P_CTRL_DRIVEMODE_STANDARD,\r
 266   /** 0.5 mA */\r
 267   gpioDriveModeLowest   = GPIO_P_CTRL_DRIVEMODE_LOWEST,\r
 268   /** 20 mA */\r
 269   gpioDriveModeHigh     = GPIO_P_CTRL_DRIVEMODE_HIGH,\r
 270   /** 2 mA */\r
 271   gpioDriveModeLow      = GPIO_P_CTRL_DRIVEMODE_LOW\r
 272 } GPIO_DriveMode_TypeDef;\r
 273 #endif\r
 274 \r
 275 #if defined( _GPIO_P_CTRL_DRIVESTRENGTH_MASK ) && defined( _GPIO_P_CTRL_DRIVESTRENGTHALT_MASK )\r
 276 /** GPIO drive strength. */\r
 277 typedef enum\r
 278 {\r
 279   /** GPIO weak 1mA and alternate function weak 1mA */\r
 280   gpioDriveStrengthWeakAlternateWeak     = GPIO_P_CTRL_DRIVESTRENGTH_WEAK | GPIO_P_CTRL_DRIVESTRENGTHALT_WEAK,\r
 281 \r
 282   /** GPIO weak 1mA and alternate function strong 10mA */\r
 283   gpioDriveStrengthWeakAlternateStrong   = GPIO_P_CTRL_DRIVESTRENGTH_WEAK | GPIO_P_CTRL_DRIVESTRENGTHALT_STRONG,\r
 284 \r
 285     /** GPIO strong 10mA and alternate function weak 1mA */\r
 286   gpioDriveStrengthStrongAlternateWeak   = GPIO_P_CTRL_DRIVESTRENGTH_STRONG | GPIO_P_CTRL_DRIVESTRENGTHALT_WEAK,\r
 287 \r
 288   /** GPIO strong 10mA and alternate function strong 10mA */\r
 289   gpioDriveStrengthStrongAlternateStrong = GPIO_P_CTRL_DRIVESTRENGTH_STRONG | GPIO_P_CTRL_DRIVESTRENGTHALT_STRONG,\r
 290 } GPIO_DriveStrength_TypeDef;\r
 291 /* For legacy support */\r
 292 #define gpioDriveStrengthStrong   gpioDriveStrengthStrongAlternateStrong\r
 293 #define gpioDriveStrengthWeak     gpioDriveStrengthWeakAlternateWeak\r
 294 #endif\r
 295 \r
 296 /** Pin mode. For more details on each mode, please refer to the\r
 297  * reference manual. */\r
 298 typedef enum\r
 299 {\r
 300   /** Input disabled. Pullup if DOUT is set. */\r
 301   gpioModeDisabled                  = _GPIO_P_MODEL_MODE0_DISABLED,\r
 302   /** Input enabled. Filter if DOUT is set */\r
 303   gpioModeInput                     = _GPIO_P_MODEL_MODE0_INPUT,\r
 304   /** Input enabled. DOUT determines pull direction */\r
 305   gpioModeInputPull                 = _GPIO_P_MODEL_MODE0_INPUTPULL,\r
 306   /** Input enabled with filter. DOUT determines pull direction */\r
 307   gpioModeInputPullFilter           = _GPIO_P_MODEL_MODE0_INPUTPULLFILTER,\r
 308   /** Push-pull output */\r
 309   gpioModePushPull                  = _GPIO_P_MODEL_MODE0_PUSHPULL,\r
 310 #if defined( _GPIO_P_MODEL_MODE0_PUSHPULLDRIVE )\r
 311   /** Push-pull output with drive-strength set by DRIVEMODE */\r
 312   gpioModePushPullDrive             = _GPIO_P_MODEL_MODE0_PUSHPULLDRIVE,\r
 313 #endif\r
 314 #if defined( _GPIO_P_MODEL_MODE0_PUSHPULLALT )\r
 315   /** Push-pull using alternate control */\r
 316   gpioModePushPullAlternate       = _GPIO_P_MODEL_MODE0_PUSHPULLALT,\r
 317 #endif\r
 318   /** Wired-or output */\r
 319   gpioModeWiredOr                       = _GPIO_P_MODEL_MODE0_WIREDOR,\r
 320   /** Wired-or output with pull-down */\r
 321   gpioModeWiredOrPullDown               = _GPIO_P_MODEL_MODE0_WIREDORPULLDOWN,\r
 322   /** Open-drain output */\r
 323   gpioModeWiredAnd                      = _GPIO_P_MODEL_MODE0_WIREDAND,\r
 324   /** Open-drain output with filter */\r
 325   gpioModeWiredAndFilter                = _GPIO_P_MODEL_MODE0_WIREDANDFILTER,\r
 326   /** Open-drain output with pullup */\r
 327   gpioModeWiredAndPullUp                = _GPIO_P_MODEL_MODE0_WIREDANDPULLUP,\r
 328   /** Open-drain output with filter and pullup */\r
 329   gpioModeWiredAndPullUpFilter          = _GPIO_P_MODEL_MODE0_WIREDANDPULLUPFILTER,\r
 330 #if defined( _GPIO_P_MODEL_MODE0_WIREDANDDRIVE )\r
 331   /** Open-drain output with drive-strength set by DRIVEMODE */\r
 332   gpioModeWiredAndDrive                 = _GPIO_P_MODEL_MODE0_WIREDANDDRIVE,\r
 333   /** Open-drain output with filter and drive-strength set by DRIVEMODE */\r
 334   gpioModeWiredAndDriveFilter           = _GPIO_P_MODEL_MODE0_WIREDANDDRIVEFILTER,\r
 335   /** Open-drain output with pullup and drive-strength set by DRIVEMODE */\r
 336   gpioModeWiredAndDrivePullUp           = _GPIO_P_MODEL_MODE0_WIREDANDDRIVEPULLUP,\r
 337   /** Open-drain output with filter, pullup and drive-strength set by DRIVEMODE */\r
 338   gpioModeWiredAndDrivePullUpFilter     = _GPIO_P_MODEL_MODE0_WIREDANDDRIVEPULLUPFILTER\r
 339 #endif\r
 340 #if defined( _GPIO_P_MODEL_MODE0_WIREDANDALT )\r
 341   /** Open-drain output using alternate control */\r
 342   gpioModeWiredAndAlternate             = _GPIO_P_MODEL_MODE0_WIREDANDALT,\r
 343   /** Open-drain output using alternate control with filter */\r
 344   gpioModeWiredAndAlternateFilter       = _GPIO_P_MODEL_MODE0_WIREDANDALTFILTER,\r
 345   /** Open-drain output using alternate control with pullup */\r
 346   gpioModeWiredAndAlternatePullUp       = _GPIO_P_MODEL_MODE0_WIREDANDALTPULLUP,\r
 347   /** Open-drain output uisng alternate control with filter and pullup */\r
 348   gpioModeWiredAndAlternatePullUpFilter = _GPIO_P_MODEL_MODE0_WIREDANDALTPULLUPFILTER,\r
 349 #endif\r
 350 } GPIO_Mode_TypeDef;\r
 351 \r
 352 /*******************************************************************************\r
 353  *****************************   PROTOTYPES   **********************************\r
 354  ******************************************************************************/\r
 355 \r
 356 void GPIO_DbgLocationSet(unsigned int location);\r
 357 \r
 358 void GPIO_IntConfig(GPIO_Port_TypeDef port,\r
 359                     unsigned int pin,\r
 360                     bool risingEdge,\r
 361                     bool fallingEdge,\r
 362                     bool enable);\r
 363 \r
 364 void GPIO_PinModeSet(GPIO_Port_TypeDef port,\r
 365                      unsigned int pin,\r
 366                      GPIO_Mode_TypeDef mode,\r
 367                      unsigned int out);\r
 368 \r
 369 # if defined( _GPIO_EM4WUEN_MASK )\r
 370 void GPIO_EM4EnablePinWakeup(uint32_t pinmask, uint32_t polaritymask);\r
 371 #endif\r
 372 \r
 373 /***************************************************************************//**\r
 374  * @brief\r
 375  *   Enable/disable serial wire clock pin.\r
 376  *\r
 377  * @note\r
 378  *   Disabling SWDClk will disable the debug interface, which may result in\r
 379  *   a lockout if done early in startup (before debugger is able to halt core).\r
 380  *\r
 381  * @param[in] enable\r
 382  *   @li false - disable serial wire clock.\r
 383  *   @li true - enable serial wire clock (default after reset).\r
 384  ******************************************************************************/\r
 385 __STATIC_INLINE void GPIO_DbgSWDClkEnable(bool enable)\r
 386 {\r
 387 #if defined( _GPIO_ROUTE_SWCLKPEN_MASK )\r
 388   BUS_RegBitWrite(&(GPIO->ROUTE), _GPIO_ROUTE_SWCLKPEN_SHIFT, enable);\r
 389 #elif defined( _GPIO_ROUTEPEN_SWCLKTCKPEN_MASK )\r
 390   BUS_RegBitWrite(&(GPIO->ROUTEPEN), _GPIO_ROUTEPEN_SWCLKTCKPEN_SHIFT, enable);\r
 391 #else\r
 392 #warning "ROUTE enable for SWCLK pin is not defined."\r
 393 #endif\r
 394 }\r
 395 \r
 396 \r
 397 /***************************************************************************//**\r
 398  * @brief\r
 399  *   Enable/disable serial wire data I/O pin.\r
 400  *\r
 401  * @note\r
 402  *   Disabling SWDClk will disable the debug interface, which may result in\r
 403  *   a lockout if done early in startup (before debugger is able to halt core).\r
 404  *\r
 405  * @param[in] enable\r
 406  *   @li false - disable serial wire data pin.\r
 407  *   @li true - enable serial wire data pin (default after reset).\r
 408  ******************************************************************************/\r
 409 __STATIC_INLINE void GPIO_DbgSWDIOEnable(bool enable)\r
 410 {\r
 411 #if defined( _GPIO_ROUTE_SWDIOPEN_MASK )\r
 412   BUS_RegBitWrite(&(GPIO->ROUTE), _GPIO_ROUTE_SWDIOPEN_SHIFT, enable);\r
 413 #elif defined( _GPIO_ROUTEPEN_SWDIOTMSPEN_MASK )\r
 414   BUS_RegBitWrite(&(GPIO->ROUTEPEN), _GPIO_ROUTEPEN_SWDIOTMSPEN_SHIFT, enable);\r
 415 #else\r
 416 #warning "ROUTE enable for SWDIO pin is not defined."\r
 417 #endif\r
 418 }\r
 419 \r
 420 \r
 421 #if defined( _GPIO_ROUTE_SWOPEN_MASK ) || defined( _GPIO_ROUTEPEN_SWVPEN_MASK )\r
 422 /***************************************************************************//**\r
 423  * @brief\r
 424  *   Enable/Disable serial wire output pin.\r
 425  *\r
 426  * @note\r
 427  *   Enabling this pin is not sufficient to fully enable serial wire output\r
 428  *   which is also dependent on issues outside the GPIO module. Please refer to\r
 429  *   DBG_SWOEnable().\r
 430  *\r
 431  * @param[in] enable\r
 432  *   @li false - disable serial wire viewer pin (default after reset).\r
 433  *   @li true - enable serial wire viewer pin.\r
 434  ******************************************************************************/\r
 435 __STATIC_INLINE void GPIO_DbgSWOEnable(bool enable)\r
 436 {\r
 437 #if defined( _GPIO_ROUTE_SWOPEN_MASK )\r
 438   BUS_RegBitWrite(&(GPIO->ROUTE), _GPIO_ROUTE_SWOPEN_SHIFT, enable);\r
 439 #elif defined( _GPIO_ROUTEPEN_SWVPEN_MASK )\r
 440   BUS_RegBitWrite(&(GPIO->ROUTEPEN), _GPIO_ROUTEPEN_SWVPEN_SHIFT, enable);\r
 441 #else\r
 442 #warning "ROUTE enable for SWO/SWV pin is not defined."\r
 443 #endif\r
 444 }\r
 445 #endif\r
 446 \r
 447 #if defined (_GPIO_P_CTRL_DRIVEMODE_MASK)\r
 448 void GPIO_DriveModeSet(GPIO_Port_TypeDef port, GPIO_DriveMode_TypeDef mode);\r
 449 #endif\r
 450 \r
 451 #if defined( _GPIO_P_CTRL_DRIVESTRENGTH_MASK )\r
 452 void GPIO_DriveStrengthSet(GPIO_Port_TypeDef port, GPIO_DriveStrength_TypeDef strength);\r
 453 #endif\r
 454 \r
 455 # if defined( _GPIO_EM4WUEN_MASK )\r
 456 /**************************************************************************//**\r
 457  * @brief\r
 458  *   Disable GPIO pin wake-up from EM4.\r
 459  *\r
 460  * @param[in] pinmask\r
 461  *   Bitmask containing the bitwise logic OR of which GPIO pin(s) to disable.\r
 462  *   Refer to Reference Manuals for pinmask to GPIO port/pin mapping.\r
 463  *****************************************************************************/\r
 464 __STATIC_INLINE void GPIO_EM4DisablePinWakeup(uint32_t pinmask)\r
 465 {\r
 466   EFM_ASSERT((pinmask & ~_GPIO_EM4WUEN_MASK) == 0);\r
 467 \r
 468   GPIO->EM4WUEN &= ~pinmask;\r
 469 }\r
 470 #endif\r
 471 \r
 472 \r
 473 #if defined( _GPIO_EM4WUCAUSE_MASK ) || defined( _RMU_RSTCAUSE_EM4RST_MASK )\r
 474 /**************************************************************************//**\r
 475  * @brief\r
 476  *   Check which GPIO pin(s) that caused a wake-up from EM4.\r
 477  *\r
 478  * @return\r
 479  *   Bitmask containing the bitwise logic OR of which GPIO pin(s) caused the\r
 480  *   wake-up. Refer to Reference Manuals for pinmask to GPIO port/pin mapping.\r
 481  *****************************************************************************/\r
 482 __STATIC_INLINE uint32_t GPIO_EM4GetPinWakeupCause(void)\r
 483 {\r
 484 #if defined( _GPIO_EM4WUCAUSE_MASK )\r
 485   return GPIO->EM4WUCAUSE & _GPIO_EM4WUCAUSE_MASK;\r
 486 #else\r
 487   return RMU->RSTCAUSE & _RMU_RSTCAUSE_EM4RST_MASK;\r
 488 #endif\r
 489 }\r
 490 #endif\r
 491 \r
 492 \r
 493 #if defined( GPIO_CTRL_EM4RET ) || defined( _EMU_EM4CTRL_EM4IORETMODE_MASK )\r
 494 /**************************************************************************//**\r
 495  * @brief\r
 496  *   Enable GPIO pin retention of output enable, output value, pull enable and\r
 497  *   pull direction in EM4.\r
 498  * \r
 499  * @note\r
 500  *   For platform 2 parts, EMU_EM4Init() and EMU_UnlatchPinRetention() offers \r
 501  *   more pin retention features. This function implements the EM4EXIT retention\r
 502  *   mode on platform 2.\r
 503  *\r
 504  * @param[in] enable\r
 505  *   @li true - enable EM4 pin retention.\r
 506  *   @li false - disable EM4 pin retention.\r
 507  *****************************************************************************/\r
 508 __STATIC_INLINE void GPIO_EM4SetPinRetention(bool enable)\r
 509 {\r
 510   if (enable)\r
 511   {\r
 512 #if defined( GPIO_CTRL_EM4RET )\r
 513     GPIO->CTRL |= GPIO_CTRL_EM4RET;\r
 514 #else\r
 515     EMU->EM4CTRL = (EMU->EM4CTRL & ~_EMU_EM4CTRL_EM4IORETMODE_MASK)\r
 516                    | EMU_EM4CTRL_EM4IORETMODE_EM4EXIT;\r
 517 #endif\r
 518   }\r
 519   else\r
 520   {\r
 521 #if defined( GPIO_CTRL_EM4RET )\r
 522     GPIO->CTRL &= ~GPIO_CTRL_EM4RET;\r
 523 #else\r
 524     EMU->EM4CTRL = (EMU->EM4CTRL & ~_EMU_EM4CTRL_EM4IORETMODE_MASK)\r
 525                    | EMU_EM4CTRL_EM4IORETMODE_DISABLE;\r
 526 #endif\r
 527   }\r
 528 }\r
 529 #endif\r
 530 \r
 531 \r
 532 /***************************************************************************//**\r
 533  * @brief\r
 534  *   Enable/disable input sensing.\r
 535  *\r
 536  * @details\r
 537  *   Disabling input sensing if not used, can save some energy consumption.\r
 538  *\r
 539  * @param[in] val\r
 540  *   Bitwise logic OR of one or more of:\r
 541  *   @li GPIO_INSENSE_INT - interrupt input sensing.\r
 542  *   @li GPIO_INSENSE_PRS - peripheral reflex system input sensing.\r
 543  *\r
 544  * @param[in] mask\r
 545  *   Mask containing bitwise logic OR of bits similar as for @p val used to\r
 546  *   indicate which input sense options to disable/enable.\r
 547  ******************************************************************************/\r
 548 __STATIC_INLINE void GPIO_InputSenseSet(uint32_t val, uint32_t mask)\r
 549 {\r
 550   GPIO->INSENSE = (GPIO->INSENSE & ~mask) | (val & mask);\r
 551 }\r
 552 \r
 553 \r
 554 /***************************************************************************//**\r
 555  * @brief\r
 556  *   Clear one or more pending GPIO interrupts.\r
 557  *\r
 558  * @param[in] flags\r
 559  *   Bitwise logic OR of GPIO interrupt sources to clear.\r
 560  ******************************************************************************/\r
 561 __STATIC_INLINE void GPIO_IntClear(uint32_t flags)\r
 562 {\r
 563   GPIO->IFC = flags;\r
 564 }\r
 565 \r
 566 \r
 567 /***************************************************************************//**\r
 568  * @brief\r
 569  *   Disable one or more GPIO interrupts.\r
 570  *\r
 571  * @param[in] flags\r
 572  *   GPIO interrupt sources to disable.\r
 573  ******************************************************************************/\r
 574 __STATIC_INLINE void GPIO_IntDisable(uint32_t flags)\r
 575 {\r
 576   GPIO->IEN &= ~flags;\r
 577 }\r
 578 \r
 579 \r
 580 /***************************************************************************//**\r
 581  * @brief\r
 582  *   Enable one or more GPIO interrupts.\r
 583  *\r
 584  * @note\r
 585  *   Depending on the use, a pending interrupt may already be set prior to\r
 586  *   enabling the interrupt. Consider using GPIO_IntClear() prior to enabling\r
 587  *   if such a pending interrupt should be ignored.\r
 588  *\r
 589  * @param[in] flags\r
 590  *   GPIO interrupt sources to enable.\r
 591  ******************************************************************************/\r
 592 __STATIC_INLINE void GPIO_IntEnable(uint32_t flags)\r
 593 {\r
 594   GPIO->IEN |= flags;\r
 595 }\r
 596 \r
 597 \r
 598 /***************************************************************************//**\r
 599  * @brief\r
 600  *   Get pending GPIO interrupts.\r
 601  *\r
 602  * @return\r
 603  *   GPIO interrupt sources pending.\r
 604  ******************************************************************************/\r
 605 __STATIC_INLINE uint32_t GPIO_IntGet(void)\r
 606 {\r
 607   return GPIO->IF;\r
 608 }\r
 609 \r
 610 \r
 611 /***************************************************************************//**\r
 612  * @brief\r
 613  *   Get enabled and pending GPIO interrupt flags.\r
 614  *   Useful for handling more interrupt sources in the same interrupt handler.\r
 615  *\r
 616  * @note\r
 617  *   Interrupt flags are not cleared by the use of this function.\r
 618  *\r
 619  * @return\r
 620  *   Pending and enabled GPIO interrupt sources.\r
 621  *   The return value is the bitwise AND combination of\r
 622  *   - the OR combination of enabled interrupt sources in GPIO_IEN register\r
 623  *     and\r
 624  *   - the OR combination of valid interrupt flags in GPIO_IF register.\r
 625  ******************************************************************************/\r
 626 __STATIC_INLINE uint32_t GPIO_IntGetEnabled(void)\r
 627 {\r
 628   uint32_t tmp;\r
 629 \r
 630   /* Store GPIO->IEN in temporary variable in order to define explicit order\r
 631    * of volatile accesses. */\r
 632   tmp = GPIO->IEN;\r
 633 \r
 634   /* Bitwise AND of pending and enabled interrupts */\r
 635   return GPIO->IF & tmp;\r
 636 }\r
 637 \r
 638 \r
 639 /**************************************************************************//**\r
 640  * @brief\r
 641  *   Set one or more pending GPIO interrupts from SW.\r
 642  *\r
 643  * @param[in] flags\r
 644  *   GPIO interrupt sources to set to pending.\r
 645  *****************************************************************************/\r
 646 __STATIC_INLINE void GPIO_IntSet(uint32_t flags)\r
 647 {\r
 648   GPIO->IFS = flags;\r
 649 }\r
 650 \r
 651 \r
 652 /***************************************************************************//**\r
 653  * @brief\r
 654  *   Locks the GPIO configuration.\r
 655  ******************************************************************************/\r
 656 __STATIC_INLINE void GPIO_Lock(void)\r
 657 {\r
 658   GPIO->LOCK = GPIO_LOCK_LOCKKEY_LOCK;\r
 659 }\r
 660 \r
 661 \r
 662 /***************************************************************************//**\r
 663  * @brief\r
 664  *   Read the pad value for a single pin in a GPIO port.\r
 665  *\r
 666  * @param[in] port\r
 667  *   The GPIO port to access.\r
 668  *\r
 669  * @param[in] pin\r
 670  *   The pin number to read.\r
 671  *\r
 672  * @return\r
 673  *   The pin value, 0 or 1.\r
 674  ******************************************************************************/\r
 675 __STATIC_INLINE unsigned int GPIO_PinInGet(GPIO_Port_TypeDef port,\r
 676                                            unsigned int pin)\r
 677 {\r
 678   EFM_ASSERT(GPIO_PORT_PIN_VALID(port, pin));\r
 679   return BUS_RegBitRead(&GPIO->P[port].DIN, pin);\r
 680 }\r
 681 \r
 682 \r
 683 /***************************************************************************//**\r
 684  * @brief\r
 685  *   Set a single pin in GPIO data out port register to 0.\r
 686  *\r
 687  * @note\r
 688  *   In order for the setting to take effect on the output pad, the pin must\r
 689  *   have been configured properly. If not, it will take effect whenever the\r
 690  *   pin has been properly configured.\r
 691  *\r
 692  * @param[in] port\r
 693  *   The GPIO port to access.\r
 694  *\r
 695  * @param[in] pin\r
 696  *   The pin to set.\r
 697  ******************************************************************************/\r
 698 __STATIC_INLINE void GPIO_PinOutClear(GPIO_Port_TypeDef port, unsigned int pin)\r
 699 {\r
 700   EFM_ASSERT(GPIO_PORT_PIN_VALID(port, pin));\r
 701 #if defined( _GPIO_P_DOUTCLR_MASK )\r
 702   GPIO->P[port].DOUTCLR = 1 << pin;\r
 703 #else\r
 704   BUS_RegBitWrite(&GPIO->P[port].DOUT, pin, 0);\r
 705 #endif\r
 706 }\r
 707 \r
 708 \r
 709 /***************************************************************************//**\r
 710  * @brief\r
 711  *   Get current setting for a pin in a GPIO port data out register.\r
 712  *\r
 713  * @param[in] port\r
 714  *   The GPIO port to access.\r
 715  *\r
 716  * @param[in] pin\r
 717  *   The pin to get setting for.\r
 718  *\r
 719  * @return\r
 720  *   The DOUT setting for the requested pin, 0 or 1.\r
 721  ******************************************************************************/\r
 722 __STATIC_INLINE unsigned int GPIO_PinOutGet(GPIO_Port_TypeDef port,\r
 723                                             unsigned int pin)\r
 724 {\r
 725   EFM_ASSERT(GPIO_PORT_PIN_VALID(port, pin));\r
 726   return BUS_RegBitRead(&GPIO->P[port].DOUT, pin);\r
 727 }\r
 728 \r
 729 \r
 730 /***************************************************************************//**\r
 731  * @brief\r
 732  *   Set a single pin in GPIO data out register to 1.\r
 733  *\r
 734  * @note\r
 735  *   In order for the setting to take effect on the output pad, the pin must\r
 736  *   have been configured properly. If not, it will take effect whenever the\r
 737  *   pin has been properly configured.\r
 738  *\r
 739  * @param[in] port\r
 740  *   The GPIO port to access.\r
 741  *\r
 742  * @param[in] pin\r
 743  *   The pin to set.\r
 744  ******************************************************************************/\r
 745 __STATIC_INLINE void GPIO_PinOutSet(GPIO_Port_TypeDef port, unsigned int pin)\r
 746 {\r
 747   EFM_ASSERT(GPIO_PORT_PIN_VALID(port, pin));\r
 748 #if defined( _GPIO_P_DOUTSET_MASK )\r
 749   GPIO->P[port].DOUTSET = 1 << pin;\r
 750 #else\r
 751   BUS_RegBitWrite(&GPIO->P[port].DOUT, pin, 1);\r
 752 #endif\r
 753 }\r
 754 \r
 755 \r
 756 /***************************************************************************//**\r
 757  * @brief\r
 758  *   Toggle a single pin in GPIO port data out register.\r
 759  *\r
 760  * @note\r
 761  *   In order for the setting to take effect on the output pad, the pin must\r
 762  *   have been configured properly. If not, it will take effect whenever the\r
 763  *   pin has been properly configured.\r
 764  *\r
 765  * @param[in] port\r
 766  *   The GPIO port to access.\r
 767  *\r
 768  * @param[in] pin\r
 769  *   The pin to toggle.\r
 770  ******************************************************************************/\r
 771 __STATIC_INLINE void GPIO_PinOutToggle(GPIO_Port_TypeDef port, unsigned int pin)\r
 772 {\r
 773   EFM_ASSERT(GPIO_PORT_PIN_VALID(port, pin));\r
 774 \r
 775   GPIO->P[port].DOUTTGL = 1 << pin;\r
 776 }\r
 777 \r
 778 \r
 779 /***************************************************************************//**\r
 780  * @brief\r
 781  *   Read the pad values for GPIO port.\r
 782  *\r
 783  * @param[in] port\r
 784  *   The GPIO port to access.\r
 785  ******************************************************************************/\r
 786 __STATIC_INLINE uint32_t GPIO_PortInGet(GPIO_Port_TypeDef port)\r
 787 {\r
 788   EFM_ASSERT(GPIO_PORT_VALID(port));\r
 789 \r
 790   return GPIO->P[port].DIN;\r
 791 }\r
 792 \r
 793 \r
 794 /***************************************************************************//**\r
 795  * @brief\r
 796  *   Set bits in DOUT register for a port to 0.\r
 797  *\r
 798  * @note\r
 799  *   In order for the setting to take effect on the output pad, the pin must\r
 800  *   have been configured properly. If not, it will take effect whenever the\r
 801  *   pin has been properly configured.\r
 802  *\r
 803  * @param[in] port\r
 804  *   The GPIO port to access.\r
 805  *\r
 806  * @param[in] pins\r
 807  *   Bit mask for bits to clear in DOUT register.\r
 808  ******************************************************************************/\r
 809 __STATIC_INLINE void GPIO_PortOutClear(GPIO_Port_TypeDef port, uint32_t pins)\r
 810 {\r
 811   EFM_ASSERT(GPIO_PORT_VALID(port));\r
 812 #if defined( _GPIO_P_DOUTCLR_MASK )\r
 813   GPIO->P[port].DOUTCLR = pins;\r
 814 #else\r
 815   BUS_RegMaskedClear(&GPIO->P[port].DOUT, pins);\r
 816 #endif\r
 817 }\r
 818 \r
 819 \r
 820 /***************************************************************************//**\r
 821  * @brief\r
 822  *   Get current setting for a GPIO port data out register.\r
 823  *\r
 824  * @param[in] port\r
 825  *   The GPIO port to access.\r
 826  *\r
 827  * @return\r
 828  *   The data out setting for the requested port.\r
 829  ******************************************************************************/\r
 830 __STATIC_INLINE uint32_t GPIO_PortOutGet(GPIO_Port_TypeDef port)\r
 831 {\r
 832   EFM_ASSERT(GPIO_PORT_VALID(port));\r
 833 \r
 834   return GPIO->P[port].DOUT;\r
 835 }\r
 836 \r
 837 \r
 838 /***************************************************************************//**\r
 839  * @brief\r
 840  *   Set bits GPIO data out register to 1.\r
 841  *\r
 842  * @note\r
 843  *   In order for the setting to take effect on the respective output pads, the\r
 844  *   pins must have been configured properly. If not, it will take effect\r
 845  *   whenever the pin has been properly configured.\r
 846  *\r
 847  * @param[in] port\r
 848  *   The GPIO port to access.\r
 849  *\r
 850  * @param[in] pins\r
 851  *   Bit mask for bits to set to 1 in DOUT register.\r
 852  ******************************************************************************/\r
 853 __STATIC_INLINE void GPIO_PortOutSet(GPIO_Port_TypeDef port, uint32_t pins)\r
 854 {\r
 855   EFM_ASSERT(GPIO_PORT_VALID(port));\r
 856 #if defined( _GPIO_P_DOUTSET_MASK )\r
 857   GPIO->P[port].DOUTSET = pins;\r
 858 #else\r
 859   BUS_RegMaskedSet(&GPIO->P[port].DOUT, pins);\r
 860 #endif\r
 861 }\r
 862 \r
 863 \r
 864 /***************************************************************************//**\r
 865  * @brief\r
 866  *   Set GPIO port data out register.\r
 867  *\r
 868  * @note\r
 869  *   In order for the setting to take effect on the respective output pads, the\r
 870  *   pins must have been configured properly. If not, it will take effect\r
 871  *   whenever the pin has been properly configured.\r
 872  *\r
 873  * @param[in] port\r
 874  *   The GPIO port to access.\r
 875  *\r
 876  * @param[in] val\r
 877  *   Value to write to port data out register.\r
 878  *\r
 879  * @param[in] mask\r
 880  *   Mask indicating which bits to modify.\r
 881  ******************************************************************************/\r
 882 __STATIC_INLINE void GPIO_PortOutSetVal(GPIO_Port_TypeDef port,\r
 883                                         uint32_t val,\r
 884                                         uint32_t mask)\r
 885 {\r
 886   EFM_ASSERT(GPIO_PORT_VALID(port));\r
 887 \r
 888   GPIO->P[port].DOUT = (GPIO->P[port].DOUT & ~mask) | (val & mask);\r
 889 }\r
 890 \r
 891 \r
 892 /***************************************************************************//**\r
 893  * @brief\r
 894  *   Toggle pins in GPIO port data out register.\r
 895  *\r
 896  * @note\r
 897  *   In order for the setting to take effect on the output pad, the pin must\r
 898  *   have been configured properly. If not, it will take effect whenever the\r
 899  *   pin has been properly configured.\r
 900  *\r
 901  * @param[in] port\r
 902  *   The GPIO port to access.\r
 903  *\r
 904  * @param[in] pins\r
 905  *   Bitmask with pins to toggle.\r
 906  ******************************************************************************/\r
 907 __STATIC_INLINE void GPIO_PortOutToggle(GPIO_Port_TypeDef port, uint32_t pins)\r
 908 {\r
 909   EFM_ASSERT(GPIO_PORT_VALID(port));\r
 910 \r
 911   GPIO->P[port].DOUTTGL = pins;\r
 912 }\r
 913 \r
 914 \r
 915 /***************************************************************************//**\r
 916  * @brief\r
 917  *   Unlocks the GPIO configuration.\r
 918  ******************************************************************************/\r
 919 __STATIC_INLINE void GPIO_Unlock(void)\r
 920 {\r
 921   GPIO->LOCK = GPIO_LOCK_LOCKKEY_UNLOCK;\r
 922 }\r
 923 \r
 924 /** @} (end addtogroup GPIO) */\r
 925 /** @} (end addtogroup EM_Library) */\r
 926 \r
 927 #ifdef __cplusplus\r
 928 }\r
 929 #endif\r
 930 \r
 931 #endif /* defined(GPIO_COUNT) && (GPIO_COUNT > 0) */\r
 932 #endif /* __SILICON_LABS_EM_GPIO_H__ */\r