1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
|
/*
* Copyright 2017-2020 NXP
* All rights reserved.
*
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#ifndef _FSL_FLEXRAM_H_
#define _FSL_FLEXRAM_H_
#include "fsl_common.h"
#include "fsl_flexram_allocate.h"
/*!
* @addtogroup flexram
* @{
*/
/******************************************************************************
* Definitions.
*****************************************************************************/
/*! @name Driver version */
/*@{*/
/*! @brief Driver version 2.0.7. */
#define FSL_FLEXRAM_DRIVER_VERSION (MAKE_VERSION(2U, 0U, 7U))
/*@}*/
/*! @brief Flexram write/read selection. */
enum
{
kFLEXRAM_Read = 0U, /*!< read */
kFLEXRAM_Write = 1U, /*!< write */
};
/*! @brief Interrupt status flag mask */
enum
{
kFLEXRAM_OCRAMAccessError = FLEXRAM_INT_STATUS_OCRAM_ERR_STATUS_MASK, /*!< OCRAM accesses unallocated address */
kFLEXRAM_DTCMAccessError = FLEXRAM_INT_STATUS_DTCM_ERR_STATUS_MASK, /*!< DTCM accesses unallocated address */
kFLEXRAM_ITCMAccessError = FLEXRAM_INT_STATUS_ITCM_ERR_STATUS_MASK, /*!< ITCM accesses unallocated address */
#if defined(FSL_FEATURE_FLEXRAM_HAS_MAGIC_ADDR) && FSL_FEATURE_FLEXRAM_HAS_MAGIC_ADDR
kFLEXRAM_OCRAMMagicAddrMatch = FLEXRAM_INT_STATUS_OCRAM_MAM_STATUS_MASK, /*!< OCRAM magic address match */
kFLEXRAM_DTCMMagicAddrMatch = FLEXRAM_INT_STATUS_DTCM_MAM_STATUS_MASK, /*!< DTCM magic address match */
kFLEXRAM_ITCMMagicAddrMatch = FLEXRAM_INT_STATUS_ITCM_MAM_STATUS_MASK, /*!< ITCM magic address match */
kFLEXRAM_InterruptStatusAll = FLEXRAM_INT_STATUS_OCRAM_ERR_STATUS_MASK | FLEXRAM_INT_STATUS_DTCM_ERR_STATUS_MASK |
FLEXRAM_INT_STATUS_ITCM_ERR_STATUS_MASK | FLEXRAM_INT_STATUS_OCRAM_MAM_STATUS_MASK |
FLEXRAM_INT_STATUS_DTCM_MAM_STATUS_MASK | FLEXRAM_INT_STATUS_ITCM_MAM_STATUS_MASK,
/*!< all the interrupt status mask */
#else
kFLEXRAM_InterruptStatusAll = FLEXRAM_INT_STATUS_OCRAM_ERR_STATUS_MASK | FLEXRAM_INT_STATUS_DTCM_ERR_STATUS_MASK |
FLEXRAM_INT_STATUS_ITCM_ERR_STATUS_MASK, /*!< all the interrupt status mask */
#endif /* FSL_FEATURE_FLEXRAM_HAS_MAGIC_ADDR */
};
/*! @brief FLEXRAM TCM access mode.
* Fast access mode expected to be finished in 1-cycle;
* Wait access mode expected to be finished in 2-cycle.
* Wait access mode is a feature of the flexram and it should be used when
* the CPU clock is too fast to finish TCM access in 1-cycle.
* Normally, fast mode is the default mode, the efficiency of the TCM access will better.
*/
typedef enum _flexram_tcm_access_mode
{
kFLEXRAM_TCMAccessFastMode = 0U, /*!< fast access mode */
kFLEXRAM_TCMAccessWaitMode = 1U, /*!< wait access mode */
} flexram_tcm_access_mode_t;
/*! @brief FLEXRAM TCM support size */
enum
{
kFLEXRAM_TCMSize32KB = 32 * 1024U, /*!< TCM total size be 32KB */
kFLEXRAM_TCMSize64KB = 64 * 1024U, /*!< TCM total size be 64KB */
kFLEXRAM_TCMSize128KB = 128 * 1024U, /*!< TCM total size be 128KB */
kFLEXRAM_TCMSize256KB = 256 * 1024U, /*!< TCM total size be 256KB */
kFLEXRAM_TCMSize512KB = 512 * 1024U, /*!< TCM total size be 512KB */
};
/*******************************************************************************
* APIs
******************************************************************************/
#if defined(__cplusplus)
extern "C" {
#endif
/*!
* @name Initialization and de-initialization
* @{
*/
/*!
* @brief FLEXRAM module initialization function.
*
* @param base FLEXRAM base address.
*/
void FLEXRAM_Init(FLEXRAM_Type *base);
/*!
* @brief De-initializes the FLEXRAM.
*
*/
void FLEXRAN_Deinit(FLEXRAM_Type *base);
/* @} */
/*!
* @name Status
* @{
*/
/*!
* @brief FLEXRAM module gets interrupt status.
*
* @param base FLEXRAM base address.
*/
static inline uint32_t FLEXRAM_GetInterruptStatus(FLEXRAM_Type *base)
{
return base->INT_STATUS & (uint32_t)kFLEXRAM_InterruptStatusAll;
}
/*!
* @brief FLEXRAM module clears interrupt status.
*
* @param base FLEXRAM base address.
* @param status Status to be cleared.
*/
static inline void FLEXRAM_ClearInterruptStatus(FLEXRAM_Type *base, uint32_t status)
{
base->INT_STATUS |= status;
}
/*!
* @brief FLEXRAM module enables interrupt status.
*
* @param base FLEXRAM base address.
* @param status Status to be enabled.
*/
static inline void FLEXRAM_EnableInterruptStatus(FLEXRAM_Type *base, uint32_t status)
{
base->INT_STAT_EN |= status;
}
/*!
* @brief FLEXRAM module disable interrupt status.
*
* @param base FLEXRAM base address.
* @param status Status to be disabled.
*/
static inline void FLEXRAM_DisableInterruptStatus(FLEXRAM_Type *base, uint32_t status)
{
base->INT_STAT_EN &= ~status;
}
/* @} */
/*!
* @name Interrupts
* @{
*/
/*!
* @brief FLEXRAM module enables interrupt.
*
* @param base FLEXRAM base address.
* @param status Status interrupt to be enabled.
*/
static inline void FLEXRAM_EnableInterruptSignal(FLEXRAM_Type *base, uint32_t status)
{
base->INT_SIG_EN |= status;
}
/*!
* @brief FLEXRAM module disables interrupt.
*
* @param base FLEXRAM base address.
* @param status Status interrupt to be disabled.
*/
static inline void FLEXRAM_DisableInterruptSignal(FLEXRAM_Type *base, uint32_t status)
{
base->INT_SIG_EN &= ~status;
}
/* @} */
/*!
* @brief FLEXRAM module sets TCM read access mode
*
* @param base FLEXRAM base address.
* @param mode Access mode.
*/
static inline void FLEXRAM_SetTCMReadAccessMode(FLEXRAM_Type *base, flexram_tcm_access_mode_t mode)
{
base->TCM_CTRL &= ~FLEXRAM_TCM_CTRL_TCM_RWAIT_EN_MASK;
base->TCM_CTRL |= (uint32_t)mode;
}
/*!
* @brief FLEXRAM module set TCM write access mode
*
* @param base FLEXRAM base address.
* @param mode Access mode.
*/
static inline void FLEXRAM_SetTCMWriteAccessMode(FLEXRAM_Type *base, flexram_tcm_access_mode_t mode)
{
base->TCM_CTRL &= ~FLEXRAM_TCM_CTRL_TCM_WWAIT_EN_MASK;
base->TCM_CTRL |= (uint32_t)mode;
}
/*!
* @brief FLEXRAM module force ram clock on
*
* @param base FLEXRAM base address.
* @param enable Enable or disable clock force on.
*/
static inline void FLEXRAM_EnableForceRamClockOn(FLEXRAM_Type *base, bool enable)
{
if (enable)
{
base->TCM_CTRL |= FLEXRAM_TCM_CTRL_FORCE_CLK_ON_MASK;
}
else
{
base->TCM_CTRL &= ~FLEXRAM_TCM_CTRL_FORCE_CLK_ON_MASK;
}
}
#if defined(FSL_FEATURE_FLEXRAM_HAS_MAGIC_ADDR) && FSL_FEATURE_FLEXRAM_HAS_MAGIC_ADDR
/*!
* @brief FLEXRAM OCRAM magic addr configuration.
* When read/write access hit magic address, it will generate interrupt.
* @param base FLEXRAM base address.
* @param magicAddr Magic address, the actual address bits [18:3] is corresponding to the register field [16:1].
* @param rwSel Read/write selection. 0 for read access while 1 for write access.
*/
static inline void FLEXRAM_SetOCRAMMagicAddr(FLEXRAM_Type *base, uint16_t magicAddr, uint32_t rwSel)
{
base->OCRAM_MAGIC_ADDR = FLEXRAM_OCRAM_MAGIC_ADDR_OCRAM_WR_RD_SEL(rwSel) |
FLEXRAM_OCRAM_MAGIC_ADDR_OCRAM_MAGIC_ADDR((uint32_t)magicAddr >> 3);
}
/*!
* @brief FLEXRAM DTCM magic addr configuration.
* When read/write access hits magic address, it will generate interrupt.
* @param base FLEXRAM base address.
* @param magicAddr Magic address, the actual address bits [18:3] is corresponding to the register field [16:1].
* @param rwSel Read/write selection. 0 for read access while 1 write access.
*/
static inline void FLEXRAM_SetDTCMMagicAddr(FLEXRAM_Type *base, uint16_t magicAddr, uint32_t rwSel)
{
base->DTCM_MAGIC_ADDR = FLEXRAM_DTCM_MAGIC_ADDR_DTCM_WR_RD_SEL(rwSel) |
FLEXRAM_DTCM_MAGIC_ADDR_DTCM_MAGIC_ADDR((uint32_t)magicAddr >> 3);
}
/*!
* @brief FLEXRAM ITCM magic addr configuration.
* When read/write access hits magic address, it will generate interrupt.
* @param base FLEXRAM base address.
* @param magicAddr Magic address, the actual address bits [18:3] is corresponding to the register field [16:1].
* @param rwSel Read/write selection. 0 for read access while 1 for write access.
*/
static inline void FLEXRAM_SetITCMMagicAddr(FLEXRAM_Type *base, uint16_t magicAddr, uint32_t rwSel)
{
base->ITCM_MAGIC_ADDR = FLEXRAM_ITCM_MAGIC_ADDR_ITCM_WR_RD_SEL(rwSel) |
FLEXRAM_ITCM_MAGIC_ADDR_ITCM_MAGIC_ADDR((uint32_t)magicAddr >> 3);
}
#endif /* FSL_FEATURE_FLEXRAM_HAS_MAGIC_ADDR */
#if defined(__cplusplus)
}
#endif
/*! @}*/
#endif
|
