This commit adds the following:
[keystone-rtos/netapi.git] / ti / runtime / netapi / pktio.h
1 /******************************************************************************
2  * FILE PURPOSE:  Top level interface file for NWAL Module
3  ******************************************************************************
4  * FILE NAME:   pktio.h
5  *
6  * DESCRIPTION: netapi PKTIO module header file
7  *
8  * REVISION HISTORY:
9  *
10  *  Copyright (c) Texas Instruments Incorporated 2013
11  *
12  *  Redistribution and use in source and binary forms, with or without
13  *  modification, are permitted provided that the following conditions
14  *  are met:
15  *
16  *    Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  *
19  *    Redistributions in binary form must reproduce the above copyright
20  *    notice, this list of conditions and the following disclaimer in the
21  *    documentation and/or other materials provided with the
22  *    distribution.
23  *
24  *    Neither the name of Texas Instruments Incorporated nor the names of
25  *    its contributors may be used to endorse or promote products derived
26  *    from this software without specific prior written permission.
27  *
28  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39  *
40  */
42 /**
43  *   @file pktio.h
44  *   @brief pktio module main header file for user space transport library
45  *   @details:  pktio provides an abstraction to H/W queues that are used to transmit and receive packets, 
46  *              IPC messages, etc.  Pktio channels can be created by user but there are also several canned 
47  *              channels available  for NETCP transmit, receive, SA sideband crypto transmit and receive 
48  */
52 #ifndef __PKTIO__H
53 #define __PKTIO__H
54 #include "netapi.h"
55 #include "ti/drv/nwal/nwal.h"
56 #include "ti/drv/nwal/nwal_util.h"
58 /**
59  * @def NETCP_TX
60  * @ingroup pktio_constants
61  *      This defines the default PKTIO NETCP transmit channel name
62  */
63 #define NETCP_TX "NETCP_TX"
65 /**
66  * @def NETCP_RX
67  * @ingroup pktio_constants
68  * @brief This defines the default PKTIO NETCP receive channel name
69  */
70 #define NETCP_RX "NETCP_RX"
72 /**
73  * @def NETCP_SB_RX
74  * @ingroup pktio_constants
75  * @brief This defines the PKTIO NETCP-SA receive SIDEBAND channel name.
76           This channel is used to receive the results from sideband crypto operations
77  */
78 #define NETCP_SB_RX "NETCP_SB_RX"
80 /**
81  * @def NETCP_SB_TX
82  * @ingroup pktio_constants
83  * @brief This defines the PKTIO NETCP-SA transmit SIDEBAND channel name.
84           This channel is used to send packets for sideband crypto operations
85  */
86 #define NETCP_SB_TX "NETCP_SB_TX"
88 /**
89  * @def PKTIO_MAX_NAME
90  * @ingroup pktio_constants
91  *      This defines the maximum length of a pktio channel name
92  */
93 #define PKTIO_MAX_NAME 19
95 /**
96  *  @ingroup pktio_structures
97  *  @brief PKTIO meta data information .
98  *
99  *  @details PKTIO meta data information. meta data is used to convey the results of NETCP pre-processing on receive packets and to tell NETCP what functions to perform on transmitted packets. It is a union of sub-structures (one for TX, one for RX, one for sideband rx, one for sideband tx).
100  */
101 typedef struct PKTIO_METADATA_Tag
104     int flags1;     /**< Configuration flags for PKTIO channel, @ref PKTIO_META_RX,
105                                                                 @ref PKTIO_META_TX,
106                                                                 @ref PKTIO_META_SB_RX,
107                                                                 @ref PKTIO_META_SB_TX*/
109 /**
110  * @def PKTIO_META_RX
111  * @ingroup pktio_constants
112  *      This defines the PKTIO NETCP receive INFLOW channel
113  */
114 #define PKTIO_META_RX 0x01
116 /**
117  * @def PKTIO_META_TX
118  * @ingroup pktio_constants
119  *      This defines the PKTIO NETCP transmit INFLOW channel
120  */
121 #define PKTIO_META_TX 0x02
123 /**
124  * @def PKTIO_META_SB_RX
125  * @ingroup pktio_constants
126  *      This defines the PKTIO NETCP SIDEBAND channel channel
127  */
128 #define PKTIO_META_SB_RX 0x4
130 /**
131  * @def PKTIO_META_SB_TX
132  * @ingroup pktio_constants
133  *      This defines the PKTIO NETCP transmit SIDEBAND channel
134  */
135 #define PKTIO_META_SB_TX 0x8
138 /**
139  * @def PKTIO_META_IFDMA_TX
140  * @ingroup pktio_constants
141  *      This defines the PKTIO NETCP infrastructure DMA transfer channel
142  */
143 #define PKTIO_META_IFDMA_TX 0x10
145 /**
146  * @def PKTIO_META_APP_DEF
147  * @ingroup pktio_constants
148  *      This allows user space application to define custom packet types.
149  */
150 #define PKTIO_META_APP_DEF 0x80000000
152 /**
153  * @brief NWAL Packet meta data information
154  */
155     union
156     {
157         nwalRxPktInfo_t*        rx_meta;          /**< NWAL Packet meta data information for incoming packet */
158         nwalTxPktInfo_t*        tx_meta;          /**< NWAL Packet meta data information for outgoing packet */
159         nwalDmRxPayloadInfo_t*  rx_sb_meta;       /**<NWAL Data mode meta data payload information from NetCP */
160         nwalDmTxPayloadInfo_t*  tx_sb_meta;       /**< NWAL Data Mode Payload information for packet to SA */
161         unsigned int            tx_ifdma_dest;    /**< infrastructure dma destination flow */
162     } u;                                          /**< union NWAL Packet meta data information  */
164     void * sa_handle;                       /**< This contains the appplication id associated with created SA.
165                                             details This is used when crypto is to be performed on the 
166                                             egress packet */
167 } PKTIO_METADATA_T;
169 /**
170  *  @ingroup pktio_structures
171  *  @brief PKTIO fast path configuration structure.
172  *
173  *  @details This strucuture allows user space applications to specify the PKTIO packet send function.
174  *
175  *  @note This configuration is not expected at time of @ref netapi_pktioOpen but can be updated via
176  *        @ref netapi_pktioControl API.
177  */
178 typedef struct PKTIO_FAST_PATH_CONFIG_Tag
180     int               fp_send_option;  /**< PKTIO_FP_NONE, @ref PKTIO_FP_NO_CRYPTO_NO_CKSUM_PORT,
181                                         PKTIO_FP_L4CKSUM_PORT, @ref PKTIO_FP_ESP_L4CKSUM_PORT,
182                                         @ref PKTIO_FP_AH_L4CKSUM_PORT, @ref PKTIO_FP_ESP_PORT, 
183                                         @ref PKTIO_FP_AH_PORT */
185 /**
186  * @def PKTIO_FP_NONE
187  * @ingroup pktio_constants
188  *      Use this define to reconfigure the PKTIO channel send function to not use any PKTIO fast path
189         send functions.
190  */
191 #define  PKTIO_FP_NONE 0
193 /**
194  * @def PKTIO_FP_NO_CRYPTO_NO_CKSUM_PORT
195  * @ingroup pktio_constants
196  *      Use this define to send packet with updates to ENET port, no crypto operation,
197  *      no L4 checksum to be performed.
198  */
199 #define  PKTIO_FP_NO_CRYPTO_NO_CKSUM_PORT 1
201 /**
202  * @def PKTIO_FP_L4CKSUM_PORT
203  * @ingroup pktio_constants
204  *      Use this define to send packet with updates to L4 checksum, ENET port, no crypto operation
205  *      to be performed.
206  */
207 #define  PKTIO_FP_L4CKSUM_PORT 2
209 /**
210  * @def PKTIO_FP_ESP_L4CKSUM_PORT
211  * @ingroup pktio_constants
212  *      Use this define to send packet with Crypto ESP, UDP checksum, updates to ENET port
213  */
214 #define  PKTIO_FP_ESP_L4CKSUM_PORT 3
216 /**
217  * @def PKTIO_FP_AH_L4CKSUM_PORT
218   * @ingroup pktio_constants
219  *      Use this define to send packet with Cypto AH, UDP checksum, updates to ENET port
220  */
221 #define  PKTIO_FP_AH_L4CKSUM_PORT 4
223 /**
224  * @def PKTIO_FP_ESP_PORT
225  * @ingroup pktio_constants
226  *      Use this define to send packet with Crypto ESP packet
227  */
228 #define  PKTIO_FP_ESP_PORT 5
230 /**
231  * @def PKTIO_FP_AH_PORT
232  * @ingroup pktio_constants
233  *      Use this define to send packet with AH packet
234  */
235 #define  PKTIO_FP_AH_PORT 6
237     nwalTxPktInfo_t   *txPktInfo;  /** <The parameters in this structure are used to 
238                                          provide additional details for the outgoing packet*/
239 } PKTIO_FAST_PATH_CONFIG_T;
243 struct PKTIO_HANDLE_tag;
244 /**
245  *  @ingroup pktio_structures
246  *  @brief PKTIO configuration information
247  *
248  *  @details PKTIO :q information
249  */
250 typedef struct PKTIO_CFG_Tag
252 /**
253  * @def PKTIO_RX
254  * @ingroup pktio_constants
255  *      This defines the pktio channel as type read, i.e., for ingress
256  */
257 #define PKTIO_RX 0x1
259 /**
260  * @def PKTIO_TX
261  * @ingroup pktio_constants
262  *      This defines the pktio channel as type write, i.e. for egress
263  */
264 #define PKTIO_TX 0x2
266 /**
267  * @def PKTIO_RX_TX
268  * @ingroup pktio_constants
269  *      This defines the pktio channel as type read/write 
270  */
271 #define PKTIO_RX_TX (PKTIO_RX | PKTIO_TX)
273 /**
274  * Flags for PKTIO channel configuration
275  * <br>
276  * The following are flags used to configure the pktio channel:
277  *      @ref PKTIO_RX , @ref PKTIO_TX, @ref PKTIO_RX_TX
278  */
279     int flags1; 
281 /**
282  * @def PKTIO_GLOBAL
283  * @ingroup pktio_constants
284  *      This defines the pktio channel as type global. 
285         Type global means that this channel can be used by all worker threads/cores
286  */
287 #define PKTIO_GLOBAL 0x1
289 /**
290  * @def PKTIO_LOCAL
291  * @ingroup pktio_constants
292  *      This defines the pktio channel as type local.
293         Type local means that thi s channel can only be used by the the thread/core that created it; 
294         its name will not be visible to other threads/cores
295  */
296 #define PKTIO_LOCAL  0x2
298 /**
299  * @def PKTIO_PKT
300  * @ingroup pktio_constants
301  *      This defines the pktio channel is for NETCP
302  */
303 #define PKTIO_PKT    0x4
305 /**
306  * @def PKTIO_SB
307  * @ingroup pktio_constants
308  *      This defines the pktio channel is for sideband crypto
309  */
310 #define PKTIO_SB     0x8
311 #define PKTIO_IFDMA  0x10  //define this if this channel is for ifrastructure dma  
312     int flags2; /**< Flags for PKTIO channel configuration, @ref PKTIO_LOCAL , @ref PKTIO_GLOBAL, 
313                     @ref PKTIO_PKT, @ref PKTIO_SB*/
315 /**
316  * @def PKTIO_Q_ANY
317  * @ingroup pktio_constants
318  *      This defines the pktio IO queue number to be specified by the transport library. 
319  */
320 #define PKTIO_Q_ANY QMSS_PARAM_NOT_SPECIFIED
322     int qnum;       /**< PKTIO channel queue number */
323     int max_n;      /**< Maximum number of packets read in 1 poll */
324     PKTIO_FAST_PATH_CONFIG_T fast_path_cfg;  /** < @ref PKTIO_FAST_PATH_CONFIG_T */
325 } PKTIO_CFG_T;
328 /**
329  *  @ingroup pktio_structures
330  *  @brief PKTIO polling control struct, currently NOT_IMPLEMENTED
331  *
332  *  @details PKTIO polling control struct, currently NOT_IMPLEMENTED
333  */
334 typedef struct PKTIO_POLL_Tag
336 } PKTIO_POLL_T;
338 /**
339  *  @ingroup netapi_cb_functions
340  *  @brief PKTIO_CB   Callback function to be issued on packet receive
341  * 
342  *  @details The application provides a callback function that gets invoked on packet receive
343  *  @param[in]  channel     The PKTIO channel handle, @ref PKTIO_HANDLE_T
344  *  @param[in]  p_recv      Pointer to the packets received.
345  *  @param[in]  p_meta      Pointer to meta data associated with packet, @ref PKTIO_METADATA_T
346  *  @param[in]  n_pkts      Number of packets received.
347   * @param[in]  ts          Timestamp associted with received packets.
348  *  @retval     none
349  *  @pre       @ref netapi_pktioOpen
350  */
351 typedef void (*PKTIO_CB)(struct PKTIO_HANDLE_tag* channel,
352                          Ti_Pkt*                  p_recv[],
353                          PKTIO_METADATA_T         p_meta[],
354                          int                      n_pkts,
355                          uint64_t                 ts);
357 /**
358  *  @ingroup pktio_functions
359  *  @brief PKTIO_SEND   PKTIO specific send function
360  * 
361  *  @details The application calls this PKTIO specific send function to transmit packet
362  *  @param[in]  channel         The PKTIO channel handle, @ref PKTIO_HANDLE_T
363  *  @param[in]  p_send          Pointer to the packet to send
364  *  @param[in]  p_meta          Pointer to meta data associated with packet, @ref PKTIO_METADATA_T
365  *  @param[out] p_err             Pointer to error code.
366  *  @retval     none 
367  *  @pre       @ref netapi_pktioOpen
368  */
369 typedef int (*PKTIO_SEND)(struct PKTIO_HANDLE_tag * channel,
370                           Ti_Pkt*                   p_send,
371                           PKTIO_METADATA_T*         p_meta,
372                           int*                      p_err);
375 /**
376  *  @ingroup pktio_functions
377  *  @brief PKTIO_POLL   PKTIO specific poll function
378  * 
379  *  @details The application calls this PKTIO specific POLL function
380  *  @param[in]  channel     The PKTIO channel handle, @ref PKTIO_HANDLE_T
381  *  @param[in]  p_poll_cfg  @ref PKTIO_POLL_T, currently NOT_IMPLEMENTED
382  *  @param[out] p_err       Pointer to error code.
383  *  @retval     none 
384  *  @pre       @ref netapi_pktioOpen
385  */
386 typedef int (*PKTIO_POLL)(struct PKTIO_HANDLE_tag * channel,
387                           PKTIO_POLL_T*             p_poll_cfg,
388                           int*                      p_err);
391 /**
392  * @brief This defines an unused packet io channel slot
393  */
394 #define PKTIO_NA 0
397 struct NETAPI_tag;
399 /**
400  *  @ingroup pktio_structures
401  *  @brief PKTIO handle structure definition.
402  *
403  *  @details PKTIO handle strucutre which is returned from call to @ref netapi_pktioCreate
404  */
405 typedef struct PKTIO_HANDLE_Tag
407 /**
408  * @def PKTIO_INUSE
409  * @ingroup pktio_constants
410  *      This defines whether the pktio channel entry is valid.
411  */
412 #define PKTIO_INUSE 0xfeedfeed
414     int inuse;                      /**<true is pktio channel is in use  */
416 /**
417  * Set the "use_nwal" field to one of the defines listed below.
418  * <br>
419  * The following defines are used to populate the use_nwal field:
420  *      @ref PKTIO_4_IPC , @ref PKTIO_4_ADJ_NWAL, @ref PKTIO_DEF_NWAL. @ref PKTIO_4_ADJ_SB., @ref PKTIO_DEF_SB
421  */
422     int use_nwal;                  
424 /**
425  * @def PKTIO_4_IPC
426  * @ingroup pktio_constants
427  *      This define is for channels used for IPC between cores
428  */
429 #define  PKTIO_4_IPC 0
431 /**
432  * @def PKTIO_4_ADJ_NWAL
433  * @ingroup pktio_constants
434  *      This define is for NETCP (RX) channels whose associated queues are managed by NWAL
435  */
436 #define  PKTIO_4_ADJ_NWAL 1
438 /**
439  * @def PKTIO_DEF_NWAL
440  * @ingroup pktio_constants
441  *      This define is for NETCP channels that are tied to the default NWAL RX/TX queues
442  */
443 #define  PKTIO_DEF_NWAL 2
445 /**
446  * @def PKTIO_4_ADJ_SB
447  *      This define is for (RX) channels used to get crypto side band results via application managed queues
448  * @ingroup pktio_constants
449  */
450 #define  PKTIO_4_ADJ_SB 3
452 /**
453  * @def PKTIO_DEF_SB
454  * @ingroup pktio_constants
455  *      This define is for channels tied to the default crypto side band  queues
456  */
457 #define  PKTIO_DEF_SB 4
459     struct NETAPI_tag * back;           /**< back handle  to NETPAI instance */
460     void * nwalInstanceHandle;          /**<save here for conveninece  this is the nwal handle set at init time*/
461     PKTIO_CB cb;                        /**< callback for channel (for Rx) */
462     PKTIO_CFG_T cfg;                    /**<configuration  of channel */
463     Qmss_QueueHnd q;                    /**<the associated queue handle for channel */
464     Qmss_Queue qInfo;                   /**<and its qm#/q# */
465     int max_n;                          /**<max # of pkts to read in one poll */
466     void * cookie;                      /**<app specific */
467     PKTIO_SEND _send;                   /**<pktio type specific send function */
468     PKTIO_POLL _poll;                   /**<pktio type specific POLL function */
469     int poll_flags;                     /**< pktio flags to control polling options */
470     char name[PKTIO_MAX_NAME+1];        /**< Name of pktio channel */
471     Cppi_Handle             cppiHnd;    /* < cppi handle */
472     Cppi_ChHnd              rxChHnd;    /* < cppi receive channel handle */
473     Cppi_ChHnd              txChHnd;    /* < cppi transmit channe handle */
474     nwalTxPSCmdInfo_t tx_psCmdInfo; /**<Command Label to be sent to NetCP for the packet flow */
475 }  PKTIO_HANDLE_T;
478 /**
479  *  @ingroup pktio_structures
480  *  @brief PKTIO control structure 
481  *
482  *  @details PKTIO control stucture for the control API. Allows operations on pktio channel such as CLEAR ,  DIVERT, etc
483  */
484 typedef struct PKTIO_CONTROL_Tag
486 /**
487  * @def PKTIO_CLEAR
488  *      This defines is used to clear out the pktio channel
489  */
490 #define PKTIO_CLEAR 0x1
492 // @cond NOT_IMPLEMENTED
493 /**
494  * @def PKTIO_DIVERT
495  *      This define is used to divert to a dest pktio channel 
496  */
497 #define PKTIO_DIVERT 0x2
498 /// @endcond
500 /**
501  * @def PKTIO_SET_POLL_FLAGS
502  *      This define is used to set poll flags for a pktio channel
503  */
504 #define PKTIO_SET_POLL_FLAGS 0x4 //control poll flags (netcp_rx only)
505 /**
506  * @def PKTIO_UPDATE_FAST_PATH
507  *      This define is used to update the command information template for 
508  *      INFLOW mode of operation of a ptktio channel (netcp_tx only)
509  */
510 #define PKTIO_UPDATE_FAST_PATH 0x8
512 /**<max # of pkts to read in one poll */
513 /**
514  * @def PKTIO_UPDATE_MAX_PKTS_PER_POLL
515  *      This define is used to update the maximum number of packets to read in 1 poll
516  *      period for the pktio channel.
517  */
518 #define PKTIO_UPDATE_MAX_PKTS_PER_POLL 0x10
520     int op;                 /**< Control operation (CLEAR, DIVERT, ..) */
521     PKTIO_HANDLE_T *dest;   /**< Handle to PKTIO channel (for DIVERT) */
522     int poll_flags;         /**< Flags to indicate polling options */
523 } PKTIO_CONTROL_T;
525 /**
526  *  @ingroup pktio_functions
527  *  @brief API creates a NETAPI PKTIO channel 
528  *
529  *  @details This assigns global resources to a NETAPI pktio channel.
530  *   Once created, the channel can be used to send and/or receive
531  *   a Ti_Pkt. This can be used for communication with the
532  *   the Network co-processor (NETCP) or for internal inter-processor
533  *   communication. The channel is saved under the assigned name
534  *   and can be opened by other netapi threads instances.
535  *  @param[in]  netapi_handle   The NETAPI handle, @ref NETAPI_T 
536  *  @param[in]  name            A pointer to the char string name for channel
537  *  @param[in]  cb              Callback to be issued on packet receive, @ref PKTIO_CB
538  *  @param[in]  p_cfg           Pointer to channel configuration, @ref PKTIO_CFG_T
539  *  @param[out] err             Pointer to error code.
540  *  @retval     Handle to the pktio instance or NULL on error, @ref PKTIO_HANDLE_T
541  *  @pre       @ref netapi_init 
542  */
543 PKTIO_HANDLE_T * netapi_pktioCreate(NETAPI_T        netapi_handle,
544                                     char*           name,
545                                     PKTIO_CB        cb,
546                                     PKTIO_CFG_T*    p_cfg,
547                                     int*            err);
549 /**
550  *  @ingroup pktio_functions
551  *  @brief API opens an existing  NETAPI PKTIO channel
552  *
553  *  @details This opens an NETAPI pktio channel for use. The channel
554  *  must have already been created via @ref netapi_pktioCreate or may have
555  *  been created internally during the netapi intialization.
556  *   Once opened, the channel can be used to send and/or receive
557  *   a Ti_Pkt. This can be used for communication with the 
558  *   the Network co-processor (NETCP) or for internal inter-processor
559  *   communication. 
560  *
561  *  @param[in]  netapi_handle   The NETAPI handle, @ref NETAPI_T 
562  *  @param[in]  name            A pointer to the char string name for channel to open
563  *  @param[in]  cb              Callback to be issued on packet receive, @ref PKTIO_CB
564  *  @param[in]  p_cfg           Pointer to channel configuration, @ref PKTIO_CFG_T
565  *  @param[out] err             Pointer to error code.
566  *  @retval     Handle to the pktio instance or NULL on error, @ref PKTIO_HANDLE_T
567  *  @pre       @ref netapi_init, @ref netapi_pktioCreate
568  */
569 PKTIO_HANDLE_T * netapi_pktioOpen(NETAPI_T      netapi_handle, 
570                                  char*          name,
571                                  PKTIO_CB       cb,
572                                  PKTIO_CFG_T*   p_cfg,
573                                  int*           err);
575 /**
576  *  @ingroup pktio_functions
577  *  @brief API controls an existing NETAPI PKTIO channel
578  *
579  *  @details This controls an opened pktio channel
580  *
581  *  @param[in]  handle      The PKTIO channel handle, @ref PKTIO_HANDLE_T
582  *  @param[in]  cb          Callback to be issued on packet receive, @ref PKTIO_CB
583  *  @param[in]  p_cfg       Pointer to channel configuration which (optional), @ref PKTIO_CFG_T
584  *  @param[in]  p_control   Pointer to PKTIO control information (optional), @ref PKTIO_CONTROL_T
585  *  @param[out] err         Pointer to error code.
586  *  @retval     none
587  *  @pre       @ref netapi_init, @ref netapi_pktioCreate, @ref netapi_pktioOpen
588  */
589 void netapi_pktioControl(PKTIO_HANDLE_T*    handle,
590                          PKTIO_CB           cb,
591                          PKTIO_CFG_T*       p_cfg,
592                          PKTIO_CONTROL_T*   p_control,
593                          int*               err);
595 /**
596  *  @ingroup pktio_functions
597  *  @brief API closes a NETAPI PKTIO channel
598  *
599  *  @details This closes a PKTIO channel
600  *
601  *  @param[in]  handle  The PKTIO channel handle, @ref PKTIO_HANDLE_T
602  *  @param[out] err    Pointer to error code.
603  *  @retval     none
604  *  @pre       @ref netapi_init, @ref netapi_pktioCreate, @ref netapi_pktioOpen
605  */
606 void netapi_pktioClose(PKTIO_HANDLE_T*  handle,
607                        int*             err);
609 /**
610  *  @ingroup pktio_functions
611  *  @brief API deletes a NETAPI PKTIO channel
612  *
613  *  @details This deletes a PKTIO channel
614  *
615  *  @param[in]  handle  The PKTIO  handle, @ref PKTIO_HANDLE_T
616  *  @param[out] err     Pointer to error code.
617  *  @retval     none
618  *  @pre       @ref netapi_init, @ref netapi_pktioCreate, @ref netapi_pktioOpen
619  */
620 void netapi_pktioDelete(PKTIO_HANDLE_T* handle,
621                         int*            err);
623 /**
624  *  @ingroup pktio_functions
625  *  @brief  API sends a packet to a NETAPI PKTIO channel 
626  *
627  *  @details This sends a Ti_Pkt and associated meta data, 
628  *  @ref PKTIO_METADATA_T to a channel. The channel
629  *  must have already been created via @ref netapi_pktioCreate or opened
630  *  via @ref netapi_pktioOpen.  It  may have
631  *  been created internally during the netapi intialization.
632  *  @param[in]  handle  The PKTIO channel handle, @ref PKTIO_HANDLE_T
633  *  @param[in]  pkt     Pointer to the packet to send
634  *  @param[in]  m       Pointer to meta data associated with packet, @ref PKTIO_METADATA_T
635  *  @param[out] err     Pointer to error code.
636  *  @retval     1 if packet sent, 0 if error 
637  *  @pre       @ref netapi_init, @ref netapi_pktioCreate, @ref netapi_pktioOpen
638  */
639 static inline int  netapi_pktioSend(PKTIO_HANDLE_T*   handle,
640                                     Ti_Pkt*           pkt,
641                                     PKTIO_METADATA_T* m,
642                                     int*              err)
644    return handle->_send((struct PKTIO_HANDLE_tag *)handle, pkt, m, err);
647 /**
648  *  @ingroup pktio_functions
649  *  @brief API sends multiple packets to a NETAPI PKTIO channel
650  *
651  *  @details This sends an array of Ti_Pkt and associated meta data,
652  *  @ref PKTIO_METADATA_T to a channel. The channel
653  *  must have already been created via @ref netapi_pktioCreate or opened
654  *  via @ref netapi_pktioOpen.  It  may have
655  *  been created internally during the netapi intialization.
656  *  @param[in]  handle  The PKTIO channel handle, @ref PKTIO_HANDLE_T
657  *  @param[in]  pkt     Pointer to the packet to send
658  *  @param[in]  m       Pointer to meta data associated with packet, @ref PKTIO_METADATA_T
659  *  @param[in]  np      The number of packets in list to send
660  *  @param[out] err     Pointer to error code.
661  *  @retval             Number of packets sent, 0 if error
662  *  @pre       @ref netapi_init, @ref netapi_pktioCreate, @ref netapi_pktioOpen
663  */
664 int netapi_pktioSendMulti(PKTIO_HANDLE_T*   handle,
665                           Ti_Pkt*           pkt[],
666                           PKTIO_METADATA_T* m[],
667                           int               np,
668                           int*              err);
670 /**
671  *  @ingroup pktio_functions
672  *  @brief  API polls a NETAPI PKTIO channel for received packets 
673  *
674  *  @details This api polls a pktio channel. Any pending data in the channel is
675  *  passed to the @ref  PKTIO_CB registered when the channel was
676  *  created or opened. The channel must
677  *  have already been created via @ref netapi_pktioCreate or opened
678  *  via @ref netapi_pktioOpen.  It  may have
679  *  been created internally during the netapi intialization.
680  *  @param[in]  handle      The PKTIO channel handle, @ref PKTIO_HANDLE_T
681  *  @param[in]  p_poll_cfg  Pointer to pktio poll configuration. @ref PKTIO_POLL_T
682  *  @param[out] err         Pointer to error code.
683  *  @retval                 Number of packets received by poll 
684  *  @pre       @ref netapi_init, @ref netapi_pktioCreate, @ref netapi_pktioOpen
685  */
686 static inline int netapi_pktioPoll(PKTIO_HANDLE_T* handle,
687                                    PKTIO_POLL_T*   p_poll_cfg,
688                                    int*            err)
690     return handle->_poll((struct PKTIO_HANDLE_tag *) handle, p_poll_cfg, err);
693 /**
694  *  @ingroup pktio_functions
695  *  @brief API polls all NETAPI PKTIO channels associated with @ref NETAPI_T instance
696  *         for received packets
697  *
698  *  @details This api polls all pktio channels attached to an instance.
699  *  Any pending data in these channels are 
700  *  passed to the @ref  PKTIO_CB registered when the channel was
701  *  created or opened. The channels  must
702  *  have already been created via @ref netapi_pktioCreate or opened
703  *  via @ref netapi_pktioOpen.  They may have
704  *  been created internally during the netapi intialization.
705  *  @param[in]  handle      The PKTIO channel handle, @ref PKTIO_HANDLE_T
706  *  @param[in]  p_poll_cfg  Pointer to pktio poll configuration. @ref PKTIO_POLL_T
707  *  @param[out] err         Pointer to error code.
708  *  @retval                 Number of packets received by poll 
709  *  @pre       @ref netapi_init, @ref netapi_pktioCreate, @ref netapi_pktioOpen
710  */
711 int netapi_pktioPollAll(NETAPI_T        handle, 
712                         PKTIO_POLL_T*   p_poll_cfg, 
713                         int*            err);
716 /**
717  * @brief This define sets the max number of pkts to read in one poll in the @ref PKTIO_HANDLE_T
718  */
719 #define netapi_pktioSetMaxN(handle,max_n) (handle)->max_n=max_n;
721 /**
722  * @brief This define returns NETAPI handle stored in the @ref PKTIO_HANDLE_T
723  */
724 #define netapi_pktioGetNetapiHandle(handle) (handle)->back
727 /**
728  * @brief This define sets a user space application cookie in the @ref PKTIO_HANDLE_T
729  */
730 #define netapi_pktioSetCookie(handle, cookie) (handle)->cookie = cookie
732 /**
733  * @brief This define returns a previously set user space application cookie stored in the @ref PKTIO_HANDLE_T
734  */
735 #define netapi_pktioGetCookie(handle) (handle)->cookie
737 /**
738  * @brief This define returns a associate queue handle stored in the @ref PKTIO_HANDLE_T
739  */
740 #define netapi_pktioGetQ(handle) (handle)->q
742 /*-----------------Extra Fast Path pkt meta data macros--------------------*/
743 #include "cppi_desc.h"
744 #include "ti/drv/pa/pa.h"
745 #include "ti/drv/pa/pasahost.h"
748 /**
749  *  @ingroup pktio_functions
750  *  @brief  API returns default packet queue to poll for netcp RX
751  *  @note: these are expensive calls, so call once and save
752  */
753 static inline Qmss_QueueHnd pktio_mGetDefaultNetCpQ(PKTIO_HANDLE_T *h)
755     nwalGlobCxtInfo_t Info;
756     nwal_getGlobCxtInfo(h->nwalInstanceHandle,&Info);
757     return Info.rxDefPktQ;
761 /**
762  *  @ingroup pktio_functions
763  *  @brief  API returns L4Queue to poll for netcp RX (L4 classifier queue).
764  *  @note: these are expensive calls, so call once and save
765  */
766 static inline Qmss_QueueHnd pktio_mGetDefaultNetCPL4Q(PKTIO_HANDLE_T *h)
768     nwalLocCxtInfo_t Info;
769     nwal_getLocCxtInfo(h->nwalInstanceHandle,&Info);
770     return Info.rxL4PktQ;
774 /**
775  *  @ingroup pktio_functions
776  *  @brief  API to perform descriptor push to QMSS Queue
777  */
778 static inline void pktio_mQmssQueuePushDescSizeRaw(Qmss_QueueHnd    hnd,
779                                                    void*            descAddr,
780                                                    uint32_t         descSize)
782     return(Qmss_queuePushDescSizeRaw(hnd,descAddr,descSize));
785 /**
786  *  @ingroup pktio_functions
787  *  @brief  API to perform descriptor pop from QMSS Queue
788  */
789 static inline void* pktio_mQmssQueuePopRaw(Qmss_QueueHnd hnd)
791     return(Qmss_queuePopRaw(hnd));
794 /**
795  *  @ingroup pktio_functions
796  *  @brief  API to retrieve NWAL global instance handle.
797  */
798 static inline nwal_Inst pktio_mGetNwalInstance(PKTIO_HANDLE_T *h)
800     return h->nwalInstanceHandle;
804 #endif