Fix for SDOCM00107501:Compilation issues observed when compiling with C++
[keystone-rtos/netapi.git] / ti / runtime / netapi / netapi_util.h
1 /******************************************************
2  *  File: netapi_util.h
3  *  Purpose:  misc utilites
4  **************************************************************
5  * FILE: netapi_util.h
6  * 
7  * DESCRIPTION:  netapi utility header file for user space transport
8  *               library
9  * 
10  * REVISION HISTORY:
11  *
12  *  Copyright (c) Texas Instruments Incorporated 2013
13  * 
14  *  Redistribution and use in source and binary forms, with or without 
15  *  modification, are permitted provided that the following conditions 
16  *  are met:
17  *
18  *    Redistributions of source code must retain the above copyright 
19  *    notice, this list of conditions and the following disclaimer.
20  *
21  *    Redistributions in binary form must reproduce the above copyright
22  *    notice, this list of conditions and the following disclaimer in the 
23  *    documentation and/or other materials provided with the   
24  *    distribution.
25  *
26  *    Neither the name of Texas Instruments Incorporated nor the names of
27  *    its contributors may be used to endorse or promote products derived
28  *    from this software without specific prior written permission.
29  *
30  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
31  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
32  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
33  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
34  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
35  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
36  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
37  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
38  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
39  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
40  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
42  *****************************************************/
43 #ifndef __NETAPI_UTIL__H
44 #define __NETAPI_UTIL__H
47 #ifdef __cplusplus
48 extern "C" {
49 #endif
51 #include <stdint.h>
52 #include "./src/netapi_loc.h"
55 //#define NETAPI_DEBUG
56 #ifdef NETAPI_DEBUG
57 #define netapi_Log printf
58 #else
59 #define netapi_Log
60 #endif
62 extern NETAPI_SHM_T* pnetapiShm;
64 /* Wrapper functions around HPLIB APIs for QMSS , *utility to convert virt2phy, phy2virt */
65 #define _Osal_qmssVirtToPhy hplib_mVMVirtToPhy
67 #define _Osal_qmssPhyToVirt hplib_mVMPhyToVirt
69 //static hplib_spinLock_T netapi_util_lock = hplib_spinLock_UNLOCKED_INITIALIZER;
71 /**
72  *  @ingroup netapi_gen_functions
73  *  @brief netapi_registerHeap  API is used to register a heap that is created by application so that
74  *                              it's garbage queue can be polled automatically by @ref netapi_pollHeapGarbage.
75  *
76  *  @details This API registers an application-created heap with the netapi instance
77  *           so that it can add that heap's garbage queue to the garbage poll function. 
78  *           NOTE: netapi internal heap is automatically registered
79  *  @param[in]  p   The NETAPI handle, @ref NETAPI_T
80  *  @param[in]  h   Handle of pklib heap to register
81  *  @retval     1 if OK, <0 on error
82  *  @pre        @ref netapi_init
83  */
84 static inline int netapi_registerHeap(NETAPI_T p,
85                                       Pktlib_HeapHandle h)
86 {
87     NETAPI_HANDLE_T *pp = (NETAPI_HANDLE_T *) p;
88     int i;
89     pp->spinLock.lock(&pnetapiShm->netapi_util_lock);
90     for(i=0;i<TUNE_NETAPI_MAX_HEAPS;i++)
91     {
92         if (!pp->createdHeaps[i])
93         {
94             pp->createdHeaps[i]=h;
95             pp->spinLock.unlock(&pnetapiShm->netapi_util_lock);
96             return 1;
97         }
98     }
99     pp->spinLock.unlock(&pnetapiShm->netapi_util_lock);
100     return -1;
103 /**
104  *  @ingroup netapi_gen_functions
105  *  @brief netapi_unregisterHeap  API is used to un-register a heap that was created by application 
106  *                                and previously registered so that it's garbage queue could  be polled 
107  *                                automatically by @ref netapi_pollHeapGarbage. 
108  *
109  *  @details This API un-registers an application-created heap with the netapi instance. 
110  *           NOTE: netapi internal heap is automatically registered
111  *  @param[in]  p   The NETAPI handle, @ref NETAPI_T
112  *  @param[in]  h   The pklib handle to heap 
113  *  @retval     <0 if err, 1 if OK
114  *  @pre        @ref netapi_init
115  */
116 static inline int netapi_unregisterHeap(NETAPI_T p,
117                                         Pktlib_HeapHandle h)
119     NETAPI_HANDLE_T *pp = (NETAPI_HANDLE_T *) p;
120     int i;
121     pp->spinLock.lock(&pnetapiShm->netapi_util_lock);
122     for(i=0;i<TUNE_NETAPI_MAX_HEAPS;i++)
123     {
124             if (pp->createdHeaps[i] == h)
125             {
126                 pp->createdHeaps[i]=NULL;
127                 pp->spinLock.unlock(&pnetapiShm->netapi_util_lock);
128                 return 1;
129             }
130     }
131     pp->spinLock.unlock(&pnetapiShm->netapi_util_lock);
132     return -1;
135 /**
136  *  @ingroup netapi_gen_functions
137  *  @brief netapi_closeHeap  API is used to remove a created pktlib heap
138  *
139  *  @details This API removes an application-created heap with the netapi instance
140  *           NOTE: descriptors are zapped and cannot be reused]
141  *  @param[in]  p   The NETAPI handle, @ref NETAPI_T
142  *  @param[in]  h :  handle to pklib heap 
143  *  @retval     <0 if err, 1 if OK
144  *  @pre        @ref netapi_init  @ref netapi_registerHeap
145  */
146 static inline int netapi_closeHeap(NETAPI_T p,
147                                    Pktlib_HeapHandle h)
149     Qmss_QueueHnd q;
150     Pktlib_garbageCollection(h);
151     q = Pktlib_getZeroHeapQueue(h);
152     netapip_zapQ(q);
153     q= Pktlib_getInternalHeapQueue(h);
154     netapip_zapQ(q);
156 /**
157  *  @ingroup netapi_gen_functions
158  *  @brief netapi_getCookie  API is used to return a piece of application-provided opaque data that has been
159  *                           stored in the netapi instance.
160  *
161  *  @details The application can save a pointer to opaque data in the @ref NETAPI_T instance.
162  *           This APi lets this data be returned to the application.
163  *  @param[in]  p   The NETAPI handle, @ref NETAPI_T
164  *  @retval     Data provided in @ref netapi_setCookie
165  *  @pre        @ref netapi_init, @ref netapi_setCookie
166  */
168 static inline void * netapi_getCookie(NETAPI_T p)
170     NETAPI_HANDLE_T *pp = (NETAPI_HANDLE_T *) p;
171     return pp->cookie;
174 /**
175  *  @ingroup netapi_gen_functions
176  *  @brief netapi_setCookie  API is used to set a piece of application-provided opaque data t in the netapi instance.
177  *
178  *  @details The applicaiton can save a pointer to opaque data in the @ref NETAPI_T instance.
179  *           Pointer to a opaque data can be returned later to the application via @ref netapi_getCookie
180  *  @param[in]  p   The NETAPI handle, @ref NETAPI_T
181  *  @param[in]  cookie Opaque data to be saved
182  *  @retval     none
183  *  @pre        @ref netapi_init
184  */
185 static inline void netapi_setCookie(NETAPI_T p,
186                                     void * cookie)
188     NETAPI_HANDLE_T *pp = (NETAPI_HANDLE_T *) p;
189     pp->cookie= cookie;
192 /**
193  *  @ingroup netapi_gen_functions
194  *  @brief netapi_getBufMemRemainder  API is used to return the amount of free memory available for
195  *         allocating buffers for additonal Pktlib heaps
196  *
197  *  @details The application can use this API to determine how much free memory is
198  *           available for heap buffers if it decides to create its own.
199  *  @retval     Amount of memory available for heap buffer storage (in bytes)
200  *  @pre        @ref netapi_init 
201  */
202 static inline int  netapi_getBufMemRemainder(void)
204      return hplib_vmGetMemPoolRemainder(0);
207 /**
208  *  @ingroup netapi_gen_functions
209  *  @brief netapi_getDefaultFlow:  API is used to return the default NETCP flow that is to
210  *                                 be used for incoming packets.
211  *
212  *  @details   The application can use this API to return the default NETCP flow that is used
213  *             for received packets. A NETCP flow is a list of PacketLib Heaps that are to be
214  *             used to supply free packets to the receive DMA function.
215  *  @param[in]  p   The NETAPI handle, @ref NETAPI_T
216  *  @retval     NETCP_CFG_FLOW_HANDLE_T     The handle to default flow
217  *  @pre        @ref netapi_init 
218  */
219 static inline NETCP_CFG_FLOW_HANDLE_T netapi_getDefaultFlow(NETAPI_T p)
221     return NETCP_DEFAULT_FLOW;
224 /**
225  *  @ingroup netapi_gen_functions
226  *  @brief netapi_getDefaultRoute:  API is used to return the default NETCP route handle.
227  *
228  *  @details This API returns the default NETCP route created by @ref netapi_init.
229  *           A netcp route consists of a NETCP flow plus a destination pktio channel 
230  *  @param[in]  p   The NETAPI handle, @ref NETAPI_T
231  *  @retval     The handle of the default route, NETCP_CFG_ROUTE_HANDLE_T
232  *  @pre        @ref netapi_init  
233  */
234 static inline NETCP_CFG_ROUTE_HANDLE_T netapi_getDefaultRoute(NETAPI_T p)
236     return NETCP_DEFAULT_ROUTE;
239 /**
240  *  @ingroup cfg_functions
241  *  @brief netapi_netcpCfgGetPolicyUserData    API to retrieve user mode data associated with 
242  *                                             Policy APPID.
243  *
244  *  @details This api is used to retrieve user mode data associated with an Policy APPID
245  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
246  *  @param[in]  app_id  application id whose user mode data is to be retrieved
247  *  @retval void*   pointer to user mode data.
248  *  @pre       @ref netapi_init 
249  */
250 static inline void*  netapi_netcpCfgGetPolicyUserData(NETAPI_T h,
251                                                       NETCP_CFG_SA_T app_id)
253     NETAPI_NWAL_GLOBAL_CONTEXT_T *p = &netapi_get_global()->nwal_context;
254     int slot = netapi_cfgGetMatchId(app_id);
255     if ((slot <0 ) || (slot >= TUNE_NETAPI_MAX_POLICY))
256     {
257         return NULL;
258     }
259     return (p->policy[slot].user_data);
262 /**
263  *  @ingroup cfg_functions
264  *  @brief netapi_netcpCfgGetIpSecUserData    API to retrieve user mode data associated with IPSEC APPID.
265  *
266  *  @details This api is used to retrieve user mode data associated with an IPSEC APPID
267  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
268  *  @param[in]  app_id  application id whose user mode data is to be retrieved
269  *  @retval void*   pointer to user mode data.
270  *  @pre       @ref netapi_init 
271  */
272 static inline void*  netapi_netcpCfgGetIpSecUserData(NETAPI_T h,
273                                                      NETCP_CFG_SA_T app_id)
275     NETAPI_NWAL_GLOBAL_CONTEXT_T *p = &netapi_get_global()->nwal_context;
276     int slot = netapi_cfgGetMatchId(app_id);
277     netapi_Log("netapi_netcpCfgGetIpSecUserData: slot found %d\n", slot);
278     if ((slot <0 ) || (slot >= TUNE_NETAPI_MAX_SA))
279     {
280         return NULL;
281     }
282     netapi_Log("netapi_netcpCfgGetIpSecUserData: user data being returned %d\n",
283         (uint32_t)(p->tunnel[slot].user_data));
284     return (p->tunnel[slot].user_data);
288 /**
289  *  @ingroup cfg_functions
290  *  @brief netapi_netcpCfgGetIpUserData    API to retrieve user mode data associated with Generic IP APPID.
291  *
292  *  @details This api is used to retrieve user mode data associated with a Generic IP APPID
293  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
294  *  @param[in]  app_id  application id whose user mode data is to be retrieved
295  *  @retval void*   pointer to user mode data.
296  *  @pre       @ref netapi_init 
297  */
298 static inline void*  netapi_netcpCfgGetIpUserData(NETAPI_T h,
299                                                   NETCP_CFG_SA_T app_id)
301     NETAPI_NWAL_GLOBAL_CONTEXT_T *p = &netapi_get_global()->nwal_context;
302     int slot = netapi_cfgGetMatchId(app_id);
303     if ((slot <0 ) || (slot >= TUNE_NETAPI_MAX_NUM_IP))
304     {
305         return NULL;
306     }
307     return (p->ips[slot].user_data);
310 /**
311  *  @ingroup cfg_functions
312  *  @brief netapi_netcpCfgGetClassiferUserData  API to retrieve user mode data associated with Classifer APPID.
313  *
314  *  @details This api is used to retrieve user mode data associated with a flassifier APPID
315  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
316  *  @param[in]  app_id  application id whose user mode data is to be retrieved
317  *  @retval void*   pointer to user mode data.
318  *  @pre       @ref netapi_init 
319  */
320 static inline void*  netapi_netcpCfgGetClassiferUserData(NETAPI_T h,
321                                                          NETCP_CFG_SA_T app_id)
323     NETAPI_NWAL_GLOBAL_CONTEXT_T *p = &netapi_get_global()->nwal_context;
324     int slot = netapi_cfgGetMatchId(app_id);
325     if ((slot <0 ) || (slot >= TUNE_NETAPI_MAX_CLASSIFIERS))
326     {
327         return NULL;
328     }
329     return (p->classi[slot].user_data);
333 /**
334  *  @ingroup cfg_functions
335  *  @brief netapi_netcpCfgGetUserData    API to retrieve user mode data associated with APPID.
336  *
337  *  @details This api is used to retrieve user mode data associated with an APPID
338  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
339  *  @param[in]  app_id  application id whose user mode data is to be retrieved
340  *  @retval void*   pointer to user mode data.
341  *  @pre       @ref netapi_init 
342  */
343 static inline void*  netapi_netcpCfgGetUserData(NETAPI_T h,
344                                                 NETCP_CFG_SA_T app_id)
346     NETCP_CFG_SA_T appIdType;
347     NETAPI_NWAL_GLOBAL_CONTEXT_T *p = &netapi_get_global()->nwal_context;
349     appIdType = app_id & 0xff000000;
350     switch(appIdType)
351     {
352         case(NETAPI_NETCP_MATCH_IPSEC):
353             netapi_Log("netapi_netcpCfgGetUserData: ipsec appID found\n");
354             return (netapi_netcpCfgGetIpSecUserData(h, app_id));
355             break;
356         case(NETAPI_NETCP_MATCH_IPSEC_POLICY):
357             netapi_Log("netapi_netcpCfgGetUserData: policy appID found\n");
358             return (netapi_netcpCfgGetPolicyUserData(h, app_id));
359             break;
360         case(NETAPI_NETCP_MATCH_GENERIC_IP):
361             netapi_Log("netapi_netcpCfgGetUserData: IP appID found\n");
362             return (netapi_netcpCfgGetIpUserData(h, app_id));
363             break;
364         case(NETAPI_NETCP_MATCH_CLASS):
365             netapi_Log("netapi_netcpCfgGetUserData: classifier appID found\n");
366             return (netapi_netcpCfgGetClassiferUserData(h, app_id));
367             break;
368         default:
369             return NULL;
370             break;
371     }
374 /**
375  *  @ingroup cfg_functions
376  *  @brief netapi_netcpCfgUpdateUserData    API to update user mode data associated with APPID.
377  *
378  *  @details This api is used to update user mode data associated with an APPID
379  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
380  *  @param[in]  app_id  application id whose user mode data is to updated
381  *  @retval void*   pointer to user mode data.
382  *  @pre       @ref netapi_init 
383  */
384 static inline netapi_RetValue netapi_netcpCfgUpdateUserData(NETAPI_T h,
385                                                             NETCP_CFG_SA_T app_id,
386                                                             void * user_data)
388     NETCP_CFG_SA_T appIdType;
389     NETAPI_NWAL_GLOBAL_CONTEXT_T *p = &netapi_get_global()->nwal_context;
391     int slot = netapi_cfgGetMatchId(app_id);
392     if ((slot <0 ) || (slot >= TUNE_NETAPI_MAX_CLASSIFIERS))
393     {
394         return NETAPI_ERR_BAD_INPUT;
395     }
396     appIdType = app_id & 0xff000000;
397     switch(appIdType)
398     {
399         case(NETAPI_NETCP_MATCH_IPSEC):
400             netapi_Log("netapi_netcpCfgUpdateUserData: ipsec appID found\n");
401             p->tunnel[slot].user_data = user_data;
402             return NETAPI_ERR_OK;
403             break;
404         case(NETAPI_NETCP_MATCH_IPSEC_POLICY):
405             netapi_Log("netapi_netcpCfgUpdateUserData: policy appID found\n");
406             p->policy[slot].user_data = user_data;
407             return NETAPI_ERR_OK;
408             break;
409         case(NETAPI_NETCP_MATCH_GENERIC_IP):
410             netapi_Log("netapi_netcpCfgUpdateUserData: IP appID found\n");
411             p->ips[slot].user_data = user_data;
412             return NETAPI_ERR_OK;
413             break;
414         case(NETAPI_NETCP_MATCH_CLASS):
415             netapi_Log("netapi_netcpCfgUpdateUserData: classifier appID found\n");
416             p->classi[slot].user_data = user_data;
417             return NETAPI_ERR_OK;
418             break;
419         default:
420             return NETAPI_ERR_BAD_INPUT;
421             break;
422     }
425 #ifdef __cplusplus
427 #endif
430 #endif