Additional doxygen updates
[keystone-rtos/netapi.git] / ti / runtime / netapi / netcp_cfg.h
1 /******************************************************************************
2  * FILE PURPOSE:  netapi NETCP configuration API header file
3  ******************************************************************************
4  * FILE NAME:   netcp_cfg.h
5  *
6  * DESCRIPTION:netapi NETCP configuration API header  file  for user space transport library
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 netcp_cfg.h
45  *   @brief Netapi NETCP configuration API header  file for user space transport library
46  */
50 #ifndef __NETCP_CFG__H
51 #define __NETCP_CFG__H
53 #include "netapi.h"
54 #include "ti/drv/pa/pa.h"
55 #include "ti/runtime/pktlib/pktlib.h"
58 /**
59  *  @ingroup cfg_structures
60  *  @brief CPPI flow ID for default case, use NETCP_DEFAULT_FLOW
61  */
62 typedef struct NETCP_CFG_FLOW_Tag
63 {
64     int flowid;         /**< flow id*/
65 } NETCP_CFG_FLOW_T;
68 /**
69  *  @ingroup cfg_structures
70  *  @brief NETAPI configuration information
71  *
72  *  @details The parameters in this structure are used to configure NETAPI.
73  */
74 typedef struct NETAPI_CFG_Tag
75 {
76  int def_mem_size;                  /**<  Bytes of CMA memory we have allocated */
77  int def_flow_pkt_rx_offset;        /**<  Offset in pkt buffer for hw to start RX */
78  int def_max_descriptors;           /**<  Number of descriptors in system  (must be power of 2), 2^14 max */
79  int def_tot_descriptors_for_us;    /**<  Number of descriptors to create in our region (must be power of 2)*/
80  int def_heap_n_descriptors;        /**<  Number of descriptor plus buffers in default heap*/
81  int def_heap_n_zdescriptors;       /**<  Number of zero len descriptors in defaut heap*/
82  int def_heap_buf_size;             /**<  Size of buffers in default heap, max amount of area for packet data */
83  int def_heap_tailroom_size;        /**<  Size of tailroom in reserve */
84  int def_heap_extra_size;           /**<  Size of extra space at end of buffer */ 
85 }  NETAPI_CFG_T;
87 /* @note:
88    each buffer will be allocated:  def_heap_buf_size+def_heap_extra_size bytes
89    each descriptor attached to these buffers will have rigBufferLen of:
90       def_heap_buf_size.
91    for default RX flow,  for rx packet, the bufptr  will be def_flow_pkt_rx_offset.
92    for detault RX flow,  threshold (ie max # of bytes in buffer) will be:
93        def_heap_buf_size - def_heap_tailroom_size-def_flow_pkt_rx_offset
96  RX Packet from NetCP
98 Headroom [Application]     Packet [HW]                Tailroom [Application]    Extra Space [Application]
99 <-----------------------><--------------------------><------------------------><----------------------->
101 Cppi_HostDesc->origBufferLen
102 <----------------------------------------------------------------------------->
103 Cppi_HostDesc->origBuffPtr
105 \/
106 |------------def_heap_buf_size-------------------------------------------------|--def_heap_extra_size--|
107 | def_flow_pkt_rx_offset| max Cppi_HostDesc->buffLen | def_heap_tailroom_size  |   Extra Size          |
108                         ^
109                         |
110                      Cppi_HostDesc->buffPtr
113 */
116 /**
117  * @ingroup cfg_constants
118  * @brief  This defines the handle to NETCP configuration flow.
119  */
120 typedef void *  NETCP_CFG_FLOW_HANDLE_T;
122 /**
123  * @ingroup cfg_constants
124  * @def NETCP_DEFAULT_FLOW
125  *      This defines the NETCP default FLOW to be NULL.
126  */
127 #define NETCP_DEFAULT_FLOW  (NETCP_CFG_FLOW_HANDLE_T*) NULL
130 /**
131  * @ingroup cfg_constants
132  * @brief  Handle to the default NETCP route.
133  * @details Application to use this handle to identify default NETCP route.
134  */
135 typedef void * NETCP_CFG_ROUTE_HANDLE_T;
137 /**
138  * @def NETCP_DEFAULT_ROUTE
139  *      This defines the NETCP default ROUTE to be NULL.
140  */
141 #define NETCP_DEFAULT_ROUTE  (NETCP_CFG_ROUTE_HANDLE_T*) NULL
144 /**
145  *  @ingroup cfg_structures
146  *  @brief NETCP application defined route information.
147  *
148  */
149 typedef struct NETCP_CFG_ROUTE_Tag
151    NETCP_CFG_FLOW_T * p_flow;   /**< NULL or NETCP_DEFAULT_FLOW for default flow, @ref NETCP_CFG_FLOW_T */
152    PKTIO_HANDLE_T * p_dest_q;   /**<NULL for default destination queue */
153 } NETCP_CFG_ROUTE_T;
155 /**
156  * @ingroup cfg_constants
157  * @def NETCP_CFG_ACTION_DISCARD
158  *      This defines the NETCP action to discard packet.
159  */
160 #define NETCP_CFG_ACTION_DISCARD 0
161 /**
162  * @ingroup cfg_constants
163  * @def  NETCP_CFG_ACTION_CONTINUE
164  *      This defines the NETCP action to pass packet ono the next classifier
165  */
166 #define NETCP_CFG_ACTION_CONTINUE 1
167 /**
168  * @ingroup cfg_constants
169  * @def NETCP_CFG_ACTION_TO_SW
170  *      This defines the NETCP action to pass packet to User space application
171  */
172 #define NETCP_CFG_ACTION_TO_SW    2
175 /**
176  * @ingroup cfg_constants
177  * @brief  Handle to the default NETCP route.
178  * @details Application to use this handle to identify default NETCP route.
179  */
180 typedef void * NETCP_CFG_VLAN_T;
182 /**
183  * @ingroup cfg_constants
184  * @brief  AppID for MAC interface
185  */
186 typedef uint32_t NETCP_CFG_MACIF_T;
188 /**
189  * @ingroup cfg_constants
190  * @brief AppID for IP interface
191  */
192 typedef uint32_t NETCP_CFG_IP_T;
196 /**
197  * @ingroup cfg_constants
198  * @brief This define is used to identify the application id associated with a created SA
199  */
200 typedef uint32_t NETCP_CFG_SA_T;
203 /**
204  * @ingroup cfg_constants
205  * @brief AppId used to identify NETCP IPSEC policy
206  */
207 typedef uint32_t NETCP_CFG_IPSEC_POLICY_T;
210 /**
211  * @ingroup cfg_constants
212  * @def NETCP_CFG_NO_INTERFACE
213  *      This define is to be used in AddIp, AddClassifier to indicate any MAC address.
214  */
215 #define NETCP_CFG_NO_INTERFACE 0xff
219 /**
220  * @note  APPIDs are present in RX packet meta data and tell "how far the packet got
221  * through the classification rules of NETCP 
222  * APPID is 32 bits:
223  * bits 31-24 = MATCH STAGE (NETAPI_NECP_MATCH_xxx below)
224  * bits 23-8  = identifier (depends on match stage)
225  * bits  7-0  = logical mac interface
226 */
228 /**
229  * @ingroup cfg_constants
230  * @def NETAPI_NETCP_MATCH_GENERIC_MAC
231  *      This define is used to indicate that apacket matched a MAC entry.  Entry # (logical interface) is in byte 0 of APPID.
232  *      Packet did not match any other rule
233  */
234 #define NETAPI_NETCP_MATCH_GENERIC_MAC  0x10000000  //lower byte==interface
236 /**
237  * @ingroup cfg_constants
238  * @def NETAPI_NETCP_MATCH_GENERIC_IP
239  *      This define is used to indicate that a packet matched a MAC entry.  Entry # (logical interface) is in byte 0 of APPID
240  *      packet matched a generic IP rule attached to that interface.  The IP rule # for the interface
241  *      is given in Bytes 3,2 of the APPID.   Packet did not match any other rule
242  */
243 #define NETAPI_NETCP_MATCH_GENERIC_IP   0x20000000  //lower byte==interface
246 /**
247  * @ingroup cfg_constants
248  * @def NETAPI_NETCP_MATCH_CLASS
249  *      This define is used to indicate that a packet matched a MAC entry.  Entry # (logical interface) is in byte 0 of APPID
250  *      packet matched a generic IP rule  attached to that interface OR a general IP rule added as part of
251  *      the classifier or it matched a combination of ISPEC SA rule and a policy check.  Finally,
252  *      Packet matched a L4 port rule that was added as part of a classifer.  Bytes 3-2
253  *      give the ID of the classifier . Packet did not match any other rule
254  */
255 #define NETAPI_NETCP_MATCH_CLASS        0x80000000  //FULL MATCH or' in classifier (16 bits), lower byte==interface
257 /**
258  * @ingroup cfg_constants
259  * @def NETAPI_NETCP_MATCH_CLASS_L3
260  *      This define is used to indicate that a  packet matched a MAC entry.  Entry # (logical interface) is in byte 0 of APPID
261  *      packet matched a general IP rule added as part of a classifier.  But it not match a
262  *      L4 port or any other rule. We cannout say what classifer partially matched so Bytes 3-2 are
263  *      not applicable
264  */
265 #define NETAPI_NETCP_MATCH_CLASS_L3     0x40000000  //MATCHED L3 but not L4.  lower byte==interface
267 /**
268  * @ingroup cfg_constants
269  * @def NETAPI_NETCP_MATCH_IPSEC
270  *      This define is used to indicate that a packet matched a MAC entry.  Entry # (logical interface) is in byte 0 of APPID
271  *      packet matched an IPSEC SA  rule (matched proto, dest ip and SPI).  The SA id  is in
272  *      bytes 3-2 of APPID.  Packet did not match any other rule (so may have failed a policy check)
273  */
274 #define NETAPI_NETCP_MATCH_IPSEC        0x01000000  //lower byte==interface, Or' in SA id (16 bits)
276 /**
277  * @ingroup cfg_constants
278  * @def NETAPI_NETCP_MATCH_IPSEC_POLICY
279  *      This define is used to indicate that a packet matched a MAC entry.  Entry # (logical interface) is in byte 0 of APPID
280  *      packet matched an IPSEC SA rule (matched proto, dest ip and SPI).  Packet matched
281  *      a POLICY RULE - this is a check of the inner IP.  The IPSEC RX Policy ID  is in
282  *      bytes 3-2 of APPID.  Packet did not match any other rule 
283  */
284 #define NETAPI_NETCP_MATCH_IPSEC_POLICY 0x02000000  //lower byte==interface, Or' in SA id (16 bits)
290 /**
291  *  @ingroup cfg_functions
292  *  @brief netcp_cfgAddFlow   API to add a flow
293  * 
294  *  @details This api is used to add a flow
295  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
296  *  @param[in]  n    number of Pktlib_HeapHandle
297  *  @param[in]  handles[]   Handles to Pktlib_HeapHandle
298  *  @param[in]  sizes[]     must be <= heap corresponding heap size-recv_offset-any desired tail room
299  *  @param[in]  recv_offset   bytes to save in front of packet
300  *  @param[out] err     pointer to error return
301  *  @retval     NETCP flow handle, @ref NETCP_CFG_FLOW_HANDLE_T
302  *  @pre       @ref netapi_init
303  */
304 NETCP_CFG_FLOW_HANDLE_T netcp_cfgAddFlow(NETAPI_T h,
305                                             int n, 
306                                             Pktlib_HeapHandle handles[],
307                                             int sizes[],
308                                             int recv_offset,
309                                             int * err );
312 /**
313  *  @ingroup cfg_functions
314  *  @brief netcp_cfgDelFlow   API to delete a flow
315  * 
316  *  @details This api is used to delete a flow
317  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
318  *  @param[in]  p    handle to NETCP  flow
319  *  @param[out] err     pointer to error return
320  *  @retval     none
321  *  @pre       @ref netapi_init, netcp_cfgAddFlow
322  */
323 void netcp_cfgDelFlow(NETAPI_T h ,
324                                             NETCP_CFG_FLOW_HANDLE_T p ,
325                                             int * err);
327 /**
328  *  @ingroup cfg_functions
329  *  @brief netcp_cfgDelMac   API to delete MAC  interface
330  * 
331  *  @details This api is used to delete a MAC interface
332  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
333  *  @param[in]  iface_no    interface number (0,1,..)
334  *  @param[out] err     pointer to error return
335  *  @retval     returned AppID for attached rule. This is returned in RX meta data for packets matching this rule and no other, @ref NETCP_CFG_IP_T
336  *  @pre       @ref netapi_init , @ref netcp_cfgCreateMacInterface 
337  */
338 void netcp_cfgDelMac(NETAPI_T h,int iface_no,  int *err);
342 /**
343  *  @ingroup cfg_functions
344  *  @brief  API attaches an IP adderess and qualifier to a MAC interface
345  * 
346  *  @details This api is used to add an IP address to a MAC interface along
347  *            with optional IP qualifier. A route, @ref NETCP_CFG_ROUTE_HANDLE_T,or NULL for default 
348  *            may be specified to indicate where to send packets matching the MAC interface MAC address, the
349  *            supplied IP address and any qualifier.  This API adds a rule to the NETCP level 1 lookup tables
350  *            Packets arriving that match this rule are identified in meta data with Appid=  NETAPI_NETCP_MATCH_GENERIC_IP
351  *            Note: An IP address must be attached to enable NETCP receive Checksum offload feature
352  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
353  *  @param[in]  iface_no    interface number (0,1,..)
354  *  @param[in]  ipType  type of IP address (V4 for V6)
355  *  @param[in]  ip_addr      ip_address
356  *  @param[in]  ip_qualifiers   ip_qualifiers (all 0 for no qualifiers). This can be used to apply special handling for
357  *                  diffserv category for example.
358  *  @param[in]  route   [future] handle of a created route or NULL to use internal default route, @ref NETCP_CFG_ROUTE_HANDLE_T
359  *  @param[out] err     pointer to error return
360  *  @retval     returned AppID for attached rule. This is returned in RX meta data for packets matching this rule and no other, @ref NETCP_CFG_IP_T
361  *  @pre       @ref netapi_init
362  */
363 NETCP_CFG_IP_T  netcp_cfgAddIp(
364                   NETAPI_T  h,
365                   int  iface_no,
366                   nwal_IpType ipType,
367                   nwalIpAddr_t  * ip_addr,
368                   nwalIpOpt_t * ip_qualifiers,
369                   NETCP_CFG_ROUTE_HANDLE_T  route,
370                   int * err
371                   );
373 /**
374  *  @ingroup cfg_functions
375  *  @brief netcp_cfgDelIp   API to delete IP interface
376  * 
377  *  @details This api is used to delete an IP interface
378  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
379  *  @param[in]  iface_no    interface number (0,1,..)
380  *  @param[in]  ipType  type of IP address (V4 for V6)
381  *  @param[in]  ip_addr      ip_address
382  *  @param[in]  ip_qualifiers   ip_qualifiers (all 0 for no qualifiers). This can be used to apply special handling for
383  *                  diffserv category for example.
384  *  @param[in]  ip_rule_id      @ref NETCP_CFG_IP_T
385  *  @param[out] err     pointer to error return
386  *  @retval     returned AppID for attached rule. This is returned in RX meta data for packets matching this rule and no other, @ref NETCP_CFG_IP_T
387  *  @pre       @ref netapi_init , @ref netcp_cfgAddIp
388  */
389 void netcp_cfgDelIp(NETAPI_T h, int iface_no,  nwal_IpType ipType,
390                   nwalIpAddr_t  * ip_addr,
391                   nwalIpOpt_t * ip_qualifiers, 
392                   NETCP_CFG_IP_T  ip_rule_id,
393                   int *err);
397 /**
398  *  @ingroup cfg_functions
399  *  @brief netcp_cfgCreateMacInterface  API to create a MAC interface
400  * 
401  *  @details This api is used to create a MAC interface.
402  *      Once it is created, the MAC interface can be used to receive packets. The API
403  *      adds a rule to the NETCP 1st level lookup tables to route all packets with destination
404  *      MAC matching supplied argument and not matching any other lookup entry (see @ref netcp_cfgAddIp) to
405  *      the supplied route, @ref NETCP_CFG_ROUTE_T, (or default route).
406  *      Packets arriving that match this rule are identified in meta data with Appid=  NETAPI_NETCP_MATCH_GENERIC_MAC
407  *      Note: The internal SOC switch must be "taught" that this mac
408  *      address is present by transmitting a packet with destination mac = this interface mac address.
409  *  @param[in]  h   NETAPI instance handle, @ref NETAPI_T
410  *  @param[in]  p_mac   pointer to 6 byte MAC address for interface
411  *  @param[in]  iface_no    interface number (0,1,..) 
412  *  @param[in]  switch_port     (0 don't care, 1 switch port 1, 1 switch port 2) [only 0 supported] 
413  *  @param[in]  route   [future] handle of a created route or NULL to use internal default route, @ref NETCP_CFG_ROUTE_HANDLE_T
414  *  @param[in]  vlan    [future[ vlan configuration . Set to NULL, @ref NETCP_CFG_VLAN_T
415  *  @param[in]  state   [future] interface state (0=down, 1= up)
416  *  @param[out] err     pointer to error return
417  *  @retval     returns AppID for interface (this is returned in meta data for received packets matching this rule an no others, @ref NETCP_CFG_MACIF_T
418  *  @pre       @ref netapi_init 
419  */
420 NETCP_CFG_MACIF_T  netcp_cfgCreateMacInterface(
421                     NETAPI_T  h,     
422                     uint8_t *p_mac, 
423                     int iface_no,
424                     int switch_port,
425                     NETCP_CFG_ROUTE_HANDLE_T  route,
426                     NETCP_CFG_VLAN_T  vlan,
427                     int state,
428                     int * err
429 );
432 /**
433  * @brief This defines handle to installed classifier returned by API.  Pkts matching this classifier will have meta data with this tag.
434  *  Also used to delete classifier
435  */
436 typedef uint32_t NETCP_CFG_CLASS_T;  
439 /**
440  *  @ingroup cfg_structures
441  *  @brief NETAPI Class L4 Configuration
442  *
443  *  @details This structure contains Class L4 Configuration. L2,L3 implied by iface, ip
444  */
445 typedef struct NETCP_CFG_CLASS_L4_Tag
447     int             iface;      /**< Indicates which MAC interface packet is from */
448     NETCP_CFG_IP_T  ip;         /**< @ref NETCP_CFG_IP_T */
449     nwal_appProtoType_t proto;   /**< L4 proto (-1 for don't care)*/
450     nwalAppProto_t   appProto;   /**< Ports or equivalent */
452 } NETCP_CFG_CLASS_L4_T;
455 /**
456  *  @ingroup cfg_structures
457  *  @brief NETAPI Classifier L4 plus IPSEC policy configuration
458  *
459  *  @details This structure contains Class L4 plus IPSEC policy configuration. L2,L3 implied by iface, ip
460  */
461 //classifier L4 + policy  (L2, L3 (outer), tunnel, L3 (inner)  implied by policy
462 typedef struct NETCP_CFG_CLASS_L4_IPSEC_Tag
464     int             iface;      /**< Indicates which MAC interface packet is from */
465     NETCP_CFG_IPSEC_POLICY_T  ip_policy; /**< IPSEC policy configuration */
466     nwal_appProtoType_t proto;   /**< L4 proto (-1 for don't care)*/
467     nwalAppProto_t   appProto;   /**< Ports or equivalent */
469 } NETCP_CFG_CLASS_L4_IPSEC_T;
474 /**
475  *  @ingroup cfg_structures
476  *  @brief NETAPI Classifier L4/L3 configuration
477  *
478  *  @details This structure contains Class L4 and Class L3 configuration. L2 implied by iface
479  */
480 typedef struct NETCP_CFG_CLASS_L3_L4_Tag
482     int             iface;      /**< Indicates which MAC interface packet is from */
483     nwal_IpType ipType;         /**< IP address type, IPV4 or IPV6 */
484     nwalIpAddr_t  * ip_addr;    /**< IP addres */
485     nwalIpOpt_t * ip_qualifiers;/**< IP address qualifiers */
486     NETCP_CFG_ROUTE_HANDLE_T p_fail_route; /**< What to do if L3 matches but L4 fails AND L3 is a 
487                                             * new rule.(if exisitng rule, then existing fail
488                                             *route will be used. */
489     nwal_appProtoType_t proto;   /**< L4 proto (-1 for don't care)*/
490     nwalAppProto_t   appProto;   /**< Ports or equivalent */
491 } NETCP_CFG_CLASS_L3_L4_T;
493 /**
494  *  @ingroup cfg_structures
495  *  @brief NETAPI Classifier configuration
496  *
497  *  @details This structure contains the NETAPI classifer configuration
498  */
499 typedef struct NETCP_CFG_CLASSIFIER_Tag
502 /**
503  * Classifer type which can be set to one of the following defines:
504  * <br>
505  *      @ref NETCP_CFG_CLASS_TYPE_L4 , @ref NETCP_CFG_CLASS_TYPE_L3_L4
506  */
507     int classType;
509 /**
510  * @def NETCP_CFG_CLASS_TYPE_L4
511  * @ingroup cfg_constants
512  *      This defines classifier type to be Class L4 TBD
513  */
514 #define NETCP_CFG_CLASS_TYPE_L4  0
516 /**
517  * @def NETCP_CFG_CLASS_TYPE_L3_L4
518  * @ingroup cfg_constants
519  *      This defines classifier type to be Class L4/L3 TBD
520  */
521 #define NETCP_CFG_CLASS_TYPE_L3_L4  1
523      union
524     {
525         NETCP_CFG_CLASS_L3_L4_T     c_l3_l4;    /**< @ref NETCP_CFG_CLASS_L3_L4_T */
526         NETCP_CFG_CLASS_L4_T        c_l4;       /**< @ref NETCP_CFG_CLASS_L4_T */
527         NETCP_CFG_CLASS_L4_IPSEC_T  c_l4_ipsec; /**< @ref NETCP_CFG_CLASS_L4_IPSEC_T */
528     } u;                                        /**< union for classifier type configuration structure */
529 } NETCP_CFG_CLASSIFIER_T;
533 /**
534  *  @ingroup cfg_functions
535  *  @brief netcp_cfgAddClass   API can be used to route a packet flow to a specific PKTIO channel
536  * 
537  *  @details This api can be used to route a packet flow to a particular PktIO channel, use a specific
538  *  pktLib heap, and/or have NetCP attach a tag (classifier id) to the incoming packet.
539  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
540  *  @param[in]  p_class
541  *  @param[in]  p_route
542  * @param[in]  action
543  *  @param[out] err     pointer to error return
544  *  @retval     returned AppID for attached rule. This is returned in RX meta data for packets matching this rule and no other, @ref NETCP_CFG_IP_T
545  *  @pre       @ref netapi_init
546  */NETCP_CFG_CLASS_T netcp_cfgAddClass(NETAPI_T h,
547                                     NETCP_CFG_CLASSIFIER_T *p_class,
548                                     NETCP_CFG_ROUTE_HANDLE_T p_route,
549                                     int action,
550                                     int * err);
554 /**
555  *  @ingroup cfg_functions
556  *  @brief netcp_cfgDelClass   API can be used to delete a preconfigured classifier
557  * 
558  *  @details This API can be used to delete a preconfigured classifier
559  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
560  *  @param[in]  classId
561  *  @param[out] err     pointer to error return
562  *  @retval     none
563  *  @pre       @ref netapi_init, @ref netcp_cfgAddClass
564  */
565 void netcp_cfgDelClass(NETAPI_T h,
566                        NETCP_CFG_CLASS_T classId,
567                        int *err);
570 /**
571  *  @ingroup netapi_cb_functions
572  *  @brief NETCP_CFG_STATS_CB   Callback function that is used to return statistics from NETCP
573  * 
574  *  @details The application provides a callback function that NETAPI  uses to report statistics.
575  *  The request for stats is generated from the @ref netcp_cfgReqStats API.
576  *  Note: to receive ths stats callback, the @ref netapi_netcpPoll funcition must be called
577  *  @param[in]  h   NETAPI instance handle, @ref NETAPI_T
578  *  @param[out]  pPaStats    the PA (NETCP packet accelerator subsystem) statistics block 
579  *  @retval     none 
580  *  @pre       @ref netapi_init , @ref netcp_cfgReqStats, @ref netapi_netcpPoll
581  */
582 typedef void (*NETCP_CFG_STATS_CB)(NETAPI_T h, 
583                                    paSysStats_t* pPaStats);
585 /**
586  *  @ingroup cfg_functions
587  *  @brief netcp_cfgReqStats   API to request statistics from NETCP
588  * 
589  *  @details This api is used to request a statistics from NETCP.  This will generate a stats request
590  *  command to NETCP. Sometime later, the statistics result will arrive and will be passed to 
591  *  the caller via the asynchronus callback @ref NETCP_CFG_STATS_CB that is registered in this call.
592  *  Note: to receive the stats callback, the @ref netapi_netcpPoll funcition must be called
593  *  @param[in]  h    NETAPI instance handle, @ref NETAPI_T
594  *  @param[in]  cb   the callback function to invoke with the resulting statistics block, @ref NETCP_CFG_STATS_CB
595  *  @param[in]  doClear     clear the stats in NETCP after the report (0=no, 1=yes) 
596  *  @param[out] err     pointer to error return
597  *  @retval     none 
598  *  @pre       @ref netapi_init 
599  */
600 void netcp_cfgReqStats(NETAPI_T  h,
601                        NETCP_CFG_STATS_CB cb,
602                        int doClear,
603                        int *err);
607 #endif