git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M7_STM32F7_STM32756G-EVAL/ST_Library/include/stm32f7xx_hal_spi.h

   1  /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f7xx_hal_spi.h\r
   4   * @author  MCD Application Team\r
   5   * @version V0.3.0\r
   6   * @date    06-March-2015\r
   7   * @brief   Header file of SPI HAL module.\r
   8   ******************************************************************************\r
   9   * @attention\r
  10   *\r
  11   * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>\r
  12   *\r
  13   * Redistribution and use in source and binary forms, with or without modification,\r
  14   * are permitted provided that the following conditions are met:\r
  15   *   1. Redistributions of source code must retain the above copyright notice,\r
  16   *      this list of conditions and the following disclaimer.\r
  17   *   2. Redistributions in binary form must reproduce the above copyright notice,\r
  18   *      this list of conditions and the following disclaimer in the documentation\r
  19   *      and/or other materials provided with the distribution.\r
  20   *   3. Neither the name of STMicroelectronics nor the names of its contributors\r
  21   *      may be used to endorse or promote products derived from this software\r
  22   *      without specific prior written permission.\r
  23   *\r
  24   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"\r
  25   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  26   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
  27   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\r
  28   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
  29   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r
  30   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\r
  31   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\r
  32   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
  33   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  34   *\r
  35   ******************************************************************************  \r
  36   */\r
  37 \r
  38 /* Define to prevent recursive inclusion -------------------------------------*/\r
  39 #ifndef __STM32F7xx_HAL_SPI_H\r
  40 #define __STM32F7xx_HAL_SPI_H\r
  41 \r
  42 #ifdef __cplusplus\r
  43  extern "C" {\r
  44 #endif\r
  45 \r
  46 /* Includes ------------------------------------------------------------------*/\r
  47 #include "stm32f7xx_hal_def.h"\r
  48 \r
  49 /** @addtogroup STM32F7xx_HAL_Driver\r
  50   * @{\r
  51   */\r
  52 \r
  53 /** @addtogroup SPI\r
  54   * @{\r
  55   */\r
  56 \r
  57 /* Exported types ------------------------------------------------------------*/\r
  58 /** @defgroup SPI_Exported_Types SPI Exported Types\r
  59   * @{\r
  60   */\r
  61 \r
  62 /**\r
  63   * @brief  SPI Configuration Structure definition\r
  64   */\r
  65 typedef struct\r
  66 {\r
  67   uint32_t Mode;                /*!< Specifies the SPI operating mode.\r
  68                                      This parameter can be a value of @ref SPI_Mode */\r
  69 \r
  70   uint32_t Direction;           /*!< Specifies the SPI bidirectional mode state.\r
  71                                      This parameter can be a value of @ref SPI_Direction */\r
  72 \r
  73   uint32_t DataSize;            /*!< Specifies the SPI data size.\r
  74                                      This parameter can be a value of @ref SPI_Data_Size */\r
  75 \r
  76   uint32_t CLKPolarity;         /*!< Specifies the serial clock steady state.\r
  77                                      This parameter can be a value of @ref SPI_Clock_Polarity */\r
  78 \r
  79   uint32_t CLKPhase;            /*!< Specifies the clock active edge for the bit capture.\r
  80                                      This parameter can be a value of @ref SPI_Clock_Phase */\r
  81 \r
  82   uint32_t NSS;                 /*!< Specifies whether the NSS signal is managed by\r
  83                                      hardware (NSS pin) or by software using the SSI bit.\r
  84                                      This parameter can be a value of @ref SPI_Slave_Select_management */\r
  85 \r
  86   uint32_t BaudRatePrescaler;   /*!< Specifies the Baud Rate prescaler value which will be\r
  87                                      used to configure the transmit and receive SCK clock.\r
  88                                      This parameter can be a value of @ref SPI_BaudRate_Prescaler\r
  89                                      @note The communication clock is derived from the master\r
  90                                      clock. The slave clock does not need to be set. */\r
  91 \r
  92   uint32_t FirstBit;            /*!< Specifies whether data transfers start from MSB or LSB bit.\r
  93                                      This parameter can be a value of @ref SPI_MSB_LSB_transmission */\r
  94 \r
  95   uint32_t TIMode;              /*!< Specifies if the TI mode is enabled or not .\r
  96                                      This parameter can be a value of @ref SPI_TI_mode */\r
  97 \r
  98   uint32_t CRCCalculation;      /*!< Specifies if the CRC calculation is enabled or not.\r
  99                                      This parameter can be a value of @ref SPI_CRC_Calculation */\r
 100 \r
 101   uint32_t CRCPolynomial;       /*!< Specifies the polynomial used for the CRC calculation.\r
 102                                      This parameter must be a number between Min_Data = 0 and Max_Data = 65535 */\r
 103 \r
 104   uint32_t CRCLength;           /*!< Specifies the CRC Length used for the CRC calculation.\r
 105                                      CRC Length is only used with Data8 and Data16, not other data size\r
 106                                      This parameter can be a value of @ref SPI_CRC_length */\r
 107 \r
 108   uint32_t NSSPMode;            /*!< Specifies whether the NSSP signal is enabled or not .\r
 109                                      This parameter can be a value of @ref SPI_NSSP_Mode\r
 110                                      This mode is activated by the NSSP bit in the SPIx_CR2 register and\r
 111                                      it takes effect only if the SPI interface is configured as Motorola SPI\r
 112                                      master (FRF=0) with capture on the first edge (SPIx_CR1 CPHA = 0,\r
 113                                      CPOL setting is ignored).. */\r
 114 } SPI_InitTypeDef;\r
 115 \r
 116 /**\r
 117   * @brief  HAL State structures definition\r
 118   */\r
 119 typedef enum\r
 120 {\r
 121   HAL_SPI_STATE_RESET      = 0x00,    /*!< Peripheral not Initialized                         */\r
 122   HAL_SPI_STATE_READY      = 0x01,    /*!< Peripheral Initialized and ready for use           */\r
 123   HAL_SPI_STATE_BUSY       = 0x02,    /*!< an internal process is ongoing                     */\r
 124   HAL_SPI_STATE_BUSY_TX    = 0x03,    /*!< Data Transmission process is ongoing               */\r
 125   HAL_SPI_STATE_BUSY_RX    = 0x04,    /*!< Data Reception process is ongoing                  */\r
 126   HAL_SPI_STATE_BUSY_TX_RX = 0x05,    /*!< Data Transmission and Reception process is ongoing*/\r
 127   HAL_SPI_STATE_ERROR      = 0x06     /*!< SPI error state                                   */\r
 128 }HAL_SPI_StateTypeDef;\r
 129 \r
 130 /**\r
 131   * @brief  SPI handle Structure definition\r
 132   */\r
 133 typedef struct __SPI_HandleTypeDef\r
 134 {\r
 135   SPI_TypeDef             *Instance;      /* SPI registers base address     */\r
 136 \r
 137   SPI_InitTypeDef         Init;           /* SPI communication parameters   */\r
 138 \r
 139   uint8_t                 *pTxBuffPtr;    /* Pointer to SPI Tx transfer Buffer */\r
 140 \r
 141   uint16_t                TxXferSize;     /* SPI Tx Transfer size */\r
 142 \r
 143   uint16_t                TxXferCount;    /* SPI Tx Transfer Counter */\r
 144 \r
 145   uint8_t                 *pRxBuffPtr;    /* Pointer to SPI Rx transfer Buffer */\r
 146 \r
 147   uint16_t                RxXferSize;     /* SPI Rx Transfer size */\r
 148 \r
 149   uint16_t                RxXferCount;    /* SPI Rx Transfer Counter */\r
 150 \r
 151   uint32_t                CRCSize;        /* SPI CRC size used for the transfer */\r
 152 \r
 153   void (*RxISR)(struct __SPI_HandleTypeDef *hspi); /* function pointer on Rx IRQ handler   */\r
 154 \r
 155   void (*TxISR)(struct __SPI_HandleTypeDef *hspi); /* function pointer on Tx IRQ handler   */\r
 156 \r
 157   DMA_HandleTypeDef       *hdmatx;        /* SPI Tx DMA Handle parameters   */\r
 158 \r
 159   DMA_HandleTypeDef       *hdmarx;        /* SPI Rx DMA Handle parameters   */\r
 160 \r
 161   HAL_LockTypeDef         Lock;           /* Locking object                 */\r
 162 \r
 163   HAL_SPI_StateTypeDef    State;          /* SPI communication state        */\r
 164 \r
 165   uint32_t                ErrorCode;      /* SPI Error code                 */\r
 166 \r
 167 }SPI_HandleTypeDef;\r
 168 \r
 169 /**\r
 170   * @}\r
 171   */\r
 172 \r
 173 /* Exported constants --------------------------------------------------------*/\r
 174 \r
 175 /** @defgroup SPI_Exported_Constants SPI Exported Constants\r
 176   * @{\r
 177   */\r
 178 \r
 179 /** @defgroup SPI_Error_Code SPI Error Code\r
 180   * @{\r
 181   */\r
 182 #define HAL_SPI_ERROR_NONE   (uint32_t)0x00000000  /*!< No error                          */\r
 183 #define HAL_SPI_ERROR_MODF   (uint32_t)0x00000001  /*!< MODF error                        */\r
 184 #define HAL_SPI_ERROR_CRC    (uint32_t)0x00000002  /*!< CRC error                         */\r
 185 #define HAL_SPI_ERROR_OVR    (uint32_t)0x00000004  /*!< OVR error                         */\r
 186 #define HAL_SPI_ERROR_FRE    (uint32_t)0x00000008  /*!< FRE error                         */\r
 187 #define HAL_SPI_ERROR_DMA    (uint32_t)0x00000010  /*!< DMA transfer error                */\r
 188 #define HAL_SPI_ERROR_FLAG   (uint32_t)0x00000020  /*!< Error on BSY/TXE/FTLVL/FRLVL Flag */\r
 189 #define HAL_SPI_ERROR_UNKNOW (uint32_t)0x00000040  /*!< Unknow Error error                */\r
 190 /**\r
 191   * @}\r
 192   */\r
 193 \r
 194 \r
 195 /** @defgroup SPI_Mode SPI Mode\r
 196   * @{\r
 197   */\r
 198 #define SPI_MODE_SLAVE                  ((uint32_t)0x00000000)\r
 199 #define SPI_MODE_MASTER                 (SPI_CR1_MSTR | SPI_CR1_SSI)\r
 200 /**\r
 201   * @}\r
 202   */\r
 203 \r
 204 /** @defgroup SPI_Direction SPI Direction Mode\r
 205   * @{\r
 206   */\r
 207 #define SPI_DIRECTION_2LINES            ((uint32_t)0x00000000)\r
 208 #define SPI_DIRECTION_2LINES_RXONLY     SPI_CR1_RXONLY\r
 209 #define SPI_DIRECTION_1LINE             SPI_CR1_BIDIMODE\r
 210 /**\r
 211   * @}\r
 212   */\r
 213 \r
 214 /** @defgroup SPI_Data_Size SPI Data Size\r
 215   * @{\r
 216   */\r
 217 #define SPI_DATASIZE_4BIT               ((uint32_t)0x0300)\r
 218 #define SPI_DATASIZE_5BIT               ((uint32_t)0x0400)\r
 219 #define SPI_DATASIZE_6BIT               ((uint32_t)0x0500)\r
 220 #define SPI_DATASIZE_7BIT               ((uint32_t)0x0600)\r
 221 #define SPI_DATASIZE_8BIT               ((uint32_t)0x0700)\r
 222 #define SPI_DATASIZE_9BIT               ((uint32_t)0x0800)\r
 223 #define SPI_DATASIZE_10BIT              ((uint32_t)0x0900)\r
 224 #define SPI_DATASIZE_11BIT              ((uint32_t)0x0A00)\r
 225 #define SPI_DATASIZE_12BIT              ((uint32_t)0x0B00)\r
 226 #define SPI_DATASIZE_13BIT              ((uint32_t)0x0C00)\r
 227 #define SPI_DATASIZE_14BIT              ((uint32_t)0x0D00)\r
 228 #define SPI_DATASIZE_15BIT              ((uint32_t)0x0E00)\r
 229 #define SPI_DATASIZE_16BIT              ((uint32_t)0x0F00)\r
 230 /**\r
 231   * @}\r
 232   */\r
 233 \r
 234 /** @defgroup SPI_Clock_Polarity SPI Clock Polarity\r
 235   * @{\r
 236   */\r
 237 #define SPI_POLARITY_LOW                ((uint32_t)0x00000000)\r
 238 #define SPI_POLARITY_HIGH               SPI_CR1_CPOL\r
 239 /**\r
 240   * @}\r
 241   */\r
 242 \r
 243 /** @defgroup SPI_Clock_Phase SPI Clock Phase\r
 244   * @{\r
 245   */\r
 246 #define SPI_PHASE_1EDGE                 ((uint32_t)0x00000000)\r
 247 #define SPI_PHASE_2EDGE                 SPI_CR1_CPHA\r
 248 /**\r
 249   * @}\r
 250   */\r
 251 \r
 252 /** @defgroup SPI_Slave_Select_management SPI Slave Select management\r
 253   * @{\r
 254   */\r
 255 #define SPI_NSS_SOFT                    SPI_CR1_SSM\r
 256 #define SPI_NSS_HARD_INPUT              ((uint32_t)0x00000000)\r
 257 #define SPI_NSS_HARD_OUTPUT             ((uint32_t)0x00040000)\r
 258 /**\r
 259   * @}\r
 260   */\r
 261 \r
 262 /** @defgroup SPI_NSSP_Mode SPI NSS Pulse Mode\r
 263   * @{\r
 264   */\r
 265 #define SPI_NSS_PULSE_ENABLE            SPI_CR2_NSSP\r
 266 #define SPI_NSS_PULSE_DISABLE           ((uint32_t)0x00000000)\r
 267 /**\r
 268   * @}\r
 269   */\r
 270 \r
 271 /** @defgroup SPI_BaudRate_Prescaler SPI BaudRate Prescaler\r
 272   * @{\r
 273   */\r
 274 #define SPI_BAUDRATEPRESCALER_2         ((uint32_t)0x00000000)\r
 275 #define SPI_BAUDRATEPRESCALER_4         ((uint32_t)0x00000008)\r
 276 #define SPI_BAUDRATEPRESCALER_8         ((uint32_t)0x00000010)\r
 277 #define SPI_BAUDRATEPRESCALER_16        ((uint32_t)0x00000018)\r
 278 #define SPI_BAUDRATEPRESCALER_32        ((uint32_t)0x00000020)\r
 279 #define SPI_BAUDRATEPRESCALER_64        ((uint32_t)0x00000028)\r
 280 #define SPI_BAUDRATEPRESCALER_128       ((uint32_t)0x00000030)\r
 281 #define SPI_BAUDRATEPRESCALER_256       ((uint32_t)0x00000038)\r
 282 /**\r
 283   * @}\r
 284   */\r
 285 \r
 286 /** @defgroup SPI_MSB_LSB_transmission SPI MSB LSB transmission\r
 287   * @{\r
 288   */\r
 289 #define SPI_FIRSTBIT_MSB                ((uint32_t)0x00000000)\r
 290 #define SPI_FIRSTBIT_LSB                SPI_CR1_LSBFIRST\r
 291 /**\r
 292   * @}\r
 293   */\r
 294 \r
 295 /** @defgroup SPI_TI_mode SPI TI mode\r
 296   * @{\r
 297   */\r
 298 #define SPI_TIMODE_DISABLE              ((uint32_t)0x00000000)\r
 299 #define SPI_TIMODE_ENABLE               SPI_CR2_FRF\r
 300 /**\r
 301   * @}\r
 302   */\r
 303 \r
 304 /** @defgroup SPI_CRC_Calculation SPI CRC Calculation\r
 305   * @{\r
 306   */\r
 307 #define SPI_CRCCALCULATION_DISABLE      ((uint32_t)0x00000000)\r
 308 #define SPI_CRCCALCULATION_ENABLE       SPI_CR1_CRCEN\r
 309 /**\r
 310   * @}\r
 311   */\r
 312 \r
 313 /** @defgroup SPI_CRC_length SPI CRC Length\r
 314   * @{\r
 315   * This parameter can be one of the following values:\r
 316   *     SPI_CRC_LENGTH_DATASIZE: aligned with the data size\r
 317   *     SPI_CRC_LENGTH_8BIT    : CRC 8bit\r
 318   *     SPI_CRC_LENGTH_16BIT   : CRC 16bit\r
 319   */\r
 320 #define SPI_CRC_LENGTH_DATASIZE         ((uint32_t)0x00000000)\r
 321 #define SPI_CRC_LENGTH_8BIT             ((uint32_t)0x00000001)\r
 322 #define SPI_CRC_LENGTH_16BIT            ((uint32_t)0x00000002)\r
 323 /**\r
 324   * @}\r
 325   */\r
 326 \r
 327 /** @defgroup SPI_FIFO_reception_threshold SPI FIFO Reception Threshold\r
 328   * @{\r
 329   * This parameter can be one of the following values:\r
 330   *     SPI_RXFIFO_THRESHOLD or SPI_RXFIFO_THRESHOLD_QF :\r
 331   *          RXNE event is generated if the FIFO\r
 332   *          level is greater or equal to 1/2(16-bits).\r
 333   *     SPI_RXFIFO_THRESHOLD_HF: RXNE event is generated if the FIFO\r
 334   *          level is greater or equal to 1/4(8 bits). */\r
 335 #define SPI_RXFIFO_THRESHOLD            SPI_CR2_FRXTH\r
 336 #define SPI_RXFIFO_THRESHOLD_QF         SPI_CR2_FRXTH\r
 337 #define SPI_RXFIFO_THRESHOLD_HF         ((uint32_t)0x00000000)\r
 338 \r
 339 /**\r
 340   * @}\r
 341   */\r
 342 \r
 343 /** @defgroup SPI_Interrupt_configuration_definition SPI Interrupt configuration definition\r
 344   * @brief SPI Interrupt definition\r
 345   *        Elements values convention: 0xXXXXXXXX\r
 346   *           - XXXXXXXX  : Interrupt control mask\r
 347   * @{\r
 348   */\r
 349 #define SPI_IT_TXE                      SPI_CR2_TXEIE\r
 350 #define SPI_IT_RXNE                     SPI_CR2_RXNEIE\r
 351 #define SPI_IT_ERR                      SPI_CR2_ERRIE\r
 352 /**\r
 353   * @}\r
 354   */\r
 355 \r
 356 \r
 357 /** @defgroup SPI_Flag_definition SPI Flag definition\r
 358   * @brief Flag definition\r
 359   *        Elements values convention: 0xXXXXYYYY\r
 360   *           - XXXX  : Flag register Index\r
 361   *           - YYYY  : Flag mask\r
 362   * @{\r
 363   */\r
 364 #define SPI_FLAG_RXNE                   SPI_SR_RXNE   /* SPI status flag: Rx buffer not empty flag */\r
 365 #define SPI_FLAG_TXE                    SPI_SR_TXE    /* SPI status flag: Tx buffer empty flag */\r
 366 #define SPI_FLAG_BSY                    SPI_SR_BSY    /* SPI status flag: Busy flag */\r
 367 #define SPI_FLAG_CRCERR                 SPI_SR_CRCERR /* SPI Error flag: CRC error flag */\r
 368 #define SPI_FLAG_MODF                   SPI_SR_MODF   /* SPI Error flag: Mode fault flag */\r
 369 #define SPI_FLAG_OVR                    SPI_SR_OVR    /* SPI Error flag: Overrun flag */\r
 370 #define SPI_FLAG_FRE                    SPI_SR_FRE    /* SPI Error flag: TI mode frame format error flag */\r
 371 #define SPI_FLAG_FTLVL                  SPI_SR_FTLVL  /* SPI fifo transmission level */\r
 372 #define SPI_FLAG_FRLVL                  SPI_SR_FRLVL  /* SPI fifo reception level */\r
 373 /**\r
 374   * @}\r
 375   */\r
 376 \r
 377 /** @defgroup SPI_transmission_fifo_status_level SPI Transmission FIFO Status Level\r
 378   * @{\r
 379   */\r
 380 #define SPI_FTLVL_EMPTY           ((uint32_t)0x0000)\r
 381 #define SPI_FTLVL_QUARTER_FULL    ((uint32_t)0x0800)\r
 382 #define SPI_FTLVL_HALF_FULL       ((uint32_t)0x1000)\r
 383 #define SPI_FTLVL_FULL            ((uint32_t)0x1800)\r
 384 \r
 385 /**\r
 386   * @}\r
 387   */\r
 388 \r
 389 /** @defgroup SPI_reception_fifo_status_level SPI Reception FIFO Status Level\r
 390   * @{\r
 391   */\r
 392 #define SPI_FRLVL_EMPTY           ((uint32_t)0x0000)\r
 393 #define SPI_FRLVL_QUARTER_FULL    ((uint32_t)0x0200)\r
 394 #define SPI_FRLVL_HALF_FULL       ((uint32_t)0x0400)\r
 395 #define SPI_FRLVL_FULL            ((uint32_t)0x0600)\r
 396 /**\r
 397   * @}\r
 398   */\r
 399 \r
 400 /**\r
 401   * @}\r
 402   */\r
 403 \r
 404 /* Exported macros ------------------------------------------------------------*/\r
 405 /** @defgroup SPI_Exported_Macros SPI Exported Macros\r
 406   * @{\r
 407   */\r
 408 \r
 409 /** @brief  Reset SPI handle state\r
 410   * @param  __HANDLE__: SPI handle.\r
 411   * @retval None\r
 412   */\r
 413 #define __HAL_SPI_RESET_HANDLE_STATE(__HANDLE__) ((__HANDLE__)->State = HAL_SPI_STATE_RESET)\r
 414 \r
 415 /** @brief  Enables or disables the specified SPI interrupts.\r
 416   * @param  __HANDLE__ : specifies the SPI Handle.\r
 417   *         This parameter can be SPI where x: 1, 2, or 3 to select the SPI peripheral.\r
 418   * @param  __INTERRUPT__ : specifies the interrupt source to enable or disable.\r
 419   *        This parameter can be one of the following values:\r
 420   *            @arg SPI_IT_TXE: Tx buffer empty interrupt enable\r
 421   *            @arg SPI_IT_RXNE: RX buffer not empty interrupt enable\r
 422   *            @arg SPI_IT_ERR: Error interrupt enable\r
 423   * @retval None\r
 424   */\r
 425 #define __HAL_SPI_ENABLE_IT(__HANDLE__, __INTERRUPT__)   ((__HANDLE__)->Instance->CR2 |= (__INTERRUPT__))\r
 426 #define __HAL_SPI_DISABLE_IT(__HANDLE__, __INTERRUPT__)  ((__HANDLE__)->Instance->CR2 &= (~(__INTERRUPT__)))\r
 427 \r
 428 /** @brief  Checks if the specified SPI interrupt source is enabled or disabled.\r
 429   * @param  __HANDLE__ : specifies the SPI Handle.\r
 430   *         This parameter can be SPI where x: 1, 2, or 3 to select the SPI peripheral.\r
 431   * @param  __INTERRUPT__ : specifies the SPI interrupt source to check.\r
 432   *          This parameter can be one of the following values:\r
 433   *            @arg SPI_IT_TXE: Tx buffer empty interrupt enable\r
 434   *            @arg SPI_IT_RXNE: RX buffer not empty interrupt enable\r
 435   *            @arg SPI_IT_ERR: Error interrupt enable\r
 436   * @retval The new state of __IT__ (TRUE or FALSE).\r
 437   */\r
 438 #define __HAL_SPI_GET_IT_SOURCE(__HANDLE__, __INTERRUPT__) ((((__HANDLE__)->Instance->CR2 & (__INTERRUPT__)) == (__INTERRUPT__)) ? SET : RESET)\r
 439 \r
 440 /** @brief  Checks whether the specified SPI flag is set or not.\r
 441   * @param  __HANDLE__ : specifies the SPI Handle.\r
 442   *         This parameter can be SPI where x: 1, 2, or 3 to select the SPI peripheral.\r
 443   * @param  __FLAG__ : specifies the flag to check.\r
 444   *        This parameter can be one of the following values:\r
 445   *            @arg SPI_FLAG_RXNE: Receive buffer not empty flag\r
 446   *            @arg SPI_FLAG_TXE: Transmit buffer empty flag\r
 447   *            @arg SPI_FLAG_CRCERR: CRC error flag\r
 448   *            @arg SPI_FLAG_MODF: Mode fault flag\r
 449   *            @arg SPI_FLAG_OVR: Overrun flag\r
 450   *            @arg SPI_FLAG_BSY: Busy flag\r
 451   *            @arg SPI_FLAG_FRE: Frame format error flag\r
 452   *            @arg SPI_FLAG_FTLVL: SPI fifo transmission level\r
 453   *            @arg SPI_FLAG_FRLVL: SPI fifo reception level\r
 454   * @retval The new state of __FLAG__ (TRUE or FALSE).\r
 455   */\r
 456 #define __HAL_SPI_GET_FLAG(__HANDLE__, __FLAG__) ((((__HANDLE__)->Instance->SR) & (__FLAG__)) == (__FLAG__))\r
 457 \r
 458 /** @brief  Clears the SPI CRCERR pending flag.\r
 459   * @param  __HANDLE__ : specifies the SPI Handle.\r
 460   *         This parameter can be SPI where x: 1, 2, or 3 to select the SPI peripheral.\r
 461   * @retval None\r
 462   */\r
 463 #define __HAL_SPI_CLEAR_CRCERRFLAG(__HANDLE__) ((__HANDLE__)->Instance->SR = (uint16_t)(~SPI_FLAG_CRCERR))\r
 464 \r
 465 /** @brief  Clears the SPI MODF pending flag.\r
 466   * @param  __HANDLE__ : specifies the SPI Handle.\r
 467   *         This parameter can be SPI where x: 1, 2, or 3 to select the SPI peripheral.\r
 468   *\r
 469   * @retval None\r
 470   */\r
 471 #define __HAL_SPI_CLEAR_MODFFLAG(__HANDLE__)        \\r
 472    do{                                              \\r
 473      __IO uint32_t tmpreg;                          \\r
 474      tmpreg = (__HANDLE__)->Instance->SR;           \\r
 475      (__HANDLE__)->Instance->CR1 &= (~SPI_CR1_SPE); \\r
 476      UNUSED(tmpreg);                                \\r
 477    } while(0)\r
 478 \r
 479 /** @brief  Clears the SPI OVR pending flag.\r
 480   * @param  __HANDLE__ : specifies the SPI Handle.\r
 481   *         This parameter can be SPI where x: 1, 2, or 3 to select the SPI peripheral.\r
 482   *\r
 483   * @retval None\r
 484   */\r
 485 #define __HAL_SPI_CLEAR_OVRFLAG(__HANDLE__)         \\r
 486    do{                                              \\r
 487      __IO uint32_t tmpreg;                          \\r
 488      tmpreg = (__HANDLE__)->Instance->DR;           \\r
 489      tmpreg = (__HANDLE__)->Instance->SR;           \\r
 490      UNUSED(tmpreg);                                \\r
 491    } while(0)\r
 492 \r
 493 /** @brief  Clears the SPI FRE pending flag.\r
 494   * @param  __HANDLE__ : specifies the SPI Handle.\r
 495   *         This parameter can be SPI where x: 1, 2, or 3 to select the SPI peripheral.\r
 496   *\r
 497   * @retval None\r
 498   */\r
 499 #define __HAL_SPI_CLEAR_FREFLAG(__HANDLE__)         \\r
 500    do{                                              \\r
 501      __IO uint32_t tmpreg;                          \\r
 502      tmpreg = (__HANDLE__)->Instance->SR;           \\r
 503      UNUSED(tmpreg);                                \\r
 504    } while(0)\r
 505 \r
 506 /** @brief  Enables the SPI.\r
 507   * @param  __HANDLE__ : specifies the SPI Handle.\r
 508   *         This parameter can be SPI where x: 1, 2, or 3 to select the SPI peripheral.\r
 509   * @retval None\r
 510   */\r
 511 #define __HAL_SPI_ENABLE(__HANDLE__) ((__HANDLE__)->Instance->CR1 |=  SPI_CR1_SPE)\r
 512 \r
 513 /** @brief  Disables the SPI.\r
 514   * @param  __HANDLE__ : specifies the SPI Handle.\r
 515   *         This parameter can be SPI where x: 1, 2, or 3 to select the SPI peripheral.\r
 516   * @retval None\r
 517   */\r
 518 #define __HAL_SPI_DISABLE(__HANDLE__) ((__HANDLE__)->Instance->CR1 &= (~SPI_CR1_SPE))\r
 519 \r
 520 /**\r
 521   * @}\r
 522   */\r
 523 \r
 524 /* Private macros --------------------------------------------------------*/\r
 525 /** @defgroup SPI_Private_Macros   SPI Private Macros\r
 526   * @{\r
 527   */\r
 528 \r
 529 /** @brief  Sets the SPI transmit-only mode.\r
 530   * @param  __HANDLE__ : specifies the SPI Handle.\r
 531   *         This parameter can be SPI where x: 1, 2, or 3 to select the SPI peripheral.\r
 532   * @retval None\r
 533   */\r
 534 #define SPI_1LINE_TX(__HANDLE__) ((__HANDLE__)->Instance->CR1 |= SPI_CR1_BIDIOE)\r
 535 \r
 536 /** @brief  Sets the SPI receive-only mode.\r
 537   * @param  __HANDLE__ : specifies the SPI Handle.\r
 538   *         This parameter can be SPI where x: 1, 2, or 3 to select the SPI peripheral.\r
 539   * @retval None\r
 540   */\r
 541 #define SPI_1LINE_RX(__HANDLE__) ((__HANDLE__)->Instance->CR1 &= (~SPI_CR1_BIDIOE))\r
 542 \r
 543 /** @brief  Resets the CRC calculation of the SPI.\r
 544   * @param  __HANDLE__ : specifies the SPI Handle.\r
 545   *         This parameter can be SPI where x: 1, 2, or 3 to select the SPI peripheral.\r
 546   * @retval None\r
 547   */\r
 548 #define SPI_RESET_CRC(__HANDLE__) do{(__HANDLE__)->Instance->CR1 &= (uint16_t)(~SPI_CR1_CRCEN);\\r
 549                                      (__HANDLE__)->Instance->CR1 |= SPI_CR1_CRCEN;}while(0)\r
 550 \r
 551 #define IS_SPI_MODE(MODE) (((MODE) == SPI_MODE_SLAVE) || \\r
 552                            ((MODE) == SPI_MODE_MASTER))\r
 553 \r
 554 #define IS_SPI_DIRECTION(MODE)   (((MODE) == SPI_DIRECTION_2LINES) || \\r
 555                                   ((MODE) == SPI_DIRECTION_2LINES_RXONLY) ||\\r
 556                                   ((MODE) == SPI_DIRECTION_1LINE))\r
 557 \r
 558 #define IS_SPI_DIRECTION_2LINES(MODE) ((MODE) == SPI_DIRECTION_2LINES)\r
 559 \r
 560 #define IS_SPI_DIRECTION_2LINES_OR_1LINE(MODE) (((MODE) == SPI_DIRECTION_2LINES)|| \\r
 561                                                  ((MODE) == SPI_DIRECTION_1LINE))\r
 562 \r
 563 #define IS_SPI_DATASIZE(DATASIZE) (((DATASIZE) == SPI_DATASIZE_16BIT) || \\r
 564                                    ((DATASIZE) == SPI_DATASIZE_15BIT) || \\r
 565                                    ((DATASIZE) == SPI_DATASIZE_14BIT) || \\r
 566                                    ((DATASIZE) == SPI_DATASIZE_13BIT) || \\r
 567                                    ((DATASIZE) == SPI_DATASIZE_12BIT) || \\r
 568                                    ((DATASIZE) == SPI_DATASIZE_11BIT) || \\r
 569                                    ((DATASIZE) == SPI_DATASIZE_10BIT) || \\r
 570                                    ((DATASIZE) == SPI_DATASIZE_9BIT)  || \\r
 571                                    ((DATASIZE) == SPI_DATASIZE_8BIT)  || \\r
 572                                    ((DATASIZE) == SPI_DATASIZE_7BIT)  || \\r
 573                                    ((DATASIZE) == SPI_DATASIZE_6BIT)  || \\r
 574                                    ((DATASIZE) == SPI_DATASIZE_5BIT)  || \\r
 575                                    ((DATASIZE) == SPI_DATASIZE_4BIT))\r
 576 \r
 577 #define IS_SPI_CPOL(CPOL) (((CPOL) == SPI_POLARITY_LOW) || \\r
 578                            ((CPOL) == SPI_POLARITY_HIGH))\r
 579 \r
 580 #define IS_SPI_CPHA(CPHA) (((CPHA) == SPI_PHASE_1EDGE) || \\r
 581                            ((CPHA) == SPI_PHASE_2EDGE))\r
 582 \r
 583 #define IS_SPI_NSS(NSS) (((NSS) == SPI_NSS_SOFT) || \\r
 584                          ((NSS) == SPI_NSS_HARD_INPUT) || \\r
 585                          ((NSS) == SPI_NSS_HARD_OUTPUT))\r
 586 \r
 587 #define IS_SPI_NSSP(NSSP) (((NSSP) == SPI_NSS_PULSE_ENABLE) || \\r
 588                            ((NSSP) == SPI_NSS_PULSE_DISABLE))\r
 589 \r
 590 #define IS_SPI_BAUDRATE_PRESCALER(PRESCALER) (((PRESCALER) == SPI_BAUDRATEPRESCALER_2) || \\r
 591                                               ((PRESCALER) == SPI_BAUDRATEPRESCALER_4) || \\r
 592                                               ((PRESCALER) == SPI_BAUDRATEPRESCALER_8) || \\r
 593                                               ((PRESCALER) == SPI_BAUDRATEPRESCALER_16) || \\r
 594                                               ((PRESCALER) == SPI_BAUDRATEPRESCALER_32) || \\r
 595                                               ((PRESCALER) == SPI_BAUDRATEPRESCALER_64) || \\r
 596                                               ((PRESCALER) == SPI_BAUDRATEPRESCALER_128) || \\r
 597                                               ((PRESCALER) == SPI_BAUDRATEPRESCALER_256))\r
 598 \r
 599 #define IS_SPI_FIRST_BIT(BIT) (((BIT) == SPI_FIRSTBIT_MSB) || \\r
 600                                ((BIT) == SPI_FIRSTBIT_LSB))\r
 601 \r
 602 #define IS_SPI_TIMODE(MODE) (((MODE) == SPI_TIMODE_DISABLE) || \\r
 603                              ((MODE) == SPI_TIMODE_ENABLE))\r
 604 \r
 605 #define IS_SPI_CRC_CALCULATION(CALCULATION) (((CALCULATION) == SPI_CRCCALCULATION_DISABLE) || \\r
 606                                              ((CALCULATION) == SPI_CRCCALCULATION_ENABLE))\r
 607 \r
 608 #define IS_SPI_CRC_LENGTH(LENGTH) (((LENGTH) == SPI_CRC_LENGTH_DATASIZE) ||\\r
 609                                    ((LENGTH) == SPI_CRC_LENGTH_8BIT)  ||   \\r
 610                                    ((LENGTH) == SPI_CRC_LENGTH_16BIT))\r
 611 \r
 612 #define IS_SPI_CRC_POLYNOMIAL(POLYNOMIAL) (((POLYNOMIAL) >= 0x1) && ((POLYNOMIAL) <= 0xFFFF))\r
 613 \r
 614 \r
 615 /**\r
 616   * @}\r
 617   */\r
 618 \r
 619 /* Exported functions --------------------------------------------------------*/\r
 620 /** @addtogroup SPI_Exported_Functions SPI Exported Functions\r
 621   * @{\r
 622   */\r
 623 \r
 624 /** @addtogroup SPI_Exported_Functions_Group1 Initialization and de-initialization functions\r
 625   * @{\r
 626   */\r
 627 \r
 628 /* Initialization and de-initialization functions  ****************************/\r
 629 HAL_StatusTypeDef HAL_SPI_Init(SPI_HandleTypeDef *hspi);\r
 630 HAL_StatusTypeDef HAL_SPI_DeInit (SPI_HandleTypeDef *hspi);\r
 631 void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi);\r
 632 void HAL_SPI_MspDeInit(SPI_HandleTypeDef *hspi);\r
 633 /**\r
 634   * @}\r
 635   */\r
 636 \r
 637 /** @addtogroup SPI_Exported_Functions_Group2 Input and Output operation functions \r
 638   * @{\r
 639   */\r
 640 \r
 641 /* IO operation functions *****************************************************/\r
 642 HAL_StatusTypeDef HAL_SPI_Transmit(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout);\r
 643 HAL_StatusTypeDef HAL_SPI_Receive(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size, uint32_t Timeout);\r
 644 HAL_StatusTypeDef HAL_SPI_TransmitReceive(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size, uint32_t Timeout);\r
 645 HAL_StatusTypeDef HAL_SPI_Transmit_IT(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size);\r
 646 HAL_StatusTypeDef HAL_SPI_Receive_IT(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size);\r
 647 HAL_StatusTypeDef HAL_SPI_TransmitReceive_IT(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size);\r
 648 HAL_StatusTypeDef HAL_SPI_Transmit_DMA(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size);\r
 649 HAL_StatusTypeDef HAL_SPI_Receive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pData, uint16_t Size);\r
 650 HAL_StatusTypeDef HAL_SPI_TransmitReceive_DMA(SPI_HandleTypeDef *hspi, uint8_t *pTxData, uint8_t *pRxData, uint16_t Size);\r
 651 HAL_StatusTypeDef HAL_SPI_DMAPause(SPI_HandleTypeDef *hspi);\r
 652 HAL_StatusTypeDef HAL_SPI_DMAResume(SPI_HandleTypeDef *hspi);\r
 653 HAL_StatusTypeDef HAL_SPI_DMAStop(SPI_HandleTypeDef *hspi);\r
 654 \r
 655 void HAL_SPI_IRQHandler(SPI_HandleTypeDef *hspi);\r
 656 void HAL_SPI_TxCpltCallback(SPI_HandleTypeDef *hspi);\r
 657 void HAL_SPI_RxCpltCallback(SPI_HandleTypeDef *hspi);\r
 658 void HAL_SPI_TxRxCpltCallback(SPI_HandleTypeDef *hspi);\r
 659 void HAL_SPI_TxHalfCpltCallback(SPI_HandleTypeDef *hspi);\r
 660 void HAL_SPI_RxHalfCpltCallback(SPI_HandleTypeDef *hspi);\r
 661 void HAL_SPI_TxRxHalfCpltCallback(SPI_HandleTypeDef *hspi);\r
 662 void HAL_SPI_ErrorCallback(SPI_HandleTypeDef *hspi);\r
 663 /**\r
 664   * @}\r
 665   */\r
 666 \r
 667 /** @addtogroup SPI_Exported_Functions_Group3 Peripheral Control functions \r
 668   * @{\r
 669   */\r
 670 \r
 671 /* Peripheral State and Error functions ***************************************/\r
 672 HAL_SPI_StateTypeDef HAL_SPI_GetState(SPI_HandleTypeDef *hspi);\r
 673 uint32_t             HAL_SPI_GetError(SPI_HandleTypeDef *hspi);\r
 674 /**\r
 675   * @}\r
 676   */\r
 677 \r
 678 /**\r
 679   * @}\r
 680   */\r
 681 \r
 682 /**\r
 683   * @}\r
 684   */\r
 685 \r
 686 /**\r
 687   * @}\r
 688   */\r
 689 \r
 690 #ifdef __cplusplus\r
 691 }\r
 692 #endif\r
 693 \r
 694 #endif /* __STM32F7xx_HAL_SPI_H */\r
 695 \r
 696 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r