1 /*
2 * Copyright 2023 NXP
3 * All rights reserved.
4 *
5 * SPDX-License-Identifier: BSD-3-Clause
6 */
7
8 #ifndef __FSL_FLEXSPI_FOLLOWER_H_
9 #define __FSL_FLEXSPI_FOLLOWER_H_
10
11 #include <stddef.h>
12 #include "fsl_device_registers.h"
13 #include "fsl_common.h"
14
15 /*!
16 * @addtogroup flexspi_flr
17 * @{
18 */
19
20 /*******************************************************************************
21 * Definitions
22 ******************************************************************************/
23
24 /*! @name Driver version */
25 /*@{*/
26 /*! @brief FLEXSPI FOLLOWER driver version. */
27 #define FSL_FLEXSPI_SLV_DRIVER_VERSION (MAKE_VERSION(1, 0, 0))
28 /*@}*/
29
30 #define FSL_FEATURE_FLEXSPI_SLV_AXI_RX_BUFFER_SIZE (2*1024)
31 #define FSL_FEATURE_FLEXSPI_SLV_AXI_TX_BUFFER_SIZE (1024)
32
33 #define FLEXSPI_SLV_MAILBOX_CMD(x) ((x) & 0xFFFFFFFE)
34 #define FLEXSPI_SLV_MAILBOX_CMD_INT(x) ((x) | 0x1)
35
36 #define FLEXSPI_SLV_CMD_DDR(x) (((x) << 8) | (x))
37
38 /*! @brief IO mode enumeration of FLEXSPI FOLLOWER.*/
39 enum
40 {
41 kFLEXSPI_SLV_IOMODE_SDRx4 = 0,
42 kFLEXSPI_SLV_IOMODE_SDRx8 = 1,
43 kFLEXSPI_SLV_IOMODE_DDRx4 = 2,
44 kFLEXSPI_SLV_IOMODE_DDRx8 = 3
45 };
46
47 /*! @brief Clock frequency enumeration of FLEXSPI FOLLOWER.*/
48 enum
49 {
50 RootClock_50M = 50,
51 RootClock_66M = 66,
52 RootClock_80M = 80,
53 RootClock_100M = 100,
54 RootClock_133M = 133,
55 RootClock_166M = 166,
56 RootClock_200M = 200,
57 RootClock_400M = 400,
58 };
59
60 /*! @brief The read fetch size enumeration of FLEXSPI FOLLOWER.*/
61 enum
62 {
63 Read_Fetch_256Bytes = 0,
64 Read_Fetch_512Bytes = 1,
65 Read_Fetch_1KBytes = 2,
66 Read_Fetch_2KBytes = 3
67 };
68
69 /*! @brief Clock frequency enumeration of FLEXSPI FOLLOWER.*/
70 enum
71 {
72 Write_Watermark_32Bytes = 0,
73 Write_Watermark_64Bytes = 1,
74 Write_Watermark_128Bytes = 2,
75 Write_Watermark_256Bytes = 3
76 };
77
78 /*! @brief Interrupt status flags of FLEXSPI FOLLOWER.*/
79 enum
80 {
81 kFLEXSPI_SLV_Mail0InterruptFlag = 0, /*!< Mailbox0 interrupt */
82 kFLEXSPI_SLV_Mail1InterruptFlag = 1, /*!< Mailbox1 interrupt */
83 kFLEXSPI_SLV_Mail2InterruptFlag = 2, /*!< Mailbox2 interrupt */
84 kFLEXSPI_SLV_Mail3InterruptFlag = 3, /*!< Mailbox3 interrupt */
85 kFLEXSPI_SLV_Mail4InterruptFlag = 4, /*!< Mailbox4 interrupt */
86 kFLEXSPI_SLV_Mail5InterruptFlag = 5, /*!< Mailbox5 interrupt */
87 kFLEXSPI_SLV_Mail6InterruptFlag = 6, /*!< Mailbox6 interrupt */
88 kFLEXSPI_SLV_Mail7InterruptFlag = 7, /*!< Mailbox7 interrupt */
89 kFLEXSPI_SLV_Mail8InterruptFlag = 8, /*!< Mailbox8 interrupt */
90 kFLEXSPI_SLV_WriteOverflowFlag = 9, /*!< An IO RX FIFO overflow occurred during
91 command/address/write data phase */
92 kFLEXSPI_SLV_ReadUnderflowFlag = 10, /*!< IO TX FIFO underflow has occurred
93 during a read command */
94 kFLEXSPI_SLV_ErrorCommandFlag = 11, /*!< An unknown command has been received
95 from the SPI bus */
96 kFLEXSPI_SLV_InvalidInterruptFlag = 12,
97 };
98
99 /*! @brief FLEXSPI FOLLOWER configuration structure. */
100 typedef struct _flexspi_slv_config
101 {
102 int clock_freq;
103 uint32_t baseAddr1; /*!< Read/Write CMD1 Base Address. */
104 uint32_t baseAddr2; /*!< Read/Write CMD2 Base Address. */
105 uint32_t addrRange1; /*!< Read/Write CMD1 Addr Range. */
106 uint32_t addrRange2; /*!< Read/Write CMD2 Addr Range. */
107 uint8_t io_mode; /*!< IO mode control - SDRx4, SDRx8, DDRx4, DDRx8*/
108 uint8_t rxFetch_size; /*!< Specifies the maximum read size triggered by a single read command. */
109 uint8_t rxWatermark; /*!< Triggers a new AXI read to fetch more data through the IP AXI header. */
110 uint8_t txWatermark; /*!< Specifies the watermark value. During the write command, if pending
111 write data equals or exceeds the watermark level, it triggers a new AXI write. */
112 } flexspi_slv_config_t;
113
114 /* Forward declaration of the handle typedef. */
115 typedef struct _flexspi_slv_handle flexspi_slv_handle_t;
116
117 /*! @brief FLEXSPI FOLLOWER interrupt callback function. */
118 typedef void (*flexspi_slv_interrupt_callback_t)(FLEXSPI_SLV_Type *base,
119 flexspi_slv_handle_t *handle);
120
121 /*! @brief Interrupt handle structure for FLEXSPI FOLLOWER. */
122 struct _flexspi_slv_handle
123 {
124 uint32_t state; /*!< Interrupt state for FLEXSPI FOLLOWER */
125 flexspi_slv_interrupt_callback_t callback; /*!< Callback for users while mailbox received or error occurred */
126 void *userData; /*!< FLEXSPI FOLLOWER callback function parameter.*/
127 };
128
129 /*******************************************************************************
130 * API
131 ******************************************************************************/
132
133 #if defined(__cplusplus)
134 extern "C" {
135 #endif /*_cplusplus. */
136
137 /*!
138 * @name Initialization and deinitialization
139 * @{
140 */
141
142 /*!
143 * @brief Get the instance number for FLEXSPI FOLLOWER.
144 *
145 * @param base FLEXSPI FOLLOWER base pointer.
146 */
147 uint32_t FLEXSPI_SLV_GetInstance(FLEXSPI_SLV_Type *base);
148
149 /*!
150 * @brief Check and clear interrupt flags.
151 *
152 * @param base FLEXSPI FOLLOWER base pointer.
153 * @return Interrupt flag.
154 */
155 uint32_t FLEXSPI_SLV_CheckAndClearInterrupt(FLEXSPI_SLV_Type *base);
156
157 /*!
158 * @brief Initializes the FLEXSPI FOLLOWER module and internal state.
159 *
160 * This function enables the clock for FLEXSPI FOLLOWER and also configures the FLEXSPI FOLLOWER
161 * with the input configure parameters. Users should call this function before any FLEXSPI
162 * FOLLOWER operations.
163 *
164 * @param base FLEXSPI FOLLOWER peripheral base address.
165 * @param config FLEXSPI FOLLOWER configure structure.
166 */
167 void FLEXSPI_SLV_Init(FLEXSPI_SLV_Type *base, const flexspi_slv_config_t *config);
168
169 /*!
170 * @brief Gets default settings for FLEXSPI FOLLOWER.
171 *
172 * @param config FLEXSPI FOLLOWER configuration structure.
173 */
174 void FLEXSPI_SLV_GetDefaultConfig(flexspi_slv_config_t *config);
175
176 /*!
177 * @brief Deinitializes the FLEXSPI FOLLOWER module.
178 *
179 * Clears the FLEXSPI FOLLOWER state and FLEXSPI FOLLOWER module registers.
180 * @param base FLEXSPI FOLLOWER peripheral base address.
181 */
182 void FLEXSPI_SLV_Deinit(FLEXSPI_SLV_Type *base);
183
184 /*!
185 * @brief Software reset for the FLEXSPI FOLLOWER logic.
186 *
187 * This function sets the software reset flags for the FLEXSPI FOLLOWER.
188 *
189 * @param base FLEXSPI FOLLOWER peripheral base address.
190 * @param val 0(Finished) or 1(Initiate)
191 */
FLEXSPI_SLV_SoftwareReset_SetVal(FLEXSPI_SLV_Type * base,uint32_t val)192 static inline void FLEXSPI_SLV_SoftwareReset_SetVal(FLEXSPI_SLV_Type *base, uint32_t val)
193 {
194 base->MODULE_CONTROL &= ~FLEXSPI_SLV_MODULE_CONTROL_SWRESET_MASK;
195 base->MODULE_CONTROL |= FLEXSPI_SLV_MODULE_CONTROL_SWRESET(val);
196 }
197
198 /*!
199 * @brief Set IO mode for the FLEXSPI FOLLOWER module.
200 *
201 * This function sets the IO mode flags for the FLEXSPI FOLLOWER.
202 *
203 * @param base FLEXSPI FOLLOWER peripheral base address.
204 * @param val Set IO Mode for FLEXSPI FOLLOWER
205 */
FLEXSPI_SLV_IOMode_SetVal(FLEXSPI_SLV_Type * base,uint32_t val)206 static inline void FLEXSPI_SLV_IOMode_SetVal(FLEXSPI_SLV_Type *base, uint32_t val)
207 {
208 base->MODULE_CONTROL &= ~FLEXSPI_SLV_MODULE_CONTROL_IOMODE_MASK;
209 base->MODULE_CONTROL |= FLEXSPI_SLV_MODULE_CONTROL_IOMODE(val);
210 }
211
212 /*!
213 * @brief Update RW CMD base address and range value for the FLEXSPI FOLLOWER module.
214 *
215 * This function updates RW CMD base address and range value for the FLEXSPI FOLLOWER.
216 *
217 * @param base FLEXSPI FOLLOWER peripheral base address.
218 */
FLEXSPI_SLV_Update_RWCMD_Base_Range(FLEXSPI_SLV_Type * base)219 static inline void FLEXSPI_SLV_Update_RWCMD_Base_Range(FLEXSPI_SLV_Type *base)
220 {
221 base->MODULE_CONTROL |= FLEXSPI_SLV_MODULE_CONTROL_CMDRANGEBASEUPDATE_MASK;
222 }
223
224 /*!
225 * @brief Set RW command base address1 for the FLEXSPI FOLLOWER module.
226 *
227 * This function sets the RW command base address1 for the FLEXSPI FOLLOWER.
228 *
229 * @param base FLEXSPI FOLLOWER peripheral base address.
230 * @param val The high 16-bit base address of the RW command
231 */
FLEXSPI_SLV_RW_CMD_BaseAddr1_SetVal(FLEXSPI_SLV_Type * base,uint32_t val)232 static inline void FLEXSPI_SLV_RW_CMD_BaseAddr1_SetVal(FLEXSPI_SLV_Type *base, uint32_t val)
233 {
234 base->RW_COMMAND_BASE &= ~FLEXSPI_SLV_RW_COMMAND_BASE_ADDRBASE1_MASK;
235 base->RW_COMMAND_BASE |= FLEXSPI_SLV_RW_COMMAND_BASE_ADDRBASE1(val);
236 }
237
238 /*!
239 * @brief Set RW command base address2 for the FLEXSPI FOLLOWER module.
240 *
241 * This function sets the RW command base address2 for the FLEXSPI FOLLOWER.
242 *
243 * @param base FLEXSPI FOLLOWER peripheral base address.
244 * @param val The high 16-bit base address of the RW command
245 */
FLEXSPI_SLV_RW_CMD_BaseAddr2_SetVal(FLEXSPI_SLV_Type * base,uint32_t val)246 static inline void FLEXSPI_SLV_RW_CMD_BaseAddr2_SetVal(FLEXSPI_SLV_Type *base, uint32_t val)
247 {
248 base->RW_COMMAND_BASE &= ~FLEXSPI_SLV_RW_COMMAND_BASE_ADDRBASE2_MASK;
249 base->RW_COMMAND_BASE |= FLEXSPI_SLV_RW_COMMAND_BASE_ADDRBASE2(val);
250 }
251
252 /*!
253 * @brief Set address1/2 range for the FLEXSPI FOLLOWER module.
254 *
255 * This function sets the address1/2 range for the FLEXSPI FOLLOWER.
256 *
257 * @param base FLEXSPI FOLLOWER peripheral base address.
258 * @param i The index of RW command, 0 or 1.
259 * @param val The size of the memory range in 1KB units.
260 */
FLEXSPI_SLV_AddrRange_SetVal(FLEXSPI_SLV_Type * base,uint32_t i,uint32_t val)261 static inline void FLEXSPI_SLV_AddrRange_SetVal(FLEXSPI_SLV_Type *base, uint32_t i, uint32_t val)
262 {
263 base->CMD_RANGE[i] = FLEXSPI_SLV_CMD_RANGE_RANGE(val);
264 }
265
266 /*!
267 * @brief Enable or disable read water mark for the FLEXSPI FOLLOWER module.
268 *
269 * This function enables or disables read water mark for the FLEXSPI FOLLOWER.
270 *
271 * @param base FLEXSPI FOLLOWER peripheral base address.
272 * @param val 0(Disable) or 1(Enable)
273 */
FLEXSPI_SLV_Read_WMEN_SetVal(FLEXSPI_SLV_Type * base,uint32_t val)274 static inline void FLEXSPI_SLV_Read_WMEN_SetVal(FLEXSPI_SLV_Type *base, uint32_t val)
275 {
276 base->READ_COMMAND_CONTROL &= ~FLEXSPI_SLV_READ_COMMAND_CONTROL_WMEN_MASK;
277 base->READ_COMMAND_CONTROL |= FLEXSPI_SLV_READ_COMMAND_CONTROL_WMEN(val);
278 }
279
280 /*!
281 * @brief Set read water mark level for the FLEXSPI FOLLOWER module.
282 *
283 * This function sets read water mark level for the FLEXSPI FOLLOWER.
284 *
285 * @param base FLEXSPI FOLLOWER peripheral base address.
286 * @param val Read watermark level in bytes
287 */
FLEXSPI_SLV_Read_RDWM_SetVal(FLEXSPI_SLV_Type * base,uint32_t val)288 static inline void FLEXSPI_SLV_Read_RDWM_SetVal(FLEXSPI_SLV_Type *base, uint32_t val)
289 {
290 base->READ_COMMAND_CONTROL &= ~FLEXSPI_SLV_READ_COMMAND_CONTROL_RDWM_MASK;
291 base->READ_COMMAND_CONTROL |= FLEXSPI_SLV_READ_COMMAND_CONTROL_RDWM(val);
292 }
293
294 /*!
295 * @brief Sets the maximum read size triggered by a single read command.
296 *
297 * This function sets the maximum read size for the FLEXSPI FOLLOWER.
298 *
299 * @param base FLEXSPI FOLLOWER peripheral base address.
300 * @param val The maximum read size
301 */
FLEXSPI_SLV_Read_FetchSizeSet(FLEXSPI_SLV_Type * base,uint32_t val)302 static inline void FLEXSPI_SLV_Read_FetchSizeSet(FLEXSPI_SLV_Type *base, uint32_t val)
303 {
304 base->READ_COMMAND_CONTROL &= ~FLEXSPI_SLV_READ_COMMAND_CONTROL_RDFETCHSIZE_MASK;
305 base->READ_COMMAND_CONTROL |= FLEXSPI_SLV_READ_COMMAND_CONTROL_RDFETCHSIZE(val);
306 }
307
308 /*!
309 * @brief Gets the maximum read size triggered by a single read command.
310 *
311 * This function gets the maximum read size for the FLEXSPI FOLLOWER.
312 *
313 * @param base FLEXSPI FOLLOWER peripheral base address.
314 * @return The maximum read size
315 */
FLEXSPI_SLV_Read_FetchSizeGet(FLEXSPI_SLV_Type * base)316 static inline uint32_t FLEXSPI_SLV_Read_FetchSizeGet(FLEXSPI_SLV_Type *base)
317 {
318 uint32_t regBitVal = base->READ_COMMAND_CONTROL & FLEXSPI_SLV_READ_COMMAND_CONTROL_RDFETCHSIZE_MASK;
319
320 return (regBitVal >> FLEXSPI_SLV_READ_COMMAND_CONTROL_RDFETCHSIZE_SHIFT);
321 }
322
323 /*!
324 * @brief Set write water mark level for the FLEXSPI FOLLOWER module.
325 *
326 * This function sets write water mark level for the FLEXSPI FOLLOWER.
327 *
328 * @param base FLEXSPI FOLLOWER peripheral base address.
329 * @param val Write watermark level
330 */
FLEXSPI_SLV_Write_WRWM_SetVal(FLEXSPI_SLV_Type * base,uint32_t val)331 static inline void FLEXSPI_SLV_Write_WRWM_SetVal(FLEXSPI_SLV_Type *base, uint32_t val)
332 {
333 base->WRITE_COMMAND_CONTROL &= ~FLEXSPI_SLV_WRITE_COMMAND_CONTROL_WRWM_MASK;
334 base->WRITE_COMMAND_CONTROL |= FLEXSPI_SLV_WRITE_COMMAND_CONTROL_WRWM(val);
335 }
336
337 /*!
338 * @brief Set CS mask value for the FLEXSPI FOLLOWER module.
339 *
340 * This function sets CS mask value for the FLEXSPI FOLLOWER.
341 *
342 * @param base FLEXSPI FOLLOWER peripheral base address.
343 * @param val 0(Not masked) or 1(Masked)
344 */
FLEXSPI_SLV_CSMASK_SetVal(FLEXSPI_SLV_Type * base,uint32_t val)345 static inline void FLEXSPI_SLV_CSMASK_SetVal(FLEXSPI_SLV_Type *base, uint32_t val)
346 {
347 base->MODULE_CONTROL &= ~FLEXSPI_SLV_MODULE_CONTROL_CSMASK_MASK;
348 base->MODULE_CONTROL |= FLEXSPI_SLV_MODULE_CONTROL_CSMASK(val);
349 }
350 /* @} */
351
352 /*!
353 * @name Interrupts
354 * @{
355 */
356 /*!
357 * @brief Enables the FLEXSPI FOLLOWER interrupts.
358 *
359 * @param base FLEXSPI FOLLOWER peripheral base address.
360 * @param mask FLEXSPI FOLLOWER interrupt source.
361 */
FLEXSPI_SLV_EnableInterrupts(FLEXSPI_SLV_Type * base,uint32_t mask)362 static inline void FLEXSPI_SLV_EnableInterrupts(FLEXSPI_SLV_Type *base, uint32_t mask)
363 {
364 base->MODULE_INTEN |= mask;
365 }
366
367 /*!
368 * @brief Disable the FLEXSPI FOLLOWER interrupts.
369 *
370 * @param base FLEXSPI FOLLOWER peripheral base address.
371 * @param mask FLEXSPI FOLLOWER interrupt source.
372 */
FLEXSPI_SLV_DisableInterrupts(FLEXSPI_SLV_Type * base,uint32_t mask)373 static inline void FLEXSPI_SLV_DisableInterrupts(FLEXSPI_SLV_Type *base, uint32_t mask)
374 {
375 base->MODULE_INTEN &= ~mask;
376 }
377
378 /*!
379 * @brief Get the FLEXSPI FOLLOWER enabled interrupts.
380 *
381 * @param base FLEXSPI FOLLOWER peripheral base address.
382 */
FLEXSPI_SLV_GetEnabledInterrupts(FLEXSPI_SLV_Type * base)383 static inline uint32_t FLEXSPI_SLV_GetEnabledInterrupts(FLEXSPI_SLV_Type *base)
384 {
385 return (base->MODULE_INTEN);
386 }
387
388 /*!
389 * @brief Enable the FLEXSPI FOLLOWER mailbox interrupts.
390 *
391 * @param base FLEXSPI FOLLOWER peripheral base address.
392 * @param enable Whether enable the mailbox interrupt.
393 */
FLEXSPI_SLV_EnableMailInterrupt(FLEXSPI_SLV_Type * base,bool enable)394 static inline void FLEXSPI_SLV_EnableMailInterrupt(FLEXSPI_SLV_Type *base, bool enable)
395 {
396 base->SPI_MAIL_CTRL = FLEXSPI_SLV_SPI_MAIL_CTRL_SPIINTEN(enable ? 1 : 0);
397 }
398
399 /*!
400 * @brief Return whether the FLEXSPI FOLLOWER enables the mailbox interrupt.
401 *
402 * @param base FLEXSPI FOLLOWER peripheral base address.
403 */
FLEXSPI_SLV_GetEnabledMailInterrupt(FLEXSPI_SLV_Type * base)404 static inline bool FLEXSPI_SLV_GetEnabledMailInterrupt(FLEXSPI_SLV_Type *base)
405 {
406 return ((base->SPI_MAIL_CTRL & FLEXSPI_SLV_SPI_MAIL_CTRL_SPIINTEN_MASK) ? true : false);
407 }
408 /* @} */
409
410 /*!
411 * @brief Gets the SPI leader read/write out-of-allowed-range count.
412 *
413 * @param base FLEXSPI FOLLOWER peripheral base address.
414 * @param[out] rdCount Pointer through which the current number in the read out-of-allowed-range counter is returned.
415 * Pass NULL if this value is not required.
416 * @param[out] wrCount Pointer through which the current number in the write out-of-allowed-range counter is returned
417 * Pass NULL if this value is not required.
418 */
FLEXSPI_SLV_GetOutOfRangeCounts(FLEXSPI_SLV_Type * base,size_t * rdCount,size_t * wrCount)419 static inline void FLEXSPI_SLV_GetOutOfRangeCounts(FLEXSPI_SLV_Type *base, size_t *rdCount, size_t *wrCount)
420 {
421 if (NULL != rdCount)
422 {
423 *rdCount = ((base->MODULE_STATUS) & FLEXSPI_SLV_MODULE_STATUS_RDOFR_MASK) >> FLEXSPI_SLV_MODULE_STATUS_RDOFR_SHIFT;
424 }
425 if (NULL != wrCount)
426 {
427 *wrCount = ((base->MODULE_STATUS) & FLEXSPI_SLV_MODULE_STATUS_WROFR_MASK) >> FLEXSPI_SLV_MODULE_STATUS_WROFR_SHIFT;
428 }
429 }
430
431 /*!
432 * @name Status
433 * @{
434 */
435 /*!
436 * @brief Get the FLEXSPI FOLLOWER interrupt status flags.
437 *
438 * @param base FLEXSPI FOLLOWER peripheral base address.
439 * @retval Interrupt status flag, use status flag to AND the bit mask could get the related status.
440 */
FLEXSPI_SLV_GetInterruptStatusFlags(FLEXSPI_SLV_Type * base)441 static inline uint32_t FLEXSPI_SLV_GetInterruptStatusFlags(FLEXSPI_SLV_Type *base)
442 {
443 return (base->MODULE_INT);
444 }
445
446 /*!
447 * @brief Get the FLEXSPI FOLLOWER mailbox interrupt register.
448 *
449 * @param base FLEXSPI FOLLOWER peripheral base address.
450 * @return Return the index of the FLEXSPI FOLLOWER mail interrupt register
451 */
FLEXSPI_SLV_GetMailInterruptIndex(FLEXSPI_SLV_Type * base)452 static inline uint32_t FLEXSPI_SLV_GetMailInterruptIndex(FLEXSPI_SLV_Type *base)
453 {
454 uint32_t index;
455
456 for (index = 0; index < FLEXSPI_SLV_SPIMAIL_COUNT; index++)
457 {
458 if (base->SPIMAIL[index] & 0x1U)
459 {
460 break;
461 }
462 }
463 return index;
464 }
465
466 /*!
467 * @brief Get the FLEXSPI FOLLOWER mailbox data.
468 *
469 * @param base FLEXSPI FOLLOWER peripheral base address.
470 * @param index The index of the mail interrupt register
471 * @return Return the FLEXSPI FOLLOWER mailbox data
472 */
FLEXSPI_SLV_GetMailboxData(FLEXSPI_SLV_Type * base,uint32_t index)473 static inline uint32_t FLEXSPI_SLV_GetMailboxData(FLEXSPI_SLV_Type *base, uint32_t index)
474 {
475 return ((index < FLEXSPI_SLV_SPIMAIL_COUNT) ? base->SPIMAIL[index] : 0U);
476 }
477
478 /*!
479 * @brief Clear the FLEXSPI FOLLOWER interrupt status flags.
480 *
481 * @param base FLEXSPI FOLLOWER peripheral base address.
482 * @param mask FLEXSPI FOLLOWER interrupt source.
483 */
FLEXSPI_SLV_ClearInterruptStatusFlags(FLEXSPI_SLV_Type * base,uint32_t mask)484 static inline void FLEXSPI_SLV_ClearInterruptStatusFlags(FLEXSPI_SLV_Type *base, uint32_t mask)
485 {
486 base->MODULE_INT |= mask;
487 }
488
489 /*!
490 * @brief Clear the FLEXSPI FOLLOWER mailbox interrupt flag.
491 *
492 * @param base FLEXSPI FOLLOWER peripheral base address.
493 */
FLEXSPI_SLV_ClearMailInterruptFlag(FLEXSPI_SLV_Type * base)494 static inline void FLEXSPI_SLV_ClearMailInterruptFlag(FLEXSPI_SLV_Type *base)
495 {
496 base->SPI_MAIL_CTRL |= FLEXSPI_SLV_SPI_MAIL_CTRL_CLRINT_MASK;
497 }
498
499 /*! @brief Returns whether the current AXI write leader is busy with a write command.
500 *
501 * @param base FLEXSPI FOLLOWER peripheral base address.
502 * @retval true The current AXI write leader is busy.
503 * @retval false The current AXI write leader is not busy.
504 */
FLEXSPI_SLV_GetAXIWriteBusyStatus(FLEXSPI_SLV_Type * base)505 static inline bool FLEXSPI_SLV_GetAXIWriteBusyStatus(FLEXSPI_SLV_Type *base)
506 {
507 return ((base->MODULE_STATUS & FLEXSPI_SLV_MODULE_STATUS_WIP_MASK) ? true : false);
508 }
509
510 /*! @brief Returns whether the AXI read leader is busy with a read request or else idle with no pending
511 * AXI read request.
512 *
513 * @param base FLEXSPI FOLLOWER peripheral base address.
514 * @retval true The current AXI read leader is idle.
515 * @retval false The current AXI read leader is busy.
516 */
FLEXSPI_SLV_GetAXIReadIdleStatus(FLEXSPI_SLV_Type * base)517 static inline bool FLEXSPI_SLV_GetAXIReadIdleStatus(FLEXSPI_SLV_Type *base)
518 {
519 return ((base->MODULE_STATUS & FLEXSPI_SLV_MODULE_STATUS_AXIREADIDLE_MASK) ? true : false);
520 }
521
522 /*! @brief Returns whether the SPI to read/write register queue is idle.
523 *
524 * @param base FLEXSPI FOLLOWER peripheral base address.
525 * @retval true The SPI to read/write register queue is idle.
526 * @retval false The SPI to read/write register queue is busy.
527 */
FLEXSPI_SLV_GetRegReadWriteIdleStatus(FLEXSPI_SLV_Type * base)528 static inline bool FLEXSPI_SLV_GetRegReadWriteIdleStatus(FLEXSPI_SLV_Type *base)
529 {
530 return ((base->MODULE_STATUS & FLEXSPI_SLV_MODULE_STATUS_REGRWIDLE_MASK) ? true : false);
531 }
532
533 /*! @brief Returns whether the SEQ control logic is idle or else busy with an ongoing SPI request.
534 *
535 * @param base FLEXSPI FOLLOWER peripheral base address.
536 * @retval true The SEQ control logic is idle.
537 * @retval false The SEQ control logic is busy.
538 */
FLEXSPI_SLV_GetSEQIdleStatus(FLEXSPI_SLV_Type * base)539 static inline bool FLEXSPI_SLV_GetSEQIdleStatus(FLEXSPI_SLV_Type *base)
540 {
541 return ((base->MODULE_STATUS & FLEXSPI_SLV_MODULE_STATUS_SEQIDLE_MASK) ? true : false);
542 }
543
544 /*! @brief Returns whether the FLEXSPI FOLLOWER module is busy.
545 *
546 * @param base FLEXSPI FOLLOWER peripheral base address.
547 * @retval true The SEQ control logic is busy.
548 * @retval false The SEQ control logic is idle.
549 */
FLEXSPI_SLV_GetModuleBusyStatus(FLEXSPI_SLV_Type * base)550 static inline bool FLEXSPI_SLV_GetModuleBusyStatus(FLEXSPI_SLV_Type *base)
551 {
552 uint32_t statusMasks = 0, idleFlags = 0;
553
554 statusMasks = FLEXSPI_SLV_MODULE_STATUS_WIP_MASK |
555 FLEXSPI_SLV_MODULE_STATUS_AXIREADIDLE_MASK |
556 FLEXSPI_SLV_MODULE_STATUS_REGRWIDLE_MASK |
557 FLEXSPI_SLV_MODULE_STATUS_SEQIDLE_MASK;
558
559 idleFlags = FLEXSPI_SLV_MODULE_STATUS_WIP(0) |
560 FLEXSPI_SLV_MODULE_STATUS_AXIREADIDLE(1) |
561 FLEXSPI_SLV_MODULE_STATUS_REGRWIDLE(1) |
562 FLEXSPI_SLV_MODULE_STATUS_SEQIDLE(1);
563
564 return (((base->MODULE_STATUS & statusMasks) != idleFlags) ? true : false);
565 }
566 /*@}*/
567
568 /*!
569 * @name Bus Operations
570 * @{
571 */
572
573 /*!
574 * @brief Sets the read memory command.
575 *
576 * @param base FLEXSPI FOLLOWER peripheral base address
577 * @param i The read command setting register index
578 * @param val The read command value.
579 */
FLEXSPI_SLV_Read_CommandSet(FLEXSPI_SLV_Type * base,uint32_t i,uint32_t val)580 static inline void FLEXSPI_SLV_Read_CommandSet(FLEXSPI_SLV_Type *base, uint32_t i, uint32_t val)
581 {
582 base->READ_COMMAND[i] &= ~FLEXSPI_SLV_READ_COMMAND_COMMANDSET_MASK;
583 base->READ_COMMAND[i] |= FLEXSPI_SLV_READ_COMMAND_COMMANDSET(val);
584 }
585
586 /*!
587 * @brief Gets the read memory command.
588 *
589 * @param base FLEXSPI FOLLOWER peripheral base address
590 * @param i The read command setting register index
591 */
FLEXSPI_SLV_Read_CommandGet(FLEXSPI_SLV_Type * base,uint32_t i)592 static inline uint32_t FLEXSPI_SLV_Read_CommandGet(FLEXSPI_SLV_Type *base, uint32_t i)
593 {
594 uint32_t regBitVal = base->READ_COMMAND[i] & FLEXSPI_SLV_READ_COMMAND_COMMANDSET_MASK;
595
596 return (regBitVal >> FLEXSPI_SLV_READ_COMMAND_COMMANDSET_SHIFT);
597 }
598
599 /*!
600 * @brief Sets the dummy cycle for the read memory command.
601 *
602 * @param base FLEXSPI FOLLOWER peripheral base address
603 * @param i The read command dummy cycle setting register index
604 * @param val The dummy cycle value of the read command.
605 */
FLEXSPI_SLV_Read_Command_DummyCyclesSet(FLEXSPI_SLV_Type * base,uint32_t i,uint32_t val)606 static inline void FLEXSPI_SLV_Read_Command_DummyCyclesSet(FLEXSPI_SLV_Type *base, uint32_t i, uint32_t val)
607 {
608 base->READ_COMMAND[i] &= ~FLEXSPI_SLV_READ_COMMAND_DUMMYCYCLES_MASK;
609 base->READ_COMMAND[i] |= FLEXSPI_SLV_READ_COMMAND_DUMMYCYCLES(val);
610 }
611
612 /*!
613 * @brief Gets the dummy cycle for the read memory command.
614 *
615 * @param base FLEXSPI FOLLOWER peripheral base address
616 * @param i The read command dummy cycle setting register index
617 */
FLEXSPI_SLV_Read_Command_DummyCyclesGet(FLEXSPI_SLV_Type * base,uint32_t i)618 static inline uint32_t FLEXSPI_SLV_Read_Command_DummyCyclesGet(FLEXSPI_SLV_Type *base, uint32_t i)
619 {
620 uint32_t regBitVal = base->READ_COMMAND[i] & FLEXSPI_SLV_READ_COMMAND_DUMMYCYCLES_MASK;
621
622 return (regBitVal >> FLEXSPI_SLV_READ_COMMAND_DUMMYCYCLES_SHIFT);
623 }
624
625 /*!
626 * @brief Sets the write memory command.
627 *
628 * @param base FLEXSPI FOLLOWER peripheral base address
629 * @param i The write command setting register index
630 * @param val The write command value.
631 */
FLEXSPI_SLV_Write_CommandSet(FLEXSPI_SLV_Type * base,uint32_t i,uint32_t val)632 static inline void FLEXSPI_SLV_Write_CommandSet(FLEXSPI_SLV_Type *base, uint32_t i, uint32_t val)
633 {
634 base->WRITE_COMMAND[i] &= ~FLEXSPI_SLV_WRITE_COMMAND_COMMANDSET_MASK;
635 base->WRITE_COMMAND[i] |= FLEXSPI_SLV_WRITE_COMMAND_COMMANDSET(val);
636 }
637
638 /*!
639 * @brief Sets the read register command.
640 *
641 * @param base FLEXSPI FOLLOWER peripheral base address
642 * @param val The read register command value.
643 */
FLEXSPI_SLV_Read_Register_CommandSet(FLEXSPI_SLV_Type * base,uint32_t val)644 static inline void FLEXSPI_SLV_Read_Register_CommandSet(FLEXSPI_SLV_Type *base, uint32_t val)
645 {
646 base->READ_REGISTER_COMMAND0 &= ~FLEXSPI_SLV_READ_REGISTER_COMMAND0_COMMANDSET_MASK;
647 base->READ_REGISTER_COMMAND0 |= FLEXSPI_SLV_READ_REGISTER_COMMAND0_COMMANDSET(val);
648 }
649
650 /*!
651 * @brief Sets the dummy cycle for the read register command.
652 *
653 * @param base FLEXSPI FOLLOWER peripheral base address
654 * @param val The dummy cycle value of the read register command.
655 */
FLEXSPI_SLV_Read_Register_Command_DummyCyclesSet(FLEXSPI_SLV_Type * base,uint32_t val)656 static inline void FLEXSPI_SLV_Read_Register_Command_DummyCyclesSet(FLEXSPI_SLV_Type *base, uint32_t val)
657 {
658 base->READ_REGISTER_COMMAND0 &= ~FLEXSPI_SLV_READ_REGISTER_COMMAND0_DUMMYCYCLES_MASK;
659 base->READ_REGISTER_COMMAND0 |= FLEXSPI_SLV_READ_REGISTER_COMMAND0_DUMMYCYCLES(val);
660 }
661
662 /*!
663 * @brief Sets the write register command.
664 *
665 * @param base FLEXSPI FOLLOWER peripheral base address
666 * @param val The write register command value.
667 */
FLEXSPI_SLV_Write_Register_CommandSet(FLEXSPI_SLV_Type * base,uint32_t val)668 static inline void FLEXSPI_SLV_Write_Register_CommandSet(FLEXSPI_SLV_Type *base, uint32_t val)
669 {
670 base->WRITE_REGISTER_COMMAND0 &= ~FLEXSPI_SLV_WRITE_REGISTER_COMMAND0_COMMANDSET_MASK;
671 base->WRITE_REGISTER_COMMAND0 |= FLEXSPI_SLV_WRITE_REGISTER_COMMAND0_COMMANDSET(val);
672 }
673
674 /*! @} */
675
676 /*!
677 * @name Transactional
678 * @{
679 */
680
681 /*!
682 * @brief Initializes the FLEXSPI FOLLOWER handle which is used in transactional functions.
683 *
684 * @param base FLEXSPI FOLLOWER peripheral base address.
685 * @param handle Pointer to flexspi_slv_handle_t structure to store the interrupt state.
686 * @param callback Pointer to user callback function.
687 * @param userData User parameter passed to the callback function.
688 */
689 void FLEXSPI_SLV_InterruptCreateHandle(FLEXSPI_SLV_Type *base,
690 flexspi_slv_handle_t *handle,
691 flexspi_slv_interrupt_callback_t callback,
692 void *userData);
693
694 /*!
695 * @brief Master interrupt handler.
696 *
697 * @param base FLEXSPI FOLLOWER peripheral base address.
698 * @param handle Pointer to flexspi_slv_handle_t structure.
699 */
700 void FLEXSPI_SLV_HandleIRQ(FLEXSPI_SLV_Type *base, flexspi_slv_handle_t *handle);
701 /*! @} */
702
703 #if defined(__cplusplus)
704 }
705 #endif /*_cplusplus. */
706 /*@}*/
707
708 #endif /* __FSL_FLEXSPI_FOLLOWER_H_ */
709
710
