/home/tom/src/ogc-dev/trunk/nm/frameworks/src/include/nmf/nmf.h

/*
 * Copyright (c) 2008 Open Grid Computing, Inc.
 * All rights reserved.
 *
 * Confidential and Proprietary
 */
#ifndef __NMF_H
#define __NMF_H

#include <nm/nm.h>
#include <nm/nm_bv.h>
#include <nm/nm_list.h>

#ifdef __cplusplus
NM_CDECL_BEGIN
#endif

typedef nm_u32_t nmf_id_t;

typedef nm_u32_t nmf_client_t;

enum nmf_status {
        NMF_OK = 0,
        NMF_EPERM,
        NMF_ENOENT,
        NMF_ESRCH,
        NMF_EINTR,
        NMF_EIO,
        NMF_ENXIO,
        NMF_E2BIG,
        NMF_ENOEXEC,
        NMF_EBADF,
        NMF_ECHILD,
        NMF_EAGAIN,
        NMF_ENOMEM,
        NMF_EACCESS,
        NMF_EFAULT,
        NMF_ENOTBLK,
        NMF_EBUSY,
        NMF_EEXIST,
        NMF_EXDEV,
        NMF_ENODEV,
        NMF_ENOTDIR,
        NMF_EISDIR,
        NMF_EINVAL,
        NMF_INFILE,
        NMF_EMFILE,
        NMF_ENOTTY,
        NMF_ETXTBSY,
        NMF_EFBIG,
        NMF_ENOSPC,
        NMF_ESPIPE,
        NMF_EROFS,
        NMF_EMLINK,
        NMF_EPIPE,
        NMF_EDOM,
        NMF_ERANGE,
        NMF_EINUSE,
        NMF_ENOSYS
};
typedef enum nmf_status nmf_status_t;

#define NMF_ATTR_ERROR -1

typedef void (*nmf_aeh_t)(nmf_client_t client_id, int type, void *e, u_int ctxt);

nmf_status_t nmf_init(nmf_aeh_t aeh, u_int context);

#define NMF_EVENT_NONE  0
#define NMF_EVENT_ALL   ((u_int)-1)

nmf_client_t nmf_open(char *host, u_int events, nmf_aeh_t cb, u_int ctxt);

void nmf_close(nmf_client_t clid);

void nmf_close_all();

void nmf_set_eh(nmf_client_t client_id, nmf_aeh_t aeh, void *context);
enum nmf_sw_attr_id {
        NMF_SW_ATTR_SLOT_COUNT = 1,

        NMF_SW_ATTR_CFG_PATH
};
union nmf_sw_attr_value {
        int slot_count;
        char *cfg_path;
};

nmf_status_t nmf_sw_attr_get(nmf_client_t client_id,
                             enum nmf_sw_attr_id attr_id,
                             union nmf_sw_attr_value *value);

nmf_status_t nmf_sw_cfg_save(nmf_client_t client_id, char *cfg_name);

nmf_status_t nmf_sw_cfg_restore(nmf_client_t client_id, char *cfg_name);

enum nmf_slot_state {
        NMF_SLOT_STATE_EMPTY = 1,
        NMF_SLOT_STATE_PWR_DOWN,
        NMF_SLOT_STATE_RESET,   
        NMF_SLOT_STATE_READY    
};

enum nmf_spanning_tree_mode {
        NMF_SPANNING_TREE_SHARED = 1,

        NMF_SPANNING_TREE_PER_VLAN,

        NMF_SPANNING_TREE_MULTIPLE

};

enum nmf_flood_policy {
        NMF_FLOOD_FWD = 1,
        NMF_FLOOD_FWD_AND_LOG,
        NMF_FLOOD_LOG,
        NMF_FLOOD_DROP,
        NMF_FLOOD_PER_PORT
};

enum nmf_routing_hash {
        NMF_ROUTING_HASH_SYM = 1,
        NMF_ROUTING_HASH_SIP,
        NMF_ROUTING_HASH_DIP,
        NMF_ROUTING_HASH_IP_PROTO,
        NMF_ROUTING_HASH_TCP,
        NMF_ROUTING_HASH_UDP,
        NMF_ROUTING_HASH_L4SRC_PORT,
        NMF_ROUTING_HASH_L4DST_PORT,
        NMF_ROUTING_HASH_PROTO_1,
        NMF_ROUTING_HASH_PROTO_2
};

enum nmf_ip_options_policy {
        NMF_IP_OPTIONS_FWD = 1,
        NMF_IP_OPTIONS_LOG,
        NMF_IP_OPTIONS_LOG_MCAST,
        NMF_IP_OPTIONS_LOG_UCAST
};

enum nmf_lbg_mode {
        NMF_LBG_MODE_MAPPED = 1,
        NMF_LBG_MODE_NPLUS1,
        NMF_LBG_MODE_FAILOVER
};

enum nmf_slot_attr_id {
        NMF_SLOT_ATTR_STATE = 1,

        NMF_SLOT_ATTR_CPU_ETHADDR,

        NMF_SLOT_ATTR_VENDOR,

        NMF_SLOT_ATTR_FAMILY,

        NMF_SLOT_ATTR_MODEL,

        NMF_SLOT_ATTR_VERS,

        NMF_SLOT_ATTR_PORT_COUNT,

        NMF_SLOT_ATTR_MAX_MIRROR,

        NMF_SLOT_ATTR_MAX_LAG,

        NMF_SLOT_ATTR_MAX_LAG_HASH,

        NMF_SLOT_ATTR_MAX_VLAN,

        NMF_SLOT_ATTR_SPANNING_TREE_MODE,

        NMF_SLOT_ATTR_TRAP_IEEE_8021X,

        NMF_SLOT_ATTR_TRAP_IEEE_BPDU,

        NMF_SLOT_ATTR_TRAP_IEEE_LACP,

        NMF_SLOT_ATTR_TRAP_IEEE_GARP,

        NMF_SLOT_ATTR_TRAP_IEEE_OTHER,

        NMF_SLOT_ATTR_DROP_PAUSE,

        NMF_SLOT_ATTR_BCAST_FLOOD,

        NMF_SLOT_ATTR_MCAST_FLOOD,

        NMF_SLOT_ATTR_UCAST_FLOOD,

        NMF_SLOT_ATTR_FRAME_AGING_TIME_MSEC,

        NMF_SLOT_ATTR_ROUTING_HASH,

        NMF_SLOT_ATTR_ROUTING_HASH_ROTATION,

        NMF_SLOT_ATTR_ROUTING_HASH_PROTO_1,

        NMF_SLOT_ATTR_ROUTING_HASH_PROTO_2,

