1 /** 2 **************************************************************************************** 3 * 4 * @file gr55xx_hal_spi.h 5 * @author BLE Driver Team 6 * @brief Header file containing functions prototypes of SPI HAL library. 7 * 8 **************************************************************************************** 9 * @attention 10 #####Copyright (c) 2019 GOODIX 11 All rights reserved. 12 13 Redistribution and use in source and binary forms, with or without 14 modification, are permitted provided that the following conditions are met: 15 * Redistributions of source code must retain the above copyright 16 notice, this list of conditions and the following disclaimer. 17 * Redistributions in binary form must reproduce the above copyright 18 notice, this list of conditions and the following disclaimer in the 19 documentation and/or other materials provided with the distribution. 20 * Neither the name of GOODIX nor the names of its contributors may be used 21 to endorse or promote products derived from this software without 22 specific prior written permission. 23 24 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 25 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE 28 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 29 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 30 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 31 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 32 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 33 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 34 POSSIBILITY OF SUCH DAMAGE. 35 **************************************************************************************** 36 */ 37 38 /** @addtogroup PERIPHERAL Peripheral Driver 39 * @{ 40 */ 41 42 /** @addtogroup HAL_DRIVER HAL Driver 43 * @{ 44 */ 45 46 /** @defgroup HAL_SPI SPI 47 * @brief SPI HAL module driver. 48 * @{ 49 */ 50 51 /* Define to prevent recursive inclusion -------------------------------------*/ 52 #ifndef __GR55xx_HAL_SPI_H__ 53 #define __GR55xx_HAL_SPI_H__ 54 55 /* Includes ------------------------------------------------------------------*/ 56 #include "gr55xx_ll_spi.h" 57 #include "gr55xx_hal_def.h" 58 59 #ifdef __cplusplus 60 extern "C" { 61 #endif 62 63 /* Exported types ------------------------------------------------------------*/ 64 /** @addtogroup HAL_SPI_ENUMERATIONS Enumerations 65 * @{ 66 */ 67 68 /** @defgroup HAL_SPI_state HAL SPI state 69 * @{ 70 */ 71 72 /** 73 * @brief HAL SPI State Enumerations definition 74 */ 75 typedef enum { 76 HAL_SPI_STATE_RESET = 0x00, /**< Peripheral not initialized */ 77 HAL_SPI_STATE_READY = 0x01, /**< Peripheral initialized and ready for use */ 78 HAL_SPI_STATE_BUSY = 0x02, /**< An internal process is ongoing */ 79 HAL_SPI_STATE_BUSY_TX = 0x12, /**< Data Transmission process is ongoing */ 80 HAL_SPI_STATE_BUSY_RX = 0x22, /**< Data Reception process is ongoing */ 81 HAL_SPI_STATE_BUSY_TX_RX = 0x32, /**< Data Transmission and Reception process is ongoing */ 82 HAL_SPI_STATE_ABORT = 0x08, /**< Peripheral with abort request ongoing */ 83 HAL_SPI_STATE_ERROR = 0x04 /**< Peripheral in error */ 84 } hal_spi_state_t; 85 86 /** @} */ 87 88 /** @} */ 89 90 /** @addtogroup HAL_SPI_STRUCTURES Structures 91 * @{ 92 */ 93 94 /** @defgroup SPI_Configuration SPI Configuration 95 * @{ 96 */ 97 98 /** 99 * @brief SPI init Structure definition 100 */ 101 typedef struct _spi_init { 102 uint32_t data_size; /**< Specifies the SPI data size. 103 This parameter can be a value of @ref SPI_Data_Size */ 104 105 uint32_t clock_polarity; /**< Specifies the serial clock steady state. 106 This parameter can be a value of @ref SPI_Clock_Polarity */ 107 108 uint32_t clock_phase; /**< Specifies the clock active edge for the bit capture. 109 This parameter can be a value of @ref SPI_Clock_Phase */ 110 111 uint32_t baudrate_prescaler; /**< Specifies the BaudRate prescaler value which will be 112 used to configure the transmit and receive SCK clock. 113 @note The communication clock is derived from the master 114 clock. The slave clock does not need to be set. */ 115 116 uint32_t ti_mode; /**< Specifies if the TI mode is enabled or not. 117 This parameter can be a value of @ref SPI_TI_Mode */ 118 119 uint32_t slave_select; /**< Specifies the slaves to be selected. 120 This parameter can be a value of @ref SPI_Slave_Select */ 121 } spi_init_t; 122 /** @} */ 123 124 /** @defgroup SPI_handle SPI handle 125 * @{ 126 */ 127 128 /** 129 * @brief SPI handle Structure definition 130 */ 131 typedef struct _spi_handle { 132 ssi_regs_t *p_instance; /**< SPI registers base address */ 133 134 spi_init_t init; /**< SPI communication parameters */ 135 136 uint8_t *p_tx_buffer; /**< Pointer to SPI Tx transfer Buffer */ 137 138 __IO uint32_t tx_xfer_size; /**< SPI Tx Transfer size */ 139 140 __IO uint32_t tx_xfer_count; /**< SPI Tx Transfer Counter */ 141 142 uint8_t *p_rx_buffer; /**< Pointer to SPI Rx transfer Buffer */ 143 144 __IO uint32_t rx_xfer_size; /**< SPI Rx Transfer size */ 145 146 __IO uint32_t rx_xfer_count; /**< SPI Rx Transfer Counter */ 147 148 void (*write_fifo)(struct _spi_handle *p_spi); /**< Pointer to SPI Tx transfer FIFO write function */ 149 150 void (*read_fifo)(struct _spi_handle *p_spi); /**< Pointer to SPI Rx transfer FIFO read function */ 151 152 void (*read_write_fifo)(struct _spi_handle *p_spi); /**< Pointer to SPI transfer FIFO read and write function */ 153 154 dma_handle_t *p_dmatx; /**< SPI Tx DMA Handle parameters */ 155 156 dma_handle_t *p_dmarx; /**< SPI Rx DMA Handle parameters */ 157 158 __IO hal_lock_t lock; /**< Locking object */ 159 160 __IO hal_spi_state_t state; /**< SPI communication state */ 161 162 __IO uint32_t error_code; /**< SPI Error code */ 163 164 uint32_t timeout; /**< Timeout for the SPI memory access */ 165 166 #if defined(HAL_SPI_V2_MODULE_ENABLED) 167 uint32_t retention[9]; /**< SPI important register information. */ 168 #else 169 uint32_t retention[8]; /**< SPI important register information. */ 170 #endif 171 } spi_handle_t; 172 /** @} */ 173 174 /** @} */ 175 176 /** @addtogroup HAL_SPI_CALLBACK_STRUCTURES Callback Structures 177 * @{ 178 */ 179 180 /** @defgroup HAL_SPI_Callback Callback 181 * @{ 182 */ 183 184 /** 185 * @brief HAL_SPI Callback function definition 186 */ 187 188 typedef struct _hal_spi_callback { 189 void (*spi_msp_init)(spi_handle_t *p_spi); /**< SPI init MSP callback */ 190 void (*spi_msp_deinit)(spi_handle_t *p_spi); /**< SPI de-init MSP callback */ 191 void (*spi_error_callback)(spi_handle_t *p_spi); /**< SPI error callback */ 192 void (*spi_abort_cplt_callback)(spi_handle_t *p_spi); /**< SPI abort completed callback */ 193 void (*spi_rx_cplt_callback)(spi_handle_t *p_spi); /**< SPI rx transfer completed callback */ 194 void (*spi_tx_cplt_callback)(spi_handle_t *p_spi); /**< SPI tx transfer completed callback */ 195 void (*spi_tx_rx_cplt_callback)(spi_handle_t *p_spi); /**< SPI tx/rx transfer completed callback */ 196 } hal_spi_callback_t; 197 198 /** @} */ 199 200 /** @} */ 201 202 /** 203 * @defgroup HAL_SPI_MACRO Defines 204 * @{ 205 */ 206 207 /* Exported constants --------------------------------------------------------*/ 208 /** @defgroup SPI_Exported_Constants SPI Exported Constants 209 * @{ 210 */ 211 212 /** @defgroup SPI_Direction SPI Direction 213 * @{ 214 */ 215 #define SPI_DIRECTION_FULL_DUPLEX LL_SSI_FULL_DUPLEX /**< Full Duplex: Transmit & Receive */ 216 #define SPI_DIRECTION_SIMPLEX_TX LL_SSI_SIMPLEX_TX /**< Simplex Tx: Transmit only */ 217 #define SPI_DIRECTION_SIMPLEX_RX LL_SSI_SIMPLEX_RX /**< Simplex Rx: Receive only */ 218 #define SPI_DIRECTION_READ_EEPROM LL_SSI_READ_EEPROM /**< Read EEPROM */ 219 /** @} */ 220 221 /** @defgroup SPI_Error_Code SPI Error Code 222 * @{ 223 */ 224 #define HAL_SPI_ERROR_NONE ((uint32_t)0x00000000) /**< No error */ 225 #define HAL_SPI_ERROR_TIMEOUT ((uint32_t)0x00000001) /**< Timeout error */ 226 #define HAL_SPI_ERROR_TRANSFER ((uint32_t)0x00000002) /**< Transfer error */ 227 #define HAL_SPI_ERROR_DMA ((uint32_t)0x00000004) /**< DMA transfer error */ 228 #define HAL_SPI_ERROR_INVALID_PARAM ((uint32_t)0x00000008) /**< Invalid parameters error */ 229 /** @} */ 230 231 /** @defgroup SPI_Data_Size SPI Data Size 232 * @{ 233 */ 234 #define SPI_DATASIZE_4BIT LL_SSI_DATASIZE_4BIT /**< 4-bit serial data transfer */ 235 #define SPI_DATASIZE_5BIT LL_SSI_DATASIZE_5BIT /**< 5-bit serial data transfer */ 236 #define SPI_DATASIZE_6BIT LL_SSI_DATASIZE_6BIT /**< 6-bit serial data transfer */ 237 #define SPI_DATASIZE_7BIT LL_SSI_DATASIZE_7BIT /**< 7-bit serial data transfer */ 238 #define SPI_DATASIZE_8BIT LL_SSI_DATASIZE_8BIT /**< 8-bit serial data transfer */ 239 #define SPI_DATASIZE_9BIT LL_SSI_DATASIZE_9BIT /**< 9-bit serial data transfer */ 240 #define SPI_DATASIZE_10BIT LL_SSI_DATASIZE_10BIT /**< 10-bit serial data transfer */ 241 #define SPI_DATASIZE_11BIT LL_SSI_DATASIZE_11BIT /**< 11-bit serial data transfer */ 242 #define SPI_DATASIZE_12BIT LL_SSI_DATASIZE_12BIT /**< 12-bit serial data transfer */ 243 #define SPI_DATASIZE_13BIT LL_SSI_DATASIZE_13BIT /**< 13-bit serial data transfer */ 244 #define SPI_DATASIZE_14BIT LL_SSI_DATASIZE_14BIT /**< 14-bit serial data transfer */ 245 #define SPI_DATASIZE_15BIT LL_SSI_DATASIZE_15BIT /**< 15-bit serial data transfer */ 246 #define SPI_DATASIZE_16BIT LL_SSI_DATASIZE_16BIT /**< 16-bit serial data transfer */ 247 #define SPI_DATASIZE_17BIT LL_SSI_DATASIZE_17BIT /**< 17-bit serial data transfer */ 248 #define SPI_DATASIZE_18BIT LL_SSI_DATASIZE_18BIT /**< 18-bit serial data transfer */ 249 #define SPI_DATASIZE_19BIT LL_SSI_DATASIZE_19BIT /**< 19-bit serial data transfer */ 250 #define SPI_DATASIZE_20BIT LL_SSI_DATASIZE_20BIT /**< 20-bit serial data transfer */ 251 #define SPI_DATASIZE_21BIT LL_SSI_DATASIZE_21BIT /**< 21-bit serial data transfer */ 252 #define SPI_DATASIZE_22BIT LL_SSI_DATASIZE_22BIT /**< 22-bit serial data transfer */ 253 #define SPI_DATASIZE_23BIT LL_SSI_DATASIZE_23BIT /**< 23-bit serial data transfer */ 254 #define SPI_DATASIZE_24BIT LL_SSI_DATASIZE_24BIT /**< 24-bit serial data transfer */ 255 #define SPI_DATASIZE_25BIT LL_SSI_DATASIZE_25BIT /**< 25-bit serial data transfer */ 256 #define SPI_DATASIZE_26BIT LL_SSI_DATASIZE_26BIT /**< 26-bit serial data transfer */ 257 #define SPI_DATASIZE_27BIT LL_SSI_DATASIZE_27BIT /**< 27-bit serial data transfer */ 258 #define SPI_DATASIZE_28BIT LL_SSI_DATASIZE_28BIT /**< 28-bit serial data transfer */ 259 #define SPI_DATASIZE_29BIT LL_SSI_DATASIZE_29BIT /**< 29-bit serial data transfer */ 260 #define SPI_DATASIZE_30BIT LL_SSI_DATASIZE_30BIT /**< 30-bit serial data transfer */ 261 #define SPI_DATASIZE_31BIT LL_SSI_DATASIZE_31BIT /**< 31-bit serial data transfer */ 262 #define SPI_DATASIZE_32BIT LL_SSI_DATASIZE_32BIT /**< 32-bit serial data transfer */ 263 /** @} */ 264 265 /** @defgroup SPI_Clock_Polarity SPI Clock Polarity 266 * @{ 267 */ 268 #define SPI_POLARITY_LOW LL_SSI_SCPOL_LOW /**< Inactive state of CLK is low */ 269 #define SPI_POLARITY_HIGH LL_SSI_SCPOL_HIGH /**< Inactive state of CLK is high */ 270 /** @} */ 271 272 /** @defgroup SPI_Clock_Phase SPI Clock Phase 273 * @{ 274 */ 275 #define SPI_PHASE_1EDGE LL_SSI_SCPHA_1EDGE /**< CLK toggles at start of first data bit */ 276 #define SPI_PHASE_2EDGE LL_SSI_SCPHA_2EDGE /**< CLK toggles in middle of first data bit */ 277 /** @} */ 278 279 /** @defgroup SPI_TI_Mode SPI TI Mode 280 * @{ 281 */ 282 #define SPI_TIMODE_DISABLE ((uint32_t)0x00000000) /**< SPI TI mode disable */ 283 #define SPI_TIMODE_ENABLE LL_SSI_PROTOCOL_TI /**< SPI TI mode enable */ 284 /** @} */ 285 286 /** @defgroup SPI_Slave_Select SPI Slave Select 287 * @{ 288 */ 289 #define SPI_SLAVE_SELECT_0 LL_SSI_SLAVE0 /**< SPIM Select Slave 0 */ 290 #define SPI_SLAVE_SELECT_1 LL_SSI_SLAVE1 /**< SPIM Select Slave 1 */ 291 #define SPI_SLAVE_SELECT_ALL (LL_SSI_SLAVE0 | LL_SSI_SLAVE1) /**< SPIM Select All Slave */ 292 /** @} */ 293 294 /** @defgroup SPI_FIFO_LEVEL_MAX SPI FIFO Level Max 295 * @{ 296 */ 297 #define SPI_TX_FIFO_LEVEL_MAX 8 /**< SPI TX FIFO Level Max Value */ 298 #define SPI_RX_FIFO_LEVEL_MAX 8 /**< SPI RX FIFO Level Max Value */ 299 /** @} */ 300 301 /** @defgroup SPI_Flags_definition SPI Flags Definition 302 * @{ 303 */ 304 #define SPI_FLAG_DCOL LL_SSI_SR_DCOL /**< Data collision error flag */ 305 #define SPI_FLAG_TXE LL_SSI_SR_TXE /**< Transmission error flag */ 306 #define SPI_FLAG_RFF LL_SSI_SR_RFF /**< Rx FIFO full flag */ 307 #define SPI_FLAG_RFNE LL_SSI_SR_RFNE /**< Rx FIFO not empty flag */ 308 #define SPI_FLAG_TFE LL_SSI_SR_TFE /**< Tx FIFO empty flag */ 309 #define SPI_FLAG_TFNF LL_SSI_SR_TFNF /**< Tx FIFO not full flag */ 310 #define SPI_FLAG_BUSY LL_SSI_SR_BUSY /**< Busy flag */ 311 /** @} */ 312 313 /** @defgroup SPI_Interrupt_definition SPI Interrupt Definition 314 * @{ 315 */ 316 #define SPI_IT_MST LL_SSI_IS_MST /**< Multi-Master Contention Interrupt flag */ 317 #define SPI_IT_RXF LL_SSI_IS_RXF /**< Receive FIFO Full Interrupt flag */ 318 #define SPI_IT_RXO LL_SSI_IS_RXO /**< Receive FIFO Overflow Interrupt flag */ 319 #define SPI_IT_RXU LL_SSI_IS_RXU /**< Receive FIFO Underflow Interrupt flag */ 320 #define SPI_IT_TXO LL_SSI_IS_TXO /**< Transmit FIFO Overflow Interrupt flag */ 321 #define SPI_IT_TXE LL_SSI_IS_TXE /**< Transmit FIFO Empty Interrupt flag */ 322 /** @} */ 323 324 /** @defgroup SPI_Timeout_definition SPI Timeout_definition 325 * @{ 326 */ 327 #define HAL_SPI_TIMEOUT_DEFAULT_VALUE ((uint32_t)5000) /**< 5s */ 328 /** @} */ 329 330 /** @} */ 331 332 /* Exported macro ------------------------------------------------------------*/ 333 /** @defgroup SPI_Exported_Macros SPI Exported Macros 334 * @{ 335 */ 336 337 /** @brief Reset SPI handle states. 338 * @param __HANDLE__ SPI handle. 339 * @retval None 340 */ 341 #define __HAL_SPI_RESET_HANDLE_STATE(__HANDLE__) ((__HANDLE__)->state = HAL_SPI_STATE_RESET) 342 343 /** @brief Enable the specified SPI peripheral. 344 * @param __HANDLE__ Specifies the SPI Handle. 345 * @retval None 346 */ 347 #define __HAL_SPI_ENABLE(__HANDLE__) SET_BITS((__HANDLE__)->p_instance->SSI_EN, SSI_SSIEN_EN) 348 349 /** @brief Disable the specified SPI peripheral. 350 * @param __HANDLE__ Specifies the SPI Handle. 351 * @retval None 352 */ 353 #define __HAL_SPI_DISABLE(__HANDLE__) CLEAR_BITS((__HANDLE__)->p_instance->SSI_EN, SSI_SSIEN_EN) 354 355 /** @brief Enable the SPI DMA TX Request. 356 * @param __HANDLE__ Specifies the SPI Handle. 357 * @retval None 358 */ 359 #define __HAL_SPI_ENABLE_DMATX(__HANDLE__) SET_BITS((__HANDLE__)->p_instance->DMAC, SSI_DMAC_TDMAE) 360 361 /** @brief Enable the SPI DMA RX Request. 362 * @param __HANDLE__ Specifies the SPI Handle. 363 * @retval None 364 */ 365 #define __HAL_SPI_ENABLE_DMARX(__HANDLE__) SET_BITS((__HANDLE__)->p_instance->DMAC, SSI_DMAC_RDMAE) 366 367 /** @brief Disable the SPI DMA TX Request. 368 * @param __HANDLE__ Specifies the SPI Handle. 369 * @retval None 370 */ 371 #define __HAL_SPI_DISABLE_DMATX(__HANDLE__) CLEAR_BITS((__HANDLE__)->p_instance->DMAC, SSI_DMAC_TDMAE) 372 373 /** @brief Disable the SPI DMA RX Request. 374 * @param __HANDLE__ Specifies the SPI Handle. 375 * @retval None 376 */ 377 #define __HAL_SPI_DISABLE_DMARX(__HANDLE__) CLEAR_BITS((__HANDLE__)->p_instance->DMAC, SSI_DMAC_RDMAE) 378 379 /** @brief Enable the specified SPI interrupts. 380 * @param __HANDLE__ Specifies the SPI Handle. 381 * @param __INTERRUPT__ Specifies the interrupt source to enable. 382 * This parameter can be one of the following values: 383 * @arg @ref SPI_IT_MST Multi-Master Contention Interrupt enable 384 * @arg @ref SPI_IT_RXF Receive FIFO Full Interrupt enable 385 * @arg @ref SPI_IT_RXO Receive FIFO Overflow Interrupt enable 386 * @arg @ref SPI_IT_RXU Receive FIFO Underflow Interrupt enable 387 * @arg @ref SPI_IT_TXO Transmit FIFO Overflow Interrupt enable 388 * @arg @ref SPI_IT_TXE Transmit FIFO Empty Interrupt enable 389 * @retval None 390 */ 391 #define __HAL_SPI_ENABLE_IT(__HANDLE__, __INTERRUPT__) SET_BITS((__HANDLE__)->p_instance->INTMASK, (__INTERRUPT__)) 392 393 /** @brief Disable the specified SPI interrupts. 394 * @param __HANDLE__ Specifies the SPI handle. 395 * @param __INTERRUPT__ Specifies the interrupt source to disable. 396 * This parameter can be one of the following values: 397 * @arg @ref SPI_IT_MST Multi-Master Contention Interrupt enable 398 * @arg @ref SPI_IT_RXF Receive FIFO Full Interrupt enable 399 * @arg @ref SPI_IT_RXO Receive FIFO Overflow Interrupt enable 400 * @arg @ref SPI_IT_RXU Receive FIFO Underflow Interrupt enable 401 * @arg @ref SPI_IT_TXO Transmit FIFO Overflow Interrupt enable 402 * @arg @ref SPI_IT_TXE Transmit FIFO Empty Interrupt enable 403 * @retval None 404 */ 405 #define __HAL_SPI_DISABLE_IT(__HANDLE__, __INTERRUPT__) CLEAR_BITS((__HANDLE__)->p_instance->INTMASK, (__INTERRUPT__)) 406 407 /** @brief Check whether the specified SPI interrupt source is enabled or not. 408 * @param __HANDLE__ Specifies the SPI Handle. 409 * @param __INTERRUPT__ Specifies the interrupt source to check. 410 * This parameter can be one of the following values: 411 * @arg @ref SPI_IT_MST Multi-Master Contention Interrupt enable 412 * @arg @ref SPI_IT_RXF Receive FIFO Full Interrupt enable 413 * @arg @ref SPI_IT_RXO Receive FIFO Overflow Interrupt enable 414 * @arg @ref SPI_IT_RXU Receive FIFO Underflow Interrupt enable 415 * @arg @ref SPI_IT_TXO Transmit FIFO Overflow Interrupt enable 416 * @arg @ref SPI_IT_TXE Transmit FIFO Empty Interrupt enable 417 * @retval The new state of __IT__ (TRUE or FALSE). 418 */ 419 #define __HAL_SPI_GET_IT_SOURCE(__HANDLE__, __INTERRUPT__) \ 420 (READ_BITS((__HANDLE__)->p_instance->INTSTAT, (__INTERRUPT__)) == (__INTERRUPT__)) 421 422 /** @brief Check whether the specified SPI flag is set or not. 423 * @param __HANDLE__ Specifies the SPI Handle. 424 * @param __FLAG__ Specifies the flag to check. 425 * This parameter can be one of the following values: 426 * @arg @ref SPI_FLAG_DCOL Data collision error flag 427 * @arg @ref SPI_FLAG_TXE Transmission error flag 428 * @arg @ref SPI_FLAG_RFF Rx FIFO full flag 429 * @arg @ref SPI_FLAG_RFNE Rx FIFO not empty flag 430 * @arg @ref SPI_FLAG_TFE Tx FIFO empty flag 431 * @arg @ref SPI_FLAG_TFNF Tx FIFO not full flag 432 * @arg @ref SPI_FLAG_BUSY Busy flag 433 * @retval The new state of __FLAG__ (TRUE or FALSE). 434 */ 435 #define __HAL_SPI_GET_FLAG(__HANDLE__, __FLAG__) \ 436 ((READ_BITS((__HANDLE__)->p_instance->STAT, (__FLAG__)) != 0) ? SET : RESET) 437 438 /** @brief Clear the specified SPI flag. 439 * @param __HANDLE__ Specifies the SPI Handle. 440 * @param __FLAG__ Specifies the flag to clear. 441 * This parameter can be one of the following values: 442 * @arg @ref SPI_FLAG_DCOL Data collision error flag 443 * @arg @ref SPI_FLAG_TXE Transmission error flag 444 * @arg @ref SPI_FLAG_RFF Rx FIFO full flag 445 * @arg @ref SPI_FLAG_RFNE Rx FIFO not empty flag 446 * @arg @ref SPI_FLAG_TFE Tx FIFO empty flag 447 * @arg @ref SPI_FLAG_TFNF Tx FIFO not full flag 448 * @arg @ref SPI_FLAG_BUSY Busy flag 449 * @retval None 450 */ 451 #define __HAL_SPI_CLEAR_FLAG(__HANDLE__, __FLAG__) READ_BITS((__HANDLE__)->p_instance->STAT, (__FLAG__)) 452 453 /** @} */ 454 455 /* Private macros ------------------------------------------------------------*/ 456 /** @defgroup SPI_Private_Macro SPI Private Macros 457 * @{ 458 */ 459 460 /** @brief Check if SPI Direction Mode is valid. 461 * @param __MODE__ SPI Direction Mode. 462 * @retval SET (__MODE__ is valid) or RESET (__MODE__ is invalid) 463 */ 464 #define IS_SPI_DIRECTION(__MODE__) (((__MODE__) == SPI_DIRECTION_FULL_DUPLEX) || \ 465 ((__MODE__) == SPI_DIRECTION_SIMPLEX_TX) || \ 466 ((__MODE__) == SPI_DIRECTION_SIMPLEX_RX) || \ 467 ((__MODE__) == SPI_DIRECTION_READ_EEPROM)) 468 469 /** @brief Check if SPI Data Size is valid. 470 * @param __DATASIZE__ SPI Data Size. 471 * @retval SET (__DATASIZE__ is valid) or RESET (__DATASIZE__ is invalid) 472 */ 473 #define IS_SPI_DATASIZE(__DATASIZE__) (((__DATASIZE__) >= SPI_DATASIZE_4BIT) && \ 474 ((__DATASIZE__) <= SPI_DATASIZE_32BIT)) 475 476 /** @brief Check if SPI Clock Polarity is valid. 477 * @param __CPOL__ SPI Clock Polarity. 478 * @retval SET (__CPOL__ is valid) or RESET (__CPOL__ is invalid) 479 */ 480 #define IS_SPI_CPOL(__CPOL__) (((__CPOL__) == SPI_POLARITY_LOW) || \ 481 ((__CPOL__) == SPI_POLARITY_HIGH)) 482 483 /** @brief Check if SPI Clock Phase is valid. 484 * @param __CPHA__ SPI Clock Phase. 485 * @retval SET (__CPHA__ is valid) or RESET (__CPHA__ is invalid) 486 */ 487 #define IS_SPI_CPHA(__CPHA__) (((__CPHA__) == SPI_PHASE_1EDGE) || \ 488 ((__CPHA__) == SPI_PHASE_2EDGE)) 489 490 /** @brief Check if SPI BaudRate Prescaler is valid. 491 * @param __PRESCALER__ SPI BaudRate Prescaler. 492 * @retval SET (__PRESCALER__ is valid) or RESET (__PRESCALER__ is invalid) 493 */ 494 #define IS_SPI_BAUDRATE_PRESCALER(__PRESCALER__) ((__PRESCALER__) <= 0xFFFF) 495 496 /** @brief Check if SPI TI Mode is valid. 497 * @param __MODE__ SPI TI Mode. 498 * @retval SET (__MODE__ is valid) or RESET (__MODE__ is invalid) 499 */ 500 #define IS_SPI_TIMODE(__MODE__) (((__MODE__) == SPI_TIMODE_DISABLE) || \ 501 ((__MODE__) == SPI_TIMODE_ENABLE)) 502 503 /** @brief Check if SPI Slave Select is valid. 504 * @param __SLAVE__ SPI Slave Select. 505 * @retval SET (__SLAVE__ is valid) or RESET (__SLAVE__ is invalid) 506 */ 507 #define IS_SPI_SLAVE(__SLAVE__) (((__SLAVE__) == SPI_SLAVE_SELECT_0) || \ 508 ((__SLAVE__) == SPI_SLAVE_SELECT_1) || \ 509 ((__SLAVE__) == SPI_SLAVE_SELECT_ALL)) 510 511 /** @brief Check if SPI Receive Sample Delay Value is valid. 512 * @param __DLY__ SPI Receive Sample Delay Value 513 * @retval SET (__DLY__ is valid) or RESET (__DLY__ is invalid) 514 */ 515 #define IS_SPI_RX_SAMPLE_DLY(__DLY__) (((__DLY__) >= 0) && ((__DLY__) <= 7)) 516 517 518 /** @brief Check if SPI FIFO Threshold is valid. 519 * @param __THR__ SPI FIFO Threshold. 520 * @retval SET (__THR__ is valid) or RESET (__THR__ is invalid) 521 */ 522 #define IS_SPI_FIFO_THRESHOLD(__THR__) (((__THR__) >= 0) && ((__THR__) <= 7)) 523 524 /** @} */ 525 526 /** @} */ 527 528 /* Exported functions --------------------------------------------------------*/ 529 /** @addtogroup HAL_SPI_DRIVER_FUNCTIONS Functions 530 * @{ 531 */ 532 533 /** @defgroup SPI_Exported_Functions_Group1 Initialization and de-initialization functions 534 * @brief Initialization and de-initialization functions 535 * 536 @verbatim 537 =============================================================================== 538 ##### Initialization and de-initialization functions ##### 539 =============================================================================== 540 [..] This subsection provides a set of functions allowing to initialize and 541 de-initialize the SPIx peripheral. 542 543 (+) User must implement hal_spi_msp_init() function in which he configures 544 all related peripherals resources (GPIO, DMA, IT and NVIC ). 545 546 (+) Call the function hal_spi_init() to configure the selected device with 547 the selected configuration: 548 (++) Direction 549 (++) Data Size 550 (++) Clock Polarity and Phase 551 (++) BaudRate Prescaler 552 (++) TIMode 553 (++) Slave Select 554 555 (+) Call the function hal_spi_deinit() to restore the default configuration 556 of the selected SPIx peripheral. 557 558 @endverbatim 559 * @{ 560 */ 561 562 /** 563 **************************************************************************************** 564 * @brief Initialize the SPI according to the specified parameters 565 * in the spi_init_t and initialize the associated handle. 566 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 567 * @retval ::HAL_OK: Operation is OK. 568 * @retval ::HAL_ERROR: Parameter error or operation not supported. 569 * @retval ::HAL_BUSY: Driver is busy. 570 * @retval ::HAL_TIMEOUT: Timeout occurred. 571 **************************************************************************************** 572 */ 573 hal_status_t hal_spi_init(spi_handle_t *p_spi); 574 575 /** 576 **************************************************************************************** 577 * @brief De-initialize the SPI peripheral. 578 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 579 * @retval ::HAL_OK: Operation is OK. 580 * @retval ::HAL_ERROR: Parameter error or operation not supported. 581 * @retval ::HAL_BUSY: Driver is busy. 582 * @retval ::HAL_TIMEOUT: Timeout occurred. 583 **************************************************************************************** 584 */ 585 hal_status_t hal_spi_deinit(spi_handle_t *p_spi); 586 587 /** 588 **************************************************************************************** 589 * @brief Initialize the SPI MSP. 590 * @note This function should not be modified. When the callback is needed, 591 the hal_spi_msp_deinit can be implemented in the user file. 592 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 593 **************************************************************************************** 594 */ 595 void hal_spi_msp_init(spi_handle_t *p_spi); 596 597 /** 598 **************************************************************************************** 599 * @brief De-initialize the SPI MSP. 600 * @note This function should not be modified. When the callback is needed, 601 the hal_spi_msp_deinit can be implemented in the user file. 602 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 603 **************************************************************************************** 604 */ 605 void hal_spi_msp_deinit(spi_handle_t *p_spi); 606 607 /** @} */ 608 609 /** @defgroup SPI_Exported_Functions_Group2 IO operation functions 610 * @brief Data transfer functions 611 * 612 @verbatim 613 ============================================================================== 614 ##### IO operation functions ##### 615 =============================================================================== 616 [..] 617 This subsection provides a set of functions allowing to manage the SPI 618 data transfer. 619 620 [..] The SPI supports master and slave mode: 621 622 (#) There are two modes of transfer: 623 (++) Blocking mode: The communication is performed in polling mode. 624 The HAL status of all data processing is returned by the same function 625 after finishing transfer. 626 (++) No-Blocking mode: The communication is performed using Interrupts 627 or DMA, These APIs return the HAL status. 628 The end of the data processing will be indicated through the 629 dedicated SPI IRQ when using Interrupt mode or the DMA IRQ when 630 using DMA mode. 631 The hal_spi_tx_cplt_callback(), hal_spi_rx_cplt_callback() and hal_spi_txrx_cplt_callback() 632 user callbacks will be executed respectively at the end of the transmit or Receive process 633 The hal_spi_error_callback() user callback will be executed when a communication error is detected. 634 635 (#) APIs provided for these 2 transfer modes (Blocking mode or Non blocking mode using either Interrupt or DMA) 636 exist for 1-Line (simplex) and 2-Line (full duplex) modes. 637 638 @endverbatim 639 * @{ 640 */ 641 642 /** 643 **************************************************************************************** 644 * @brief Transmit an amount of data in blocking mode. 645 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 646 * @param[in] p_data: Pointer to data buffer 647 * @param[in] length: Amount of data to be sent in bytes 648 * @param[in] timeout: Timeout duration 649 * @retval ::HAL_OK: Operation is OK. 650 * @retval ::HAL_ERROR: Parameter error or operation not supported. 651 * @retval ::HAL_BUSY: Driver is busy. 652 * @retval ::HAL_TIMEOUT: Timeout occurred. 653 **************************************************************************************** 654 */ 655 hal_status_t hal_spi_transmit(spi_handle_t *p_spi, uint8_t *p_data, uint32_t length, uint32_t timeout); 656 657 /** 658 **************************************************************************************** 659 * @brief Receive an amount of data in blocking mode. 660 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 661 * @param[out] p_data: Pointer to data buffer 662 * @param[in] length: Amount of data to be received in bytes 663 * @param[in] timeout: Timeout duration 664 * @retval ::HAL_OK: Operation is OK. 665 * @retval ::HAL_ERROR: Parameter error or operation not supported. 666 * @retval ::HAL_BUSY: Driver is busy. 667 * @retval ::HAL_TIMEOUT: Timeout occurred. 668 **************************************************************************************** 669 */ 670 hal_status_t hal_spi_receive(spi_handle_t *p_spi, uint8_t *p_data, uint32_t length, uint32_t timeout); 671 672 /** 673 **************************************************************************************** 674 * @brief Transmit and Receive an amount of data in blocking mode. 675 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 676 * @param[in] p_tx_data: Pointer to transmission data buffer 677 * @param[out] p_rx_data: Pointer to reception data buffer 678 * @param[in] length: Amount of data to be sent and received in bytes 679 * @param[in] timeout: Timeout duration 680 * @retval ::HAL_OK: Operation is OK. 681 * @retval ::HAL_ERROR: Parameter error or operation not supported. 682 * @retval ::HAL_BUSY: Driver is busy. 683 * @retval ::HAL_TIMEOUT: Timeout occurred. 684 **************************************************************************************** 685 */ 686 hal_status_t hal_spi_transmit_receive(spi_handle_t *p_spi, uint8_t *p_tx_data, uint8_t *p_rx_data, 687 uint32_t length, uint32_t timeout); 688 689 /** 690 **************************************************************************************** 691 * @brief Read an amount of data from EEPROM in blocking mode. 692 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 693 * @param[in] p_tx_data: Pointer to transmission data buffer 694 * @param[out] p_rx_data: Pointer to reception data buffer 695 * @param[in] tx_number_data: Amount of data to be sent in bytes 696 * @param[in] rx_number_data: Amount of data to be received in bytes 697 * @param[in] timeout: Timeout duration 698 * @retval ::HAL_OK: Operation is OK. 699 * @retval ::HAL_ERROR: Parameter error or operation not supported. 700 * @retval ::HAL_BUSY: Driver is busy. 701 * @retval ::HAL_TIMEOUT: Timeout occurred. 702 **************************************************************************************** 703 */ 704 hal_status_t hal_spi_read_eeprom(spi_handle_t *p_spi, uint8_t *p_tx_data, uint8_t *p_rx_data, 705 uint32_t tx_number_data, uint32_t rx_number_data, uint32_t timeout); 706 707 /** 708 **************************************************************************************** 709 * @brief Transmit an amount of data in non-blocking mode with Interrupt. 710 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 711 * @param[in] p_data: Pointer to data buffer 712 * @param[in] length: Amount of data to be sent in bytes 713 * @retval ::HAL_OK: Operation is OK. 714 * @retval ::HAL_ERROR: Parameter error or operation not supported. 715 * @retval ::HAL_BUSY: Driver is busy. 716 * @retval ::HAL_TIMEOUT: Timeout occurred. 717 **************************************************************************************** 718 */ 719 hal_status_t hal_spi_transmit_it(spi_handle_t *p_spi, uint8_t *p_data, uint32_t length); 720 721 /** 722 **************************************************************************************** 723 * @brief Receive an amount of data in non-blocking mode with Interrupt. 724 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 725 * @param[out] p_data: Pointer to data buffer 726 * @param[in] length: Amount of data to be sent in bytes 727 * @retval ::HAL_OK: Operation is OK. 728 * @retval ::HAL_ERROR: Parameter error or operation not supported. 729 * @retval ::HAL_BUSY: Driver is busy. 730 * @retval ::HAL_TIMEOUT: Timeout occurred. 731 **************************************************************************************** 732 */ 733 hal_status_t hal_spi_receive_it(spi_handle_t *p_spi, uint8_t *p_data, uint32_t length); 734 735 /** 736 **************************************************************************************** 737 * @brief Transmit and Receive an amount of data in non-blocking mode with Interrupt. 738 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 739 * @param[in] p_tx_data: Pointer to transmission data buffer 740 * @param[out] p_rx_data: Pointer to reception data buffer 741 * @param[in] length: Amount of data to be sent and received in bytes 742 * @retval ::HAL_OK: Operation is OK. 743 * @retval ::HAL_ERROR: Parameter error or operation not supported. 744 * @retval ::HAL_BUSY: Driver is busy. 745 * @retval ::HAL_TIMEOUT: Timeout occurred. 746 **************************************************************************************** 747 */ 748 hal_status_t hal_spi_transmit_receive_it(spi_handle_t *p_spi, uint8_t *p_tx_data, uint8_t *p_rx_data, uint32_t length); 749 750 /** 751 **************************************************************************************** 752 * @brief Read an amount of data from EEPROM in non-blocking mode with Interrupt. 753 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 754 * @param[in] p_tx_data: Pointer to transmission data buffer 755 * @param[out] p_rx_data: Pointer to reception data buffer 756 * @param[in] tx_number_data: Amount of data to be sent in bytes 757 * @param[in] rx_number_data: Amount of data to be received in bytes 758 * @retval ::HAL_OK: Operation is OK. 759 * @retval ::HAL_ERROR: Parameter error or operation not supported. 760 * @retval ::HAL_BUSY: Driver is busy. 761 * @retval ::HAL_TIMEOUT: Timeout occurred. 762 **************************************************************************************** 763 */ 764 hal_status_t hal_spi_read_eeprom_it(spi_handle_t *p_spi, uint8_t *p_tx_data, uint8_t *p_rx_data, 765 uint32_t tx_number_data, uint32_t rx_number_data); 766 767 /** 768 **************************************************************************************** 769 * @brief Transmit an amount of data in non-blocking mode with DMA. 770 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 771 * @param[in] p_data: Pointer to data buffer 772 * @param[in] length: Amount of data to be sent in bytes, ranging between 0 and 4095. 773 * @retval ::HAL_OK: Operation is OK. 774 * @retval ::HAL_ERROR: Parameter error or operation not supported. 775 * @retval ::HAL_BUSY: Driver is busy. 776 * @retval ::HAL_TIMEOUT: Timeout occurred. 777 **************************************************************************************** 778 */ 779 hal_status_t hal_spi_transmit_dma(spi_handle_t *p_spi, uint8_t *p_data, uint32_t length); 780 781 /** 782 **************************************************************************************** 783 * @brief Receive an amount of data in non-blocking mode with DMA. 784 * @note In case of MASTER mode and SPI_DIRECTION_2LINES direction, p_dmatx shall be defined. 785 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 786 * @param[out] p_data: Pointer to data buffer 787 * @param[in] length: Amount of data to be sent in bytes, ranging between 0 and 4095. 788 * @retval ::HAL_OK: Operation is OK. 789 * @retval ::HAL_ERROR: Parameter error or operation not supported. 790 * @retval ::HAL_BUSY: Driver is busy. 791 * @retval ::HAL_TIMEOUT: Timeout occurred. 792 **************************************************************************************** 793 */ 794 hal_status_t hal_spi_receive_dma(spi_handle_t *p_spi, uint8_t *p_data, uint32_t length); 795 796 /** 797 **************************************************************************************** 798 * @brief Transmit and Receive an amount of data in non-blocking mode with DMA. 799 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 800 * @param[in] p_tx_data: Pointer to transmission data buffer 801 * @param[out] p_rx_data: Pointer to reception data buffer 802 * @param[in] length: Amount of data to be sent in bytes, ranging between 0 and 4095. 803 * @retval ::HAL_OK: Operation is OK. 804 * @retval ::HAL_ERROR: Parameter error or operation not supported. 805 * @retval ::HAL_BUSY: Driver is busy. 806 * @retval ::HAL_TIMEOUT: Timeout occurred. 807 **************************************************************************************** 808 */ 809 hal_status_t hal_spi_transmit_receive_dma(spi_handle_t *p_spi, uint8_t *p_tx_data, uint8_t *p_rx_data, uint32_t length); 810 811 /** 812 **************************************************************************************** 813 * @brief Read an amount of data from EEPROM in non-blocking mode with DMA. 814 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 815 * @param[in] p_tx_data: Pointer to transmission data buffer 816 * @param[out] p_rx_data: Pointer to reception data buffer 817 * @param[in] tx_number_data: Amount of data to be sent in bytes 818 * @param[in] rx_number_data: Amount of data to be received in bytes, ranging between 0 and 4095. 819 * @retval ::HAL_OK: Operation is OK. 820 * @retval ::HAL_ERROR: Parameter error or operation not supported. 821 * @retval ::HAL_BUSY: Driver is busy. 822 * @retval ::HAL_TIMEOUT: Timeout occurred. 823 **************************************************************************************** 824 */ 825 hal_status_t hal_spi_read_eeprom_dma(spi_handle_t *p_spi, uint8_t *p_tx_data, uint8_t *p_rx_data, 826 uint32_t tx_number_data, uint32_t rx_number_data); 827 828 /** 829 **************************************************************************************** 830 * @brief Abort ongoing transfer (blocking mode). 831 * @param[in] p_spi: SPI handle. 832 * @note This procedure could be used for aborting any ongoing transfer (Tx and Rx), 833 * started in Interrupt or DMA mode. 834 * This procedure performs following operations : 835 * - Disable SPI Interrupts (depending of transfer direction) 836 * - Disable the DMA transfer in the peripheral register (if enabled) 837 * - Abort DMA transfer by calling hal_dma_abort (in case of transfer in DMA mode) 838 * - Set handle State to READY 839 * @note This procedure is executed in blocking mode: when exiting function, Abort is considered as completed. 840 * @retval ::HAL_OK: Operation is OK. 841 * @retval ::HAL_ERROR: Parameter error or operation not supported. 842 * @retval ::HAL_BUSY: Driver is busy. 843 * @retval ::HAL_TIMEOUT: Timeout occurred. 844 **************************************************************************************** 845 */ 846 hal_status_t hal_spi_abort(spi_handle_t *p_spi); 847 848 /** 849 **************************************************************************************** 850 * @brief Abort ongoing transfer (Interrupt mode). 851 * @param[in] p_spi: SPI handle. 852 * @note This procedure could be used for aborting any ongoing transfer (Tx and Rx), 853 * started in Interrupt or DMA mode. 854 * This procedure performs following operations : 855 * - Disable SPI Interrupts (depending of transfer direction) 856 * - Disable the DMA transfer in the peripheral register (if enabled) 857 * - Abort DMA transfer by calling hal_dma_abort_it (in case of transfer in DMA mode) 858 * - Set handle State to READY 859 * - At abort completion, call user abort complete callback 860 * @note This procedure is executed in Interrupt mode, meaning that abort procedure could be 861 * considered as completed only when user abort complete callback is executed (not when exiting function). 862 * @retval ::HAL_OK: Operation is OK. 863 * @retval ::HAL_ERROR: Parameter error or operation not supported. 864 * @retval ::HAL_BUSY: Driver is busy. 865 * @retval ::HAL_TIMEOUT: Timeout occurred. 866 **************************************************************************************** 867 */ 868 hal_status_t hal_spi_abort_it(spi_handle_t *p_spi); 869 870 /** @} */ 871 872 /** @addtogroup SPI_IRQ_Handler_and_Callbacks IRQ Handler and Callbacks 873 * @brief IRQ Handler and Callbacks functions 874 * @{ 875 */ 876 877 /** 878 **************************************************************************************** 879 * @brief Handle SPI interrupt request. 880 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 881 **************************************************************************************** 882 */ 883 void hal_spi_irq_handler(spi_handle_t *p_spi); 884 885 /** 886 **************************************************************************************** 887 * @brief Tx Transfer completed callback. 888 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 889 **************************************************************************************** 890 */ 891 void hal_spi_tx_cplt_callback(spi_handle_t *p_spi); 892 893 /** 894 **************************************************************************************** 895 * @brief Rx Transfer completed callback. 896 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 897 **************************************************************************************** 898 */ 899 void hal_spi_rx_cplt_callback(spi_handle_t *p_spi); 900 901 /** 902 **************************************************************************************** 903 * @brief Tx and Rx Transfer completed callback. 904 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 905 **************************************************************************************** 906 */ 907 void hal_spi_tx_rx_cplt_callback(spi_handle_t *p_spi); 908 909 /** 910 **************************************************************************************** 911 * @brief SPI error callback. 912 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 913 **************************************************************************************** 914 */ 915 void hal_spi_error_callback(spi_handle_t *p_spi); 916 917 /** 918 **************************************************************************************** 919 * @brief SPI Abort Completed callback. 920 * @param[in] p_spi: SPI handle. 921 **************************************************************************************** 922 */ 923 void hal_spi_abort_cplt_callback(spi_handle_t *p_spi); 924 925 /** @} */ 926 927 /** @defgroup SPI_Exported_Functions_Group3 Peripheral State and Errors functions 928 * @brief SPI control functions 929 * 930 @verbatim 931 =============================================================================== 932 ##### Peripheral State and Errors functions ##### 933 =============================================================================== 934 [..] 935 This subsection provides a set of functions allowing to control the SPI. 936 (+) hal_spi_get_state() API can be helpful to check in run-time the state of the SPI peripheral 937 (+) hal_spi_get_error() check in run-time Errors occurring during communication 938 (+) hal_spi_set_timeout() set the timeout during internal process 939 (+) hal_spi_set_tx_fifo_threshold() set the TX FIFO Threshold 940 (+) hal_spi_set_rx_fifo_threshold() set the RX FIFO Threshold 941 (+) hal_spi_get_tx_fifo_threshold() get the TX FIFO Threshold 942 (+) hal_spi_get_rx_fifo_threshold() get the RX FIFO Threshold 943 @endverbatim 944 * @{ 945 */ 946 947 /** 948 **************************************************************************************** 949 * @brief Return the SPI handle state. 950 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 951 * @retval ::HAL_SPI_STATE_RESET: Peripheral not initialized. 952 * @retval ::HAL_SPI_STATE_READY: Peripheral initialized and ready for use. 953 * @retval ::HAL_SPI_STATE_BUSY: An internal process is ongoing. 954 * @retval ::HAL_SPI_STATE_BUSY_TX: Data Transmission process is ongoing. 955 * @retval ::HAL_SPI_STATE_BUSY_RX: Data Reception process is ongoing. 956 * @retval ::HAL_SPI_STATE_BUSY_TX_RX: Data Transmission and Reception process is ongoing. 957 * @retval ::HAL_SPI_STATE_ABORT: Peripheral with abort request ongoing. 958 * @retval ::HAL_SPI_STATE_ERROR: Peripheral in error. 959 **************************************************************************************** 960 */ 961 hal_spi_state_t hal_spi_get_state(spi_handle_t *p_spi); 962 963 /** 964 **************************************************************************************** 965 * @brief Return the SPI error code. 966 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 967 * @return SPI error code in bitmap format 968 **************************************************************************************** 969 */ 970 uint32_t hal_spi_get_error(spi_handle_t *p_spi); 971 972 /** 973 **************************************************************************************** 974 * @brief Set the SPI internal process timeout value. 975 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 976 * @param[in] timeout: Internal process timeout value. 977 **************************************************************************************** 978 */ 979 void hal_spi_set_timeout(spi_handle_t *p_spi, uint32_t timeout); 980 981 /** 982 **************************************************************************************** 983 * @brief Set the TX FIFO threshold. 984 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 985 * @param[in] threshold: TX FIFO threshold value ranging bwtween 0x0U ~ 0x7U. 986 * @retval ::HAL_OK: Operation is OK. 987 * @retval ::HAL_ERROR: Parameter error or operation not supported. 988 * @retval ::HAL_BUSY: Driver is busy. 989 * @retval ::HAL_TIMEOUT: Timeout occurred. 990 **************************************************************************************** 991 */ 992 hal_status_t hal_spi_set_tx_fifo_threshold(spi_handle_t *p_spi, uint32_t threshold); 993 994 /** 995 **************************************************************************************** 996 * @brief Set the RX FIFO threshold. 997 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 998 * @param[in] threshold: RX FIFO threshold value ranging bwtween 0x0U ~ 0x7U. 999 * @retval ::HAL_OK: Operation is OK. 1000 * @retval ::HAL_ERROR: Parameter error or operation not supported. 1001 * @retval ::HAL_BUSY: Driver is busy. 1002 * @retval ::HAL_TIMEOUT: Timeout occurred. 1003 **************************************************************************************** 1004 */ 1005 hal_status_t hal_spi_set_rx_fifo_threshold(spi_handle_t *p_spi, uint32_t threshold); 1006 1007 /** 1008 **************************************************************************************** 1009 * @brief Get the TX FIFO threshold. 1010 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 1011 * @return TX FIFO threshold 1012 **************************************************************************************** 1013 */ 1014 uint32_t hal_spi_get_tx_fifo_threshold(spi_handle_t *p_spi); 1015 1016 /** 1017 **************************************************************************************** 1018 * @brief Get the RX FIFO threshold. 1019 * @param[in] p_spi: Pointer to an SPI handle which contains the configuration information for the specified SPI. 1020 * @return RX FIFO threshold 1021 **************************************************************************************** 1022 */ 1023 uint32_t hal_spi_get_rx_fifo_threshold(spi_handle_t *p_spi); 1024 1025 /** 1026 **************************************************************************************** 1027 * @brief Suspend some registers related to SPI configuration before sleep. 1028 * @param[in] p_spi: Pointer to a SPI handle which contains the configuration 1029 * information for the specified SPI module. 1030 * @retval ::HAL_OK: Operation is OK. 1031 * @retval ::HAL_ERROR: Parameter error or operation not supported. 1032 * @retval ::HAL_BUSY: Driver is busy. 1033 * @retval ::HAL_TIMEOUT: Timeout occurred. 1034 **************************************************************************************** 1035 */ 1036 hal_status_t hal_spi_suspend_reg(spi_handle_t *p_spi); 1037 1038 /** 1039 **************************************************************************************** 1040 * @brief Restore some registers related to SPI configuration after sleep. 1041 * This function must be used in conjunction with the hal_spi_suspend_reg(). 1042 * @param[in] p_spi: Pointer to a SPI handle which contains the configuration 1043 * information for the specified SPI module. 1044 * @retval ::HAL_OK: Operation is OK. 1045 * @retval ::HAL_ERROR: Parameter error or operation not supported. 1046 * @retval ::HAL_BUSY: Driver is busy. 1047 * @retval ::HAL_TIMEOUT: Timeout occurred. 1048 **************************************************************************************** 1049 */ 1050 hal_status_t hal_spi_resume_reg(spi_handle_t *p_spi); 1051 1052 /** @} */ 1053 1054 /** @} */ 1055 1056 #ifdef __cplusplus 1057 } 1058 #endif 1059 1060 #endif /* __GR55xx_HAL_SPI_H__ */ 1061 1062 /** @} */ 1063 1064 /** @} */ 1065 1066 /** @} */ 1067