Additional doxygen updates
[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 2010-2011
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  */
41 /* ============================================================= */
43 /**
44  *   @file pktio.h
45  *   @brief pktio module main header file for user space transport library
46  *   @details:  pktio provides an abstraction to H/W queues that are used to transmit and receive packets, IPC messages, etc.  Pktio channels can be created by user but there are also several canned channels available  for NETCP transmit, receive, SA sideband crypto transmit and receive 
47  */
51 #ifndef __PKTIO__H
52 #define __PKTIO__H
53 #include "netapi.h"
54 #include "ti/runtime/pktlib/pktlib.h"
55 #include "ti/drv/nwal/nwal.h"
56 #include "ti/drv/nwal/nwal_util.h"
57 #include "netapi_err.h"
59 /*--------------------defines-----------------------*/
61 /**
62  * @def PKTIO_NOMEM
63  * @ingroup pktio_constants
64  *      This define is used to indicate out of memory to user space application 
65  */
66 #define PKTIO_NOMEM  NETAPI_ERR_NOMEM
68 /**
69  * @def NETCP_TX
70  * @ingroup pktio_constants
71  *      This defines the pktio NETCP transmit  channel name
72  */
73 #define NETCP_TX "NETCP_TX"
75 /**
76  * @def NETCP_RX
77  * @ingroup pktio_constants
78  *      This defines the pktio NETCP receive channel name
79  */
80 #define NETCP_RX "NETCP_RX"
82 /**
83  * @def NETCP_SB_RX
84  * @ingroup pktio_constants
85  *      This defines the pktio NETCP-SA receive SIDEBAND channel name
86  */
87 #define NETCP_SB_RX "NETCP_SB_RX"
89 /**
90  * @def NETCP_SB_TX
91  * @ingroup pktio_constants
92  *      This defines the pktio NETCP-SA transmit SIDEBAND channel name
93  */
94 #define NETCP_SB_TX "NETCP_SB_TX"
96 /**
97  * @def PKTIO_MAX_NAME
98  * @ingroup pktio_constants
99  *      This defines the maximum length of a pktio channel name
100  */
101 #define PKTIO_MAX_NAME 19  
103 /**
104  *  @ingroup pktio_structures
105  *  @brief PKTIO meta data information .
106  *
107  *  @details PKTIO meta data information TBD
108  */
109 typedef struct PKTIO_METADATA_Tag
111 /**
112  * Flags for PKTIO Meta Data configuration
113  * <br>
114  * valid flag1 parameters are as follows:
115  *      @ref PKTIO_META_RX , @ref PKTIO_META_TX, @ref PKTIO_META_SB_RX, @ref PKTIO_META_SB_TX
116  */
117     int flags1; 
119 /**
120  * @def PKTIO_META_RX
121  * @ingroup pktio_constants
122  *      This defines the pktio NETCP receive INFLOW channel
123  */
124 #define PKTIO_META_RX 0x01
126 /**
127  * @def PKTIO_META_TX
128  * @ingroup pktio_constants
129  *      This defines the pktio NETCP transmit INFLOW channel
130  */
131 #define PKTIO_META_TX 0x02
133 /**
134  * @def PKTIO_META_SB_RX
135  * @ingroup pktio_constants
136  *      This defines the pktio NETCP SIDEBAND channel channel
137  */
138 #define PKTIO_META_SB_RX 0x4  /**< SB crypto rx */
140 /**
141  * @def PKTIO_META_SB_TX
142  * @ingroup pktio_constants
143  *      This defines the pktio NETCP transmit SIDEBAND channel
144  */
145 #define PKTIO_META_SB_TX 0x8  /** <SB crypto tx */
147 /**
148  * @def PKTIO_META_APP_DEF
149  * @ingroup pktio_constants
150  *      TBD- is this part of flags2?
151  */
152 #define PKTIO_META_APP_DEF 0x80000000
154 /**
155  * @brief NWAL Packet meta data information
156  */
157     union
158     {
159         nwalRxPktInfo_t * rx_meta;          /**< NWAL Packet meta data information for incoming packet */
160         nwalTxPktInfo_t * tx_meta;          /**< NWAL Packet meta data information for outgoing packet */
161         nwalDmRxPayloadInfo_t * rx_sb_meta; /**<NWAL Data mode meta data payload information from NetCP */
162         nwalDmTxPayloadInfo_t * tx_sb_meta; /**< NWAL Data Mode Payload information for packet to SA */
163     } u;                                    /**< union NWAL Packet meta data information  */
165 /**
166  * @brief valid for PKTIO_META_TX with IPSEC inflow or PKTIO_PKTIO_META_SB_TX MUST BE nwal_HANDLE_INVALID otherwise
167  */
168     void * sa_handle;
169 } PKTIO_METADATA_T;
171 /* the callback function */
172 struct PKTIO_HANDLE_tag;
174 /**
175  *  @ingroup pktio_structures
176  *  @brief PKTIO polling control struct FUTURE- TBD
177  *
178  *  @details PKTIO polling control struct FUTURE- TBD
179  */
180 typedef struct PKTIO_POLL_Tag
182 /* future */
183 } PKTIO_POLL_T;
185 /**
186  * @def PKTIO_MAX_RECV
187  * @ingroup pktio_constants
188  *      This defines the maximum number of packets to receive in one pktio poll, @ref TUNE_NETAPI_MAX_BURST_RCV
189  */
190 #define PKTIO_MAX_RECV  (TUNE_NETAPI_MAX_BURST_RCV)
193 /**
194  *  @ingroup netapi_cb_functions
195  *  @brief PKTIO_CB   Callback function to be issued on packet receive
196  * 
197  *  @details The application provides a callback function that gets invoked on packet receive
198  *  @param[in]  channel     The PKTIO channel handle, @ref PKTIO_HANDLE_T
199  *  @param[in]  p_recv      Pointer to the packets received.
200  *  @param[in]  p_meta      Pointer to meta data associated with packet, @ref PKTIO_METADATA_T
201  *  @param[in]  n_pkts      Number of packets received.
202   * @param[in]  ts          Timestamp associted with received packets.
203  *  @retval     none
204  *  @pre       @ref pktio_open
205  */
206 typedef void (*PKTIO_CB)(struct PKTIO_HANDLE_tag * channel,
207                          Ti_Pkt* p_recv[],
208                          PKTIO_METADATA_T p_meta[],
209                          int n_pkts,
210                          uint64_t ts);
212 /**
213  *  @ingroup pktio_functions
214  *  @brief PKTIO_SEND   PKTIO specific send function
215  * 
216  *  @details The application calls this PKTIO specific send function to transmit packet
217  *  @param[in]  channel         The PKTIO channel handle, @ref PKTIO_HANDLE_T
218  *  @param[in]  p_send          Pointer to the packet to send
219  *  @param[in]  p_meta          Pointer to meta data associated with packet, @ref PKTIO_METADATA_T
220  *  @param[out] p_err             Pointer to error code.
221  *  @retval     none 
222  *  @pre       @ref pktio_open
223  */
224 typedef int (*PKTIO_SEND)(struct PKTIO_HANDLE_tag * channel,
225                           Ti_Pkt* p_send,
226                           PKTIO_METADATA_T *p_meta,
227                           int * p_err);
230 /**
231  *  @ingroup pktio_functions
232  *  @brief PKTIO_POLL   PKTIO specific poll function
233  * 
234  *  @details The application calls this PKTIO specific POLL function
235  *  @param[in]  channel     The PKTIO channel handle, @ref PKTIO_HANDLE_T
236  *  @param[in]  p_poll_cfg  Pointer to pktio poll configuration. @ref PKTIO_POLL_T
237  *  @param[out] p_err       Pointer to error code.
238  *  @retval     none 
239  *  @pre       @ref pktio_open
240  */
241 typedef int (*PKTIO_POLL)(struct PKTIO_HANDLE_tag * channel,
242                           PKTIO_POLL_T * p_poll_cfg,
243                           int * p_err);
245 /**
246  * @brief This defines TBD
247  */
248 #define PKTIO_NA 0
250 /**
251  *  @ingroup pktio_structures
252  *  @brief PKTIO configuration information
253  *
254  *  @details PKTIO :q information
255  */
256 typedef struct PKTIO_CFG_Tag
258 /**
259  * Flags for PKTIO channel configuration
260  * <br>
261  * The following are flags used to configure the pktio channel:
262  *      @ref PKTIO_R , @ref PKTIO_W, @ref PKTIO_RW
263  */
264     int flags1; 
266 /**
267  * @def PKTIO_R
268  * @ingroup pktio_constants
269  *      This defines the pktio channel as type read TBD
270  */
271 #define PKTIO_R 0x1
273 /**
274  * @def PKTIO_W
275  * @ingroup pktio_constants
276  *      This defines the pktio channel as type write TBD
277  */
278 #define PKTIO_W 0x2
280 /**
281  * @def PKTIO_RW
282  * @ingroup pktio_constants
283  *      This defines the pktio channel as type read/write TBD
284  */
285 #define PKTIO_RW (PKTIO_R | PKTIO_W)
289 /**
290  * Additional flags  for PKTIO channel configuration
291  * <br>
292  * The following are flags used to configure the pktio channel:
293  *      @ref PKTIO_LOCAL , @ref PKTIO_GLOBAL, @ref PKTIO_RW
294  */
295 int flags2; /**< Flags for PKTIO channel configuration */
297 /**
298  * @def PKTIO_GLOBAL
299  * @ingroup pktio_constants
300  *      This defines the pktio channel as type global TBD
301  */
302 #define PKTIO_GLOBAL 0x1
304 /**
305  * @def PKTIO_LOCAL
306  * @ingroup pktio_constants
307  *      This defines the pktio channel as type local TBD
308  */
309 #define PKTIO_LOCAL  0x2
311 /**
312  * @def PKTIO_PKT
313  * @ingroup pktio_constants
314  *      This defines the pktio channel is for NETCP
315  */
316 #define PKTIO_PKT    0x4
318 /**
319  * @def PKTIO_SB
320  * @ingroup pktio_constants
321  *      This defines the pktio channel is for sideband crypto
322  */
323 #define PKTIO_SB     0x8
325 /**
326  * @def PKTIO_Q_ANY
327  * @ingroup pktio_constants
328  *      This defines the pktio IO queue number to be TBD 
329  */
330 #define PKTIO_Q_ANY -1
332 int qnum;       /**< PKTIO channel queue number */
335 int max_n;      /**< Maximum number of packets read in 1 poll */
336 } PKTIO_CFG_T;
338 struct NETAPI_tag;
340 /* a pktio channel .. */
344 /**
345  *  @ingroup pktio_structures
346  *  @brief PKTIO handle structure definition.
347  *
348  *  @details PKTIO handle strucutre which is returned from call to @ref pktio_create
349  */
350 typedef struct PKTIO_HANDLE_Tag
352 /**
353  * @def PKTIO_INUSE
354  * @ingroup pktio_constants
355  *      This defines is used to TBD
356  */
357 #define PKTIO_INUSE 0xfeedfeed
359     int inuse;                      /**<true is pktio channel is in use TBD */
361 /**
362  * Set the "use_nwal" field to one of the defines listed below.
363  * <br>
364  * The following defines are used to populate the use_nwal field TBD:
365  *      @ref PKTIO_4_IPC , @ref PKTIO_4_ADJ_NWAL, @ref PKTIO_DEF_NWAL. @ref PKTIO_4_ADJ_SB., @ref PKTIO_DEF_SB
366  */
367     int use_nwal;                  
369 /**
370  * @def PKTIO_4_IPC
371  * @ingroup pktio_constants
372  *      This define is for IPC TBD
373  */
374 #define  PKTIO_4_IPC 0
376 /**
377  * @def PKTIO_4_ADJ_NWAL
378  * @ingroup pktio_constants
379  *      This define is for (RX)app queues managed by NWAL
380  */
381 #define  PKTIO_4_ADJ_NWAL 1
383 /**
384  * @def PKTIO_DEF_NWAL
385  * @ingroup pktio_constants
386  *      This define is for default NWAL RX/TX queues
387  */
388 #define  PKTIO_DEF_NWAL 2
390 /**
391  * @def PKTIO_4_ADJ_SB
392  *      This define is for (RX) crypto side band app defined
393  * @ingroup pktio_constants
394  */
395 #define  PKTIO_4_ADJ_SB 3
397 /**
398  * @def PKTIO_DEF_SB
399  * @ingroup pktio_constants
400  *      This define is for crypto side band default
401  */
402 #define  PKTIO_DEF_SB 4
404     struct NETAPI_tag * back;       /**< back handle */
405     void * nwalInstanceHandle;      /**<save here for conveninece  TBD*/
406     PKTIO_CB cb;                    /**< callback for channel */
407     PKTIO_CFG_T cfg;                /**<configuration */
408     Qmss_QueueHnd q;                /**<the associated queue handle */
409     Qmss_Queue qInfo;               /**<and its qm#/q# */
410     int max_n;                      /**<max # of pkts to read in one poll */
411     void * cookie;                  /**<app specific */
412     PKTIO_SEND _send;               /**<pktio type specific send function */
413     PKTIO_POLL _poll;               /**<pktio type specific POLL function */
414     char name[PKTIO_MAX_NAME+1];    /**< Name of pktio channel */
415 }  PKTIO_HANDLE_T;
418 /**
419  *  @ingroup pktio_structures
420  *  @brief PKTIO control TBD
421  *
422  *  @details PKTIO control RBD
423  */
424 typedef struct PKTIO_CONTROL_Tag
426 /**
427  * @def PKTIO_CLEAR
428  *      This defines is used to clear out the PKTIO channel
429  */
430 #define PKTIO_CLEAR 0x1
432 /**
433  * @def PKTIO_DIVERT
434  *      This defines is used to divert to dest channel TBD
435  */
436 #define PKTIO_DIVERT 0x2
438     int op;                 /**< TBD */
439     PKTIO_HANDLE_T *dest;   /**< Handle to PKTIO channel */
440 } PKTIO_CONTROL_T;
444 /**
445  *  @ingroup pktio_functions
446  *  @brief API creates a NETAPI PKTIO channel 
447  *
448  *  @details This assigns global resources to a NETAPI pktio channel.
449  *   Once created, the channel can be used to send and/or receive
450  *   a Ti_Pkt. This can be used for communication with the 
451  *   the Network co-processor (NETCP) or for internal inter-processor
452  *   communication. The channel is saved under the assigned name 
453  *   and can be opened by other netapi threads instances.
454  *  @param[in]  netapi_handle   The NETAPI handle, @ref NETAPI_T 
455  *  @param[in]  name            A pointer to the char string name for channel
456  *  @param[in]  cb              Callback to be issued on packet receive, @ref PKTIO_CB
457  *  @param[in]  p_cfg           Pointer to channel configuration, @ref PKTIO_CFG_T
458  *  @param[out] err             Pointer to error code.
459  *  @retval     Handle to the pktio instance or NULL on error, @ref PKTIO_HANDLE_T
460  *  @pre       @ref netapi_init 
461  */
462 PKTIO_HANDLE_T * pktio_create(NETAPI_T netapi_handle,
463                                char * name,
464                                PKTIO_CB cb,
465                                PKTIO_CFG_T* p_cfg,
466                                int * err);
468 /**
469  *  @ingroup pktio_functions
470  *  @brief API opens an existing  NETAPI PKTIO channel
471  *
472  *  @details This opens an NETAPI pktio channel for use. The channel
473  *  must have already been created via @ref pktio_create or may have
474  *  been created internally during the netapi intialization.
475  *   Once opened, the channel can be used to send and/or receive
476  *   a Ti_Pkt. This can be used for communication with the 
477  *   the Network co-processor (NETCP) or for internal inter-processor
478  *   communication. 
479  *
480  *  @param[in]  netapi_handle   The NETAPI handle, @ref NETAPI_T 
481  *  @param[in]  name            A pointer to the char string name for channel to open
482  *  @param[in]  cb              Callback to be issued on packet receive, @ref PKTIO_CB
483  *  @param[in]  p_cfg           Pointer to channel configuration, @ref PKTIO_CFG_T
484  *  @param[out] err             Pointer to error code.
485  *  @retval     Handle to the pktio instance or NULL on error, @ref PKTIO_HANDLE_T
486  *  @pre       @ref netapi_init, @ref pktio_create
487  */
488 PKTIO_HANDLE_T * pktio_open(NETAPI_T netapi_handle, 
489                             char *name,
490                             PKTIO_CB cb,
491                             PKTIO_CFG_T *p_cfg,
492                             int * err);
494 /**
495  *  @ingroup pktio_functions
496  *  @brief API controls an existing NETAPI PKTIO channel
497  *
498  *  @details This controls an opened pktio channel
499  *
500  *  @param[in]  handle      The PKTIO channel handle, @ref PKTIO_HANDLE_T
501  *  @param[in]  cb          Callback to be issued on packet receive, @ref PKTIO_CB
502  *  @param[in]  p_cfg       Pointer to channel configuration which (optional), @ref PKTIO_CFG_T
503  *  @param[in]  p_control   Pointer to PKTIO control information (optional), @ref PKTIO_CONTROL_T
504  *  @param[out] err         Pointer to error code.
505  *  @retval     none
506  *  @pre       @ref netapi_init, @ref pktio_create, @ref pktio_open
507  */
508 void pktio_control(PKTIO_HANDLE_T * handle,
509                     PKTIO_CB cb,
510                     PKTIO_CFG_T * p_cfg,
511                     PKTIO_CONTROL_T *p_control,
512                     int *err);
514 /**
515  *  @ingroup pktio_functions
516  *  @brief API closes a PKTIO channel
517  *
518  *  @details This closes a PKTIO channel
519  *
520  *  @param[in]  handle  The PKTIO channel handle, @ref PKTIO_HANDLE_T
521  *  @param[out] err    Pointer to error code.
522  *  @retval     none
523  *  @pre       @ref netapi_init, @ref pktio_create, @ref pktio_open
524  */
525 void pktio_close(PKTIO_HANDLE_T * handle,
526                  int * err);
528 /**
529  *  @ingroup pktio_functions
530  *  @brief API deletes a PKTIO channel
531  *
532  *  @details This deletes a PKTIO channel
533  *
534  *  @param[in]  handle  The PKTIO  handle, @ref PKTIO_HANDLE_T
535  *  @param[out] err     Pointer to error code.
536  *  @retval     none
537  *  @pre       @ref netapi_init, @ref pktio_create, @ref pktio_open
538  */
539 void pktio_delete(PKTIO_HANDLE_T * handle,
540                   int * err);
542 /**
543  *  @ingroup pktio_functions
544  *  @brief  API sends data to a NETAPI PKTIO channel 
545  *
546  *  @details This sends a Ti_Pkt and associated meta data, 
547  *  @ref PKTIO_METADATA_T to a channel. The channel
548  *  must have already been created via @ref pktio_create or opened
549  *  via @ref pktio_open.  It  may have
550  *  been created internally during the netapi intialization.
551  *  @param[in]  handle  The PKTIO channel handle, @ref PKTIO_HANDLE_T
552  *  @param[in]  pkt     Pointer to the packet to send
553  *  @param[in]  m       Pointer to meta data associated with packet, @ref PKTIO_METADATA_T
554  *  @param[out] err     Pointer to error code.
555  *  @retval     1 if packet sent, 0 if error 
556  *  @pre       @ref netapi_init, @ref pktio_create, @ref pktio_open
557  */
558 static inline int  pktio_send(PKTIO_HANDLE_T * handle, 
559                               Ti_Pkt *pkt,
560                               PKTIO_METADATA_T *m,
561                               int * err)
563    return handle->_send((struct PKTIO_HANDLE_tag *)handle, pkt, m, err);
566 /**
567  *  @ingroup pktio_functions
568  *  @brief API sends data to a NETAPI PKTIO channel
569  *
570  *  @details This sends an array of Ti_Pkt and associated meta data,
571  *  @ref PKTIO_METADATA_T to a channel. The channel
572  *  must have already been created via @ref pktio_create or opened
573  *  via @ref pktio_open.  It  may have
574  *  been created internally during the netapi intialization.
575  *  @param[in]  handle  The PKTIO channel handle, @ref PKTIO_HANDLE_T
576  *  @param[in]  pkt     Pointer to the packet to send
577  *  @param[in]  m       Pointer to meta data associated with packet, @ref PKTIO_METADATA_T
578  *  @param[in]  np      The number of packets in list to send
579  *  @param[out] err     Pointer to error code.
580  *  @retval             Number of packets sent, 0 if error
581  *  @pre       @ref netapi_init, @ref pktio_create, @ref pktio_open
582  */
583 int pktio_sendMulti(PKTIO_HANDLE_T *handle,
584                     Ti_Pkt * pkt[],
585                     PKTIO_METADATA_T * m[],
586                     int np,      
587                     int * err);
589 /**
590  *  @ingroup pktio_functions
591  *  @brief  API polls a NETAPI PKTIO channel for received packets 
592  *
593  *  @details This api polls a pktio channel. Any pending data in the channel is
594  *  passed to the @ref  PKTIO_CB registered when the channel was
595  *  created or opened. The channel must
596  *  have already been created via @ref pktio_create or opened
597  *  via @ref pktio_open.  It  may have
598  *  been created internally during the netapi intialization.
599  *  @param[in]  handle      The PKTIO channel handle, @ref PKTIO_HANDLE_T
600  *  @param[in]  p_poll_cfg  Pointer to pktio poll configuration. @ref PKTIO_POLL_T
601  *  @param[out] err         Pointer to error code.
602  *  @retval                 Number of packets received by poll 
603  *  @pre       @ref netapi_init, @ref pktio_create, @ref pktio_open
604  */
605 static inline int pktio_poll(PKTIO_HANDLE_T * handle,
606                              PKTIO_POLL_T * p_poll_cfg,
607                              int * err)
609     return handle->_poll((struct PKTIO_HANDLE_tag *) handle, p_poll_cfg, err);
612 /**
613  *  @ingroup pktio_functions
614  *  @brief API polls all NETAPI PKTIO channels associarted with @ref NETAPI_T instance
615  *         for received packets
616  *
617  *  @details This api polls all pktio channels attached to an instance.
618  *  Any pending data in these channels are 
619  *  passed to the @ref  PKTIO_CB registered when the channel was
620  *  created or opened. The channels  must
621  *  have already been created via @ref pktio_create or opened
622  *  via @ref pktio_open.  They may have
623  *  been created internally during the netapi intialization.
624  *  @param[in]  handle      The PKTIO channel handle, @ref PKTIO_HANDLE_T
625  *  @param[in]  p_poll_cfg  Pointer to pktio poll configuration. @ref PKTIO_POLL_T
626  *  @param[out] err         Pointer to error code.
627  *  @retval                 Number of packets received by poll 
628  *  @pre       @ref netapi_init, @ref pktio_create, @ref pktio_open
629  */
630 int pktio_pollAll(NETAPI_T handle, 
631                   PKTIO_POLL_T * p_poll_cfg, 
632                   int *err);
635 /* update max_n for poll */
638 /**
639  * @brief This define sets the max number of pkts to read in one poll in the @ref PKTIO_HANDLE_T
640  */
641 #define pktio_set_max_n(handle,max_n) (handle)->max_n=max_n;
643 /**
644  * @brief This define returns NETAPI handle stored in the @ref PKTIO_HANDLE_T
645  */
646 #define pktio_get_netapi_handle(handle) (handle)->back
648 /**
649  * @brief This define sets a user space application cookie in the @ref PKTIO_HANDLE_T
650  */
651 #define pktio_set_cookie(handle, cookie) (handle)->cookie = cookie
653 /**
654  * @brief This define returns a previously set user space application cookie stored in the @ref PKTIO_HANDLE_T
655  */
656 #define pktio_get_cookie(handle) (handle)->cookie
659 /**
660  * @brief This define returns a associate queue handle stored in the @ref PKTIO_HANDLE_T
661  */
663 #define pktio_get_q(handle) (handle)->q
665 /*-----------------Extra Fast Path pkt meta data macros--------------------*/
666 #include "cppi_desc.h"
667 #include "ti/drv/pa/pa.h"
668 #include "ti/drv/pa/pasahost.h"
671 /**
672  *  @ingroup pktio_functions
673  *  @brief  API returns default packet queue to poll for netcp RX
674  *  @note: these are expensive calls, so call once and save
675  */
676 static inline Qmss_QueueHnd PKTIO_GET_DEFAULT_NETCP_Q(PKTIO_HANDLE_T *h)
678     nwalGlobCxtInfo_t Info;
679     nwal_getGlobCxtInfo(h->nwalInstanceHandle,&Info);
680     return Info.rxDefPktQ;
684 /**
685  *  @ingroup pktio_functions
686  *  @brief  API returns L4Queue to poll for netcp RX (L4 classifier queue).
687  *  @note: these are expensive calls, so call once and save
688  */
689 static inline Qmss_QueueHnd PKTIO_GET_DEFAULT_NETCP_L4Q(PKTIO_HANDLE_T *h)
691 nwalLocCxtInfo_t Info;
692 nwal_getLocCxtInfo(h->nwalInstanceHandle,&Info);
693 return Info.rxL4PktQ;
697 /**
698  *  @ingroup pktio_functions
699  *  @brief  API to perform descriptor push to QMSS Queue
700  */
701 static inline void PKTIO_QMSS_QUEUE_PUSH_DESC_SIZE_RAW(Qmss_QueueHnd hnd,
702                                                        void *descAddr,
703                                                        uint32_t descSize)
705     return(Qmss_queuePushDescSizeRaw(hnd,descAddr,descSize));
708 /**
709  *  @ingroup pktio_functions
710  *  @brief  API to perform descriptor pop from QMSS Queue
711  */
712 static inline void* PKTIO_QMSS_QUEUE_POP_RAW(Qmss_QueueHnd hnd)
714     return(Qmss_queuePopRaw(hnd));
717 /**
718  *  @ingroup pktio_functions
719  *  @brief  API to retrieve NWAL global instance handle.
720  */
721 static inline nwal_Inst PKTIO_GET_NWAL_INSTANCE(PKTIO_HANDLE_T *h)
723 return h->nwalInstanceHandle;
727 #endif