        NMF_SLOT_ATTR_ROUTING_HASH_FLOW_DIFFSERV_MASK,

        NMF_SLOT_ATTR_ROUTING_HASH_FLOW_USER_MASK,

        NMF_SLOT_ATTR_ROUTING_HASH_FLOW_LABEL_MASK,

        NMF_SLOT_ATTR_IP_OPTIONS_DISPOSITION,

        NMF_SLOT_ATTR_LBG_MODE,

        NMF_SLOT_ATTR_AUTH_MAC_ID_TRIGGER,

        NMF_SLOT_ATTR_REDIRECT_CPU_TRAFFIC,

        NMF_SLOT_ATTR_IFG_PENALTY
};

#define NMF_SLOT_ATTR_MAX_VENDOR_LEN 32

union nmf_slot_attr_value {
        enum nmf_slot_state state;
        u_char cpu_ethaddr[6];
        char vendor[NMF_SLOT_ATTR_MAX_VENDOR_LEN];
        u_int family;
        u_int model;
        u_int vers;
        u_int port_count;
        u_int max_mirror;
        u_int max_lag;
        u_int max_lag_hash;
        u_int max_vlan;
        enum nmf_flood_policy ucast_flood;
        enum nmf_flood_policy bcast_flood;
        enum nmf_flood_policy mcast_flood;
        enum nmf_spanning_tree_mode spanning_tree_mode;
        u_int trap_ieee_8021x;
        u_int trap_ieee_bpdu;
        u_int trap_ieee_lacp;
        u_int trap_ieee_garp;
        u_int trap_ieee_other;
        u_int drop_pause;
        u_int frame_aging_time_msec;
        u_int routing_hash;
        u_int routing_hash_rotation;
        u_int routing_hash_proto_1;
        u_int routing_hash_proto_2;
        u_int routing_hash_flow_diffserv_mask;
        u_int routing_hash_flow_user_mask;
        u_int routing_hash_flow_label_mask;
        enum nmf_ip_options_policy ip_options_disposition;
        enum nmf_lbg_mode lbg_mode;
        u_int auth_mac_id_trigger;
        u_int redirect_cpu_traffic;
        u_int ifg_penalty;
};

nmf_status_t nmf_slot_reset(nmf_client_t client_id, int slot);

nmf_status_t nmf_slot_attr_get(nmf_client_t client_id, int slot,
                               enum nmf_slot_attr_id attr_id,
                               union nmf_slot_attr_value *value);

nmf_status_t nmf_slot_attr_set(nmf_client_t client_id, int slot,
                               enum nmf_slot_attr_id attr_id,
                               union nmf_slot_attr_value *value);

/* \} */


enum nmf_port_state {
        NMF_PORT_STATE_ADMIN_DOWN = 1,
        NMF_PORT_STATE_ADMIN_PWRDOWN,
        NMF_PORT_STATE_BIST,
        NMF_PORT_STATE_DOWN,
        NMF_PORT_STATE_LOCAL_FAULT,
        NMF_PORT_STATE_BAD_SYNC,
        NMF_PORT_STATE_REMOTE_FAULT,
        NMF_PORT_STATE_UP
};
typedef enum nmf_port_state nmf_port_state_t;
enum nmf_port_bist_mode {
        NMF_BIST_TX_CJPAT = 1,
        NMF_BIST_TX_HIGHFREQ,
        NMF_BIST_TX_IDLECHAR,
        NMF_BIST_TX_LOWFREQ,
        NMF_BIST_TX_PRBS_1024,
        NMF_BIST_TX_PRBS_512A,
        NMF_BIST_TX_PRBS_512B,
        NMF_BIST_TX_TESTCHAR
};
typedef enum nmf_port_bist_mode nmf_port_bist_mode_t;

enum nmf_port_tagging_policy {
        NMF_PORT_VLAN_TAG_ADD_DEFAULT = 1,
        NMF_PORT_VLAN_TAG_ADD_EMPTY,
        NMF_PORT_VLAN_TAG_KEEP,
        NMF_PORT_VLAN_TAG_REPLACE
};

enum nmf_port_attr_id {
        NMF_PORT_ATTR_SPEED = 1,
        NMF_PORT_ATTR_MTU,
        NMF_PORT_ATTR_AUTONEG,
        NMF_PORT_ATTR_AUTONEG_CAPS,
        NMF_PORT_ATTR_AUTONEG_PARTNER_CAPS,
        NMF_PORT_ATTR_AUTONEG_RAW_CAP,
        NMF_PORT_ATTR_BRIDGING_ROLE,
        NMF_PORT_ATTR_DEF_CFI,
        NMF_PORT_ATTR_DEF_DSCP,
        NMF_PORT_ATTR_DEF_PRI,
        NMF_PORT_ATTR_DEF_SWPRI,
        NMF_PORT_ATTR_DOT1X_STATE,
        NMF_PORT_ATTR_DRIVE_STRENGTH,
        NMF_PORT_ATTR_DROP_VLAN_BV,
        NMF_PORT_ATTR_DROP_TAGGED,
        NMF_PORT_ATTR_DROP_UNTAGGED,
        NMF_PORT_ATTR_DEF_VLAN,
        NMF_PORT_ATTR_FWD_LIST,
        NMF_PORT_ATTR_VLAN_LIST,
        NMF_PORT_ATTR_EMPHASIS,
        NMF_PORT_ATTR_IFG,
        NMF_PORT_ATTR_IGNORE_IFG_ERRORS,
        NMF_PORT_ATTR_LEARNING,
        NMF_PORT_ATTR_ETHADDR,
        NMF_PORT_ATTR_RX_PAUSE_CLASS_MASK,
        NMF_PORT_ATTR_TX_PAUSE_MODE,
        NMF_PORT_ATTR_TX_PAUSE_PEER_DELAY,
        NMF_PORT_ATTR_TX_PAUSE_RESEND_DELAY,
        NMF_PORT_ATTR_STATE,
        NMF_PORT_ATTR_DESC,
        NMF_PORT_ATTR_MCAST_FLOOD,
        NMF_PORT_ATTR_MCAST_PRUNING,
        NMF_PORT_ATTR_MIN_FRAME_SIZE,
        NMF_PORT_ATTR_RX_LANE_ORDERING,
        NMF_PORT_ATTR_RX_LANE_POLARITY,
        NMF_PORT_ATTR_SECURITY_MODE,
        NMF_PORT_ATTR_SWPRI_DSCP_PREF,
        NMF_PORT_ATTR_SWPRI_SOURCE,
        NMF_PORT_ATTR_TAGGING,
        NMF_PORT_ATTR_TX_LANE_ORDERING,
        NMF_PORT_ATTR_TX_LANE_POLARITY,
        NMF_PORT_ATTR_TXCFI,
        NMF_PORT_ATTR_TXVPRI,
        NMF_PORT_ATTR_UCAST_FLOOD,
        NMF_PORT_ATTR_REPLACE_DSCP,
        NMF_PORT_ATTR_UPDATE_DSCP,
        NMF_PORT_ATTR_UPDATE_ROUTED_FRAME,
        NMF_PORT_ATTR_UPDATE_TTL,
        NMF_PORT_ATTR_ROUTABLE,
        NMF_PORT_ATTR_RX_CRC_DISCARD
};

