git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_EFM32_Giant_Gecko_Simplicity_Studio/SiLabs_Source/BSP/bsp_bcc.c

   1 /***************************************************************************//**\r
   2  * @file\r
   3  * @brief Board Controller Communications (BCC) definitions\r
   4  * @version 4.2.1\r
   5  *******************************************************************************\r
   6  * @section License\r
   7  * <b>(C) Copyright 2014 Silicon Labs, http://www.silabs.com</b>\r
   8  *******************************************************************************\r
   9  *\r
  10  * This file is licensed under the Silabs License Agreement. See the file\r
  11  * "Silabs_License_Agreement.txt" for details. Before using this software for\r
  12  * any purpose, you must agree to the terms of that agreement.\r
  13  *\r
  14  ******************************************************************************/\r
  15 \r
  16 \r
  17 \r
  18 #include <string.h>\r
  19 #include "em_device.h"\r
  20 #include "em_cmu.h"\r
  21 #include "em_gpio.h"\r
  22 \r
  23 #include "bsp.h"\r
  24 \r
  25 #if defined( BSP_BCC_LEUART )\r
  26 #include "em_leuart.h"\r
  27 #else\r
  28 #include "em_usart.h"\r
  29 #endif\r
  30 \r
  31 #if defined( BSP_STK )\r
  32 \r
  33 /** @cond DO_NOT_INCLUDE_WITH_DOXYGEN */\r
  34 \r
  35 /* Module local variables */\r
  36 static uint32_t rxByteCount;\r
  37 static uint32_t txByteCount;\r
  38 \r
  39 /* Module local prototypes */\r
  40 static void    TxByte( uint8_t data );\r
  41 static uint8_t RxByte( void );\r
  42 \r
  43 /** @endcond */\r
  44 \r
  45 /***************************************************************************//**\r
  46  * @addtogroup BSP\r
  47  * @{\r
  48  ******************************************************************************/\r
  49 \r
  50 /***************************************************************************//**\r
  51  * @addtogroup BSP_STK API for STKs and WSTKs\r
  52  * @{\r
  53  ******************************************************************************/\r
  54 \r
  55 /**************************************************************************//**\r
  56  * @brief Deinitialize board controller communication support (BCC)\r
  57  *        functionality. Reverse actions performed by @ref BSP_BccInit().\r
  58  *\r
  59  * @return @ref BSP_STATUS_OK.\r
  60  *****************************************************************************/\r
  61 int BSP_BccDeInit( void )\r
  62 {\r
  63   /* Reset counters */\r
  64   rxByteCount = 0xFFFFFFFFUL;\r
  65   txByteCount = 0xFFFFFFFFUL;\r
  66 \r
  67   BSP_BccPinsEnable( false );\r
  68 \r
  69 #if defined( BSP_BCC_LEUART )\r
  70   /* Reset LEUART */\r
  71   LEUART_Reset( BSP_BCC_LEUART );\r
  72 #else\r
  73   /* Reset USART */\r
  74   USART_Reset( BSP_BCC_USART );\r
  75 #endif\r
  76 \r
  77   /* Disable clock */\r
  78   CMU_ClockEnable( BSP_BCC_CLK, false );\r
  79 \r
  80   return BSP_STATUS_OK;\r
  81 }\r
  82 \r
  83 /**************************************************************************//**\r
  84  * @brief Initialize board controller communication support (BCC)\r
  85  *        functionality.\r
  86  *\r
  87  * @return @ref BSP_STATUS_OK.\r
  88  *****************************************************************************/\r
  89 int BSP_BccInit( void )\r
  90 {\r
  91 #if defined( BSP_BCC_LEUART )\r
  92   LEUART_Init_TypeDef leuartInit = LEUART_INIT_DEFAULT;\r
  93 #else\r
  94   USART_InitAsync_TypeDef usartInit = USART_INITASYNC_DEFAULT;\r
  95 #endif\r
  96 \r
  97   rxByteCount = 0;\r
  98   txByteCount = 0;\r
  99 \r
 100   /* Enable High Frequency Peripherals */\r
 101   CMU_ClockEnable(cmuClock_HFPER, true);\r
 102 \r
 103   /* Enable clocks to GPIO */\r
 104   CMU_ClockEnable(cmuClock_GPIO, true);\r
 105 \r
 106   /* Enable UART clock */\r
 107   CMU_ClockEnable( BSP_BCC_CLK, true );\r
 108 \r
 109 #if defined( BSP_BCC_LEUART )\r
 110   /* Enable CORE LE clock in order to access LE modules */\r
 111   CMU_ClockEnable(cmuClock_CORELE, true);\r
 112 \r
 113   /* Select CORE LE clock for LE modules */\r
 114   CMU_ClockSelectSet( cmuClock_LFB, cmuSelect_CORELEDIV2 );\r
 115 \r
 116    /* Initialize LEUART */\r
 117    leuartInit.baudrate = 115200;\r
 118    LEUART_Init( BSP_BCC_LEUART, &leuartInit );\r
 119 #else\r
 120   /* Initialize USART */\r
 121   USART_InitAsync( BSP_BCC_USART, &usartInit );\r
 122 #endif\r
 123 \r
 124   /* Initialize UART pins */\r
 125   BSP_BccPinsEnable( true );\r
 126 \r
 127   return BSP_STATUS_OK;\r
 128 }\r
 129 \r
 130 /**************************************************************************//**\r
 131  * @brief Get a packet from the board controller.\r
 132  *\r
 133  * @param[in] pkt Pointer to a @ref BCP_Packet instance.\r
 134  *\r
 135  * @return True if packet received without errors, false otherwise.\r
 136  *****************************************************************************/\r
 137 bool BSP_BccPacketReceive( BCP_Packet *pkt )\r
 138 {\r
 139   int i;\r
 140   int length;\r
 141   uint8_t *bptr;\r
 142 \r
 143   /* Setup a byte pointer to start of packet buffer */\r
 144   bptr   = (uint8_t *) pkt;\r
 145 \r
 146   /* Receive packet magic */\r
 147   *bptr++ = RxByte();\r
 148   if (pkt->magic != BSP_BCP_MAGIC)\r
 149   {\r
 150      return false;\r
 151   }\r
 152 \r
 153   /* Receive packet type */\r
 154   *bptr++ = RxByte();\r
 155   if ( (pkt->type < BSP_BCP_FIRST) || (pkt->type > BSP_BCP_LAST) )\r
 156   {\r
 157      return false;\r
 158   }\r
 159 \r
 160   /* Receive packet length */\r
 161   *bptr++ = RxByte();\r
 162   if (pkt->payloadLength > BSP_BCP_PACKET_SIZE)\r
 163   {\r
 164      return false;\r
 165   }\r
 166 \r
 167 #if ( BSP_BCP_VERSION == 2 )\r
 168    /* Receive reserved byte */\r
 169    *bptr++ = RxByte();\r
 170 #endif\r
 171 \r
 172   /* Receive packet data length field and sanity check it */\r
 173   length  = pkt->payloadLength;\r
 174   if (length > BSP_BCP_PACKET_SIZE)\r
 175   {\r
 176      length = BSP_BCP_PACKET_SIZE;\r
 177   }\r
 178 \r
 179   /* Receive packet payload */\r
 180   for( i=0; i<length; i++ )\r
 181   {\r
 182      *bptr++ = RxByte();\r
 183   }\r
 184 \r
 185   return true;\r
 186 }\r
 187 \r
 188 /**************************************************************************//**\r
 189  * @brief Send a packet to the board controller.\r
 190  *\r
 191  * @param[in] pkt Pointer to a @ref BCP_Packet instance.\r
 192  *\r
 193  * @return @ref BSP_STATUS_OK.\r
 194  *****************************************************************************/\r
 195 int BSP_BccPacketSend( BCP_Packet *pkt )\r
 196 {\r
 197   int i;\r
 198 \r
 199   /* Apply magic */\r
 200   pkt->magic = BSP_BCP_MAGIC;\r
 201 \r
 202   /* Transmit packet magic */\r
 203   TxByte( pkt->magic );\r
 204 \r
 205   /* Transmit packet type */\r
 206   TxByte( pkt->type );\r
 207 \r
 208   /* Transmit packet length */\r
 209   TxByte( pkt->payloadLength );\r
 210 \r
 211 #if ( BSP_BCP_VERSION == 2 )\r
 212   /* Transmit reserved byte */\r
 213   TxByte( pkt->reserved );\r
 214 #endif\r
 215 \r
 216   /* Transmit packet payload */\r
 217   for ( i=0; i<pkt->payloadLength; i++ )\r
 218   {\r
 219     TxByte( pkt->data[i] );\r
 220   }\r
 221 \r
 222   return BSP_STATUS_OK;\r
 223 }\r
 224 \r
 225 /**************************************************************************//**\r
 226  * @brief Enable GPIO pins for the USART/LEUART used for board communication.\r
 227  *\r
 228  * @param[in] enable Set to true to enable pins, set to false to disable.\r
 229  *****************************************************************************/\r
 230 void BSP_BccPinsEnable( bool enable )\r
 231 {\r
 232   if (enable)\r
 233   {\r
 234     /* Configure GPIO pin for UART TX */\r
 235     /* To avoid false start, configure output as high. */\r
 236     GPIO_PinModeSet( BSP_BCC_TXPORT, BSP_BCC_TXPIN, gpioModePushPull, 1 );\r
 237 \r
 238     /* Configure GPIO pin for UART RX */\r
 239     GPIO_PinModeSet( BSP_BCC_RXPORT, BSP_BCC_RXPIN, gpioModeInput, 1 );\r
 240 \r
 241     /* Enable the switch that enables UART communication. */\r
 242     GPIO_PinModeSet( BSP_BCC_ENABLE_PORT, BSP_BCC_ENABLE_PIN, gpioModePushPull, 1 );\r
 243 \r
 244     #if defined( BSP_BCC_LEUART )\r
 245     BSP_BCC_LEUART->ROUTE |= LEUART_ROUTE_RXPEN | LEUART_ROUTE_TXPEN | BSP_BCC_LOCATION;\r
 246     #else\r
 247 \r
 248       #if defined( USART_ROUTEPEN_TXPEN )\r
 249     BSP_BCC_USART->ROUTEPEN = USART_ROUTEPEN_TXPEN | USART_ROUTEPEN_RXPEN;\r
 250     BSP_BCC_USART->ROUTELOC0 =\r
 251       ( BSP_BCC_USART->ROUTELOC0 &\r
 252         ~( _USART_ROUTELOC0_TXLOC_MASK | _USART_ROUTELOC0_RXLOC_MASK ) )\r
 253       | ( BSP_BCC_TX_LOCATION  << _USART_ROUTELOC0_TXLOC_SHIFT  )\r
 254       | ( BSP_BCC_RX_LOCATION  << _USART_ROUTELOC0_RXLOC_SHIFT  );\r
 255       #else\r
 256     BSP_BCC_USART->ROUTE |= USART_ROUTE_RXPEN | USART_ROUTE_TXPEN | BSP_BCC_LOCATION;\r
 257       #endif\r
 258     #endif\r
 259   }\r
 260   else\r
 261   {\r
 262     GPIO_PinModeSet( BSP_BCC_ENABLE_PORT, BSP_BCC_ENABLE_PIN, gpioModeDisabled, 0 );\r
 263 \r
 264     #if defined( BSP_BCC_LEUART )\r
 265       BSP_BCC_LEUART->ROUTE &= ~(LEUART_ROUTE_RXPEN | LEUART_ROUTE_TXPEN);\r
 266     #else\r
 267       #if defined( USART_ROUTEPEN_TXPEN )\r
 268       BSP_BCC_USART->ROUTEPEN &= ~(USART_ROUTEPEN_TXPEN | USART_ROUTEPEN_RXPEN);\r
 269       #else\r
 270       BSP_BCC_USART->ROUTE &= ~(USART_ROUTE_RXPEN | USART_ROUTE_TXPEN);\r
 271       #endif\r
 272     #endif\r
 273 \r
 274     GPIO_PinModeSet( BSP_BCC_TXPORT, BSP_BCC_TXPIN, gpioModeDisabled, 0 );\r
 275 \r
 276     GPIO_PinModeSet( BSP_BCC_RXPORT, BSP_BCC_RXPIN, gpioModeDisabled, 0 );\r
 277   }\r
 278 }\r
 279 \r
 280 /** @cond DO_NOT_INCLUDE_WITH_DOXYGEN */\r
 281 \r
 282 static uint8_t RxByte( void )\r
 283 {\r
 284   uint8_t byte;\r
 285 \r
 286   /* Poll RX data available flag and return a character when one is available */\r
 287 \r
 288 #if defined( BSP_BCC_LEUART )\r
 289   while (!(BSP_BCC_LEUART->IF & LEUART_IF_RXDATAV)) ;\r
 290   byte = BSP_BCC_LEUART->RXDATA;\r
 291 #else\r
 292   while (!(BSP_BCC_USART->STATUS & USART_STATUS_RXDATAV)) ;\r
 293   byte = BSP_BCC_USART->RXDATA;\r
 294 #endif\r
 295 \r
 296   rxByteCount++;\r
 297   return byte;\r
 298 }\r
 299 \r
 300 static void TxByte( uint8_t data )\r
 301 {\r
 302   /* Check TX buffer and allow for a pending transfer to complete */\r
 303 \r
 304 #if defined( BSP_BCC_LEUART )\r
 305   while (!(BSP_BCC_LEUART->STATUS & LEUART_STATUS_TXBL)) ;\r
 306   BSP_BCC_LEUART->TXDATA = (uint32_t) data;\r
 307 #else\r
 308   while (!(BSP_BCC_USART->STATUS & USART_STATUS_TXBL)) ;\r
 309   BSP_BCC_USART->TXDATA = (uint32_t) data;\r
 310 #endif\r
 311 \r
 312   txByteCount++;\r
 313 }\r
 314 \r
 315 /** @endcond */\r
 316 \r
 317 /** @} (end group BSP_STK) */\r
 318 /** @} (end group BSP) */\r
 319 \r
 320 #endif /* BSP_STK */\r