ll_spi.h
Go to the documentation of this file.
1 /**
2  ****************************************************************************************
3  *
4  * @file ll_spi.h
5  * @author BLE Driver Team
6  * @brief Header file containing functions prototypes of SPI LL 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 LL_DRIVER LL Driver
43  * @{
44  */
45 
46 /** @defgroup LL_SPI SPI
47  * @brief SPI LL module driver.
48  * @{
49  */
50 
51 /* Define to prevent recursive inclusion -------------------------------------*/
52 #ifndef LL_SPI_H
53 #define LL_SPI_H
54 
55 #ifdef __cplusplus
56 extern "C" {
57 #endif
58 
59 /* Includes ------------------------------------------------------------------*/
60 #include "gr5405.h"
61 #include <stdbool.h>
62 #if defined (SPIM) || defined (SPIS)
63 
64 /** @defgroup LL_SPI_DRIVER_STRUCTURES Structures
65  * @{
66  */
67 
68 /* Exported types ------------------------------------------------------------*/
69 /** @defgroup SPI_LL_ES_INIT SPI Exported init structure
70  * @{
71  */
72 
73 /**
74  * @brief LL SPIM init structures definition
75  */
76 typedef struct _ll_spim_init_t
77 {
78  uint32_t transfer_direction; /**< Specifies the SPI unidirectional or bidirectional data mode.
79  This parameter can be a value of @ref SPI_LL_EC_TRANSFER_MODE.
80 
81  This feature can be modified afterwards using unitary function @ref ll_spi_set_transfer_direction().*/
82 
83  uint32_t data_size; /**< Specifies the SPI data size.
84  This parameter can be a value of @ref SPI_LL_EC_DATASIZE.
85 
86  This feature can be modified afterwards using unitary function @ref ll_spi_set_data_size().*/
87 
88  uint32_t clock_polarity; /**< Specifies the serial clock steady state.
89  This parameter can be a value of @ref SPI_LL_EC_POLARITY.
90 
91  This feature can be modified afterwards using unitary function @ref ll_spi_set_clock_polarity().*/
92 
93  uint32_t clock_phase; /**< Specifies the clock active edge for the bit capture.
94  This parameter can be a value of @ref SPI_LL_EC_PHASE.
95 
96  This feature can be modified afterwards using unitary function @ref ll_spi_set_clock_phase().*/
97 
98  uint32_t slave_select; /**< Specifies the SPI slave select.
99  This parameter can be a value of @ref SPI_LL_EC_SLAVESELECT.
100 
101  This feature can be modified afterwards using unitary function @ref ll_spi_enable_ss().*/
102 
103  uint32_t baud_rate; /**< Specifies the BaudRate prescaler value which will be used to configure the transmit and receive SCK clock.
104  This parameter can be one even value between 2 and 65534, if the value is 0, the SCLK is disable.
105  @note The communication clock is derived from the master clock. The slave clock does not need to be set.
106 
107  This feature can be modified afterwards using unitary function @ref ll_spi_set_baud_rate_prescaler().*/
108 
109  uint32_t rx_sample_delay; /**< Specifies the RX sample delay. It is used to delay the sample of the RX input port.
110  This parameter can be a number between 0 and 0x7 */
112 
113 /**
114  * @brief SPIS init structures definition
115  */
116 typedef struct _ll_spis_init_t
117 {
118  uint32_t data_size; /**< Specifies the SPI data width.
119  This parameter can be a value of @ref SPI_LL_EC_DATASIZE.
120 
121  This feature can be modified afterwards using unitary function @ref ll_spi_set_data_size().*/
122 
123  uint32_t clock_polarity; /**< Specifies the serial clock steady state.
124  This parameter can be a value of @ref SPI_LL_EC_POLARITY.
125 
126  This feature can be modified afterwards using unitary function @ref ll_spi_set_clock_polarity().*/
127 
128  uint32_t clock_phase; /**< Specifies the clock active edge for the bit capture.
129  This parameter can be a value of @ref SPI_LL_EC_PHASE.
130 
131  This feature can be modified afterwards using unitary function @ref ll_spi_set_clock_phase().*/
132 
134 
135 /** @} */
136 
137 /** @} */
138 
139 /**
140  * @defgroup SPI_LL_MACRO Defines
141  * @{
142  */
143 
144 /* Exported constants --------------------------------------------------------*/
145 /** @defgroup SPI_LL_Exported_Constants SPI Exported Constants
146  * @{
147  */
148 
149 
150 /** @defgroup SPI_LL_EC_GET_FLAG Get Flags Defines
151  * @brief Flags definitions which can be used with LL_SPI_ReadReg function
152  * @{
153  */
154 #define LL_SPI_SR_DCOL SPI_STAT_DATA_COLN_ERR /**< Data collision error flag */
155 #define LL_SPI_SR_TXE SPI_STAT_TX_ERR /**< Transmission error flag */
156 #define LL_SPI_SR_RFF SPI_STAT_RX_FIFO_FULL /**< Rx FIFO full flag */
157 #define LL_SPI_SR_RFNE SPI_STAT_RX_FIFO_NE /**< Rx FIFO not empty flag */
158 #define LL_SPI_SR_TFE SPI_STAT_TX_FIFO_EMPTY /**< Tx FIFO empty flag */
159 #define LL_SPI_SR_TFNF SPI_STAT_TX_FIFO_NF /**< Tx FIFO not full flag */
160 #define LL_SPI_SR_BUSY SPI_STAT_SSI_BUSY /**< Busy flag */
161 /** @} */
162 
163 /** @defgroup SPI_LL_EC_IT IT Defines
164  * @brief Interrupt definitions which can be used with LL_SPI_ReadReg and LL_SPI_WriteReg functions
165  * @{
166  */
167 #define LL_SPI_IM_MST SPI_INT_MASK_MULTI_M_CIM /**< Multi-Master Contention Interrupt enable */
168 #define LL_SPI_IM_RXF SPI_INT_MASK_RX_FIFO_FIM /**< Receive FIFO Full Interrupt enable */
169 #define LL_SPI_IM_RXO SPI_INT_MASK_RX_FIFO_OIM /**< Receive FIFO Overflow Interrupt enable */
170 #define LL_SPI_IM_RXU SPI_INT_MASK_RX_FIFO_UIM /**< Receive FIFO Underflow Interrupt enable */
171 #define LL_SPI_IM_TXO SPI_INT_MASK_TX_FIFO_OIM /**< Transmit FIFO Overflow Interrupt enable */
172 #define LL_SPI_IM_TXE SPI_INT_MASK_TX_FIFO_EIM /**< Transmit FIFO Empty Interrupt enable */
173 
174 #define LL_SPI_IS_MST SPI_INT_STAT_MULTI_M_CIS /**< Multi-Master Contention Interrupt flag */
175 #define LL_SPI_IS_RXF SPI_INT_STAT_RX_FIFO_FIS /**< Receive FIFO Full Interrupt flag */
176 #define LL_SPI_IS_RXO SPI_INT_STAT_RX_FIFO_OIS /**< Receive FIFO Overflow Interrupt flag */
177 #define LL_SPI_IS_RXU SPI_INT_STAT_RX_FIFO_UIS /**< Receive FIFO Underflow Interrupt flag */
178 #define LL_SPI_IS_TXO SPI_INT_STAT_TX_FIFO_OIS /**< Transmit FIFO Overflow Interrupt flag */
179 #define LL_SPI_IS_TXE SPI_INT_STAT_TX_FIFO_EIS /**< Transmit FIFO Empty Interrupt flag */
180 
181 #define LL_SPI_RIS_MST SPI_RAW_INT_STAT_MULTI_M_CRIS /**< Multi-Master Contention RAW Interrupt flag */
182 #define LL_SPI_RIS_RXF SPI_RAW_INT_STAT_RX_FIFO_FRIS /**< Receive FIFO Full RAW Interrupt flag */
183 #define LL_SPI_RIS_RXO SPI_RAW_INT_STAT_RX_FIFO_ORIS /**< Receive FIFO Overflow RAW Interrupt flag */
184 #define LL_SPI_RIS_RXU SPI_RAW_INT_STAT_RX_FIFO_URIS /**< Receive FIFO Underflow RAW Interrupt flag */
185 #define LL_SPI_RIS_TXO SPI_RAW_INT_STAT_TX_FIFO_ORIS /**< Transmit FIFO Overflow RAW Interrupt flag */
186 #define LL_SPI_RIS_TXE SPI_RAW_INT_STAT_TX_FIFO_ERIS /**< Transmit FIFO Empty RAW Interrupt flag */
187 /** @} */
188 
189 /** @defgroup SPI_LL_EC_DATASIZE Datawidth
190  * @{
191  */
192 #define LL_SPI_DATASIZE_4BIT (3UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 4 bits */
193 #define LL_SPI_DATASIZE_5BIT (4UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 5 bits */
194 #define LL_SPI_DATASIZE_6BIT (5UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 6 bits */
195 #define LL_SPI_DATASIZE_7BIT (6UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 7 bits */
196 #define LL_SPI_DATASIZE_8BIT (7UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 8 bits */
197 #define LL_SPI_DATASIZE_9BIT (8UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 9 bits */
198 #define LL_SPI_DATASIZE_10BIT (9UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 10 bits */
199 #define LL_SPI_DATASIZE_11BIT (10UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 11 bits */
200 #define LL_SPI_DATASIZE_12BIT (11UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 12 bits */
201 #define LL_SPI_DATASIZE_13BIT (12UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 13 bits */
202 #define LL_SPI_DATASIZE_14BIT (13UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 14 bits */
203 #define LL_SPI_DATASIZE_15BIT (14UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 15 bits */
204 #define LL_SPI_DATASIZE_16BIT (15UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 16 bits */
205 #define LL_SPI_DATASIZE_17BIT (16UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 17 bits */
206 #define LL_SPI_DATASIZE_18BIT (17UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 18 bits */
207 #define LL_SPI_DATASIZE_19BIT (18UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 19 bits */
208 #define LL_SPI_DATASIZE_20BIT (19UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 20 bits */
209 #define LL_SPI_DATASIZE_21BIT (20UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 21 bits */
210 #define LL_SPI_DATASIZE_22BIT (21UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 22 bits */
211 #define LL_SPI_DATASIZE_23BIT (22UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 23 bits */
212 #define LL_SPI_DATASIZE_24BIT (23UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 24 bits */
213 #define LL_SPI_DATASIZE_25BIT (24UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 25 bits */
214 #define LL_SPI_DATASIZE_26BIT (25UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 26 bits */
215 #define LL_SPI_DATASIZE_27BIT (26UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 27 bits */
216 #define LL_SPI_DATASIZE_28BIT (27UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 28 bits */
217 #define LL_SPI_DATASIZE_29BIT (28UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 29 bits */
218 #define LL_SPI_DATASIZE_30BIT (29UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 30 bits */
219 #define LL_SPI_DATASIZE_31BIT (30UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 31 bits */
220 #define LL_SPI_DATASIZE_32BIT (31UL << SPI_CTRL0_DATA_FRAME_SIZE_POS) /**< Data length for SPI transfer: 32 bits */
221 /** @} */
222 
223 /** @defgroup SPI_LL_EC_MICROWIRECOMMANDSIZE MicroWire CommandSize
224  * @{
225  */
226 #define LL_SPI_MW_CMDSIZE_1BIT 0x00000000UL /**< CMD length for Microwire transfer: 1 bits */
227 #define LL_SPI_MW_CMDSIZE_2BIT (1UL << SPI_CTRL0_CTRL_FRAME_SIZE_POS) /**< CMD length for Microwire transfer: 2 bits */
228 #define LL_SPI_MW_CMDSIZE_3BIT (2UL << SPI_CTRL0_CTRL_FRAME_SIZE_POS) /**< CMD length for Microwire transfer: 3 bits */
229 #define LL_SPI_MW_CMDSIZE_4BIT (3UL << SPI_CTRL0_CTRL_FRAME_SIZE_POS) /**< CMD length for Microwire transfer: 4 bits */
230 #define LL_SPI_MW_CMDSIZE_5BIT (4UL << SPI_CTRL0_CTRL_FRAME_SIZE_POS) /**< CMD length for Microwire transfer: 5 bits */
231 #define LL_SPI_MW_CMDSIZE_6BIT (5UL << SPI_CTRL0_CTRL_FRAME_SIZE_POS) /**< CMD length for Microwire transfer: 6 bits */
232 #define LL_SPI_MW_CMDSIZE_7BIT (6UL << SPI_CTRL0_CTRL_FRAME_SIZE_POS) /**< CMD length for Microwire transfer: 7 bits */
233 #define LL_SPI_MW_CMDSIZE_8BIT (7UL << SPI_CTRL0_CTRL_FRAME_SIZE_POS) /**< CMD length for Microwire transfer: 8 bits */
234 #define LL_SPI_MW_CMDSIZE_9BIT (8UL << SPI_CTRL0_CTRL_FRAME_SIZE_POS) /**< CMD length for Microwire transfer: 9 bits */
235 #define LL_SPI_MW_CMDSIZE_10BIT (9UL << SPI_CTRL0_CTRL_FRAME_SIZE_POS) /**< CMD length for Microwire transfer: 10 bits */
236 #define LL_SPI_MW_CMDSIZE_11BIT (10UL << SPI_CTRL0_CTRL_FRAME_SIZE_POS) /**< CMD length for Microwire transfer: 11 bits */
237 #define LL_SPI_MW_CMDSIZE_12BIT (11UL << SPI_CTRL0_CTRL_FRAME_SIZE_POS) /**< CMD length for Microwire transfer: 12 bits */
238 #define LL_SPI_MW_CMDSIZE_13BIT (12UL << SPI_CTRL0_CTRL_FRAME_SIZE_POS) /**< CMD length for Microwire transfer: 13 bits */
239 #define LL_SPI_MW_CMDSIZE_14BIT (13UL << SPI_CTRL0_CTRL_FRAME_SIZE_POS) /**< CMD length for Microwire transfer: 14 bits */
240 #define LL_SPI_MW_CMDSIZE_15BIT (14UL << SPI_CTRL0_CTRL_FRAME_SIZE_POS) /**< CMD length for Microwire transfer: 15 bits */
241 #define LL_SPI_MW_CMDSIZE_16BIT (15UL << SPI_CTRL0_CTRL_FRAME_SIZE_POS) /**< CMD length for Microwire transfer: 16 bits */
242 /** @} */
243 
244 /** @defgroup SPI_LL_EC_TEST_MODE Test Mode
245  * @{
246  */
247 #define LL_SPI_NORMAL_MODE 0x00000000UL /**< Normal mode for SPI transfer */
248 #define LL_SPI_TEST_MODE (1UL << SPI_CTRL0_SHIFT_REG_LOOP_POS) /**< Test mode for SPI transfer: Rx and Tx connected inside */
249 /** @} */
250 
251 /** @defgroup SPI_LL_EC_SLAVEOUT_ENABLE Slave Out Enable
252  * @{
253  */
254 #define LL_SPI_SLAVE_OUTDIS 0x00000000UL /**< Output enable for SPI transfer as slave */
255 #define LL_SPI_SLAVE_OUTEN (1UL << SPI_CTRL0_S_OUT_EN_POS) /**< Output disable for SPI transfer as slave */
256 /** @} */
257 
258 /** @defgroup SPI_LL_EC_TRANSFER_MODE Transfer Mode
259  * @{
260  */
261 #define LL_SPI_FULL_DUPLEX 0x00000000UL /**< Full-Duplex mode. Rx and Tx transfer on 2 lines */
262 #define LL_SPI_SIMPLEX_TX (1UL << SPI_CTRL0_XFE_MODE_POS) /**< Simplex Tx mode. Tx transfer only on 1 line */
263 #define LL_SPI_SIMPLEX_RX (2UL << SPI_CTRL0_XFE_MODE_POS) /**< Simplex Rx mode. Rx transfer only on 1 line */
264 #define LL_SPI_READ_EEPROM (3UL << SPI_CTRL0_XFE_MODE_POS) /**< Read EEPROM mode. Rx transfer only on 1 line */
265 /** @} */
266 
267 /** @defgroup SPI_LL_EC_PHASE Clock Phase
268  * @{
269  */
270 #define LL_SPI_SCPHA_1EDGE 0x00000000UL /**< First clock transition is the first data capture edge */
271 #define LL_SPI_SCPHA_2EDGE (1UL << SPI_CTRL0_SERIAL_CLK_PHASE_POS) /**< Second clock transition is the first data capture edge */
272 /** @} */
273 
274 /** @defgroup SPI_LL_EC_POLARITY Clock Polarity
275  * @{
276  */
277 #define LL_SPI_SCPOL_LOW 0x00000000UL /**< Clock to 0 when idle */
278 #define LL_SPI_SCPOL_HIGH (1UL << SPI_CTRL0_SERIAL_CLK_POL_POS) /**< Clock to 1 when idle */
279 /** @} */
280 
281 /** @defgroup SPI_LL_EC_PROTOCOL Serial Protocol
282  * @{
283  */
284 #define LL_SPI_PROTOCOL_MOTOROLA 0x00000000UL /**< Motorola mode. Used as default value */
285 #define LL_SPI_PROTOCOL_TI (1UL << SPI_CTRL0_FRAME_FORMAT_POS) /**< TI mode */
286 #define LL_SPI_PROTOCOL_MICROWIRE (2UL << SPI_CTRL0_FRAME_FORMAT_POS) /**< Microwire mode */
287 /** @} */
288 
289 /** @defgroup SPI_LL_EC_MICROWIRECONTROL MicroWire Control
290  * @{
291  */
292 #define LL_SPI_MICROWIRE_HANDSHAKE_DIS 0x00000000UL /**< Enable Handshake for Microwire transfer */
293 #define LL_SPI_MICROWIRE_HANDSHAKE_EN (1UL << SPI_MW_CTRL_MW_HSG_POS) /**< Disable Handshake for Microwire transfer */
294 
295 #define LL_SPI_MICROWIRE_RX 0x00000000UL /**< Rx mode. Rx transfer at Microwire mode */
296 #define LL_SPI_MICROWIRE_TX (1UL << SPI_MW_CTRL_MW_DIR_DW_POS) /**< Tx mode. Tx transfer at Microwire mode */
297 
298 #define LL_SPI_MICROWIRE_NON_SEQUENTIAL 0x00000000UL /**< Non-sequential for Microwire transfer */
299 #define LL_SPI_MICROWIRE_SEQUENTIAL (1UL << SPI_MW_CTRL_MW_XFE_MODE_POS) /**< Sequential for Microwire transfer */
300 /** @} */
301 
302 /** @defgroup SPI_LL_EC_SLAVESELECT Slave Select
303  * @{
304  */
305 #define LL_SPI_SLAVE1 SPI_SLA_S1_SEL_EN /**< Enable slave1 select pin for SPI transfer */
306 #define LL_SPI_SLAVE0 SPI_SLA_S0_SEL_EN /**< Enable slave0 select pin for SPI transfer */
307 /** @} */
308 
309 /** @defgroup SPI_LL_EC_DMA DMA Defines
310  * @{
311  */
312 #define LL_SPI_DMA_TX_DIS 0x00000000UL /**< Disable the transmit FIFO DMA channel */
313 #define LL_SPI_DMA_TX_EN SPI_DMA_CTRL_TX_DMA_EN /**< Enable the transmit FIFO DMA channel */
314 
315 #define LL_SPI_DMA_RX_DIS 0x00000000UL /**< Disable the receive FIFO DMA channel */
316 #define LL_SPI_DMA_RX_EN SPI_DMA_CTRL_RX_DMA_EN /**< Enable the receive FIFO DMA channel */
317 /** @} */
318 
319 /** @defgroup LL_SPI_x_FIFO_DEPTH Defines
320  * @{
321  */
322 #define LL_SPI_M_FIFO_DEPTH (8u) /**< FIFO Depth for SPI Master */
323 #define LL_SPI_S_FIFO_DEPTH (8u) /**< FIFO Depth for SPI Slave */
324 /** @} */
325 
326 /** @defgroup LL_SPI_x_DEFAULT_CONFIG Defines
327  * @{
328  */
329 
330 /**
331  * @brief LL SPIM InitStrcut default configuartion
332  */
333 #define LL_SPIM_DEFAULT_CONFIG \
334  { \
335  .transfer_direction = LL_SPI_FULL_DUPLEX, \
336  .data_size = LL_SPI_DATASIZE_8BIT, \
337  .clock_polarity = LL_SPI_SCPOL_LOW, \
338  .clock_phase = LL_SPI_SCPHA_1EDGE, \
339  .slave_select = LL_SPI_SLAVE0, \
340  .baud_rate = (SystemCoreClock / 2000000U),\
341  .rx_sample_delay = 0U \
342  }
343 
344 /**
345  * @brief LL SPIS InitStrcut default configuartion
346  */
347 #define LL_SPIS_DEFAULT_CONFIG \
348 { \
349  .data_size = LL_SPI_DATASIZE_8BIT, \
350  .clock_polarity = LL_SPI_SCPOL_LOW, \
351  .clock_phase = LL_SPI_SCPHA_1EDGE \
352 }
353 /** @} */
354 
355 /** @} */
356 
357 /* Exported macro ------------------------------------------------------------*/
358 /** @defgroup SPI_LL_Exported_Macros SPI Exported Macros
359  * @{
360  */
361 
362 /** @defgroup SPI_LL_EM_WRITE_READ Common Write and read registers Macros
363  * @{
364  */
365 
366 /**
367  * @brief Write a value in SPI register
368  * @param __instance__ SPI instance
369  * @param __REG__ Register to be written
370  * @param __VALUE__ Value to be written in the register
371  * @retval None
372  */
373 #define LL_SPI_WriteReg(__instance__, __REG__, __VALUE__) WRITE_REG(__instance__->__REG__, (__VALUE__))
374 
375 /**
376  * @brief Read a value in SPI register
377  * @param __instance__ SPI instance
378  * @param __REG__ Register to be read
379  * @retval Register value
380  */
381 #define LL_SPI_ReadReg(__instance__, __REG__) READ_REG(__instance__->__REG__)
382 
383 /** @} */
384 
385 /** @} */
386 
387 /** @} */
388 
389 /* Exported functions --------------------------------------------------------*/
390 /** @defgroup SPI_LL_DRIVER_FUNCTIONS Functions
391  * @{
392  */
393 
394 /** @defgroup SPI_LL_EF_Configuration Configuration functions
395  * @{
396  */
397 
398 /**
399  * @brief Enable slave select toggle
400  * @note This bit should not be changed when communication is ongoing.
401  *
402  * Register|BitsName
403  * --------|--------
404  * CTRL0 | SSTEN
405  *
406  * @param SPIx SPI instance
407  * @retval None
408  */
409 __STATIC_INLINE void ll_spi_enable_ss_toggle(spi_regs_t *SPIx)
410 {
411  SET_BITS(SPIx->CTRL0, SPI_CTRL0_S_ST_EN);
412 }
413 
414 /**
415  * @brief Disable slave select toggle
416  * @note This bit should not be changed when communication is ongoing.
417  *
418  * Register|BitsName
419  * --------|--------
420  * CTRL0 | SSTEN
421  *
422  * @param SPIx SPI instance
423  * @retval None
424  */
425 __STATIC_INLINE void ll_spi_disable_ss_toggle(spi_regs_t *SPIx)
426 {
427  CLEAR_BITS(SPIx->CTRL0, SPI_CTRL0_S_ST_EN);
428 }
429 
430 /**
431  * @brief Check if slave select toggle is enabled
432  * @note This bit should not be changed when communication is ongoing.
433  *
434  * Register|BitsName
435  * --------|--------
436  * CTRL0 | SSTEN
437  *
438  * @param SPIx SPI instance
439  * @retval State of bit (1 or 0).
440  */
441 __STATIC_INLINE uint32_t ll_spi_is_enabled_ss_toggle(spi_regs_t *SPIx)
442 {
443  return (READ_BITS(SPIx->CTRL0, SPI_CTRL0_S_ST_EN) == (SPI_CTRL0_S_ST_EN));
444 }
445 
446 /**
447  * @brief Set frame data size
448  *
449  * Register|BitsName
450  * --------|--------
451  * CTRL0 | DFS32
452  *
453  * @param SPIx SPI instance
454  * @param size This parameter can be one of the following values:
455  * @arg @ref LL_SPI_DATASIZE_4BIT
456  * @arg @ref LL_SPI_DATASIZE_5BIT
457  * @arg @ref LL_SPI_DATASIZE_6BIT
458  * @arg @ref LL_SPI_DATASIZE_7BIT
459  * @arg @ref LL_SPI_DATASIZE_8BIT
460  * @arg @ref LL_SPI_DATASIZE_9BIT
461  * @arg @ref LL_SPI_DATASIZE_10BIT
462  * @arg @ref LL_SPI_DATASIZE_11BIT
463  * @arg @ref LL_SPI_DATASIZE_12BIT
464  * @arg @ref LL_SPI_DATASIZE_13BIT
465  * @arg @ref LL_SPI_DATASIZE_14BIT
466  * @arg @ref LL_SPI_DATASIZE_15BIT
467  * @arg @ref LL_SPI_DATASIZE_16BIT
468  * @arg @ref LL_SPI_DATASIZE_17BIT
469  * @arg @ref LL_SPI_DATASIZE_18BIT
470  * @arg @ref LL_SPI_DATASIZE_19BIT
471  * @arg @ref LL_SPI_DATASIZE_20BIT
472  * @arg @ref LL_SPI_DATASIZE_21BIT
473  * @arg @ref LL_SPI_DATASIZE_22BIT
474  * @arg @ref LL_SPI_DATASIZE_23BIT
475  * @arg @ref LL_SPI_DATASIZE_24BIT
476  * @arg @ref LL_SPI_DATASIZE_25BIT
477  * @arg @ref LL_SPI_DATASIZE_26BIT
478  * @arg @ref LL_SPI_DATASIZE_27BIT
479  * @arg @ref LL_SPI_DATASIZE_28BIT
480  * @arg @ref LL_SPI_DATASIZE_29BIT
481  * @arg @ref LL_SPI_DATASIZE_30BIT
482  * @arg @ref LL_SPI_DATASIZE_31BIT
483  * @arg @ref LL_SPI_DATASIZE_32BIT
484  * @retval None
485  */
486 __STATIC_INLINE void ll_spi_set_data_size(spi_regs_t *SPIx, uint32_t size)
487 {
488  MODIFY_REG(SPIx->CTRL0, SPI_CTRL0_DATA_FRAME_SIZE, size);
489 }
490 
491 /**
492  * @brief Get frame data size
493  *
494  * Register|BitsName
495  * --------|--------
496  * CTRL0 | DFS32
497  *
498  * @param SPIx SPI instance
499  * @retval Returned value can be one of the following values:
500  * @arg @ref LL_SPI_DATASIZE_4BIT
501  * @arg @ref LL_SPI_DATASIZE_5BIT
502  * @arg @ref LL_SPI_DATASIZE_6BIT
503  * @arg @ref LL_SPI_DATASIZE_7BIT
504  * @arg @ref LL_SPI_DATASIZE_8BIT
505  * @arg @ref LL_SPI_DATASIZE_9BIT
506  * @arg @ref LL_SPI_DATASIZE_10BIT
507  * @arg @ref LL_SPI_DATASIZE_11BIT
508  * @arg @ref LL_SPI_DATASIZE_12BIT
509  * @arg @ref LL_SPI_DATASIZE_13BIT
510  * @arg @ref LL_SPI_DATASIZE_14BIT
511  * @arg @ref LL_SPI_DATASIZE_15BIT
512  * @arg @ref LL_SPI_DATASIZE_16BIT
513  * @arg @ref LL_SPI_DATASIZE_17BIT
514  * @arg @ref LL_SPI_DATASIZE_18BIT
515  * @arg @ref LL_SPI_DATASIZE_19BIT
516  * @arg @ref LL_SPI_DATASIZE_20BIT
517  * @arg @ref LL_SPI_DATASIZE_21BIT
518  * @arg @ref LL_SPI_DATASIZE_22BIT
519  * @arg @ref LL_SPI_DATASIZE_23BIT
520  * @arg @ref LL_SPI_DATASIZE_24BIT
521  * @arg @ref LL_SPI_DATASIZE_25BIT
522  * @arg @ref LL_SPI_DATASIZE_26BIT
523  * @arg @ref LL_SPI_DATASIZE_27BIT
524  * @arg @ref LL_SPI_DATASIZE_28BIT
525  * @arg @ref LL_SPI_DATASIZE_29BIT
526  * @arg @ref LL_SPI_DATASIZE_30BIT
527  * @arg @ref LL_SPI_DATASIZE_31BIT
528  * @arg @ref LL_SPI_DATASIZE_32BIT
529  */
530 __STATIC_INLINE uint32_t ll_spi_get_data_size(spi_regs_t *SPIx)
531 {
532  return (uint32_t)(READ_BITS(SPIx->CTRL0, SPI_CTRL0_DATA_FRAME_SIZE));
533 }
534 
535 /**
536  * @brief Set the length of the control word for the Microwire frame format
537  * @note This bit should be written only when SPI is disabled (SSI_EN = 0) for correct operation.
538  *
539  * Register|BitsName
540  * --------|--------
541  * CTRL0 | CFS
542  *
543  * @param SPIx SPI instance
544  * @param size This parameter can be one of the following values:
545  * @arg @ref LL_SPI_MW_CMDSIZE_1BIT
546  * @arg @ref LL_SPI_MW_CMDSIZE_2BIT
547  * @arg @ref LL_SPI_MW_CMDSIZE_3BIT
548  * @arg @ref LL_SPI_MW_CMDSIZE_4BIT
549  * @arg @ref LL_SPI_MW_CMDSIZE_5BIT
550  * @arg @ref LL_SPI_MW_CMDSIZE_6BIT
551  * @arg @ref LL_SPI_MW_CMDSIZE_7BIT
552  * @arg @ref LL_SPI_MW_CMDSIZE_8BIT
553  * @arg @ref LL_SPI_MW_CMDSIZE_9BIT
554  * @arg @ref LL_SPI_MW_CMDSIZE_10BIT
555  * @arg @ref LL_SPI_MW_CMDSIZE_11BIT
556  * @arg @ref LL_SPI_MW_CMDSIZE_12BIT
557  * @arg @ref LL_SPI_MW_CMDSIZE_13BIT
558  * @arg @ref LL_SPI_MW_CMDSIZE_14BIT
559  * @arg @ref LL_SPI_MW_CMDSIZE_15BIT
560  * @arg @ref LL_SPI_MW_CMDSIZE_16BIT
561  * @retval None
562  */
563 __STATIC_INLINE void ll_spi_set_control_frame_size(spi_regs_t *SPIx, uint32_t size)
564 {
565  MODIFY_REG(SPIx->CTRL0, SPI_CTRL0_CTRL_FRAME_SIZE, size);
566 }
567 
568 /**
569  * @brief Get the length of the control word for the Microwire frame format
570  * @note This bit should be written only when SPI is disabled (SSI_EN = 0) for correct operation.
571  *
572  * Register|BitsName
573  * --------|--------
574  * CTRL0 | CFS
575  *
576  * @param SPIx SPI instance
577  * @retval Returned value can be one of the following values:
578  * @arg @ref LL_SPI_MW_CMDSIZE_1BIT
579  * @arg @ref LL_SPI_MW_CMDSIZE_2BIT
580  * @arg @ref LL_SPI_MW_CMDSIZE_3BIT
581  * @arg @ref LL_SPI_MW_CMDSIZE_4BIT
582  * @arg @ref LL_SPI_MW_CMDSIZE_5BIT
583  * @arg @ref LL_SPI_MW_CMDSIZE_6BIT
584  * @arg @ref LL_SPI_MW_CMDSIZE_7BIT
585  * @arg @ref LL_SPI_MW_CMDSIZE_8BIT
586  * @arg @ref LL_SPI_MW_CMDSIZE_9BIT
587  * @arg @ref LL_SPI_MW_CMDSIZE_10BIT
588  * @arg @ref LL_SPI_MW_CMDSIZE_11BIT
589  * @arg @ref LL_SPI_MW_CMDSIZE_12BIT
590  * @arg @ref LL_SPI_MW_CMDSIZE_13BIT
591  * @arg @ref LL_SPI_MW_CMDSIZE_14BIT
592  * @arg @ref LL_SPI_MW_CMDSIZE_15BIT
593  * @arg @ref LL_SPI_MW_CMDSIZE_16BIT
594  */
595 __STATIC_INLINE uint32_t ll_spi_get_control_frame_size(spi_regs_t *SPIx)
596 {
597  return (uint32_t)(READ_BITS(SPIx->CTRL0, SPI_CTRL0_CTRL_FRAME_SIZE));
598 }
599 
600 /**
601  * @brief Enable SPI test mode
602  *
603  * Register|BitsName
604  * --------|--------
605  * CTRL0 | SRL
606  *
607  * @param SPIx SPI instance
608  * @retval None
609  */
610 __STATIC_INLINE void ll_spi_enable_test_mode(spi_regs_t *SPIx)
611 {
612  SET_BITS(SPIx->CTRL0, SPI_CTRL0_SHIFT_REG_LOOP);
613 }
614 
615 /**
616  * @brief Disable SPI test mode
617  *
618  * Register|BitsName
619  * --------|--------
620  * CTRL0 | SRL
621  *
622  * @param SPIx SPI instance
623  * @retval None
624  */
625 __STATIC_INLINE void ll_spi_disable_test_mode(spi_regs_t *SPIx)
626 {
627  CLEAR_BITS(SPIx->CTRL0, SPI_CTRL0_SHIFT_REG_LOOP);
628 }
629 
630 /**
631  * @brief Check if SPI test mode is enabled
632  *
633  * Register|BitsName
634  * --------|--------
635  * CTRL0 | SRL
636  *
637  * @param SPIx SPI instance
638  * @retval State of bit (1 or 0).
639  */
640 __STATIC_INLINE uint32_t ll_spi_is_enabled_test_mode(spi_regs_t *SPIx)
641 {
642  return (READ_BITS(SPIx->CTRL0, SPI_CTRL0_SHIFT_REG_LOOP) == (SPI_CTRL0_SHIFT_REG_LOOP));
643 }
644 
645 /**
646  * @brief Enable slave output
647  *
648  * Register|BitsName
649  * --------|--------
650  * CTRL0 | SLVOE
651  *
652  * @param SPIx SPI instance
653  * @retval None
654  */
655 __STATIC_INLINE void ll_spi_enable_slave_out(spi_regs_t *SPIx)
656 {
657  CLEAR_BITS(SPIx->CTRL0, SPI_CTRL0_S_OUT_EN);
658 }
659 
660 /**
661  * @brief Disable slave output
662  *
663  * Register|BitsName
664  * --------|--------
665  * CTRL0 | SLVOE
666  *
667  * @param SPIx SPI instance
668  * @retval None
669  */
670 __STATIC_INLINE void ll_spi_disable_salve_out(spi_regs_t *SPIx)
671 {
672  SET_BITS(SPIx->CTRL0, SPI_CTRL0_S_OUT_EN);
673 }
674 
675 /**
676  * @brief Check if slave output is enabled
677  *
678  * Register|BitsName
679  * --------|--------
680  * CTRL0 | SLVOE
681  *
682  * @param SPIx SPI instance
683  * @retval State of bit (1 or 0).
684  */
685 __STATIC_INLINE uint32_t ll_spi_is_enabled_slave_out(spi_regs_t *SPIx)
686 {
687  return (READ_BITS(SPIx->CTRL0, SPI_CTRL0_S_OUT_EN) != (SPI_CTRL0_S_OUT_EN));
688 }
689 
690 /**
691  * @brief Set transfer direction mode
692  *
693  * Register|BitsName
694  * --------|--------
695  * CTRL0 | TMOD
696  *
697  * @param SPIx SPI instance
698  * @param transfer_direction This parameter can be one of the following values:
699  * @arg @ref LL_SPI_FULL_DUPLEX
700  * @arg @ref LL_SPI_SIMPLEX_TX
701  * @arg @ref LL_SPI_SIMPLEX_RX
702  * @arg @ref LL_SPI_READ_EEPROM
703  * @retval None
704  */
705 __STATIC_INLINE void ll_spi_set_transfer_direction(spi_regs_t *SPIx, uint32_t transfer_direction)
706 {
707  MODIFY_REG(SPIx->CTRL0, SPI_CTRL0_XFE_MODE, transfer_direction);
708 }
709 
710 /**
711  * @brief Get transfer direction mode
712  *
713  * Register|BitsName
714  * --------|--------
715  * CTRL0 | TMOD
716  *
717  * @param SPIx SPI instance
718  * @retval Returned value can be one of the following values:
719  * @arg @ref LL_SPI_FULL_DUPLEX
720  * @arg @ref LL_SPI_SIMPLEX_TX
721  * @arg @ref LL_SPI_SIMPLEX_RX
722  * @arg @ref LL_SPI_READ_EEPROM
723  */
724 __STATIC_INLINE uint32_t ll_spi_get_transfer_direction(spi_regs_t *SPIx)
725 {
726  return (uint32_t)(READ_BITS(SPIx->CTRL0, SPI_CTRL0_XFE_MODE));
727 }
728 
729 /**
730  * @brief Set clock polarity
731  * @note This bit should not be changed when communication is ongoing.
732  * This bit is not used in SPI TI mode.
733  *
734  * Register|BitsName
735  * --------|--------
736  * CTRL0 | SCPOL
737  *
738  * @param SPIx SPI instance
739  * @param clock_polarity This parameter can be one of the following values:
740  * @arg @ref LL_SPI_SCPOL_LOW
741  * @arg @ref LL_SPI_SCPOL_HIGH
742  * @retval None
743  */
744 __STATIC_INLINE void ll_spi_set_clock_polarity(spi_regs_t *SPIx, uint32_t clock_polarity)
745 {
746  MODIFY_REG(SPIx->CTRL0, SPI_CTRL0_SERIAL_CLK_POL, clock_polarity);
747 }
748 
749 /**
750  * @brief Get clock polarity
751  *
752  * Register|BitsName
753  * --------|--------
754  * CTRL0 | SCPOL
755  *
756  * @param SPIx SPI instance
757  * @retval Returned value can be one of the following values:
758  * @arg @ref LL_SPI_SCPOL_LOW
759  * @arg @ref LL_SPI_SCPOL_HIGH
760  */
761 __STATIC_INLINE uint32_t ll_spi_get_clock_polarity(spi_regs_t *SPIx)
762 {
763  return (uint32_t)(READ_BITS(SPIx->CTRL0, SPI_CTRL0_SERIAL_CLK_POL));
764 }
765 
766 /**
767  * @brief Set clock phase
768  * @note This bit should not be changed when communication is ongoing.
769  * This bit is not used in SPI TI mode.
770  *
771  * Register|BitsName
772  * --------|--------
773  * CTRL0 | SCPHA
774  *
775  * @param SPIx SPI instance
776  * @param clock_phase This parameter can be one of the following values:
777  * @arg @ref LL_SPI_SCPHA_1EDGE
778  * @arg @ref LL_SPI_SCPHA_2EDGE
779  * @retval None
780  */
781 __STATIC_INLINE void ll_spi_set_clock_phase(spi_regs_t *SPIx, uint32_t clock_phase)
782 {
783  MODIFY_REG(SPIx->CTRL0, SPI_CTRL0_SERIAL_CLK_PHASE, clock_phase);
784 }
785 
786 /**
787  * @brief Get clock phase
788  *
789  * Register|BitsName
790  * --------|--------
791  * CTRL0 | SCPHA
792  *
793  * @param SPIx SPI instance
794  * @retval Returned value can be one of the following values:
795  * @arg @ref LL_SPI_SCPHA_1EDGE
796  * @arg @ref LL_SPI_SCPHA_2EDGE
797  */
798 __STATIC_INLINE uint32_t ll_spi_get_clock_phase(spi_regs_t *SPIx)
799 {
800  return (uint32_t)(READ_BITS(SPIx->CTRL0, SPI_CTRL0_SERIAL_CLK_PHASE));
801 }
802 
803 /**
804  * @brief Set serial protocol used
805  * @note This bit should be written only when SPI is disabled (SSI_EN = 0) for correct operation.
806  *
807  * Register|BitsName
808  * --------|--------
809  * CTRL0 | FRF
810  *
811  * @param SPIx SPI instance
812  * @param standard This parameter can be one of the following values:
813  * @arg @ref LL_SPI_PROTOCOL_MOTOROLA
814  * @arg @ref LL_SPI_PROTOCOL_TI
815  * @arg @ref LL_SPI_PROTOCOL_MICROWIRE
816  * @retval None
817  */
818 __STATIC_INLINE void ll_spi_set_standard(spi_regs_t *SPIx, uint32_t standard)
819 {
820  MODIFY_REG(SPIx->CTRL0, SPI_CTRL0_FRAME_FORMAT, standard);
821 }
822 
823 /**
824  * @brief Get serial protocol used
825  *
826  * Register|BitsName
827  * --------|--------
828  * CTRL0 | FRF
829  *
830  * @param SPIx SPI instance
831  * @retval Returned value can be one of the following values:
832  * @arg @ref LL_SPI_PROTOCOL_MOTOROLA
833  * @arg @ref LL_SPI_PROTOCOL_TI
834  * @arg @ref LL_SPI_PROTOCOL_MICROWIRE
835  */
836 __STATIC_INLINE uint32_t ll_spi_get_standard(spi_regs_t *SPIx)
837 {
838  return (uint32_t)(READ_BITS(SPIx->CTRL0, SPI_CTRL0_FRAME_FORMAT));
839 }
840 
841 /**
842  * @brief Set the number of data frames to be continuously received
843  * @note These bits should not be changed when communication is ongoing.
844  This bits are effect when TMOD = 2b10 or 2b11.
845  This bits are not effect in SPIS.
846  *
847  * Register|BitsName
848  * --------|--------
849  * CTRL1 | NDF
850  *
851  * @param SPIx SPI instance
852  * @param size This parameter can be one of the following values: 0 ~ 65535
853  * @retval None
854  */
855 __STATIC_INLINE void ll_spi_set_receive_size(spi_regs_t *SPIx, uint32_t size)
856 {
857  MODIFY_REG(SPIx->CTRL1, SPI_CTRL1_NUM_DATA_FRAME, size);
858 }
859 
860 /**
861  * @brief Get the number of data frames to be continuously received
862  * @note These bits should not be changed when communication is ongoing.
863  This bits are effect when TMOD = 2b10 or 2b11.
864  This bits are not effect in SPIS.
865  *
866  * Register|BitsName
867  * --------|--------
868  * CTRL1 | NDF
869  *
870  * @param SPIx SPI instance
871  * @retval Returned value can be one of the following values: 0 ~ 65535
872  */
873 __STATIC_INLINE uint32_t ll_spi_get_receive_size(spi_regs_t *SPIx)
874 {
875  return (uint32_t)(READ_BITS(SPIx->CTRL1, SPI_CTRL1_NUM_DATA_FRAME));
876 }
877 
878 /**
879  * @brief Enable SPI peripheral
880  *
881  * Register|BitsName
882  * --------|--------
883  * SSI_EN | EN
884  *
885  * @param SPIx SPI instance
886  * @retval None
887  */
888 __STATIC_INLINE void ll_spi_enable(spi_regs_t *SPIx)
889 {
890  SET_BITS(SPIx->SSI_EN, SPI_SSI_EN);
891 }
892 
893 /**
894  * @brief Disable SPI peripheral
895  * @note When disabling the SPI, follow the procedure described in the Reference Manual.
896  *
897  * Register|BitsName
898  * --------|--------
899  * SSI_EN | EN
900  *
901  * @param SPIx SPI instance
902  * @retval None
903  */
904 __STATIC_INLINE void ll_spi_disable(spi_regs_t *SPIx)
905 {
906  CLEAR_BITS(SPIx->SSI_EN, SPI_SSI_EN);
907 }
908 
909 /**
910  * @brief Check if SPI peripheral is enabled
911  *
912  * Register|BitsName
913  * --------|--------
914  * SSI_EN | EN
915  *
916  * @param SPIx SPI instance
917  * @retval State of bit (1 or 0).
918  */
919 __STATIC_INLINE bool ll_spi_is_enabled(spi_regs_t *SPIx)
920 {
921  return (READ_BITS(SPIx->SSI_EN, SPI_SSI_EN) == (SPI_SSI_EN));
922 }
923 
924 /**
925  * @brief Enable Handshake in Microwire mode
926  *
927  * Register|BitsName
928  * --------|--------
929  * MWC | MHS
930  *
931  * @param SPIx SPI instance
932  * @retval None
933  */
934 __STATIC_INLINE void ll_spi_enable_micro_handshake(spi_regs_t *SPIx)
935 {
936  SET_BITS(SPIx->MW_CTRL, SPI_MW_CTRL_MW_HSG);
937 }
938 
939 /**
940  * @brief Disable Handshake in Microwire mode
941  *
942  * Register|BitsName
943  * --------|--------
944  * MWC | MHS
945  *
946  * @param SPIx SPI instance
947  * @retval None
948  */
949 __STATIC_INLINE void ll_spi_disable_micro_handshake(spi_regs_t *SPIx)
950 {
951  CLEAR_BITS(SPIx->MW_CTRL, SPI_MW_CTRL_MW_HSG);
952 }
953 
954 /**
955  * @brief Check if Handshake in Microwire mode is enabled
956  *
957  * Register|BitsName
958  * --------|--------
959  * MWC | MHS
960  *
961  * @param SPIx SPI instance
962  * @retval State of bit (1 or 0).
963  */
964 __STATIC_INLINE uint32_t ll_spi_is_enabled_micro_handshake(spi_regs_t *SPIx)
965 {
966  return (READ_BITS(SPIx->MW_CTRL, SPI_MW_CTRL_MW_HSG) == (SPI_MW_CTRL_MW_HSG));
967 }
968 
969 /**
970  * @brief Set transfer direction mode in Microwire mode
971  * @note This bit should not be changed when communication is ongoing.
972  *
973  * Register|BitsName
974  * --------|--------
975  * MWC | MDD
976  *
977  * @param SPIx SPI instance
978  * @param transfer_direction This parameter can be one of the following values:
979  * @arg @ref LL_SPI_MICROWIRE_RX
980  * @arg @ref LL_SPI_MICROWIRE_TX
981  * @retval None
982  */
983 __STATIC_INLINE void ll_spi_set_micro_transfer_direction(spi_regs_t *SPIx, uint32_t transfer_direction)
984 {
985  MODIFY_REG(SPIx->MW_CTRL, SPI_MW_CTRL_MW_DIR_DW, transfer_direction);
986 }
987 
988 /**
989  * @brief Get transfer direction mode in Microwire mode
990  * @note This bit should not be changed when communication is ongoing.
991  *
992  * Register|BitsName
993  * --------|--------
994  * MWC | MDD
995  *
996  * @param SPIx SPI instance
997  * @retval Returned value can be one of the following values:
998  * @arg @ref LL_SPI_MICROWIRE_RX
999  * @arg @ref LL_SPI_MICROWIRE_TX
1000  */
1001 __STATIC_INLINE uint32_t ll_spi_get_micro_transfer_direction(spi_regs_t *SPIx)
1002 {
1003  return (uint32_t)(READ_BITS(SPIx->MW_CTRL, SPI_MW_CTRL_MW_DIR_DW));
1004 }
1005 
1006 /**
1007  * @brief Set transfer mode in Microwire mode
1008  * @note This bit should not be changed when communication is ongoing.
1009  *
1010  * Register|BitsName
1011  * --------|--------
1012  * MWC | MWMOD
1013  *
1014  * @param SPIx SPI instance
1015  * @param transfer_mode This parameter can be one of the following values:
1016  * @arg @ref LL_SPI_MICROWIRE_NON_SEQUENTIAL
1017  * @arg @ref LL_SPI_MICROWIRE_SEQUENTIAL
1018  * @retval None
1019  */
1020 __STATIC_INLINE void ll_spi_set_micro_transfer_mode(spi_regs_t *SPIx, uint32_t transfer_mode)
1021 {
1022  MODIFY_REG(SPIx->MW_CTRL, SPI_MW_CTRL_MW_XFE_MODE, transfer_mode);
1023 }
1024 
1025 /**
1026  * @brief Get transfer mode in Microwire mode
1027  * @note This bit should not be changed when communication is ongoing.
1028  *
1029  * Register|BitsName
1030  * --------|--------
1031  * MWC | MWMOD
1032  *
1033  * @param SPIx SPI instance
1034  * @retval Returned value can be one of the following values:
1035  * @arg @ref LL_SPI_MICROWIRE_NON_SEQUENTIAL
1036  * @arg @ref LL_SPI_MICROWIRE_SEQUENTIAL
1037  */
1038 __STATIC_INLINE uint32_t ll_spi_get_micro_transfer_mode(spi_regs_t *SPIx)
1039 {
1040  return (uint32_t)(READ_BITS(SPIx->MW_CTRL, SPI_MW_CTRL_MW_XFE_MODE));
1041 }
1042 
1043 /**
1044  * @brief Enable slave select
1045  *
1046  * Register|BitsName
1047  * --------|--------
1048  * SE | SLAVE1
1049  * SE | SLAVE0
1050  *
1051  * @param SPIx SPI instance
1052  * @param ss This parameter can be one of the following values:
1053  * @arg @ref LL_SPI_SLAVE1
1054  * @arg @ref LL_SPI_SLAVE0
1055  * @retval None
1056  */
1057 __STATIC_INLINE void ll_spi_enable_ss(spi_regs_t *SPIx, uint32_t ss)
1058 {
1059  SET_BITS(SPIx->S_EN, ss);
1060 }
1061 
1062 /**
1063  * @brief Disable slave select
1064  *
1065  * Register|BitsName
1066  * --------|--------
1067  * SE | SLAVE1
1068  * SE | SLAVE0
1069  *
1070  * @param SPIx SPI instance
1071  * @param ss This parameter can be one of the following values:
1072  * @arg @ref LL_SPI_SLAVE1
1073  * @arg @ref LL_SPI_SLAVE0
1074  * @retval None
1075  */
1076 __STATIC_INLINE void ll_spi_disable_ss(spi_regs_t *SPIx, uint32_t ss)
1077 {
1078  CLEAR_BITS(SPIx->S_EN, ss);
1079 }
1080 
1081 /**
1082  * @brief Check if slave select is enabled
1083  *
1084  * Register|BitsName
1085  * --------|--------
1086  * SE | SLAVE1
1087  * SE | SLAVE0
1088  *
1089  * @param SPIx SPI instance
1090  * @param ss This parameter can be one of the following values:
1091  * @arg @ref LL_SPI_SLAVE1
1092  * @arg @ref LL_SPI_SLAVE0
1093  * @retval State of bit (1 or 0).
1094  */
1095 __STATIC_INLINE uint32_t ll_spi_is_enabled_ss(spi_regs_t *SPIx, uint32_t ss)
1096 {
1097  return (READ_BITS(SPIx->S_EN, ss) == ss);
1098 }
1099 
1100 /**
1101  * @brief Set baud rate prescaler
1102  * @note These bits should not be changed when communication is ongoing. SPI BaudRate = fPCLK/Prescaler.
1103  *
1104  * Register|BitsName
1105  * --------|--------
1106  * BAUD | SCKDIV
1107  *
1108  * @param SPIx SPI instance
1109  * @param baud_rate This parameter can be one even value between 2 and 65534, if the value is 0, the SCLK is disable.
1110  * @retval None
1111  */
1112 __STATIC_INLINE void ll_spi_set_baud_rate_prescaler(spi_regs_t *SPIx, uint32_t baud_rate)
1113 {
1114  WRITE_REG(SPIx->BAUD, baud_rate);
1115 }
1116 
1117 /**
1118  * @brief Get baud rate prescaler
1119  *
1120  * Register|BitsName
1121  * --------|--------
1122  * BAUD | SCKDIV
1123  *
1124  * @param SPIx SPI instance
1125  * @retval Returned value can be one even value between 2 and 65534.
1126  */
1127 __STATIC_INLINE uint32_t ll_spi_get_baud_rate_prescaler(spi_regs_t *SPIx)
1128 {
1129  return (uint32_t)(READ_BITS(SPIx->BAUD, SPI_BAUD_CLK_DIV));
1130 }
1131 
1132 /**
1133  * @brief Set threshold of TXFIFO that triggers an TXE event
1134  *
1135  * Register|BitsName
1136  * --------|--------
1137  * TXFTL | TFT
1138  *
1139  * @param SPIx SPI instance
1140  * @param threshold This parameter can be one of the following values: 0 ~ (LL_SPI_x_FIFO_DEPTH - 1)
1141  * @retval None
1142  */
1143 __STATIC_INLINE void ll_spi_set_tx_fifo_threshold(spi_regs_t *SPIx, uint32_t threshold)
1144 {
1145  WRITE_REG(SPIx->TX_FIFO_TL, threshold);
1146 }
1147 
1148 /**
1149  * @brief Get threshold of TXFIFO that triggers an TXE event
1150  *
1151  * Register|BitsName
1152  * --------|--------
1153  * TXFTL | TFT
1154  *
1155  * @param SPIx SPI instance
1156  * @retval Returned value can be one of the following values: 0 ~ (LL_SPI_x_FIFO_DEPTH - 1)
1157  */
1158 __STATIC_INLINE uint32_t ll_spi_get_tx_fifo_threshold(spi_regs_t *SPIx)
1159 {
1160  return (uint32_t)(READ_BITS(SPIx->TX_FIFO_TL, SPI_TX_FIFO_TL_TX_FIFO_THD));
1161 }
1162 
1163 /**
1164  * @brief Set threshold of RXFIFO that triggers an RXNE event
1165  *
1166  * Register|BitsName
1167  * --------|--------
1168  * RXFTL | RFT
1169  *
1170  * @param SPIx SPI instance
1171  * @param threshold This parameter can be one of the following values: 0 ~ (LL_SPI_x_FIFO_DEPTH - 1)
1172  * @retval None
1173  */
1174 __STATIC_INLINE void ll_spi_set_rx_fifo_threshold(spi_regs_t *SPIx, uint32_t threshold)
1175 {
1176  WRITE_REG(SPIx->RX_FIFO_TL, threshold);
1177 }
1178 
1179 /**
1180  * @brief Get threshold of RXFIFO that triggers an RXNE event
1181  *
1182  * Register|BitsName
1183  * --------|--------
1184  * RXFTL | RFT
1185  *
1186  * @param SPIx SPI instance
1187  * @retval Returned value can be one of the following values: 0 ~ (LL_SPI_x_FIFO_DEPTH - 1)
1188  */
1189 __STATIC_INLINE uint32_t ll_spi_get_rx_fifo_threshold(spi_regs_t *SPIx)
1190 {
1191  return (uint32_t)(READ_BITS(SPIx->RX_FIFO_TL, SPI_RX_FIFO_TL_RX_FIFO_THD));
1192 }
1193 
1194 /**
1195  * @brief Get FIFO Transmission Level
1196  *
1197  * Register|BitsName
1198  * --------|--------
1199  * TXFL | TXTFL
1200  *
1201  * @param SPIx SPI instance
1202  * @retval Returned value can be one of the following values: 0 ~ LL_SPI_x_FIFO_DEPTH
1203  */
1204 __STATIC_INLINE uint32_t ll_spi_get_tx_fifo_level(spi_regs_t *SPIx)
1205 {
1206  return (uint32_t)(READ_BITS(SPIx->TX_FIFO_LEVEL, SPI_TX_FIFO_LEVEL_TX_FIFO_LEVEL));
1207 }
1208 
1209 /**
1210  * @brief Get FIFO reception Level
1211  *
1212  * Register|BitsName
1213  * --------|--------
1214  * RXFL | RXTFL
1215  *
1216  * @param SPIx SPI instance
1217  * @retval Returned value can be one of the following values: 0 ~ LL_SPI_x_FIFO_DEPTH
1218  */
1219 __STATIC_INLINE uint32_t ll_spi_get_rx_fifo_level(spi_regs_t *SPIx)
1220 {
1221  return (uint32_t)(READ_BITS(SPIx->RX_FIFO_LEVEL, SPI_RX_FIFO_LEVEL_RX_FIFO_LEVEL));
1222 }
1223 
1224 /** @} */
1225 
1226 /** @defgroup SPI_LL_EF_IT_Management IT_Management
1227  * @{
1228  */
1229 
1230 /**
1231  * @brief Enable interrupt
1232  * @note This bit controls the generation of an interrupt when an event occurs.
1233  *
1234  * Register|BitsName
1235  * --------|--------
1236  * INTMASK | INTMASK
1237  *
1238  * @param SPIx SPI instance
1239  * @param mask This parameter can be one of the following values:
1240  * @arg @ref LL_SPI_IM_MST(not effect in SPIS)
1241  * @arg @ref LL_SPI_IM_RXF
1242  * @arg @ref LL_SPI_IM_RXO
1243  * @arg @ref LL_SPI_IM_RXU
1244  * @arg @ref LL_SPI_IM_TXO
1245  * @arg @ref LL_SPI_IM_TXE
1246  * @retval None
1247  */
1248 __STATIC_INLINE void ll_spi_enable_it(spi_regs_t *SPIx, uint32_t mask)
1249 {
1250  SET_BITS(SPIx->INT_MASK, mask);
1251 }
1252 
1253 /**
1254  * @brief Disable interrupt
1255  * @note This bit controls the generation of an interrupt when an event occurs.
1256  *
1257  * Register|BitsName
1258  * --------|--------
1259  * INTMASK | INTMASK
1260  *
1261  * @param SPIx SPI instance
1262  * @param mask This parameter can be one of the following values:
1263  * @arg @ref LL_SPI_IM_MST(not effect in SPIS)
1264  * @arg @ref LL_SPI_IM_RXF
1265  * @arg @ref LL_SPI_IM_RXO
1266  * @arg @ref LL_SPI_IM_RXU
1267  * @arg @ref LL_SPI_IM_TXO
1268  * @arg @ref LL_SPI_IM_TXE
1269  * @retval None
1270  */
1271 __STATIC_INLINE void ll_spi_disable_it(spi_regs_t *SPIx, uint32_t mask)
1272 {
1273  CLEAR_BITS(SPIx->INT_MASK, mask);
1274 }
1275 
1276 /**
1277  * @brief Check if interrupt is enabled
1278  *
1279  * Register|BitsName
1280  * --------|--------
1281  * INTMASK | INTMASK
1282  *
1283  * @param SPIx SPI instance
1284  * @param mask This parameter can be one of the following values:
1285  * @arg @ref LL_SPI_IM_MST(not effect in SPIS)
1286  * @arg @ref LL_SPI_IM_RXF
1287  * @arg @ref LL_SPI_IM_RXO
1288  * @arg @ref LL_SPI_IM_RXU
1289  * @arg @ref LL_SPI_IM_TXO
1290  * @arg @ref LL_SPI_IM_TXE
1291  * @retval State of bit (1 or 0).
1292  */
1293 __STATIC_INLINE uint32_t ll_spi_is_enabled_it(spi_regs_t *SPIx, uint32_t mask)
1294 {
1295  return (READ_BITS(SPIx->INT_MASK, mask) == mask);
1296 }
1297 
1298 /** @} */
1299 
1300 /** @defgroup SPI_LL_EF_FLAG_Management FLAG_Management
1301  * @{
1302  */
1303 
1304 /**
1305  * @brief Get SPI status
1306  *
1307  * Register|BitsName
1308  * --------|--------
1309  * STAT | STAT
1310  *
1311  * @param SPIx SPI instance
1312  * @retval Returned value can be one or combination of the following values:
1313  * @arg @ref LL_SPI_SR_DCOL(no effect in SPIS)
1314  * @arg @ref LL_SPI_SR_TXE
1315  * @arg @ref LL_SPI_SR_RFF
1316  * @arg @ref LL_SPI_SR_RFNE
1317  * @arg @ref LL_SPI_SR_TFE
1318  * @arg @ref LL_SPI_SR_TFNF
1319  * @arg @ref LL_SPI_SR_BUSY
1320  */
1321 __STATIC_INLINE uint32_t ll_spi_get_status(spi_regs_t *SPIx)
1322 {
1323  return (uint32_t)(READ_REG(SPIx->STAT));
1324 }
1325 
1326 /**
1327  * @brief Check active flag
1328  *
1329  * Register|BitsName
1330  * --------|--------
1331  * STAT | DCOL
1332  * STAT | TXE
1333  * STAT | RFF
1334  * STAT | RFNE
1335  * STAT | TFE
1336  * STAT | TFNF
1337  * STAT | BUSY
1338  *
1339  * @param SPIx SPI instance
1340  * @param flag This parameter can be one of the following values:
1341  * @arg @ref LL_SPI_SR_DCOL(no effect in SPIS)
1342  * @arg @ref LL_SPI_SR_TXE
1343  * @arg @ref LL_SPI_SR_RFF
1344  * @arg @ref LL_SPI_SR_RFNE
1345  * @arg @ref LL_SPI_SR_TFE
1346  * @arg @ref LL_SPI_SR_TFNF
1347  * @arg @ref LL_SPI_SR_BUSY
1348  * @retval State of bit (1 or 0).
1349  */
1350 __STATIC_INLINE uint32_t ll_spi_is_active_flag(spi_regs_t *SPIx, uint32_t flag)
1351 {
1352  return (READ_BITS(SPIx->STAT, flag) == (flag));
1353 }
1354 
1355 /**
1356  * @brief Get SPI interrupt flags
1357  *
1358  * Register|BitsName
1359  * --------|--------
1360  * INTSTAT | INTSTAT
1361  *
1362  * @param SPIx SPI instance
1363  * @retval Returned value can be one or combination of the following values:
1364  * @arg @ref LL_SPI_IM_MST(not effect in SPIS)
1365  * @arg @ref LL_SPI_IM_RXF
1366  * @arg @ref LL_SPI_IM_RXO
1367  * @arg @ref LL_SPI_IM_RXU
1368  * @arg @ref LL_SPI_IM_TXO
1369  * @arg @ref LL_SPI_IM_TXE
1370  */
1371 __STATIC_INLINE uint32_t ll_spi_get_it_flag(spi_regs_t *SPIx)
1372 {
1373  return (uint32_t)(READ_REG(SPIx->INT_STAT));
1374 }
1375 
1376 /**
1377  * @brief Check interrupt flag
1378  *
1379  * Register|BitsName
1380  * --------|--------
1381  * INTSTAT | MSTIS
1382  * INTSTAT | RXFIS
1383  * INTSTAT | RXOIS
1384  * INTSTAT | RXUIS
1385  * INTSTAT | TXOIS
1386  * INTSTAT | TXEIS
1387  *
1388  * @param SPIx SPI instance
1389  * @param flag This parameter can be one of the following values:
1390  * @arg @ref LL_SPI_IM_MST(not effect in SPIS)
1391  * @arg @ref LL_SPI_IM_RXF
1392  * @arg @ref LL_SPI_IM_RXO
1393  * @arg @ref LL_SPI_IM_RXU
1394  * @arg @ref LL_SPI_IM_TXO
1395  * @arg @ref LL_SPI_IM_TXE
1396  * @retval State of bit (1 or 0).
1397  */
1398 __STATIC_INLINE uint32_t ll_spi_is_it_flag(spi_regs_t *SPIx, uint32_t flag)
1399 {
1400  return (READ_BITS(SPIx->INT_STAT, flag) == flag);
1401 }
1402 
1403 /**
1404  * @brief Get SPI raw interrupt flags
1405  *
1406  * Register|BitsName
1407  * --------|--------
1408  * RAW_INTSTAT | RAW_INTSTAT
1409  *
1410  * @param SPIx SPI instance
1411  * @retval Returned value can be one or combination of the following values:
1412  * @arg @ref LL_SPI_IM_MST(not effect in SPIS)
1413  * @arg @ref LL_SPI_IM_RXF
1414  * @arg @ref LL_SPI_IM_RXO
1415  * @arg @ref LL_SPI_IM_RXU
1416  * @arg @ref LL_SPI_IM_TXO
1417  * @arg @ref LL_SPI_IM_TXE
1418  */
1419 __STATIC_INLINE uint32_t ll_spi_get_raw_if_flag(spi_regs_t *SPIx)
1420 {
1421  return (uint32_t)(READ_REG(SPIx->RAW_INT_STAT));
1422 }
1423 
1424 /**
1425  * @brief Clear transmit FIFO overflow error flag
1426  * @note Clearing this flag is done by reading TXOIC register
1427  *
1428  * Register|BitsName
1429  * --------|--------
1430  * TXOIC | TXOIC
1431  *
1432  * @param SPIx SPI instance
1433  * @retval None
1434  */
1435 __STATIC_INLINE void ll_spi_clear_flag_txo(spi_regs_t *SPIx)
1436 {
1437  __IOM uint32_t tmpreg;
1438  tmpreg = SPIx->TX_FIFO_OIC;
1439  (void) tmpreg;
1440 }
1441 
1442 /**
1443  * @brief Clear receive FIFO overflow error flag
1444  * @note Clearing this flag is done by reading RXOIC register
1445  *
1446  * Register|BitsName
1447  * --------|--------
1448  * RXOIC | RXOIC
1449  *
1450  * @param SPIx SPI instance
1451  * @retval None
1452  */
1453 __STATIC_INLINE void ll_spi_clear_flag_rxo(spi_regs_t *SPIx)
1454 {
1455  __IOM uint32_t tmpreg;
1456  tmpreg = SPIx->RX_FIFO_OIC;
1457  (void) tmpreg;
1458 }
1459 
1460 /**
1461  * @brief Clear receive FIFO underflow error flag
1462  * @note Clearing this flag is done by reading RXUIC register
1463  *
1464  * Register|BitsName
1465  * --------|--------
1466  * RXUIC | RXUIC
1467  *
1468  * @param SPIx SPI instance
1469  * @retval None
1470  */
1471 __STATIC_INLINE void ll_spi_clear_flag_rxu(spi_regs_t *SPIx)
1472 {
1473  __IOM uint32_t tmpreg;
1474  tmpreg = SPIx->RX_FIFO_UIC;
1475  (void) tmpreg;
1476 }
1477 
1478 /**
1479  * @brief Clear multi-master error flag
1480  * @note Clearing this flag is done by reading MSTIC register
1481  *
1482  * Register|BitsName
1483  * --------|--------
1484  * MSTIC | MSTIC
1485  *
1486  * @param SPIx SPI instance
1487  * @retval None
1488  */
1489 __STATIC_INLINE void ll_spi_clear_flag_mst(spi_regs_t *SPIx)
1490 {
1491  __IOM uint32_t tmpreg;
1492  tmpreg = SPIx->MULTI_M_IC;
1493  (void) tmpreg;
1494 }
1495 
1496 /**
1497  * @brief Clear all error flag
1498  * @note Clearing this flag is done by reading INTCLR register
1499  *
1500  * Register|BitsName
1501  * --------|--------
1502  * INTCLR | INTCLR
1503  *
1504  * @param SPIx SPI instance
1505  * @retval None
1506  */
1507 __STATIC_INLINE void ll_spi_clear_flag_all(spi_regs_t *SPIx)
1508 {
1509  __IOM uint32_t tmpreg;
1510  tmpreg = SPIx->INT_CLR;
1511  (void) tmpreg;
1512 }
1513 
1514 /** @} */
1515 
1516 /** @defgroup SPI_LL_EF_DMA_Management DMA_Management
1517  * @{
1518  */
1519 
1520 /**
1521  * @brief Enable DMA Tx
1522  *
1523  * Register|BitsName
1524  * --------|--------
1525  * DMAC | TDMAE
1526  *
1527  * @param SPIx SPI instance
1528  * @retval None
1529  */
1530 __STATIC_INLINE void ll_spi_enable_dma_req_tx(spi_regs_t *SPIx)
1531 {
1532  SET_BITS(SPIx->DMA_CTRL, SPI_DMA_CTRL_TX_DMA_EN);
1533 }
1534 
1535 /**
1536  * @brief Disable DMA Tx
1537  *
1538  * Register|BitsName
1539  * --------|--------
1540  * DMAC | TDMAE
1541  *
1542  * @param SPIx SPI instance
1543  * @retval None
1544  */
1545 __STATIC_INLINE void ll_spi_disable_dma_req_tx(spi_regs_t *SPIx)
1546 {
1547  CLEAR_BITS(SPIx->DMA_CTRL, SPI_DMA_CTRL_TX_DMA_EN);
1548 }
1549 
1550 /**
1551  * @brief Check if DMA Tx is enabled
1552  *
1553  * Register|BitsName
1554  * --------|--------
1555  * DMAC | TDMAE
1556  *
1557  * @param SPIx SPI instance
1558  * @retval State of bit (1 or 0).
1559  */
1560 __STATIC_INLINE uint32_t ll_spi_is_enabled_dma_req_tx(spi_regs_t *SPIx)
1561 {
1562  return (READ_BITS(SPIx->DMA_CTRL, SPI_DMA_CTRL_TX_DMA_EN) == (SPI_DMA_CTRL_TX_DMA_EN));
1563 }
1564 
1565 /**
1566  * @brief Enable DMA Rx
1567  *
1568  * Register|BitsName
1569  * --------|--------
1570  * DMAC | RDMAE
1571  *
1572  * @param SPIx SPI instance
1573  * @retval None
1574  */
1575 __STATIC_INLINE void ll_spi_enable_dma_req_rx(spi_regs_t *SPIx)
1576 {
1577  SET_BITS(SPIx->DMA_CTRL, SPI_DMA_CTRL_RX_DMA_EN);
1578 }
1579 
1580 /**
1581  * @brief Disable DMA Rx
1582  *
1583  * Register|BitsName
1584  * --------|--------
1585  * DMAC | RDMAE
1586  *
1587  * @param SPIx SPI instance
1588  * @retval None
1589  */
1590 __STATIC_INLINE void ll_spi_disable_dma_req_rx(spi_regs_t *SPIx)
1591 {
1592  CLEAR_BITS(SPIx->DMA_CTRL, SPI_DMA_CTRL_RX_DMA_EN);
1593 }
1594 
1595 /**
1596  * @brief Check if DMA Rx is enabled
1597  *
1598  * Register|BitsName
1599  * --------|--------
1600  * DMAC | RDMAE
1601  *
1602  * @param SPIx SPI instance
1603  * @retval State of bit (1 or 0).
1604  */
1605 __STATIC_INLINE uint32_t ll_spi_is_enabled_dma_req_rx(spi_regs_t *SPIx)
1606 {
1607  return (READ_BITS(SPIx->DMA_CTRL, SPI_DMA_CTRL_RX_DMA_EN) == (SPI_DMA_CTRL_RX_DMA_EN));
1608 }
1609 
1610 /**
1611  * @brief Set threshold of TXFIFO that triggers an DMA Tx request event
1612  *
1613  * Register|BitsName
1614  * --------|--------
1615  * DMATDL | DMATDL
1616  *
1617  * @param SPIx SPI instance
1618  * @param threshold This parameter can be one of the following values: 0 ~ 7
1619  * @retval None
1620  */
1621 __STATIC_INLINE void ll_spi_set_dma_tx_fifo_threshold(spi_regs_t *SPIx, uint32_t threshold)
1622 {
1623  WRITE_REG(SPIx->DMA_TX_DL, threshold);
1624 }
1625 
1626 /**
1627  * @brief Get threshold of TXFIFO that triggers an DMA Tx request event
1628  *
1629  * Register|BitsName
1630  * --------|--------
1631  * DMATDL | DMATDL
1632  *
1633  * @param SPIx SPI instance
1634  * @retval Returned value can be one of the following values: 0 ~ 7
1635  */
1636 __STATIC_INLINE uint32_t ll_spi_get_dma_tx_fifo_threshold(spi_regs_t *SPIx)
1637 {
1638  return (uint32_t)(READ_BITS(SPIx->DMA_TX_DL, SPI_DMA_TX_DL_DMA_TX_DL));
1639 }
1640 
1641 /**
1642  * @brief Set threshold of RXFIFO that triggers an DMA Rx request event
1643  *
1644  * Register|BitsName
1645  * --------|--------
1646  * DMARDL | DMARDL
1647  *
1648  * @param SPIx SPI instance
1649  * @param threshold This parameter can be one of the following values: 0 ~ 7
1650  * @retval None
1651  */
1652 __STATIC_INLINE void ll_spi_set_dma_rx_fifo_threshold(spi_regs_t *SPIx, uint32_t threshold)
1653 {
1654  WRITE_REG(SPIx->DMA_RX_DL, threshold);
1655 }
1656 
1657 /**
1658  * @brief Get threshold of RXFIFO that triggers an DMA Rx request event
1659  *
1660  * Register|BitsName
1661  * --------|--------
1662  * DMARDL | DMARDL
1663  *
1664  * @param SPIx SPI instance
1665  * @retval Returned value can be one of the following values: 0 ~ 7
1666  */
1667 __STATIC_INLINE uint32_t ll_spi_get_dma_rx_fifo_threshold(spi_regs_t *SPIx)
1668 {
1669  return (uint32_t)(READ_BITS(SPIx->DMA_RX_DL, SPI_DMA_RX_DL_DMA_RX_DL));
1670 }
1671 
1672 /** @} */
1673 
1674 /** @defgroup SPI_LL_EF_Data_Management Data_Management
1675  * @{
1676  */
1677 
1678 /**
1679  * @brief Write 8-Bits in the data register
1680  *
1681  * Register|BitsName
1682  * --------|--------
1683  * DATA | DATA
1684  *
1685  * @param SPIx SPI instance
1686  * @param tx_data Value between Min_Data=0x00 and Max_Data=0xFF
1687  * @retval None
1688  */
1689 __STATIC_INLINE void ll_spi_transmit_data8(spi_regs_t *SPIx, uint8_t tx_data)
1690 {
1691  *((__IOM uint8_t *)&SPIx->DATA) = tx_data;
1692 }
1693 
1694 /**
1695  * @brief Write 16-Bits in the data register
1696  *
1697  * Register|BitsName
1698  * --------|--------
1699  * DATA | DATA
1700  *
1701  * @param SPIx SPI instance
1702  * @param tx_data Value between Min_Data=0x0000 and Max_Data=0xFFFF
1703  * @retval None
1704  */
1705 __STATIC_INLINE void ll_spi_transmit_data16(spi_regs_t *SPIx, uint16_t tx_data)
1706 {
1707  *((__IOM uint16_t *)&SPIx->DATA) = tx_data;
1708 }
1709 
1710 /**
1711  * @brief Write 32-Bits in the data register
1712  *
1713  * Register|BitsName
1714  * --------|--------
1715  * DATA | DATA
1716  *
1717  * @param SPIx SPI instance
1718  * @param tx_data Value between Min_Data=0x00000000 and Max_Data=0xFFFFFFFF
1719  * @retval None
1720  */
1721 __STATIC_INLINE void ll_spi_transmit_data32(spi_regs_t *SPIx, uint32_t tx_data)
1722 {
1723  *((__IOM uint32_t *)&SPIx->DATA) = tx_data;
1724 }
1725 
1726 /**
1727  * @brief Read 8-Bits in the data register
1728  *
1729  * Register|BitsName
1730  * --------|--------
1731  * DATA | DATA
1732  *
1733  * @param SPIx SPI instance
1734  * @retval Rerturned Value between Min_Data=0x00 and Max_Data=0xFF
1735  */
1736 __STATIC_INLINE uint8_t ll_spi_receive_data8(spi_regs_t *SPIx)
1737 {
1738  return (uint8_t)(READ_REG(SPIx->DATA));
1739 }
1740 
1741 /**
1742  * @brief Read 16-Bits in the data register
1743  *
1744  * Register|BitsName
1745  * --------|--------
1746  * DATA | DATA
1747  *
1748  * @param SPIx SPI instance
1749  * @retval Returned Value between Min_Data=0x0000 and Max_Data=0xFFFF
1750  */
1751 __STATIC_INLINE uint16_t ll_spi_receive_data16(spi_regs_t *SPIx)
1752 {
1753  return (uint16_t)(READ_REG(SPIx->DATA));
1754 }
1755 
1756 /**
1757  * @brief Read 32-Bits in the data register
1758  *
1759  * Register|BitsName
1760  * --------|--------
1761  * DATA | DATA
1762  *
1763  * @param SPIx SPI instance
1764  * @retval Returned Value between Min_Data=0x00000000 and Max_Data=0xFFFFFFFF
1765  */
1766 __STATIC_INLINE uint32_t ll_spi_receive_data32(spi_regs_t *SPIx)
1767 {
1768  return (uint32_t)(READ_REG(SPIx->DATA));
1769 }
1770 
1771 /**
1772  * @brief Set Rx sample delay
1773  * @note This bit should not be changed when communication is ongoing.
1774  *
1775  * Register|BitsName
1776  * --------|--------
1777  * RX_SAMPLEDLY | RX_SAMPLEDLY
1778  *
1779  * @param SPIx SPI instance
1780  * @param delay This parameter can be one of the following values: 0 ~ 7
1781  * @retval None
1782  */
1783 __STATIC_INLINE void ll_spi_set_rx_sample_delay(spi_regs_t *SPIx, uint32_t delay)
1784 {
1785  MODIFY_REG(SPIx->RX_SAMPLE_DLY, SPI_RX_SAMPLEDLY, delay);
1786 }
1787 
1788 /**
1789  * @brief Get Rx sample delay
1790  * @note This bit should not be changed when communication is ongoing.
1791  *
1792  * Register|BitsName
1793  * --------|--------
1794  * RX_SAMPLEDLY | RX_SAMPLEDLY
1795  *
1796  * @param SPIx SPI instance
1797  * @retval Returned value can be one of the following values: 0 ~ 7
1798  */
1799 __STATIC_INLINE uint32_t ll_spi_get_rx_sample_delay(spi_regs_t *SPIx)
1800 {
1801  return (uint32_t)(READ_BITS(SPIx->RX_SAMPLE_DLY, SPI_RX_SAMPLEDLY));
1802 }
1803 
1804 /** @} */
1805 
1806 /** @defgroup SPI_LL_EF_Init SPIM Initialization and de-initialization functions
1807  * @{
1808  */
1809 
1810 /**
1811  * @brief De-initialize SSI registers (Registers restored to their default values).
1812  * @param SPIx SSI instance
1813  * @retval None
1814  */
1815 void ll_spim_deinit(spi_regs_t *SPIx);
1816 
1817 /**
1818  * @brief Initialize SPIM registers according to the specified
1819  * parameters in p_spi_init.
1820  * @param SPIx SSI instance
1821  * @param p_spi_init Pointer to a ll_spim_init_t structure that contains the configuration
1822  * information for the specified SPIM peripheral.
1823  * @retval None
1824  */
1825 void ll_spim_init(spi_regs_t *SPIx, const ll_spim_init_t *p_spi_init);
1826 
1827 /**
1828  * @brief Set each field of a @ref ll_spim_init_t type structure to default value.
1829  * @param p_spi_init Pointer to a @ref ll_spim_init_t structure
1830  * whose fields will be set to default values.
1831  * @retval None
1832  */
1834 
1835 /** @} */
1836 
1837 /** @defgroup SPIS_LL_Init SPIS Initialization and de-initialization functions
1838  * @{
1839  */
1840 
1841 /**
1842  * @brief De-initialize SSI registers (Registers restored to their default values).
1843  * @param SPIx SSI instance
1844  * @retval None
1845  */
1846 void ll_spis_deinit(spi_regs_t *SPIx);
1847 
1848 /**
1849  * @brief Initialize SSI registers according to the specified
1850  * parameters in p_spi_init.
1851  * @param SPIx SSI instance
1852  * @param p_spi_init Pointer to a ll_spis_init_t structure that contains the configuration
1853  * information for the specified SPIS peripheral.
1854  * @retval None
1855 
1856  */
1857 void ll_spis_init(spi_regs_t *SPIx, const ll_spis_init_t *p_spi_init);
1858 
1859 /**
1860  * @brief Set each field of a @ref ll_spis_init_t type structure to default value.
1861  * @param p_spi_init Pointer to a @ref ll_spis_init_t structure
1862  * whose fields will be set to default values.
1863  * @retval None
1864  */
1866 /** @} */
1867 
1868 /** @} */
1869 
1870 #endif /* SPIM || SPIS */
1871 
1872 #ifdef __cplusplus
1873 }
1874 #endif
1875 
1876 #endif /* LL_SPI_H */
1877 
1878 /** @} */
1879 
1880 /** @} */
1881 
1882 /** @} */
ll_spi_enable_dma_req_rx
__STATIC_INLINE void ll_spi_enable_dma_req_rx(spi_regs_t *SPIx)
Enable DMA Rx.
Definition: ll_spi.h:1575
ll_spi_is_enabled_test_mode
__STATIC_INLINE uint32_t ll_spi_is_enabled_test_mode(spi_regs_t *SPIx)
Check if SPI test mode is enabled.
Definition: ll_spi.h:640
ll_spi_set_tx_fifo_threshold
__STATIC_INLINE void ll_spi_set_tx_fifo_threshold(spi_regs_t *SPIx, uint32_t threshold)
Set threshold of TXFIFO that triggers an TXE event.
Definition: ll_spi.h:1143
ll_spi_transmit_data8
__STATIC_INLINE void ll_spi_transmit_data8(spi_regs_t *SPIx, uint8_t tx_data)
Write 8-Bits in the data register.
Definition: ll_spi.h:1689
ll_spi_get_rx_sample_delay
__STATIC_INLINE uint32_t ll_spi_get_rx_sample_delay(spi_regs_t *SPIx)
Get Rx sample delay.
Definition: ll_spi.h:1799
ll_spi_disable_dma_req_rx
__STATIC_INLINE void ll_spi_disable_dma_req_rx(spi_regs_t *SPIx)
Disable DMA Rx.
Definition: ll_spi.h:1590
_ll_spis_init_t
SPIS init structures definition.
Definition: ll_spi.h:117
ll_spi_get_tx_fifo_threshold
__STATIC_INLINE uint32_t ll_spi_get_tx_fifo_threshold(spi_regs_t *SPIx)
Get threshold of TXFIFO that triggers an TXE event.
Definition: ll_spi.h:1158
ll_spi_get_dma_rx_fifo_threshold
__STATIC_INLINE uint32_t ll_spi_get_dma_rx_fifo_threshold(spi_regs_t *SPIx)
Get threshold of RXFIFO that triggers an DMA Rx request event.
Definition: ll_spi.h:1667
gr5405.h
ll_spim_struct_init
void ll_spim_struct_init(ll_spim_init_t *p_spi_init)
Set each field of a ll_spim_init_t type structure to default value.
_ll_spis_init_t::data_size
uint32_t data_size
Definition: ll_spi.h:118
ll_spi_enable_ss
__STATIC_INLINE void ll_spi_enable_ss(spi_regs_t *SPIx, uint32_t ss)
Enable slave select.
Definition: ll_spi.h:1057
ll_spi_enable_ss_toggle
__STATIC_INLINE void ll_spi_enable_ss_toggle(spi_regs_t *SPIx)
Enable slave select toggle.
Definition: ll_spi.h:409
ll_spi_enable_it
__STATIC_INLINE void ll_spi_enable_it(spi_regs_t *SPIx, uint32_t mask)
Enable interrupt.
Definition: ll_spi.h:1248
ll_spi_enable_test_mode
__STATIC_INLINE void ll_spi_enable_test_mode(spi_regs_t *SPIx)
Enable SPI test mode.
Definition: ll_spi.h:610
ll_spi_set_dma_tx_fifo_threshold
__STATIC_INLINE void ll_spi_set_dma_tx_fifo_threshold(spi_regs_t *SPIx, uint32_t threshold)
Set threshold of TXFIFO that triggers an DMA Tx request event.
Definition: ll_spi.h:1621
_ll_spim_init_t
LL SPIM init structures definition.
Definition: ll_spi.h:77
ll_spi_enable_slave_out
__STATIC_INLINE void ll_spi_enable_slave_out(spi_regs_t *SPIx)
Enable slave output.
Definition: ll_spi.h:655
ll_spi_set_receive_size
__STATIC_INLINE void ll_spi_set_receive_size(spi_regs_t *SPIx, uint32_t size)
Set the number of data frames to be continuously received.
Definition: ll_spi.h:855
ll_spi_set_rx_sample_delay
__STATIC_INLINE void ll_spi_set_rx_sample_delay(spi_regs_t *SPIx, uint32_t delay)
Set Rx sample delay.
Definition: ll_spi.h:1783
ll_spi_is_active_flag
__STATIC_INLINE uint32_t ll_spi_is_active_flag(spi_regs_t *SPIx, uint32_t flag)
Check active flag.
Definition: ll_spi.h:1350
ll_spi_enable
__STATIC_INLINE void ll_spi_enable(spi_regs_t *SPIx)
Enable SPI peripheral.
Definition: ll_spi.h:888
ll_spis_struct_init
void ll_spis_struct_init(ll_spis_init_t *p_spi_init)
Set each field of a ll_spis_init_t type structure to default value.
ll_spi_clear_flag_all
__STATIC_INLINE void ll_spi_clear_flag_all(spi_regs_t *SPIx)
Clear all error flag.
Definition: ll_spi.h:1507
ll_spi_get_rx_fifo_threshold
__STATIC_INLINE uint32_t ll_spi_get_rx_fifo_threshold(spi_regs_t *SPIx)
Get threshold of RXFIFO that triggers an RXNE event.
Definition: ll_spi.h:1189
ll_spi_enable_micro_handshake
__STATIC_INLINE void ll_spi_enable_micro_handshake(spi_regs_t *SPIx)
Enable Handshake in Microwire mode.
Definition: ll_spi.h:934
ll_spi_disable_ss_toggle
__STATIC_INLINE void ll_spi_disable_ss_toggle(spi_regs_t *SPIx)
Disable slave select toggle.
Definition: ll_spi.h:425
_ll_spim_init_t::clock_polarity
uint32_t clock_polarity
Definition: ll_spi.h:88
ll_spi_get_raw_if_flag
__STATIC_INLINE uint32_t ll_spi_get_raw_if_flag(spi_regs_t *SPIx)
Get SPI raw interrupt flags.
Definition: ll_spi.h:1419
ll_spi_disable_salve_out
__STATIC_INLINE void ll_spi_disable_salve_out(spi_regs_t *SPIx)
Disable slave output.
Definition: ll_spi.h:670
_ll_spis_init_t::clock_polarity
uint32_t clock_polarity
Definition: ll_spi.h:123
ll_spi_get_it_flag
__STATIC_INLINE uint32_t ll_spi_get_it_flag(spi_regs_t *SPIx)
Get SPI interrupt flags.
Definition: ll_spi.h:1371
ll_spi_set_dma_rx_fifo_threshold
__STATIC_INLINE void ll_spi_set_dma_rx_fifo_threshold(spi_regs_t *SPIx, uint32_t threshold)
Set threshold of RXFIFO that triggers an DMA Rx request event.
Definition: ll_spi.h:1652
ll_spi_disable
__STATIC_INLINE void ll_spi_disable(spi_regs_t *SPIx)
Disable SPI peripheral.
Definition: ll_spi.h:904
ll_spi_receive_data32
__STATIC_INLINE uint32_t ll_spi_receive_data32(spi_regs_t *SPIx)
Read 32-Bits in the data register.
Definition: ll_spi.h:1766
ll_spi_set_baud_rate_prescaler
__STATIC_INLINE void ll_spi_set_baud_rate_prescaler(spi_regs_t *SPIx, uint32_t baud_rate)
Set baud rate prescaler.
Definition: ll_spi.h:1112
ll_spi_get_dma_tx_fifo_threshold
__STATIC_INLINE uint32_t ll_spi_get_dma_tx_fifo_threshold(spi_regs_t *SPIx)
Get threshold of TXFIFO that triggers an DMA Tx request event.
Definition: ll_spi.h:1636
ll_spim_init_t
struct _ll_spim_init_t ll_spim_init_t
LL SPIM init structures definition.
ll_spi_get_micro_transfer_direction
__STATIC_INLINE uint32_t ll_spi_get_micro_transfer_direction(spi_regs_t *SPIx)
Get transfer direction mode in Microwire mode.
Definition: ll_spi.h:1001
_ll_spim_init_t::baud_rate
uint32_t baud_rate
Definition: ll_spi.h:103
ll_spi_is_enabled_micro_handshake
__STATIC_INLINE uint32_t ll_spi_is_enabled_micro_handshake(spi_regs_t *SPIx)
Check if Handshake in Microwire mode is enabled.
Definition: ll_spi.h:964
ll_spi_get_control_frame_size
__STATIC_INLINE uint32_t ll_spi_get_control_frame_size(spi_regs_t *SPIx)
Get the length of the control word for the Microwire frame format.
Definition: ll_spi.h:595
_ll_spim_init_t::transfer_direction
uint32_t transfer_direction
Definition: ll_spi.h:78
ll_spi_transmit_data16
__STATIC_INLINE void ll_spi_transmit_data16(spi_regs_t *SPIx, uint16_t tx_data)
Write 16-Bits in the data register.
Definition: ll_spi.h:1705
ll_spi_set_standard
__STATIC_INLINE void ll_spi_set_standard(spi_regs_t *SPIx, uint32_t standard)
Set serial protocol used.
Definition: ll_spi.h:818
ll_spis_init_t
struct _ll_spis_init_t ll_spis_init_t
SPIS init structures definition.
_ll_spim_init_t::data_size
uint32_t data_size
Definition: ll_spi.h:83
ll_spi_get_status
__STATIC_INLINE uint32_t ll_spi_get_status(spi_regs_t *SPIx)
Get SPI status.
Definition: ll_spi.h:1321
ll_spi_is_enabled
__STATIC_INLINE bool ll_spi_is_enabled(spi_regs_t *SPIx)
Check if SPI peripheral is enabled.
Definition: ll_spi.h:919
ll_spi_get_data_size
__STATIC_INLINE uint32_t ll_spi_get_data_size(spi_regs_t *SPIx)
Get frame data size.
Definition: ll_spi.h:530
ll_spi_get_micro_transfer_mode
__STATIC_INLINE uint32_t ll_spi_get_micro_transfer_mode(spi_regs_t *SPIx)
Get transfer mode in Microwire mode.
Definition: ll_spi.h:1038
ll_spim_init
void ll_spim_init(spi_regs_t *SPIx, const ll_spim_init_t *p_spi_init)
Initialize SPIM registers according to the specified parameters in p_spi_init.
ll_spi_set_clock_polarity
__STATIC_INLINE void ll_spi_set_clock_polarity(spi_regs_t *SPIx, uint32_t clock_polarity)
Set clock polarity.
Definition: ll_spi.h:744
ll_spi_set_micro_transfer_direction
__STATIC_INLINE void ll_spi_set_micro_transfer_direction(spi_regs_t *SPIx, uint32_t transfer_direction)
Set transfer direction mode in Microwire mode.
Definition: ll_spi.h:983
ll_spi_get_tx_fifo_level
__STATIC_INLINE uint32_t ll_spi_get_tx_fifo_level(spi_regs_t *SPIx)
Get FIFO Transmission Level.
Definition: ll_spi.h:1204
ll_spim_deinit
void ll_spim_deinit(spi_regs_t *SPIx)
De-initialize SSI registers (Registers restored to their default values).
ll_spi_is_enabled_dma_req_tx
__STATIC_INLINE uint32_t ll_spi_is_enabled_dma_req_tx(spi_regs_t *SPIx)
Check if DMA Tx is enabled.
Definition: ll_spi.h:1560
ll_spi_set_data_size
__STATIC_INLINE void ll_spi_set_data_size(spi_regs_t *SPIx, uint32_t size)
Set frame data size.
Definition: ll_spi.h:486
ll_spi_enable_dma_req_tx
__STATIC_INLINE void ll_spi_enable_dma_req_tx(spi_regs_t *SPIx)
Enable DMA Tx.
Definition: ll_spi.h:1530
ll_spi_disable_ss
__STATIC_INLINE void ll_spi_disable_ss(spi_regs_t *SPIx, uint32_t ss)
Disable slave select.
Definition: ll_spi.h:1076
ll_spi_set_rx_fifo_threshold
__STATIC_INLINE void ll_spi_set_rx_fifo_threshold(spi_regs_t *SPIx, uint32_t threshold)
Set threshold of RXFIFO that triggers an RXNE event.
Definition: ll_spi.h:1174
ll_spi_disable_micro_handshake
__STATIC_INLINE void ll_spi_disable_micro_handshake(spi_regs_t *SPIx)
Disable Handshake in Microwire mode.
Definition: ll_spi.h:949
_ll_spim_init_t::slave_select
uint32_t slave_select
Definition: ll_spi.h:98
ll_spi_get_receive_size
__STATIC_INLINE uint32_t ll_spi_get_receive_size(spi_regs_t *SPIx)
Get the number of data frames to be continuously received.
Definition: ll_spi.h:873
ll_spi_get_clock_phase
__STATIC_INLINE uint32_t ll_spi_get_clock_phase(spi_regs_t *SPIx)
Get clock phase.
Definition: ll_spi.h:798
ll_spi_get_rx_fifo_level
__STATIC_INLINE uint32_t ll_spi_get_rx_fifo_level(spi_regs_t *SPIx)
Get FIFO reception Level.
Definition: ll_spi.h:1219
ll_spi_disable_dma_req_tx
__STATIC_INLINE void ll_spi_disable_dma_req_tx(spi_regs_t *SPIx)
Disable DMA Tx.
Definition: ll_spi.h:1545
ll_spi_get_baud_rate_prescaler
__STATIC_INLINE uint32_t ll_spi_get_baud_rate_prescaler(spi_regs_t *SPIx)
Get baud rate prescaler.
Definition: ll_spi.h:1127
ll_spi_receive_data16
__STATIC_INLINE uint16_t ll_spi_receive_data16(spi_regs_t *SPIx)
Read 16-Bits in the data register.
Definition: ll_spi.h:1751
ll_spi_is_enabled_slave_out
__STATIC_INLINE uint32_t ll_spi_is_enabled_slave_out(spi_regs_t *SPIx)
Check if slave output is enabled.
Definition: ll_spi.h:685
ll_spi_is_enabled_ss_toggle
__STATIC_INLINE uint32_t ll_spi_is_enabled_ss_toggle(spi_regs_t *SPIx)
Check if slave select toggle is enabled.
Definition: ll_spi.h:441
ll_spi_get_standard
__STATIC_INLINE uint32_t ll_spi_get_standard(spi_regs_t *SPIx)
Get serial protocol used.
Definition: ll_spi.h:836
ll_spi_clear_flag_rxo
__STATIC_INLINE void ll_spi_clear_flag_rxo(spi_regs_t *SPIx)
Clear receive FIFO overflow error flag.
Definition: ll_spi.h:1453
ll_spi_clear_flag_txo
__STATIC_INLINE void ll_spi_clear_flag_txo(spi_regs_t *SPIx)
Clear transmit FIFO overflow error flag.
Definition: ll_spi.h:1435
ll_spi_transmit_data32
__STATIC_INLINE void ll_spi_transmit_data32(spi_regs_t *SPIx, uint32_t tx_data)
Write 32-Bits in the data register.
Definition: ll_spi.h:1721
ll_spi_get_transfer_direction
__STATIC_INLINE uint32_t ll_spi_get_transfer_direction(spi_regs_t *SPIx)
Get transfer direction mode.
Definition: ll_spi.h:724
_ll_spim_init_t::rx_sample_delay
uint32_t rx_sample_delay
Definition: ll_spi.h:109
ll_spi_is_it_flag
__STATIC_INLINE uint32_t ll_spi_is_it_flag(spi_regs_t *SPIx, uint32_t flag)
Check interrupt flag.
Definition: ll_spi.h:1398
_ll_spis_init_t::clock_phase
uint32_t clock_phase
Definition: ll_spi.h:128
_ll_spim_init_t::clock_phase
uint32_t clock_phase
Definition: ll_spi.h:93
ll_spi_set_control_frame_size
__STATIC_INLINE void ll_spi_set_control_frame_size(spi_regs_t *SPIx, uint32_t size)
Set the length of the control word for the Microwire frame format.
Definition: ll_spi.h:563
ll_spi_receive_data8
__STATIC_INLINE uint8_t ll_spi_receive_data8(spi_regs_t *SPIx)
Read 8-Bits in the data register.
Definition: ll_spi.h:1736
ll_spi_is_enabled_dma_req_rx
__STATIC_INLINE uint32_t ll_spi_is_enabled_dma_req_rx(spi_regs_t *SPIx)
Check if DMA Rx is enabled.
Definition: ll_spi.h:1605
ll_spi_set_clock_phase
__STATIC_INLINE void ll_spi_set_clock_phase(spi_regs_t *SPIx, uint32_t clock_phase)
Set clock phase.
Definition: ll_spi.h:781
ll_spi_disable_it
__STATIC_INLINE void ll_spi_disable_it(spi_regs_t *SPIx, uint32_t mask)
Disable interrupt.
Definition: ll_spi.h:1271
ll_spi_set_micro_transfer_mode
__STATIC_INLINE void ll_spi_set_micro_transfer_mode(spi_regs_t *SPIx, uint32_t transfer_mode)
Set transfer mode in Microwire mode.
Definition: ll_spi.h:1020
ll_spi_is_enabled_ss
__STATIC_INLINE uint32_t ll_spi_is_enabled_ss(spi_regs_t *SPIx, uint32_t ss)
Check if slave select is enabled.
Definition: ll_spi.h:1095
ll_spis_deinit
void ll_spis_deinit(spi_regs_t *SPIx)
De-initialize SSI registers (Registers restored to their default values).
ll_spi_is_enabled_it
__STATIC_INLINE uint32_t ll_spi_is_enabled_it(spi_regs_t *SPIx, uint32_t mask)
Check if interrupt is enabled.
Definition: ll_spi.h:1293
ll_spi_set_transfer_direction
__STATIC_INLINE void ll_spi_set_transfer_direction(spi_regs_t *SPIx, uint32_t transfer_direction)
Set transfer direction mode.
Definition: ll_spi.h:705
ll_spi_disable_test_mode
__STATIC_INLINE void ll_spi_disable_test_mode(spi_regs_t *SPIx)
Disable SPI test mode.
Definition: ll_spi.h:625
ll_spi_clear_flag_mst
__STATIC_INLINE void ll_spi_clear_flag_mst(spi_regs_t *SPIx)
Clear multi-master error flag.
Definition: ll_spi.h:1489
ll_spi_get_clock_polarity
__STATIC_INLINE uint32_t ll_spi_get_clock_polarity(spi_regs_t *SPIx)
Get clock polarity.
Definition: ll_spi.h:761
ll_spis_init
void ll_spis_init(spi_regs_t *SPIx, const ll_spis_init_t *p_spi_init)
Initialize SSI registers according to the specified parameters in p_spi_init.
ll_spi_clear_flag_rxu
__STATIC_INLINE void ll_spi_clear_flag_rxu(spi_regs_t *SPIx)
Clear receive FIFO underflow error flag.
Definition: ll_spi.h:1471