enum nmf_port_security_mode {
        NMF_PORT_SECURITY_OFF = 1,
        NMF_PORT_SECURITY_SAV,
        NMF_PORT_SECURITY_SPV,
        NMF_PORT_SECURITY_SHV
};

enum nmf_port_security_action {
        NMF_PORT_SECURITY_DROP= 1,
        NMF_PORT_SECURITY_TRAP
};

enum nmf_port_attr_lane_order {
        NMF_PORT_LANE_ORDER_NORMAL = 1,
        NMF_PORT_LANE_ORDER_REVERSE
};

enum nmf_port_attr_lane_polarity {
        NMF_PORT_LANE_POLARITY_NORMAL= 1,
        NMF_PORT_LANE_POLARITY_INVERT
};

struct nmf_port_attr_state {
        enum nmf_port_state port_state;
        enum nmf_port_bist_mode bist_mode;
};

struct nmf_port_vlan_spec {
        nm_bv_t vlan_list;
        nm_bv_t tag_list;
};

enum nmf_autoneg {
        NMF_AUTONEG_NONE = 1,
        NMF_AUTONEG_SGMII,
        NMF_AUTONEG_CLAUSE_37
};

enum nmf_autoneg_capabilities {
        NMF_PORT_AUTONEG_ANNOUNCE_10G = 1,
        NMF_PORT_AUTONEG_ANNOUNCE_2500M = 2,
        NMF_PORT_AUTONEG_ANNOUNCE_1000M = 4,
        NMF_PORT_AUTONEG_ANNOUNCE_100M = 8,
        NMF_PORT_AUTONEG_ANNOUNCE_10M = 16,
        NMF_PORT_AUTONEG_ANNOUNCE_FLOW_CONTROL = 32
};

enum nmf_dot1x_state {
        NMF_DOT1X_STATE_NOT_ACTIVE = 1,
        NMF_DOT1X_STATE_AUTH,
        NMF_DOT1X_STATE_NOT_AUTH
};

enum nmf_port_capabilities {
        NMF_PORT_CAPABILITY_CAN_ROUTE = 1,
        NMF_PORT_CAPABILITY_LAG_CAPABLE = 2,
        NMF_PORT_CAPABILITY_SPEED_10M = 4,
        NMF_PORT_CAPABILITY_SPEED_100M = 8,
        NMF_PORT_CAPABILITY_SPEED_1G = 16,
        NMF_PORT_CAPABILITY_SPEED_2_5G = 32,
        NMF_PORT_CAPABILITY_SPEED_5G = 64,
        NMF_PORT_CAPABILITY_SPEED_10G = 128,
        NMF_PORT_CAPABILITY_SPEED_20G = 256
};

enum nmf_port_bridging_role {
        NMF_PORT_BRIDGING_ROLE_NORMAL = 1,
        NMF_PORT_BRIDGING_ROLE_CUSTOMER,
        NMF_PORT_BRIDGING_ROLE_NETWORK
};

enum nmf_port_pause_mode {
        NMF_PORT_PAUSE_CLASS_BASED = 1,
        NMF_PORT_PAUSE_NORMAL
};

union nmf_port_attr_value {
        enum nmf_port_capabilities caps;
        enum nmf_autoneg_capabilities autoneg_caps;
        u_int speed;
        u_int mtu;
        enum nmf_autoneg autoneg;
        u_int def_cfi;
        u_int def_dscp;
        u_int def_pri;
        u_int def_swpri;
        u_int def_vlan;
        u_int ifg;
        u_int learning;
        u_int drop_vlan_bv;
        u_int drop_tagged;
        u_int drop_untagged;
        u_char ethaddr[6];
        nm_bv_t fwd_list;
        struct nmf_port_vlan_spec vlan_spec;
        u_int rx_pause_class_mask;
        u_int tx_pause_mode;
        u_int tx_pause_peer_delay;
        u_int tx_pause_resend_delay;
        struct nmf_port_attr_state port_state;
        enum nmf_port_bridging_role bridging_role;
        char *desc;
        u_int min_frame_size;
        enum nmf_port_attr_lane_order rx_lane_ordering;
        enum nmf_port_attr_lane_polarity rx_lane_polarity;
        enum nmf_port_attr_lane_order tx_lane_ordering;
        enum nmf_port_attr_lane_polarity tx_lane_polarity;
        enum nmf_port_security_mode security_mode;
        enum nmf_dot1x_state dot1x_state;
        u_int replace_dscp;
        u_int swpri_dscp_pref;
        u_int update_dscp;
        u_int swpri_source;
        enum nmf_port_tagging_policy tagging;
        u_int tx_pause;
        u_int tx_pause_resend_time;
        u_int txcfi;
        u_int txvpri;
        enum nmf_flood_policy ucast_flood;
        enum nmf_flood_policy mcast_flood;
        u_int mcast_pruning;
        u_int update_routed_frame;
        u_int update_ttl;
        u_int routable;
        u_int loopback_suppression;
        int rx_crc_discard;
};

nmf_status_t nmf_port_attr_set(nmf_client_t clid, int slot,
                               int port,
                               enum nmf_port_attr_id id,
                               union nmf_port_attr_value *value);

nmf_status_t nmf_port_attr_get(nmf_client_t clid, int slot,
                               int port,
                               enum nmf_port_attr_id id,
                               union nmf_port_attr_value *value);

struct nmf_port_stats {
        nm_u64_t rx_ucst_pkts;

        nm_u64_t rx_non_ip_ucst_pkts;

        nm_u64_t rx_ipv4_ucst_pkts;

        nm_u64_t rx_ipv6_ucst_pkts;

        nm_u64_t rx_bcst_pkts;

        nm_u64_t rx_non_ip_bcst_pkts;

        nm_u64_t rx_ipv4_bcst_pkts;

        nm_u64_t rx_ipv6_bcst_pkts;

        nm_u64_t rx_mcst_pkts;

        nm_u64_t rx_non_ip_mcst_pkts;

        nm_u64_t rx_ipv4_mcst_pkts;

