Base directory structure for new RM
[keystone-rtos/rm-lld.git] / include / rm_pvt.h
1 /*
2  *  file  rm_pvt.h
3  *
4  *  Private data structures of Resource Manager Low Level Driver.
5  *
6  *  ============================================================================
7  *      (C) Copyright 2012, Texas Instruments, Inc.
8  * 
9  *  Redistribution and use in source and binary forms, with or without 
10  *  modification, are permitted provided that the following conditions 
11  *  are met:
12  *
13  *    Redistributions of source code must retain the above copyright 
14  *    notice, this list of conditions and the following disclaimer.
15  *
16  *    Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the 
18  *    documentation and/or other materials provided with the   
19  *    distribution.
20  *
21  *    Neither the name of Texas Instruments Incorporated nor the names of
22  *    its contributors may be used to endorse or promote products derived
23  *    from this software without specific prior written permission.
24  *
25  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
26  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
27  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
29  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
30  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
31  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
34  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
35  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36  *
37  *  \par
38 */
40 #ifndef RM_PVT_H_
41 #define RM_PVT_H_
43 #ifdef __cplusplus
44 extern "C" {
45 #endif
47 /* Device Include */
48 #include <c6x.h>
50 /* RM includes */
51 #include <ti/drv/rm/rm_public_lld.h>
53 /* CSL includes */
54 #include <ti/csl/csl_qm_queue.h>
56 /* QMSS Resource Information */
57 #define RM_QMSS_FIRMWARE_PDSPS 2
58 #define RM_QMSS_QUEUES 8192
59 #define RM_QMSS_MEM_REGIONS 20
60 #define RM_QMSS_LINKING_RAM_RANGES 40 /* Twice as many memory regions */
61 #define RM_QMSS_ACCUM_CH 48
62 #define RM_QMSS_QOS_CLUSTER 8
63 #define RM_QMSS_QOS_QUEUES 64
65 #define RM_QMSS_LINKING_RAM_RANGE_INIT  (0xFFFFFFFF)
67 /* CPPI Resource Information */
69 /* Set CPPI DMA increments based on which DMAs are present for the device */
71 /* Set AIF increment if present */
72 #ifdef QMSS_MAX_AIF_QUEUE
73 #define RM_CPPI_AIF_INC 1
74 #else
75 #define RM_CPPI_AIF_INC 0
76 #endif
77 /* Set FFTC A increment if present */
78 #ifdef QMSS_MAX_FFTC_A_QUEUE
79 #define RM_CPPI_FFTC_A_INC 1
80 #else
81 #define RM_CPPI_FFTC_A_INC 0
82 #endif
83 /* Set FFTC B increment if present */
84 #ifdef QMSS_MAX_FFTC_B_QUEUE
85 #define RM_CPPI_FFTC_B_INC 1
86 #else
87 #define RM_CPPI_FFTC_B_INC 0
88 #endif
89 /* Set PASS increment if present */
90 #ifdef QMSS_MAX_PASS_QUEUE
91 #define RM_CPPI_PASS_INC 1
92 #else
93 #define RM_CPPI_PASS_INC 0
94 #endif
95 /* Set FFTC C increment if present */
96 #ifdef QMSS_MAX_FFTC_C_QUEUE
97 #define RM_CPPI_FFTC_C_INC 1
98 #else
99 #define RM_CPPI_FFTC_C_INC 0
100 #endif
101 /* Set BCP increment if present */
102 #ifdef QMSS_MAX_BCP_QUEUE
103 #define RM_CPPI_BCP_INC 1
104 #else
105 #define RM_CPPI_BCP_INC 0
106 #endif
108 /* Base number of DMAs for all devices. */
109 #define RM_CPPI_BASE_DMAS 2
110 /* Set max DMAs, adding additional DMAs if present */
111 #define RM_CPPI_MAX_DMAS (RM_CPPI_BASE_DMAS + RM_CPPI_AIF_INC + RM_CPPI_FFTC_A_INC + \
112                                                 RM_CPPI_FFTC_B_INC + RM_CPPI_PASS_INC + RM_CPPI_FFTC_C_INC + \
113                                                 RM_CPPI_BCP_INC)
115 /* Set DMA indices based on which DMAs are present in device */
116 #define RM_CPPI_SRIO_DMA_ID 0
117 #define RM_CPPI_AIF_DMA_ID (RM_CPPI_SRIO_DMA_ID + RM_CPPI_AIF_INC)
118 #define RM_CPPI_FFTC_A_DMA_ID (RM_CPPI_AIF_DMA_ID + RM_CPPI_FFTC_A_INC)
119 #define RM_CPPI_FFTC_B_DMA_ID (RM_CPPI_FFTC_A_DMA_ID + RM_CPPI_FFTC_B_INC)
120 #define RM_CPPI_PASS_DMA_ID (RM_CPPI_FFTC_B_DMA_ID + RM_CPPI_PASS_INC)
121 #define RM_CPPI_QMSS_DMA_ID (RM_CPPI_PASS_DMA_ID + 1)
122 #define RM_CPPI_FFTC_C_DMA_ID (RM_CPPI_QMSS_DMA_ID + RM_CPPI_FFTC_C_INC)
123 #define RM_CPPI_BCP_DMA_ID (RM_CPPI_FFTC_C_DMA_ID + RM_CPPI_BCP_INC)
125 #define RM_CPPI_SRIO_TX_CH 16
126 #define RM_CPPI_AIF_TX_CH 129
127 #define RM_CPPI_FFTC_A_TX_CH 4
128 #define RM_CPPI_FFTC_B_TX_CH 4
129 #define RM_CPPI_PASS_TX_CH 9
130 #define RM_CPPI_QMSS_TX_CH 32
131 #define RM_CPPI_FFTC_C_TX_CH 4
132 #define RM_CPPI_BCP_TX_CH 8
134 #define RM_CPPI_SRIO_RX_CH 16
135 #define RM_CPPI_AIF_RX_CH 129
136 #define RM_CPPI_FFTC_A_RX_CH 4
137 #define RM_CPPI_FFTC_B_RX_CH 4
138 #define RM_CPPI_PASS_RX_CH 24
139 #define RM_CPPI_QMSS_RX_CH 32
140 #define RM_CPPI_FFTC_C_RX_CH 4
141 #define RM_CPPI_BCP_RX_CH 8
143 #define RM_CPPI_SRIO_FLOW 20
144 #define RM_CPPI_AIF_FLOW 129
145 #define RM_CPPI_FFTC_A_FLOW 8
146 #define RM_CPPI_FFTC_B_FLOW 8
147 #define RM_CPPI_PASS_FLOW 32
148 #define RM_CPPI_QMSS_FLOW 64
149 #define RM_CPPI_FFTC_C_FLOW 8
150 #define RM_CPPI_BCP_FLOW 64
152 /* PA Resource Information */
153 #define RM_PA_LUT 5
155 /* Permissions Access Defines and Macros */
156 #define RM_RESOURCE_PERM_INIT_SHIFT 0
157 #define RM_RESOURCE_PERM_USE_SHIFT  1
159 #define RM_GET_RESOURCE_FLAG(flag) ((flag) >> ((DNUM) << 1))
161 #define RM_GET_RESOURCE_INIT_FLAG(flag) ((RM_GET_RESOURCE_FLAG (flag) >> RM_RESOURCE_PERM_INIT_SHIFT) & 1)
162 #define RM_GET_RESOURCE_USE_FLAG(flag)  ((RM_GET_RESOURCE_FLAG (flag) >> RM_RESOURCE_PERM_USE_SHIFT)  & 1)
164 #define RM_GET_PERMISSIONS(perms) (perms >> DNUM)
166 #define RM_RANGE_CHECK(start, end, max, ret_val) \
167 do { \
168     if ((start > end) || (end > max)) \
169     { \
170         return ret_val; \
171     } \
172 } while(0)
174 /* RM standard permission structure definition */
175 typedef struct
177     /** Initialization permissions
178       * Bit 0 - Core 0 init permission
179       * Bit 1 - Core 1 init permission
180       * Bit 2 - Core 2 init permission
181       * Bit 3 - Core 3 init permission
182       */    
183     uint32_t initPerms;  
184     /** Usage permissions
185       * Bit 0 - Core 0 use permission
186       * Bit 1 - Core 1 use permission
187       * Bit 2 - Core 2 use permission
188       * Bit 3 - Core 3 use permission
189       */    
190     uint32_t usePerms;
191 } Rm_Perms;
193 /* RM permissions structure for Linking RAM regions */
194 typedef struct
196     /** Linking RAM start index for these permissions */
197     uint32_t startIndex;
198     /** Linking RAM end index for these permissions */
199     uint32_t endIndex;
200     /** Permissions for the range */
201     Rm_Perms rangePerms;
202 } Rm_qmssLinkingRamPerms;
204 /* RM permissions structure for CPPI DMA channels and flows */
205 typedef struct
207     /** Array of pointers to each DMAs channel or flow permissions
208        * From CPPI LLD - DMA 0 = SRIO
209        *                          DMA 1 = AIF
210        *                          DMA 2 = FFTC A
211        *                          DMA 3 = FFTC B
212        *                          DMA 4 = PASS
213        *                          DMA 5 = QMSS
214        *                          DMA 6 = FFTC C
215        *                          DMA 7 = BCP 
216        * 
217        * Note: Some DMAs may not be supported based on the device */
218     Rm_Perms *dmaPermPtrs[RM_CPPI_MAX_DMAS];
219 } Rm_CppiChAndFlowPerms;
221 /* RM Cache Line Alignment Defines and Macros */
223 #define RM_MAX_CACHE_ALIGN 128  /* Maximum alignment for cache line size */
225 /* This macro generates compilier error if postulate is false, so 
226  * allows 0 overhead compile time size check.  This "works" when
227  * the expression contains sizeof() which otherwise doesn't work
228  * with preprocessor */
229 #define RM_COMPILE_TIME_SIZE_CHECK(postulate)                         \
230    do {                                                                 \
231        typedef struct {                                                 \
232          uint8_t NegativeSizeIfPostulateFalse[((int)(postulate))*2 - 1];\
233        } PostulateCheck_t;                                              \
234    }                                                                    \
235    while (0)
237 /* Macro to pad out internal permission structures to multiple of RM_MAX_CACHE_ALIGN bytes
238   * The macro prevent something else from being placed on same cache line as the permission.  
239   * arrays.  Note that pad[0] is illegal, so must add full RM_MAX_CACHE_ALIGN if structure
240   * is already padded by chance. */
241 #define RM_ALIGN_PERMISSIONS_ARRAY(numElements, permStructType) ( \
242      (((sizeof(permStructType) * (numElements)) % RM_MAX_CACHE_ALIGN) == 0) ? (numElements) : \
243      ((numElements) + \
244        (RM_MAX_CACHE_ALIGN - \
245          ((sizeof(permStructType) * (numElements)) % RM_MAX_CACHE_ALIGN))/sizeof(permStructType)))
247 /* RM Global Sync Object (unpadded) */
248 typedef struct
250     /** Rm_init/Rm_start synchronization object. */
251     uint8_t globalSyncObj;
252 } Rm_Sync_Obj_Unpadded;
254 /* RM Global Sync Object (padded) */
255 typedef struct
257     /** Data structure without padding, so sizeof() can compute padding */
258     Rm_Sync_Obj_Unpadded obj;
259     /** Pad out to end of RM_MAX_CACHE_ALIGN bytes to prevent something else
260      * from being placed on same cache line as Rm_Synci_Obj.  Note that 
261      * pad[0] is illegal, so must add full RM_MAX_CACHE_ALIGN if structure
262      * is already padded by chance. */
263     uint8_t  pad[RM_MAX_CACHE_ALIGN - 
264                        (sizeof(Rm_Sync_Obj_Unpadded) % RM_MAX_CACHE_ALIGN)];
265 } Rm_Sync_Obj;
268 /* RM Global permissions object definition. (unpadded) */
269 typedef struct 
271     /** Store the QMSS PDSP firmware permissions */
272     Rm_Perms *qmssPdspFirmwarePerms;  
273     /** Store a pointer to the QMSS queue permissions array */
274     Rm_Perms *qmssQueuePerms;
275     /** Store a pointer to the QMSS memory region permissions array */
276     Rm_Perms *qmssMemRegionPerms;
277     /** Store the QMSS Linking RAM Control permissions */
278     Rm_Perms qmssLinkRamControlPerms;
279     /** Store a pointer to the QMSS linking RAM permissions list */
280     Rm_qmssLinkingRamPerms *qmssLinkRamPerms;
281     /** Store a pointer to the QMSS accumulator channel permissions array */
282     Rm_Perms *qmssAccumChPerms;
283     /** Store the QMSS QOS PDSP timer permissions */
284     Rm_Perms qmssQosPdspTimerPerms;      
285     /** Store a pointer to the QMSS QOS cluster permissions array */
286     Rm_Perms *qmssQosClusterPerms;    
287     /** Store a pointer to the QMSS QOS queue permissions array */
288     Rm_Perms *qmssQosQueuePerms;       
289     /** Store the structure of pointers to the CPPI transmit channel permissions array */
290     Rm_CppiChAndFlowPerms cppiTxChPerms;
291     /** Store the structure of pointers to the CPPI receive channel permissions array */
292     Rm_CppiChAndFlowPerms cppiRxChPerms;
293     /** Store the structure of pointers to the CPPI flow permissions array */
294     Rm_CppiChAndFlowPerms cppiFlowPerms;
295     /** Store the PA firmware permissions */
296     Rm_Perms paFirmwarePerms;  
297     /** Store a pointer to the PA lookup table permissions array */
298     Rm_Perms *paLutPerms;    
299 }Rm_GlobalPermissionsObj_Unpadded;
301 /* RM Global Permissions Object (padded) */
302 typedef struct
304     /** Data structure without padding, so sizeof() can compute padding */
305     Rm_GlobalPermissionsObj_Unpadded obj;
306     /** Pad out to end of RM_MAX_CACHE_ALIGN bytes to prevent something else
307      * from being placed on same cache line as Rm_Synci_Obj.  Note that 
308      * pad[0] is illegal, so must add full RM_MAX_CACHE_ALIGN if structure
309      * is already padded by chance. */
310     uint8_t  pad[RM_MAX_CACHE_ALIGN - 
311                        (sizeof(Rm_GlobalPermissionsObj_Unpadded) % RM_MAX_CACHE_ALIGN)];
312 } Rm_GlobalPermissionsObj;
314 extern void Rm_permissionTableInit(void);
315 extern void Rm_setTablePermissions (const Rm_Resource *resourceEntry, Rm_Perms *rmPermsArray, uint32_t len);
316 extern Rm_Result Rm_populatePermissionTable(const Rm_Resource *rmResourceTable);
317 extern void Rm_updatePermissionTable(void);
318 extern Rm_Result Rm_getInitPermissions (Rm_Perms *resourcePermissions);
319 extern Rm_Result Rm_getUsePermissions (Rm_Perms *resourcePermissions);
321 /* Permission checker handlers */
322 extern Rm_Result Rm_initPermissionChecker (Rm_ResourceInfo *resourceData);
323 extern Rm_Result Rm_usePermissionChecker (Rm_ResourceInfo *resourceData);
325 #ifdef __cplusplus
327 #endif
329 #endif /* RM_PVT_H_ */