        nm_u64_t rx_ipv6_mcst_pkts;

        nm_u64_t rx_pause_pkts;

        nm_u64_t rx_pause_class_pkts;

        nm_u64_t rx_fcs_err_pkts;

        nm_u64_t rx_symbol_err_pkts;

        nm_u64_t rx_size_err_pkts;

        nm_u64_t rx_min_64_pkts;

        nm_u64_t rx_65_127_pkts;

        nm_u64_t rx_128_255_pkts;

        nm_u64_t rx_256_511_pkts;

        nm_u64_t rx_512_1023_pkts;

        nm_u64_t rx_1024_1522_pkts;

        nm_u64_t rx_1523_2047_pkts;

        nm_u64_t rx_2048_4095_pkts;

        nm_u64_t rx_4096_8191_pkts;

        nm_u64_t rx_8192_10239_pkts;

        nm_u64_t rx_10240_max_pkts;

        nm_u64_t rx_undersized_pkts;

        nm_u64_t rx_oversized_pkts;

        nm_u64_t rx_bytes;

        nm_u64_t rx_non_ip_bytes;

        nm_u64_t rx_ipv4_bytes;

        nm_u64_t rx_ipv6_bytes;

        nm_u64_t rx_prio_pkts[8];

        nm_u64_t rx_prio_bytes[8];

        nm_u64_t rx_cpu_trapped_pkts;

        nm_u64_t rx_secure_drop_pkts;

        nm_u64_t rx_vlan_tag_drop_pkts;

        nm_u64_t rx_vlan_bv_pkts;

        nm_u64_t rx_overrun_pkts;

        nm_u64_t tx_ucst_pkts;

        nm_u64_t tx_bcst_pkts;

        nm_u64_t tx_mcst_pkts;

        nm_u64_t tx_pause_pkts;

        nm_u64_t tx_fcs_err_pkts;

        nm_u64_t tx_error_drop_pkts;

        nm_u64_t tx_time_out_pkts;

        nm_u64_t tx_loopback_drop_pkts;

        nm_u64_t tx_min_64_pkts;
        nm_u64_t tx_65_127_pkts;
        nm_u64_t tx_128_255_pkts;
        nm_u64_t tx_256_511_pkts;
        nm_u64_t tx_512_1023_pkts;
        nm_u64_t tx_1024_1522_pkts;
        nm_u64_t tx_1523_2047_pkts;
        nm_u64_t tx_2048_4095_pkts;
        nm_u64_t tx_4096_8191_pkts;
        nm_u64_t tx_8192_10239_pkts;
        nm_u64_t tx_10240_max_pkts;

        nm_u64_t tx_bytes;

        nm_u64_t tx_err_bytes;

        nm_u64_t tx_vlan_bv_pkts;

        nm_u64_t tx_underrun_pkts;

        nm_u64_t ttl_drop_pkts;

        nm_u64_t fid_fwd_pkts;

        nm_u64_t flooded_pkts;

        nm_u64_t pause_drop_pkts;

        nm_u64_t counter_drop_pkts;

        nm_u64_t stp_drop_pkts;
};

nmf_status_t nmf_port_stats_get(nmf_client_t clid, int slot,
                                int port, struct nmf_port_stats *stats);

nmf_status_t nmf_port_stats_reset(nmf_client_t clid, int slot, int port);

char *nmf_err_str(nmf_status_t s);
#define NMF_ALL         (-1)

enum nmf_addr_flags {
        NMF_ADDR_DYNAMIC = 1,   
        NMF_ADDR_STATIC = 2,    
        NMF_ADDR_SECURE = 4     
};

struct nmf_addr_rec {
        u_char eth_addr[6];     
        int vlan;               
        enum nmf_addr_flags flags; 
        nm_bv_t port_list;      
        int age;                
};

nmf_status_t nmf_addr_get(nmf_client_t clid, int slot,
                          struct nmf_addr_rec *adrec);

nmf_status_t nmf_addr_add(nmf_client_t clid, int slot,
                          struct nmf_addr_rec *adrec);

nmf_status_t nmf_addr_rem(nmf_client_t clid, int slot, int vlan_id,
                          u_char *ethaddr);

nmf_status_t nmf_addr_flush(nmf_client_t clid, int slot, nm_u32_t flags,
                            int vlan_id, int port);

enum nmf_stp_state {
        NMF_STP_FORWARDING = 1,
        NMF_STP_LEARNING,
        NMF_STP_LISTENING,
        NMF_STP_BLOCKING,
        NMF_STP_DISABLED
};
typedef enum nmf_stp_state nmf_stp_state_t;

enum nmf_vlan_attr_id {
        NMF_VLAN_ATTR_ROUTING = 1,
        NMF_VLAN_ATTR_REFLECT,
        NMF_VLAN_ATTR_MTU,
        NMF_VLAN_ATTR_IGMP_TRAPPING,
        NMF_VLAN_ATTR_NAME,
        NMF_VLAN_ATTR_DESC
};

union nmf_vlan_attr_value {
        int routing;
        int reflect;
        int mtu;
        int igmp_trapping;
        char *name;
        char *desc;
};

enum nmf_vlan_port_attr_id {
        NMF_VLAN_PORT_ATTR_TAGGING = 1,
        NMF_VLAN_PORT_ATTR_STP_STATE
};

union nmf_vlan_port_attr_value {
        int tagging;
        enum nmf_stp_state stp_state;
};

nmf_status_t nmf_vlan_add(nmf_client_t clid, int slot, int vlan_id,
                          char *vlan_name);

nmf_status_t nmf_vlan_rem(nmf_client_t clid, int slot, int vlan_id);

nmf_status_t nmf_vlan_list_get(nmf_client_t clid, int slot, nm_bv_t *vlan_list);

nmf_status_t nmf_vlan_port_add(nmf_client_t clid, int slot, int vlan_id,
                               int port_num, int tagged,
                               enum nmf_stp_state stp_state);

nmf_status_t nmf_vlan_port_rem(nmf_client_t clid, int slot, int vlan_id, int port_num);

nmf_status_t nmf_vlan_port_list_set(nmf_client_t clid, int slot, int vlan_id,
                                    int tagging, enum nmf_stp_state stp_state,
                                    nm_bv_t *port_list);

nmf_status_t nmf_vlan_port_list_get(nmf_client_t clid, int slot, int vlan_id,
                                    nm_bv_t *port_list);

nmf_status_t nmf_vlan_attr_set(nmf_client_t clid, int slot, int vlan_id,
                               enum nmf_vlan_attr_id id,
                               union nmf_vlan_attr_value *attr);

nmf_status_t nmf_vlan_attr_get(nmf_client_t clid, int slot, int vlan_id,
                               enum nmf_vlan_attr_id id,
                               union nmf_vlan_attr_value *attr);

nmf_status_t nmf_vlan_port_attr_set(nmf_client_t clid, int slot,
                                    int vlan_id, int port_no,
                                    enum nmf_vlan_port_attr_id id,
                                    union nmf_vlan_port_attr_value *attr);

nmf_status_t nmf_vlan_port_attr_get(nmf_client_t clid, int slot,
                                    int vlan_id, int port_no,
                                    enum nmf_vlan_port_attr_id id,
                                    union nmf_vlan_port_attr_value *attr);

/* \} */

nmf_status_t nmf_lag_add(nmf_client_t clid, int slot, int *lag_id, char *name);

nmf_status_t nmf_lag_rem(nmf_client_t clid, int slot, int lag_id);

nmf_status_t nmf_lag_list_get(nmf_client_t clid, int slot, nm_bv_t *lag_list);

nmf_status_t nmf_lag_port_add(nmf_client_t clid, int slot, int lag, int port_num);

nmf_status_t nmf_lag_port_rem(nmf_client_t clid, int slot, int lag, int port_num);

nmf_status_t nmf_lag_port_list_set(nmf_client_t clid, int slot, int lag,
                                   nm_bv_t *port_list);

nmf_status_t nmf_lag_port_list_get(nmf_client_t clid, int slot, int lag,
                                  nm_bv_t *port_list);

enum nmf_lag_hash_flags {
        NMF_LAG_HASH_SA                 = 0x001,
        NMF_LAG_HASH_DA                 = 0x002,
        NMF_LAG_HASH_ETHTYPE            = 0x004,
        NMF_LAG_HASH_VLAN_ID            = 0x008,
        NMF_LAG_HASH_VLAN_PRI           = 0x010,
        NMF_LAG_HASH_SRC_IP             = 0x020,
        NMF_LAG_HASH_DST_IP             = 0x040,
        NMF_LAG_HASH_SRC_TCP_PORT       = 0x080,
        NMF_LAG_HASH_DST_TCP_PORT       = 0x100,
        NMF_LAG_HASH_SRC_UDP_PORT       = 0x200,
        NMF_LAG_HASH_DST_UDP_PORT       = 0x400,
        NMF_LAG_HASH_L2_SYM             = 0x40000000,
        NMF_LAG_HASH_IP_SYM             = 0x80000000
};
enum nmf_lag_attr_id {
        NMF_LAG_ATTR_NAME = 1,
        NMF_LAG_ATTR_DESC,
        NMF_LAG_ATTR_HASH_FLAGS,
        NMF_LAG_ATTR_PORT_LIST
};

union nmf_lag_attr_value {
        char *name;
        nm_u32_t hash_flags;
        nm_bv_t port_list;
};

nmf_status_t nmf_lag_attr_set(nmf_client_t clid, int slot, int lag,
                              enum nmf_lag_attr_id id,
                              union nmf_lag_attr_value *attr);
nmf_status_t nmf_lag_attr_get(nmf_client_t clid, int slot, int lag,
                              enum nmf_lag_attr_id id,
                              union nmf_lag_attr_value *attr);
/* \} */

nmf_status_t nmf_lbg_add(nmf_client_t clid, int slot, int *lbg_id, char *name);

nmf_status_t nmf_lbg_rem(nmf_client_t clid, int slot, int lbg_id);

nmf_status_t nmf_lbg_list_get(nmf_client_t clid, int slot, nm_bv_t *lbg_list);

nmf_status_t nmf_lbg_port_add(nmf_client_t clid, int slot, int lbg_id, int port_num);

nmf_status_t nmf_lbg_port_rem(nmf_client_t clid, int slot, int lbg, int port_num);

nmf_status_t nmf_lbg_port_list_set(nmf_client_t clid, int slot, int lbg,
                                   nm_bv_t *port_list);

nmf_status_t nmf_lbg_port_list_get(nmf_client_t clid, int slot, int lbg,
                                   nm_bv_t *port_list);

enum nmf_lbg_failover_mode {
        NMF_LBG_FO_TO_PORT = 1,
        NMF_LBG_FO_TO_STANDBY_PORT_OR_ANY,
        NMF_LBG_FO_HASH_TO_STANDBY,
        NMF_LBG_FO_HASH_TO_ANY
};
enum nmf_lbg_state {
        NMF_LBG_ACTIVE = 1,
        NMF_LBG_INACTIVE
};

enum nmf_lbg_attr_id {
        NMF_LBG_ATTR_NAME = 1,
        NMF_LBG_ATTR_DESC,
        NMF_LBG_ATTR_PORT_LIST,
        NMF_LBG_ATTR_STATE,
        NMF_LBG_ATTR_VLAN,
        NMF_LBG_ATTR_MODE,
        NMF_LBG_ATTR_FAILOVER_MODE,
        NMF_LBG_ATTR_DIST_MAP,
        NMF_LBG_ATTR_DIST_MAP_SIZE
};

struct nmf_lbg_dist_map {
        size_t len;             
        u_int* map;             
};

union nmf_lbg_attr_value {
        char *name;
        char *desc;
        nm_bv_t port_list;
        enum nmf_lbg_state state;
        int vlan;
        enum nmf_lbg_mode mode;
        enum nmf_lbg_failover_mode fo_mode;
        u_int dist_map_size;
        struct nmf_lbg_dist_map dist_map;
};

nmf_status_t nmf_lbg_attr_set(nmf_client_t clid, int slot, int lbg,
                              enum nmf_lbg_attr_id id,
                              union nmf_lbg_attr_value *attr);
nmf_status_t nmf_lbg_attr_get(nmf_client_t clid, int slot, int lbg,
                              enum nmf_lbg_attr_id id,
                              union nmf_lbg_attr_value *attr);

enum nmf_lbg_port_attr_id {
        NMF_LBG_PORT_ATTR_STATE = 1,
        NMF_LBG_PORT_ATTR_FO_PARTNER
};

enum nmf_lbg_port_state {
        NMF_LBG_PORT_ACTIVE = 1,
        NMF_LBG_PORT_INACTIVE,
        NMF_LBG_PORT_STANDBY
};

union nmf_lbg_port_attr_value {
        enum nmf_lbg_port_state state;
        u_int fo_partner;
};

nmf_status_t nmf_lbg_port_attr_set(nmf_client_t clid, int slot, int lbg, int port,
                                   enum nmf_lbg_port_attr_id id,
                                   union nmf_lbg_port_attr_value *attr);
nmf_status_t nmf_lbg_port_attr_get(nmf_client_t clid, int slot, int lbg, int port,
                                   enum nmf_lbg_port_attr_id id,
                                   union nmf_lbg_port_attr_value *attr);

/* \} */

struct nmf_send {
        u_int port;
        u_int vlan_id;
};

nmf_status_t nmf_pkt_send(nmf_client_t clid, int slot, char * buf, int len,
                          struct nmf_send *args);

nmf_status_t nmf_reg_sz_get(nmf_client_t client_id, int slot_id, char *reg_name,
                            char **val_ptr, int *val_len);

/* \} */

enum nmf_policer_action {
        NMF_POLICER_ACTION_DROP=1,

        NMF_POLICER_ACTION_MKDN
};

enum nmf_policer_color {
        NMF_POLICER_COLOR_GREEN = 1, 
        NMF_POLICER_COLOR_DSCP,  
        NMF_POLICER_COLOR_SWPRI  
};

enum nmf_policer_attr_id {
        NMF_POLICER_ATTR_NAME = 1,

        NMF_POLICER_ATTR_DESC,

        NMF_POLICER_ATTR_STATS,

        NMF_POLICER_ATTR_COMMITTED_ACTION,

        NMF_POLICER_ATTR_COMMITTED_CAPACITY,

        NMF_POLICER_ATTR_COMMITTED_RATE,

        NMF_POLICER_ATTR_EXCESS_ACTION,

        NMF_POLICER_ATTR_EXCESS_CAPACITY,

        NMF_POLICER_ATTR_EXCESS_RATE,

        NMF_POLICER_ATTR_COLOR_SOURCE,

        NMF_POLICER_ATTR_MKDN_DSCP,

        NMF_POLICER_ATTR_MKDN_SWPRI,

        NMF_POLICER_ATTR_MKDN_DSCP_MAP,

        NMF_POLICER_ATTR_MKDN_SWPRI_MAP
};

struct nmf_policer_stats {
        nm_u64_t packet_count;
        nm_u64_t byte_count;
};

union nmf_policer_attr_value {
        char *name;

        char *desc;

        struct nmf_policer_stats stats;

        enum nmf_policer_action committed_action;

        u_int committed_capacity;

        u_int committed_rate;

        enum nmf_policer_action excess_action;

        u_int excess_capacity;

        u_int excess_rate;

        enum nmf_policer_color color_source;

        u_char mkdn_dscp;

        u_char mkdn_swpri;

        u_char *dscp_map;

        u_char *swpri_map;
};

nmf_status_t nmf_policer_add(nmf_client_t client_id, int slot_id,
                             nmf_id_t *policer_id,
                             char *name);

nmf_status_t nmf_policer_rem(nmf_client_t client_id, int slot_id,
                             nmf_id_t policer_id);

nmf_status_t nmf_policer_list_get(nmf_client_t client_id, int slot_id,
                                  nm_bv_t *policer_list);

nmf_status_t nmf_policer_attr_set(nmf_client_t clid, int slot,
                                  nmf_id_t policer_id,
                                  enum nmf_policer_attr_id id,
                                  union nmf_policer_attr_value *attr);
nmf_status_t nmf_policer_attr_get(nmf_client_t clid, int slot,
                                  nmf_id_t policer_id,
                                  enum nmf_policer_attr_id id,
                                  union nmf_policer_attr_value *attr);
/* \} */

struct nmf_cond_param_in6 {
        union {
                nm_u32_t value_u32[4];
                nm_u16_t value_u16[8];
                nm_u8_t value_u8[16];
        };
        union {
                nm_u32_t mask_u32[4];
                nm_u16_t mask_u16[8];
                nm_u8_t mask_u8[16];
        };
};

struct nmf_cond_param_in4 {
        union {
                nm_u32_t value;
                nm_u16_t value_u16[2];
                nm_u8_t value_u8[4];
        };
        union {
                nm_u32_t mask;
                nm_u16_t mask_u16[2];
                nm_u8_t mask_u8[4];
        };
};

struct nmf_cond_param_u32 {
        nm_u32_t value;
        nm_u32_t mask;
};

struct nmf_cond_param_u16 {
        nm_u16_t value;
        nm_u16_t mask;
};

struct nmf_cond_param_u8 {
        u_char value;
        u_char mask;
};

struct nmf_cond_param_eth_addr {
        u_char value[6];
        u_char mask[6];
};

enum nmf_ip_proto {
        NMF_PROTO_UDP = 1,
        NMF_PROTO_TCP,
        NMF_PROTO_SCTP,
        NMF_PROTO_USER,
        NMF_PROTO_ANY
};

struct nmf_cond_param_l4_port {
        nm_u16_t value;
        nm_u16_t mask;
};

struct nmf_cond_param_l4_port_range {
        nm_u16_t min_port;
        nm_u16_t max_port;
};

enum nmf_cond_type {
        NMF_COND_ETH_TYPE = 1,
        NMF_COND_VLAN_ID,
        NMF_COND_VLAN_PRI,
        NMF_COND_SWITCH_PRI,
        NMF_COND_ETH_SRC,
        NMF_COND_ETH_DST,
        NMF_COND_IP_PROTO,
        NMF_COND_IP_FLAGS,
        NMF_COND_IP_DSCP,
        NMF_COND_IP_TTL,
        NMF_COND_IP4_SRC,
        NMF_COND_IP4_DST,
        NMF_COND_IP6_SRC,
        NMF_COND_IP6_DST,
        NMF_COND_IP6_FLOW,
        NMF_COND_TCP_FLAGS,
        NMF_COND_L4_SRC_PORT,
        NMF_COND_L4_DST_PORT,
        NMF_COND_L4_SRC_PORT_RANGE,
        NMF_COND_L4_DST_PORT_RANGE,
        NMF_COND_USER,
        NMF_COND_RX_PORT_LIST
};

struct nmf_cond {
        enum nmf_cond_type cond_id;

        union {
                struct nmf_cond_param_u16 eth_type;
                struct nmf_cond_param_u16 vlan_id;
                struct nmf_cond_param_u8 vlan_pri;
                struct nmf_cond_param_u8 switch_pri;
                struct nmf_cond_param_eth_addr eth_src;
                struct nmf_cond_param_eth_addr eth_dst;
                struct nmf_cond_param_u8 ip_proto;
                struct nmf_cond_param_u8 ip_flags;
                struct nmf_cond_param_u8 ip_dscp;
                struct nmf_cond_param_u8 ip_ttl;
                struct nmf_cond_param_in4 ip4_src;
                struct nmf_cond_param_in4 ip4_dst;
                struct nmf_cond_param_in6 ip6_src;
                struct nmf_cond_param_in6 ip6_dst;
                struct nmf_cond_param_u32 ip6_flow;
                struct nmf_cond_param_u8 tcp_flags;
                struct nmf_cond_param_l4_port l4_src_port;
                struct nmf_cond_param_l4_port l4_dst_port;
                struct nmf_cond_param_l4_port_range l4_src_port_range;
                struct nmf_cond_param_l4_port_range l4_dst_port_range;
                nm_bv_t rx_port_list;
        } param;
};

enum nmf_acl_scope {
        NMF_ACL_SCOPE_IP4               = 0x01,
        NMF_ACL_SCOPE_IP6               = 0x02,
        NMF_ACL_SCOPE_UCAST_ROUTED      = 0x04,
        NMF_ACL_SCOPE_MCAST_ROUTED      = 0x08,
        NMF_ACL_SCOPE_SWITCHED          = 0x10,
        NMF_ACL_SCOPE_NONIP             = 0x20,
        NMF_ACL_SCOPE_ALL               = 0xFF
};

struct nmf_action_redirect {
        nm_bv_t port_list;
        int bypass_lag;
};

struct nmf_action_load_balance {
        int lbg_id;
};

struct nmf_action_police {
        nmf_id_t id;
};

struct nmf_action_mirror {
        int port;
};

struct nmf_action_log {
        int truncate;
};

struct nmf_action_trap {
        int truncate;
};

enum nm_modify_key {
        NMF_MODIFY_USER = 1,
        NMF_MODIFY_VLAN_ID,
        NMF_MODIFY_VLAN_PRI,
        NMF_MODIFY_SWITCH_PRI,
        NMF_MODIFY_IP_DSCP
};
struct nmf_action_modify {
        enum nm_modify_key key;
        union {
                nm_u32_t user;
                nm_u16_t vlan_id;
                nm_u8_t vlan_pri;
                nm_u8_t switch_pri;
                nm_u8_t ip_dscp;
        };
};

enum nmf_action_id {
        NMF_ACTION_PERMIT = 1,

        NMF_ACTION_DROP,

        NMF_ACTION_COUNT,

        NMF_ACTION_REDIRECT,

        NMF_ACTION_LOAD_BALANCE,

        NMF_ACTION_MODIFY,

        NMF_ACTION_POLICE,

        NMF_ACTION_MIRROR,

        NMF_ACTION_LOG,

        NMF_ACTION_TRAP
};

struct nmf_action {
        enum nmf_action_id action_id;
        union {
                /* permit void */
                /* drop void */
                struct nmf_action_redirect redirect;
                struct nmf_action_load_balance load_balance;
                struct nmf_action_modify modify;
                struct nmf_action_police policer;
                struct nmf_action_mirror mirror;
                struct nmf_action_log log;
                struct nmf_action_trap trap;
        } param;
};

enum nmf_acl_state {
        NMF_ACL_DISABLED = 1,
        NMF_ACL_ENABLED
};

enum nmf_acl_attr_id {
        NMF_ACL_ATTR_NAME = 1,
        NMF_ACL_ATTR_DESC,
        NMF_ACL_ATTR_STATE,
        NMF_ACL_ATTR_SCOPE,
        NMF_ACL_ATTR_PRECEDENCE,
        NMF_ACL_ATTR_RULE_COUNT
};
union nmf_acl_attr_value {
        char *name;
        enum nmf_acl_state state;
        nm_u32_t scope;
        nm_u32_t precedence;
        int rule_count;
};

struct nmf_acl_rule_stats {
        nm_u64_t packet_count;
        nm_u64_t byte_count;
};

struct nmf_acl_rule {
        struct nmf_cond *cond;  
        nm_u32_t cond_count;    
        struct nmf_action *action; 
        nm_u32_t action_count;     
};

nmf_status_t nmf_acl_add(nmf_client_t client_id, int slot_id, nmf_id_t *acl_id, char *name,
                         nm_u32_t scope, int precedence);
nmf_status_t nmf_acl_list_get(nmf_client_t client_id, int slot_id, nm_bv_t *bv);

nmf_status_t nmf_acl_rule_add(nmf_client_t client_id, int slot_id,
                              nmf_id_t acl_id, int rule_no,
                              struct nmf_acl_rule *acl_rule);

nmf_status_t nmf_acl_rule_rem(nmf_client_t client_id, int slot_id,
                              nmf_id_t acl_id, int rule);

nmf_status_t nmf_acl_rule_get(nmf_client_t client_id, int slot_id,
                              nmf_id_t acl_id, int rule,
                              struct nmf_acl_rule **acl_rule);

enum nmf_acl_rule_attr_id {
        NMF_ACL_RULE_ATTR_CONDACT = 1,
        NMF_ACL_RULE_ATTR_STATS
};
union nmf_acl_rule_attr_value {
        struct nmf_acl_rule *rule;
        struct nmf_acl_rule_stats stats;
};

nmf_status_t nmf_acl_rule_attr_get(nmf_client_t client_id, int slot_id,
                                   nmf_id_t acl_id, int rule,
                                   enum nmf_acl_rule_attr_id attr_id,
                                   union nmf_acl_rule_attr_value *value);

struct nmf_acl_rule *nmf_acl_rule_alloc(int cond_count, int action_count);

void nmf_acl_rule_free(struct nmf_acl_rule *acl_rule);

struct nmf_acl_rule *nmf_acl_rule_dup(struct nmf_acl_rule *dst);

nmf_status_t nmf_acl_rem(nmf_client_t client_id, int slot_id, nmf_id_t acl_id);

nmf_status_t nmf_acl_commit(nmf_client_t client_id, int slot_id);

nmf_status_t nmf_acl_attr_set(nmf_client_t clid, int slot, nmf_id_t acl_id,
                              enum nmf_acl_attr_id id,
                              union nmf_acl_attr_value *attr);
nmf_status_t nmf_acl_attr_get(nmf_client_t clid, int slot, int acl_id,
                              enum nmf_acl_attr_id id,
                              union nmf_acl_attr_value *attr);

enum nmf_qos_tc_pri_mode {
        NMF_QOS_TC_PRI_MODE_STRICT,

        NMF_QOS_TC_PRI_MODE_BALANCED
};

enum nmf_qos_cn_reaction_mode {
        NMF_QOS_CN_REACTION_FWD = 1,

        NMF_QOS_CN_REACTION_DROP,

        NMF_QOS_CN_REACTION_RATELIM
};

enum nmf_qos_port_attr_id {
        NMF_QOS_PORT_ATTR_RX_VPRI_MAP = 1,

        NMF_QOS_PORT_ATTR_TX_VPRI_MAP,

        NMF_QOS_PORT_ATTR_SCHED_PRI_SETS,

        NMF_QOS_PORT_ATTR_TC_WEIGHTS,

        NMF_QOS_PORT_ATTR_TC_PRI_MODE,

        NMF_QOS_PORT_ATTR_TC_TOKEN_RATE,

        NMF_QOS_PORT_ATTR_TC_BURST_SIZE,

        NMF_QOS_PORT_ATTR_CN_REACTION_MODE,

        NMF_QOS_PORT_ATTR_CN_REACTION_RATE,

        NMF_QOS_PORT_ATTR_CN_FRAME_DMAC_SUFFIX,

        NMF_QOS_PORT_ATTR_CN_MIN,

        NMF_QOS_PORT_ATTR_CN_MAX,

        NMF_QOS_PORT_ATTR_CN_EQ,

        NMF_QOS_PORT_ATTR_CN_SC
};

union nmf_qos_port_attr_value {
        nm_u8_t rx_vpri_map[8];
        nm_u8_t tx_vpri_map[8];
        nm_u8_t sched_pri_map[8];
        nm_u32_t tc_weights[8];
        enum nmf_qos_tc_pri_mode tc_pri_mode[8];
        nm_u64_t tc_token_rate[8];
        nm_u64_t tc_burst_size[8];
        enum nmf_qos_cn_reaction_mode cn_reaction_mode;
        nm_u64_t cn_reaction_rate;
        nm_u32_t cn_frame_dmac_suffix;
        nm_u32_t cn_min;
        nm_u32_t cn_max;
        nm_u32_t cn_eq;
        nm_u32_t cn_sc;
};

enum nmf_qos_cn_mode {
        NMF_QOS_CN_MODE_DISABLED = 1,

        NMF_QOS_CN_MODE_VCN,

        NMF_QOS_CN_MODE_FCN
};

enum nmf_qos_slot_attr_id {
        NMF_QOS_SLOT_ATTR_VPRI_SWPRI_MAP = 1,

        NMF_QOS_SLOT_ATTR_DSCP_SWPRI_MAP,

        NMF_QOS_SLOT_ATTR_SWPRI_TC_MAP,

        NMF_QOS_SLOT_ATTR_TC_SCHEDPRI_MAP,

        NMF_QOS_SLOT_ATTR_CN_MODE,

        NMF_QOS_SLOT_ATTR_CN_FRAME_ETYPE,

        NMF_QOS_SLOT_ATTR_CN_FRAME_VPRI,

        NMF_QOS_SLOT_ATTR_CN_FRAME_VLAN,

        NMF_QOS_SLOT_ATTR_CN_FRAME_SRC_PORT,

        NMF_QOS_SLOT_ATTR_CN_FRAME_SMAC,

        NMF_QOS_SLOT_ATTR_CN_FRAME_DMAC,

        NMF_QOS_SLOT_ATTR_CN_SAMPLING_RATE
};

union nmf_qos_slot_attr_value {
        nm_u8_t vpri_swpri_map[8];
        nm_u8_t dscp_swpri_map[64];
        nm_u8_t swpri_tc_map[16];
        nm_u8_t tc_schedpri_map[8];
        enum nmf_qos_cn_mode cn_mode;
        nm_u16_t cn_frame_etype;
        nm_u8_t cn_frame_vpri;
        nm_u16_t cn_frame_vlan;
        nm_u32_t cn_frame_src_port;
        nm_u8_t cn_frame_smac[6];
        nm_u8_t cn_frame_dmac[6];
        nm_u32_t cn_sampling_rate;
};

nmf_status_t nmf_qos_port_attr_set(nmf_client_t clid, int slot, int port,
                                   enum nmf_qos_port_attr_id id,
                                   union nmf_qos_port_attr_value *attr);

nmf_status_t nmf_qos_port_attr_get(nmf_client_t clid, int slot, int port,
                                   enum nmf_qos_port_attr_id id,
                                   union nmf_qos_port_attr_value *attr);

nmf_status_t nmf_qos_slot_attr_set(nmf_client_t clid, int slot, int port,
                                   enum nmf_qos_slot_attr_id id,
                                   union nmf_qos_slot_attr_value *attr);

nmf_status_t nmf_qos_slot_attr_get(nmf_client_t clid, int slot, int port,
                                   enum nmf_qos_slot_attr_id id,
                                   union nmf_qos_slot_attr_value *attr);

/* \} */

nmf_status_t nmf_mcgrp_add(nmf_client_t clid, int slot, int *mcgrp_id, char *name);

nmf_status_t nmf_mcgrp_rem(nmf_client_t clid, int slot, int mcgrp_id);

nmf_status_t nmf_mcgrp_list_get(nmf_client_t clid, int slot, nm_bv_t *mcgrp_list);

nmf_status_t nmf_mcgrp_port_add(nmf_client_t clid, int slot, int mcgrp_id,
                                int port_num, short vlan_id);

nmf_status_t nmf_mcgrp_port_rem(nmf_client_t clid, int slot, int mcgrp,
                                int port_num, short vlan_id);

nmf_status_t nmf_mcgrp_port_list_get(nmf_client_t clid, int slot,
                                     int mcgrp_id, nm_bv_t *port_list);

nmf_status_t nmf_mcgrp_port_vlan_list_get(nmf_client_t clid, int slot,
                                          int mcgrp_id, int port,
                                          nm_bv_t *vlan_list);

enum nmf_mcgrp_attr_id {
        NMF_MCGRP_ATTR_NAME = 1,
        NMF_MCGRP_ATTR_DESC,
        NMF_MCGRP_ENABLED,
        NMF_MCGRP_FWD_TO_CPU,
        NMF_MCGRP_L2_ONLY,
        NMF_MCGRP_L3_FORWARDED,
        NMF_MCGRP_L2_ADDRESS,
        NMF_MCGRP_PORT_LIST
};

union nmf_mcgrp_attr_value {
        char *name;
        char *desc;
        nm_u32_t enabled;
        nm_u32_t fwd_to_cpu;
        nm_u32_t l2_only;
        nm_u32_t l3_forwarded;
        struct av_t {
                u_char eth_addr[6];
                u_short vlan_id;
        } av;
        nm_bv_t port_list;
};

nmf_status_t nmf_mcgrp_attr_set(nmf_client_t clid, int slot, int mcgrp_id,
                                enum nmf_mcgrp_attr_id id,
                                union nmf_mcgrp_attr_value *attr);
nmf_status_t nmf_mcgrp_attr_get(nmf_client_t clid, int slot, int mcgrp_id,
                                enum nmf_mcgrp_attr_id id,
                                union nmf_mcgrp_attr_value *attr);

#ifdef __cplusplus
}
#endif

#endif

---