/* SPDX-License-Identifier: GPL-2.0+ */
/*
 * Copyright 2013-2016 Freescale Semiconductor, Inc.
 * Copyright 2017 NXP
 */
#ifndef _FSL_DPNI_H
#define _FSL_DPNI_H

/* DPNI Version */
#define DPNI_VER_MAJOR                          7
#define DPNI_VER_MINOR                          3

/* Command IDs */
#define DPNI_CMDID_OPEN                         0x8011
#define DPNI_CMDID_CLOSE                        0x8001
#define DPNI_CMDID_CREATE                       0x9011
#define DPNI_CMDID_DESTROY                      0x9811
#define DPNI_CMDID_GET_API_VERSION              0xa011

#define DPNI_CMDID_ENABLE                       0x0021
#define DPNI_CMDID_DISABLE                      0x0031
#define DPNI_CMDID_GET_ATTR                     0x0041
#define DPNI_CMDID_RESET                        0x0051

#define DPNI_CMDID_SET_POOLS                    0x2002
#define DPNI_CMDID_SET_BUFFER_LAYOUT            0x2651
#define DPNI_CMDID_GET_BUFFER_LAYOUT            0x2641
#define DPNI_CMDID_SET_ERRORS_BEHAVIOR          0x20B1

#define DPNI_CMDID_GET_QDID                     0x2101
#define DPNI_CMDID_GET_TX_DATA_OFFSET           0x2121
#define DPNI_CMDID_GET_LINK_STATE               0x2151
#define DPNI_CMDID_SET_LINK_CFG                 0x21A1

#define DPNI_CMDID_SET_PRIM_MAC                 0x2241
#define DPNI_CMDID_GET_PRIM_MAC                 0x2251
#define DPNI_CMDID_ADD_MAC_ADDR                 0x2261
#define DPNI_CMDID_REMOVE_MAC_ADDR              0x2271

#define DPNI_CMDID_GET_STATISTICS               0x25D1
#define DPNI_CMDID_RESET_STATISTICS             0x25E1
#define DPNI_CMDID_GET_QUEUE                    0x25F1
#define DPNI_CMDID_SET_QUEUE                    0x2601
#define DPNI_CMDID_SET_TX_CONFIRMATION_MODE     0x2661

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_OPEN(cmd, dpni_id) \
        MC_CMD_OP(cmd,   0,     0,      32,     int,    dpni_id)

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_PREP_CFG(param, cfg) \
do { \
        MC_PREP_OP(param, 0, 0,   32, uint16_t, cfg->adv.options); \
        MC_PREP_OP(param, 0, 32,   8, uint16_t, cfg->adv.num_queues); \
        MC_PREP_OP(param, 0, 40,   8, uint16_t, cfg->adv.num_tcs); \
        MC_PREP_OP(param, 0, 48,   8, uint16_t, cfg->adv.mac_entries); \
        MC_PREP_OP(param, 1, 0,   8, uint16_t, cfg->adv.vlan_entries); \
        MC_PREP_OP(param, 1, 16,   8, uint16_t, cfg->adv.qos_entries); \
        MC_PREP_OP(param, 1, 32,   16, uint16_t, cfg->adv.fs_entries); \
} while (0)

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_EXT_CFG(param, cfg) \
do { \
        MC_EXT_OP(param, 0, 0,   32, uint16_t, cfg->adv.options); \
        MC_EXT_OP(param, 0, 32,   8, uint16_t, cfg->adv.num_queues); \
        MC_EXT_OP(param, 0, 40,   8, uint16_t, cfg->adv.num_tcs); \
        MC_EXT_OP(param, 0, 48,   8, uint16_t, cfg->adv.mac_entries); \
        MC_EXT_OP(param, 1, 0,   8, uint16_t, cfg->adv.vlan_entries); \
        MC_EXT_OP(param, 1, 16,   8, uint16_t, cfg->adv.qos_entries); \
        MC_EXT_OP(param, 1, 32,   16, uint16_t, cfg->adv.fs_entries); \
} while (0)

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_CREATE(cmd, cfg) \
do { \
        MC_CMD_OP(cmd, 0, 0,    32,     uint32_t,  cfg->adv.options); \
        MC_CMD_OP(cmd, 0, 32,   8,      uint8_t,   cfg->adv.num_queues); \
        MC_CMD_OP(cmd, 0, 40,   8,      uint8_t,   cfg->adv.num_tcs); \
        MC_CMD_OP(cmd, 0, 48,   8,      uint8_t,   cfg->adv.mac_entries); \
        MC_CMD_OP(cmd, 1, 0,    8,      uint8_t,   cfg->adv.vlan_entries); \
        MC_CMD_OP(cmd, 1, 16,   8,      uint8_t,   cfg->adv.qos_entries); \
        MC_CMD_OP(cmd, 1, 32,   16,     uint8_t,   cfg->adv.fs_entries); \
} while (0)

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_SET_POOLS(cmd, cfg) \
do { \
        MC_CMD_OP(cmd, 0, 0,  8,  uint8_t,  cfg->num_dpbp); \
        MC_CMD_OP(cmd, 0, 8,  1,  int,      cfg->pools[0].backup_pool); \
        MC_CMD_OP(cmd, 0, 9,  1,  int,      cfg->pools[1].backup_pool); \
        MC_CMD_OP(cmd, 0, 10, 1,  int,      cfg->pools[2].backup_pool); \
        MC_CMD_OP(cmd, 0, 11, 1,  int,      cfg->pools[3].backup_pool); \
        MC_CMD_OP(cmd, 0, 12, 1,  int,      cfg->pools[4].backup_pool); \
        MC_CMD_OP(cmd, 0, 13, 1,  int,      cfg->pools[5].backup_pool); \
        MC_CMD_OP(cmd, 0, 14, 1,  int,      cfg->pools[6].backup_pool); \
        MC_CMD_OP(cmd, 0, 15, 1,  int,      cfg->pools[7].backup_pool); \
        MC_CMD_OP(cmd, 0, 32, 32, int,      cfg->pools[0].dpbp_id); \
        MC_CMD_OP(cmd, 4, 32, 16, uint16_t, cfg->pools[0].buffer_size);\
        MC_CMD_OP(cmd, 1, 0,  32, int,      cfg->pools[1].dpbp_id); \
        MC_CMD_OP(cmd, 4, 48, 16, uint16_t, cfg->pools[1].buffer_size);\
        MC_CMD_OP(cmd, 1, 32, 32, int,      cfg->pools[2].dpbp_id); \
        MC_CMD_OP(cmd, 5, 0,  16, uint16_t, cfg->pools[2].buffer_size);\
        MC_CMD_OP(cmd, 2, 0,  32, int,      cfg->pools[3].dpbp_id); \
        MC_CMD_OP(cmd, 5, 16, 16, uint16_t, cfg->pools[3].buffer_size);\
        MC_CMD_OP(cmd, 2, 32, 32, int,      cfg->pools[4].dpbp_id); \
        MC_CMD_OP(cmd, 5, 32, 16, uint16_t, cfg->pools[4].buffer_size);\
        MC_CMD_OP(cmd, 3, 0,  32, int,      cfg->pools[5].dpbp_id); \
        MC_CMD_OP(cmd, 5, 48, 16, uint16_t, cfg->pools[5].buffer_size);\
        MC_CMD_OP(cmd, 3, 32, 32, int,      cfg->pools[6].dpbp_id); \
        MC_CMD_OP(cmd, 6, 0,  16, uint16_t, cfg->pools[6].buffer_size);\
        MC_CMD_OP(cmd, 4, 0,  32, int,      cfg->pools[7].dpbp_id); \
        MC_CMD_OP(cmd, 6, 16, 16, uint16_t, cfg->pools[7].buffer_size);\
} while (0)

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_RSP_GET_ATTR(cmd, attr) \
do { \
        MC_RSP_OP(cmd, 0, 0,  32, int,      attr->options);\
        MC_RSP_OP(cmd, 0, 32,  8,  uint8_t,  attr->max_num_queues); \
        MC_RSP_OP(cmd, 0, 40,  8,  uint8_t,  attr->max_num_tcs); \
        MC_RSP_OP(cmd, 0, 48,  8,  uint8_t,  attr->max_mac_entries); \
        MC_RSP_OP(cmd, 1,  0,  8,  uint8_t,  attr->max_vlan_entries); \
        MC_RSP_OP(cmd, 1, 16,  8,  uint8_t,  attr->max_qos_entries); \
        MC_RSP_OP(cmd, 1, 32, 16,  uint16_t,  attr->max_fs_entries); \
        MC_RSP_OP(cmd, 2,  0,  8,  uint8_t,  attr->max_qos_key_size); \
        MC_RSP_OP(cmd, 2,  8,  8,  uint8_t,  attr->max_fs_key_size); \
        MC_RSP_OP(cmd, 2, 16, 16,  uint16_t,  attr->wriop_version); \
} while (0)

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_SET_ERRORS_BEHAVIOR(cmd, cfg) \
do { \
        MC_CMD_OP(cmd, 0, 0,  32, uint32_t, cfg->errors); \
        MC_CMD_OP(cmd, 0, 32, 4,  enum dpni_error_action, cfg->error_action); \
        MC_CMD_OP(cmd, 0, 36, 1,  int,      cfg->set_frame_annotation); \
} while (0)

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_SET_BUFFER_LAYOUT(cmd, layout, queue) \
do { \
        MC_CMD_OP(cmd, 0, 0,  8, enum dpni_queue_type, queue); \
        MC_CMD_OP(cmd, 1, 0,  16, uint16_t, layout->private_data_size); \
        MC_CMD_OP(cmd, 1, 16, 16, uint16_t, layout->data_align); \
        MC_CMD_OP(cmd, 0, 32, 16, uint16_t, layout->options); \
        MC_CMD_OP(cmd, 0, 48,  1,  int,     layout->pass_timestamp); \
        MC_CMD_OP(cmd, 0, 49,  1,  int,     layout->pass_parser_result); \
        MC_CMD_OP(cmd, 0, 50,  1,  int,     layout->pass_frame_status); \
        MC_CMD_OP(cmd, 1, 32, 16, uint16_t, layout->data_head_room); \
        MC_CMD_OP(cmd, 1, 48, 16, uint16_t, layout->data_tail_room); \
} while (0)

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_RSP_GET_QDID(cmd, qdid) \
        MC_RSP_OP(cmd, 0, 0,  16, uint16_t, qdid)

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_RSP_GET_TX_DATA_OFFSET(cmd, data_offset) \
        MC_RSP_OP(cmd, 0, 0,  16, uint16_t, data_offset)

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_SET_LINK_CFG(cmd, cfg) \
do { \
        MC_CMD_OP(cmd, 1, 0,  32, uint32_t, cfg->rate);\
        MC_CMD_OP(cmd, 2, 0,  64, uint64_t, cfg->options);\
} while (0)

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_RSP_GET_LINK_STATE(cmd, state) \
do { \
        MC_RSP_OP(cmd, 0, 32,  1, int,      state->up);\
        MC_RSP_OP(cmd, 1, 0,  32, uint32_t, state->rate);\
        MC_RSP_OP(cmd, 2, 0,  64, uint64_t, state->options);\
} while (0)



/*                cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_SET_PRIMARY_MAC_ADDR(cmd, mac_addr) \
do { \
        MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
        MC_CMD_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
        MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
        MC_CMD_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
        MC_CMD_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
        MC_CMD_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
} while (0)

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_RSP_GET_PRIMARY_MAC_ADDR(cmd, mac_addr) \
do { \
        MC_RSP_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
        MC_RSP_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
        MC_RSP_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
        MC_RSP_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
        MC_RSP_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
        MC_RSP_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
} while (0)

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_ADD_MAC_ADDR(cmd, mac_addr) \
do { \
        MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
        MC_CMD_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
        MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
        MC_CMD_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
        MC_CMD_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
        MC_CMD_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
} while (0)

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_REMOVE_MAC_ADDR(cmd, mac_addr) \
do { \
        MC_CMD_OP(cmd, 0, 16, 8,  uint8_t,  mac_addr[5]); \
        MC_CMD_OP(cmd, 0, 24, 8,  uint8_t,  mac_addr[4]); \
        MC_CMD_OP(cmd, 0, 32, 8,  uint8_t,  mac_addr[3]); \
        MC_CMD_OP(cmd, 0, 40, 8,  uint8_t,  mac_addr[2]); \
        MC_CMD_OP(cmd, 0, 48, 8,  uint8_t,  mac_addr[1]); \
        MC_CMD_OP(cmd, 0, 56, 8,  uint8_t,  mac_addr[0]); \
} while (0)

#define DPNI_CMD_GET_QUEUE(cmd, type, tc, index) \
do { \
        MC_CMD_OP(cmd, 0,  0,  8, enum dpni_queue_type, type); \
        MC_CMD_OP(cmd, 0,  8,  8, uint8_t, tc); \
        MC_CMD_OP(cmd, 0, 16,  8, uint8_t, index); \
} while (0)

#define DPNI_RSP_GET_QUEUE(cmd, queue) \
do { \
        MC_RSP_OP(cmd, 1,  0, 32, uint32_t, (queue)->destination.id); \
        MC_RSP_OP(cmd, 1, 56,  4, enum dpni_dest, (queue)->destination.type); \
        MC_RSP_OP(cmd, 1, 62,  1, char, (queue)->destination.stash_ctrl); \
        MC_RSP_OP(cmd, 1, 63,  1, char, (queue)->destination.hold_active); \
        MC_RSP_OP(cmd, 2,  0, 64, uint64_t, (queue)->flc); \
        MC_RSP_OP(cmd, 3,  0, 64, uint64_t, (queue)->user_context); \
        MC_RSP_OP(cmd, 4,  0, 32, uint32_t, (queue)->fqid); \
        MC_RSP_OP(cmd, 4, 32, 16, uint16_t, (queue)->qdbin); \
} while (0)

#define DPNI_CMD_SET_QUEUE(cmd, type, tc, index, queue) \
do { \
        MC_CMD_OP(cmd, 0,  0,  8, enum dpni_queue_type, type); \
        MC_CMD_OP(cmd, 0,  8,  8, uint8_t, tc); \
        MC_CMD_OP(cmd, 0, 16,  8, uint8_t, index); \
        MC_CMD_OP(cmd, 0, 24,  8, uint8_t, (queue)->options); \
        MC_CMD_OP(cmd, 1,  0, 32, uint32_t, (queue)->destination.id); \
        MC_CMD_OP(cmd, 1, 56,  4, enum dpni_dest, (queue)->destination.type); \
        MC_CMD_OP(cmd, 1, 62,  1, char, (queue)->destination.stash_ctrl); \
        MC_CMD_OP(cmd, 1, 63,  1, char, (queue)->destination.hold_active); \
        MC_CMD_OP(cmd, 1,  0, 32, uint32_t, (queue)->destination.id); \
        MC_CMD_OP(cmd, 2,  0, 64, uint64_t, (queue)->flc); \
        MC_CMD_OP(cmd, 3,  0, 64, uint64_t, (queue)->user_context); \
} while (0)

/*                      cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_GET_STATISTICS(cmd, page) \
        MC_CMD_OP(cmd, 0, 0, 8, uint8_t, page)

/*                cmd, param, offset, width, type, arg_name */
#define DPNI_RSP_GET_STATISTICS(cmd, stat) \
do { \
        MC_RSP_OP(cmd, 0, 0, 64, uint64_t, (stat)->counter0); \
        MC_RSP_OP(cmd, 1, 0, 64, uint64_t, (stat)->counter1); \
        MC_RSP_OP(cmd, 2, 0, 64, uint64_t, (stat)->counter2); \
        MC_RSP_OP(cmd, 3, 0, 64, uint64_t, (stat)->counter3); \
        MC_RSP_OP(cmd, 4, 0, 64, uint64_t, (stat)->counter4); \
        MC_RSP_OP(cmd, 5, 0, 64, uint64_t, (stat)->counter5); \
        MC_RSP_OP(cmd, 6, 0, 64, uint64_t, (stat)->counter6); \
} while (0)

enum net_prot {
        NET_PROT_NONE = 0,
        NET_PROT_PAYLOAD,
        NET_PROT_ETH,
        NET_PROT_VLAN,
        NET_PROT_IPV4,
        NET_PROT_IPV6,
        NET_PROT_IP,
        NET_PROT_TCP,
        NET_PROT_UDP,
        NET_PROT_UDP_LITE,
        NET_PROT_IPHC,
        NET_PROT_SCTP,
        NET_PROT_SCTP_CHUNK_DATA,
        NET_PROT_PPPOE,
        NET_PROT_PPP,
        NET_PROT_PPPMUX,
        NET_PROT_PPPMUX_SUBFRM,
        NET_PROT_L2TPV2,
        NET_PROT_L2TPV3_CTRL,
        NET_PROT_L2TPV3_SESS,
        NET_PROT_LLC,
        NET_PROT_LLC_SNAP,
        NET_PROT_NLPID,
        NET_PROT_SNAP,
        NET_PROT_MPLS,
        NET_PROT_IPSEC_AH,
        NET_PROT_IPSEC_ESP,
        NET_PROT_UDP_ENC_ESP, /* RFC 3948 */
        NET_PROT_MACSEC,
        NET_PROT_GRE,
        NET_PROT_MINENCAP,
        NET_PROT_DCCP,
        NET_PROT_ICMP,
        NET_PROT_IGMP,
        NET_PROT_ARP,
        NET_PROT_CAPWAP_DATA,
        NET_PROT_CAPWAP_CTRL,
        NET_PROT_RFC2684,
        NET_PROT_ICMPV6,
        NET_PROT_FCOE,
        NET_PROT_FIP,
        NET_PROT_ISCSI,
        NET_PROT_GTP,
        NET_PROT_USER_DEFINED_L2,
        NET_PROT_USER_DEFINED_L3,
        NET_PROT_USER_DEFINED_L4,
        NET_PROT_USER_DEFINED_L5,
        NET_PROT_USER_DEFINED_SHIM1,
        NET_PROT_USER_DEFINED_SHIM2,

        NET_PROT_DUMMY_LAST
};

/**
 * Data Path Network Interface API
 * Contains initialization APIs and runtime control APIs for DPNI
 */

struct fsl_mc_io;

/* General DPNI macros */

/* Maximum number of traffic classes */
#define DPNI_MAX_TC                             8
/* Maximum number of buffer pools per DPNI */
#define DPNI_MAX_DPBP                           8

/* All traffic classes considered; see dpni_set_rx_flow() */
#define DPNI_ALL_TCS                            (uint8_t)(-1)
/* All flows within traffic class considered; see dpni_set_rx_flow() */
#define DPNI_ALL_TC_FLOWS                       (uint16_t)(-1)
/* Generate new flow ID; see dpni_set_tx_flow() */
#define DPNI_NEW_FLOW_ID                        (uint16_t)(-1)
/* use for common tx-conf queue; see dpni_set_tx_conf_<x>() */
#define DPNI_COMMON_TX_CONF                     (uint16_t)(-1)

/**
 * dpni_open() - Open a control session for the specified object
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @dpni_id:    DPNI unique ID
 * @token:      Returned token; use in subsequent API calls
 *
 * This function can be used to open a control session for an
 * already created object; an object may have been declared in
 * the DPL or by calling the dpni_create() function.
 * This function returns a unique authentication token,
 * associated with the specific object ID and the specific MC
 * portal; this token must be used in all subsequent commands for
 * this specific object.
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_open(struct fsl_mc_io  *mc_io,
              uint32_t          cmd_flags,
              int               dpni_id,
              uint16_t          *token);

/**
 * dpni_close() - Close the control session of the object
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 *
 * After this function is called, no further operations are
 * allowed on the object without opening a new control session.
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_close(struct fsl_mc_io *mc_io,
               uint32_t         cmd_flags,
               uint16_t         token);

/* DPNI configuration options */

/**
 * Allow different distribution key profiles for different traffic classes;
 * if not set, a single key profile is assumed
 */
#define DPNI_OPT_ALLOW_DIST_KEY_PER_TC          0x00000001

/**
 * Disable all non-error transmit confirmation; error frames are reported
 * back to a common Tx error queue
 */
#define DPNI_OPT_TX_CONF_DISABLED               0x00000002

/* Disable per-sender private Tx confirmation/error queue */
#define DPNI_OPT_PRIVATE_TX_CONF_ERROR_DISABLED 0x00000004

/**
 * Support distribution based on hashed key;
 * allows statistical distribution over receive queues in a traffic class
 */
#define DPNI_OPT_DIST_HASH                      0x00000010

/**
 * Support distribution based on flow steering;
 * allows explicit control of distribution over receive queues in a traffic
 * class
 */
#define DPNI_OPT_DIST_FS                        0x00000020

/* Unicast filtering support */
#define DPNI_OPT_UNICAST_FILTER                 0x00000080
/* Multicast filtering support */
#define DPNI_OPT_MULTICAST_FILTER               0x00000100
/* VLAN filtering support */
#define DPNI_OPT_VLAN_FILTER                    0x00000200
/* Support IP reassembly on received packets */
#define DPNI_OPT_IPR                            0x00000800
/* Support IP fragmentation on transmitted packets */
#define DPNI_OPT_IPF                            0x00001000
/* VLAN manipulation support */
#define DPNI_OPT_VLAN_MANIPULATION              0x00010000
/* Support masking of QoS lookup keys */
#define DPNI_OPT_QOS_MASK_SUPPORT               0x00020000
/* Support masking of Flow Steering lookup keys */
#define DPNI_OPT_FS_MASK_SUPPORT                0x00040000

/**
 * enum dpni_queue_type - Identifies a type of queue targeted by the command
 * @DPNI_QUEUE_RX: Rx queue
 * @DPNI_QUEUE_TX: Tx queue
 * @DPNI_QUEUE_TX_CONFIRM: Tx confirmation queue
 * @DPNI_QUEUE_RX_ERR: Rx error queue
 */
enum dpni_queue_type {
        DPNI_QUEUE_RX,
        DPNI_QUEUE_TX,
        DPNI_QUEUE_TX_CONFIRM,
        DPNI_QUEUE_RX_ERR,
};

struct dpni_cfg {
                uint8_t mac_addr[6];
        struct {
                uint32_t                options;
                uint16_t                fs_entries;
                uint8_t                 num_queues;
                uint8_t                 num_tcs;
                uint8_t                 mac_entries;
                uint8_t                 vlan_entries;
                uint8_t                 qos_entries;
        } adv;
};

/**
 * struct dpni_extended_cfg - Structure representing extended DPNI configuration
 * @tc_cfg: TCs configuration
 * @ipr_cfg: IP reassembly configuration
 */
struct dpni_extended_cfg {
        /**
         * struct tc_cfg - TC configuration
         * @max_dist: Maximum distribution size for Rx traffic class;
         *      supported values: 1,2,3,4,6,7,8,12,14,16,24,28,32,48,56,64,96,
         *      112,128,192,224,256,384,448,512,768,896,1024;
         *      value '0' will be treated as '1'.
         *      other unsupported values will be round down to the nearest
         *      supported value.
         * @max_fs_entries: Maximum FS entries for Rx traffic class;
         *      '0' means no support for this TC;
         */
        struct {
                uint16_t        max_dist;
                uint16_t        max_fs_entries;
        } tc_cfg[DPNI_MAX_TC];
        /**
         * struct ipr_cfg - Structure representing IP reassembly configuration
         * @max_reass_frm_size: Maximum size of the reassembled frame
         * @min_frag_size_ipv4: Minimum fragment size of IPv4 fragments
         * @min_frag_size_ipv6: Minimum fragment size of IPv6 fragments
         * @max_open_frames_ipv4: Maximum concurrent IPv4 packets in reassembly
         *              process
         * @max_open_frames_ipv6: Maximum concurrent IPv6 packets in reassembly
         *              process
         */
        struct {
                uint16_t max_reass_frm_size;
                uint16_t min_frag_size_ipv4;
                uint16_t min_frag_size_ipv6;
                uint16_t max_open_frames_ipv4;
                uint16_t max_open_frames_ipv6;
        } ipr_cfg;
};

/**
 * dpni_prepare_cfg() - function prepare parameters
 * @cfg: cfg structure
 * @cfg_buf: Zeroed 256 bytes of memory before mapping it to DMA
 *
 * This function has to be called before dpni_create()
 */
int dpni_prepare_cfg(const struct dpni_cfg      *cfg,
                     uint8_t                    *cfg_buf);
/**
 * dpni_create() - Create the DPNI object
 * @mc_io:      Pointer to MC portal's I/O object
 * @token:      Authentication token.
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @cfg:        Configuration structure
 * @obj_id:     Returned obj_id; use in subsequent API calls
 *
 * Create the DPNI object, allocate required resources and
 * perform required initialization.
 *
 * The object can be created either by declaring it in the
 * DPL file, or by calling this function.
 *
 * This function returns a unique authentication token,
 * associated with the specific object ID and the specific MC
 * portal; this token must be used in all subsequent calls to
 * this specific object. For objects that are created using the
 * DPL file, call dpni_open() function to get an authentication
 * token first.
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_create(struct fsl_mc_io        *mc_io,
                uint16_t                token,
                uint32_t                cmd_flags,
                const struct dpni_cfg   *cfg,
                uint32_t                *obj_id);

/**
 * dpni_destroy() - Destroy the DPNI object and release all its resources.
 * @mc_io:      Pointer to MC portal's I/O object
 * @token:      Authentication token.
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @obj_id:     Returned obj_id; use in subsequent API calls
 *
 * Return:      '0' on Success; error code otherwise.
 */
int dpni_destroy(struct fsl_mc_io       *mc_io,
                 uint16_t               token,
                 uint32_t               cmd_flags,
                 uint32_t               obj_id);

/**
 * struct dpni_pools_cfg - Structure representing buffer pools configuration
 * @num_dpbp: Number of DPBPs
 * @pools: Array of buffer pools parameters; The number of valid entries
 *      must match 'num_dpbp' value
 */
struct dpni_pools_cfg {
        uint8_t num_dpbp;
        /**
         * struct pools - Buffer pools parameters
         * @dpbp_id: DPBP object ID
         * @buffer_size: Buffer size
         * @backup_pool: Backup pool
         */
        struct {
                int             dpbp_id;
                uint16_t        buffer_size;
                int             backup_pool;
        } pools[DPNI_MAX_DPBP];
};

/**
 * dpni_set_pools() - Set buffer pools configuration
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @cfg:        Buffer pools configuration
 *
 * mandatory for DPNI operation
 * warning:Allowed only when DPNI is disabled
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_set_pools(struct fsl_mc_io             *mc_io,
                   uint32_t                     cmd_flags,
                   uint16_t                     token,
                   const struct dpni_pools_cfg  *cfg);

/**
 * dpni_enable() - Enable the DPNI, allow sending and receiving frames.
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:              Token of DPNI object
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_enable(struct fsl_mc_io        *mc_io,
                uint32_t                cmd_flags,
                uint16_t                token);

/**
 * dpni_disable() - Disable the DPNI, stop sending and receiving frames.
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_disable(struct fsl_mc_io       *mc_io,
                 uint32_t               cmd_flags,
                 uint16_t               token);


/**
 * dpni_reset() - Reset the DPNI, returns the object to initial state.
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_reset(struct fsl_mc_io *mc_io,
               uint32_t         cmd_flags,
               uint16_t         token);

/**
 * struct dpni_attr - Structure representing DPNI attributes
 * @options: Mask of available options; reflects the value as was given in
 *              object's creation
 * @max_num_queues: Number of queues available (for both Tx and Rx)
 * @max_num_tcs: Maximum number of traffic classes (for both Tx and Rx)
 * @max_mac_entries: Maximum number of traffic classes (for both Tx and Rx)
 * @max_unicast_filters: Maximum number of unicast filters
 * @max_multicast_filters: Maximum number of multicast filters
 * @max_vlan_entries: Maximum number of VLAN filters
 * @max_qos_entries: if 'max_tcs > 1', declares the maximum entries in QoS table
 * @max_fs_entries: declares the maximum entries in flow steering table
 * @max_qos_key_size: Maximum key size for the QoS look-up
 * @max_fs_key_size: Maximum key size for the flow steering
 * @wriop_version: Indicates revision of WRIOP hardware block
 */
struct dpni_attr {
        uint32_t id;
        uint32_t options;
        uint8_t max_num_queues;
        uint8_t max_num_tcs;
        uint8_t max_mac_entries;
        uint8_t max_vlan_entries;
        uint8_t max_qos_entries;
        uint16_t max_fs_entries;
        uint8_t max_qos_key_size;
        uint8_t max_fs_key_size;
        uint16_t wriop_version;
};

/**
 * dpni_get_attributes() - Retrieve DPNI attributes.
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @attr:       Object's attributes
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_get_attributes(struct fsl_mc_io        *mc_io,
                        uint32_t                cmd_flags,
                        uint16_t                token,
                        struct dpni_attr        *attr);

/**
 * dpni_extract_cfg() - extract the parameters
 * @cfg: cfg structure
 * @cfg_buf: 256 bytes of DMA-able memory
 *
 * This function has to be called after dpni_get_attributes()
 */
int dpni_extract_cfg(struct dpni_cfg    *cfg,
                     const uint8_t      *cfg_buf);

/**
 * DPNI errors
 */

/**
 * Extract out of frame header error
 */
#define DPNI_ERROR_EOFHE        0x00020000
/**
 * Frame length error
 */
#define DPNI_ERROR_FLE          0x00002000
/**
 * Frame physical error
 */
#define DPNI_ERROR_FPE          0x00001000
/**
 * Parsing header error
 */
#define DPNI_ERROR_PHE          0x00000020
/**
 * Parser L3 checksum error
 */
#define DPNI_ERROR_L3CE         0x00000004
/**
 * Parser L3 checksum error
 */
#define DPNI_ERROR_L4CE         0x00000001

/**
 * enum dpni_error_action - Defines DPNI behavior for errors
 * @DPNI_ERROR_ACTION_DISCARD: Discard the frame
 * @DPNI_ERROR_ACTION_CONTINUE: Continue with the normal flow
 * @DPNI_ERROR_ACTION_SEND_TO_ERROR_QUEUE: Send the frame to the error queue
 */
enum dpni_error_action {
        DPNI_ERROR_ACTION_DISCARD = 0,
        DPNI_ERROR_ACTION_CONTINUE = 1,
        DPNI_ERROR_ACTION_SEND_TO_ERROR_QUEUE = 2
};

/**
 * struct dpni_error_cfg - Structure representing DPNI errors treatment
 * @errors: Errors mask; use 'DPNI_ERROR__<X>
 * @error_action: The desired action for the errors mask
 * @set_frame_annotation: Set to '1' to mark the errors in frame annotation
 *              status (FAS); relevant only for the non-discard action
 */
struct dpni_error_cfg {
        uint32_t                errors;
        enum dpni_error_action  error_action;
        int                     set_frame_annotation;
};

/**
 * dpni_set_errors_behavior() - Set errors behavior
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @cfg:        Errors configuration
 *
 * this function may be called numerous times with different
 * error masks
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_set_errors_behavior(struct fsl_mc_io           *mc_io,
                             uint32_t                   cmd_flags,
                             uint16_t                   token,
                             struct dpni_error_cfg      *cfg);

/* DPNI buffer layout modification options */

/* Select to modify the time-stamp setting */
#define DPNI_BUF_LAYOUT_OPT_TIMESTAMP           0x00000001
/* Select to modify the parser-result setting; not applicable for Tx */
#define DPNI_BUF_LAYOUT_OPT_PARSER_RESULT       0x00000002
/* Select to modify the frame-status setting */
#define DPNI_BUF_LAYOUT_OPT_FRAME_STATUS        0x00000004
/* Select to modify the private-data-size setting */
#define DPNI_BUF_LAYOUT_OPT_PRIVATE_DATA_SIZE   0x00000008
/* Select to modify the data-alignment setting */
#define DPNI_BUF_LAYOUT_OPT_DATA_ALIGN          0x00000010
/* Select to modify the data-head-room setting */
#define DPNI_BUF_LAYOUT_OPT_DATA_HEAD_ROOM      0x00000020
/*!< Select to modify the data-tail-room setting */
#define DPNI_BUF_LAYOUT_OPT_DATA_TAIL_ROOM      0x00000040

/**
 * struct dpni_buffer_layout - Structure representing DPNI buffer layout
 * @options: Flags representing the suggested modifications to the buffer
 *              layout; Use any combination of 'DPNI_BUF_LAYOUT_OPT_<X>' flags
 * @pass_timestamp: Pass timestamp value
 * @pass_parser_result: Pass parser results
 * @pass_frame_status: Pass frame status
 * @private_data_size: Size kept for private data (in bytes)
 * @data_align: Data alignment
 * @data_head_room: Data head room
 * @data_tail_room: Data tail room
 */
struct dpni_buffer_layout {
        uint16_t options;
        int pass_timestamp;
        int pass_parser_result;
        int pass_frame_status;
        uint16_t private_data_size;
        uint16_t data_align;
        uint16_t data_head_room;
        uint16_t data_tail_room;
};

/**
 * dpni_get_buffer_layout() - Retrieve buffer layout attributes.
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @layout:     Returns buffer layout attributes
 * @type:       DPNI queue type
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_get_buffer_layout(struct fsl_mc_io                     *mc_io,
                           uint32_t                             cmd_flags,
                           uint16_t                             token,
                           const struct dpni_buffer_layout      *layout,
                           enum dpni_queue_type                 type);

/**
 * dpni_set_buffer_layout() - Set buffer layout configuration.
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @layout:     Buffer layout configuration
 * @type:       DPNI queue type
 *
 * Return:      '0' on Success; Error code otherwise.
 *
 * @warning     Allowed only when DPNI is disabled
 */
int dpni_set_buffer_layout(struct fsl_mc_io                     *mc_io,
                           uint32_t                             cmd_flags,
                           uint16_t                             token,
                           const struct dpni_buffer_layout      *layout,
                           enum dpni_queue_type                 type);

/**
 * dpni_get_qdid() - Get the Queuing Destination ID (QDID) that should be used
 *                      for enqueue operations
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @qdid:       Returned virtual QDID value that should be used as an argument
 *                      in all enqueue operations
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_get_qdid(struct fsl_mc_io      *mc_io,
                  uint32_t              cmd_flags,
                  uint16_t              token,
                  uint16_t              *qdid);

/**
 * dpni_get_tx_data_offset() - Get the Tx data offset (from start of buffer)
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @data_offset: Tx data offset (from start of buffer)
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_get_tx_data_offset(struct fsl_mc_io    *mc_io,
                            uint32_t            cmd_flags,
                            uint16_t            token,
                            uint16_t            *data_offset);

/* Enable auto-negotiation */
#define DPNI_LINK_OPT_AUTONEG           0x0000000000000001ULL
/* Enable half-duplex mode */
#define DPNI_LINK_OPT_HALF_DUPLEX       0x0000000000000002ULL
/* Enable pause frames */
#define DPNI_LINK_OPT_PAUSE             0x0000000000000004ULL
/* Enable a-symmetric pause frames */
#define DPNI_LINK_OPT_ASYM_PAUSE        0x0000000000000008ULL

/**
 * struct - Structure representing DPNI link configuration
 * @rate: Rate
 * @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values
 */
struct dpni_link_cfg {
        uint32_t rate;
        uint64_t options;
};

/**
 * dpni_set_link_cfg() - set the link configuration.
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @cfg:        Link configuration
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_set_link_cfg(struct fsl_mc_io                  *mc_io,
                      uint32_t                          cmd_flags,
                      uint16_t                          token,
                      const struct dpni_link_cfg        *cfg);

/**
 * struct dpni_link_state - Structure representing DPNI link state
 * @rate: Rate
 * @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values
 * @up: Link state; '0' for down, '1' for up
 */
struct dpni_link_state {
        uint32_t rate;
        uint64_t options;
        int up;
};

/**
 * dpni_get_link_state() - Return the link state (either up or down)
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @state:      Returned link state;
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_get_link_state(struct fsl_mc_io        *mc_io,
                        uint32_t                cmd_flags,
                        uint16_t                token,
                        struct dpni_link_state  *state);

/**
 * dpni_set_primary_mac_addr() - Set the primary MAC address
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @mac_addr:   MAC address to set as primary address
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_set_primary_mac_addr(struct fsl_mc_io *mc_io,
                              uint32_t          cmd_flags,
                              uint16_t          token,
                              const uint8_t     mac_addr[6]);

/**
 * dpni_get_primary_mac_addr() - Get the primary MAC address
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @mac_addr:   Returned MAC address
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_get_primary_mac_addr(struct fsl_mc_io  *mc_io,
                              uint32_t          cmd_flags,
                              uint16_t          token,
                              uint8_t           mac_addr[6]);

/**
 * dpni_add_mac_addr() - Add MAC address filter
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @mac_addr:   MAC address to add
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_add_mac_addr(struct fsl_mc_io  *mc_io,
                      uint32_t          cmd_flags,
                      uint16_t          token,
                      const uint8_t     mac_addr[6]);

/**
 * dpni_remove_mac_addr() - Remove MAC address filter
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @mac_addr:   MAC address to remove
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_remove_mac_addr(struct fsl_mc_io       *mc_io,
                         uint32_t               cmd_flags,
                         uint16_t               token,
                         const uint8_t          mac_addr[6]);

/**
 * enum dpni_dest - DPNI destination types
 * @DPNI_DEST_NONE: Unassigned destination; The queue is set in parked mode and
 *              does not generate FQDAN notifications; user is expected to
 *              dequeue from the queue based on polling or other user-defined
 *              method
 * @DPNI_DEST_DPIO: The queue is set in schedule mode and generates FQDAN
 *              notifications to the specified DPIO; user is expected to dequeue
 *              from the queue only after notification is received
 * @DPNI_DEST_DPCON: The queue is set in schedule mode and does not generate
 *              FQDAN notifications, but is connected to the specified DPCON
 *              object; user is expected to dequeue from the DPCON channel
 */
enum dpni_dest {
        DPNI_DEST_NONE = 0,
        DPNI_DEST_DPIO = 1,
        DPNI_DEST_DPCON = 2
};

/**
 * struct dpni_dest_cfg - Structure representing DPNI destination parameters
 * @dest_type: Destination type
 * @dest_id: Either DPIO ID or DPCON ID, depending on the destination type
 * @priority: Priority selection within the DPIO or DPCON channel; valid values
 *              are 0-1 or 0-7, depending on the number of priorities in that
 *              channel; not relevant for 'DPNI_DEST_NONE' option
 */
struct dpni_dest_cfg {
        enum dpni_dest dest_type;
        int dest_id;

        uint8_t priority;
};

/**
 * enum dpni_flc_type - DPNI FLC types
 * @DPNI_FLC_USER_DEFINED: select the FLC to be used for user defined value
 * @DPNI_FLC_STASH: select the FLC to be used for stash control
 */
enum dpni_flc_type {
        DPNI_FLC_USER_DEFINED = 0,
        DPNI_FLC_STASH = 1,
};

/**
 * enum dpni_stash_size - DPNI FLC stashing size
 * @DPNI_STASH_SIZE_0B: no stash
 * @DPNI_STASH_SIZE_64B: stashes 64 bytes
 * @DPNI_STASH_SIZE_128B: stashes 128 bytes
 * @DPNI_STASH_SIZE_192B: stashes 192 bytes
 */
enum dpni_stash_size {
        DPNI_STASH_SIZE_0B = 0,
        DPNI_STASH_SIZE_64B = 1,
        DPNI_STASH_SIZE_128B = 2,
        DPNI_STASH_SIZE_192B = 3,
};

/* DPNI FLC stash options */

/* stashes the whole annotation area (up to 192 bytes) */
#define DPNI_FLC_STASH_FRAME_ANNOTATION 0x00000001

/**
 * struct dpni_flc_cfg - Structure representing DPNI FLC configuration
 * @flc_type: FLC type
 * @options: Mask of available options;
 *      use 'DPNI_FLC_STASH_<X>' values
 * @frame_data_size: Size of frame data to be stashed
 * @flow_context_size: Size of flow context to be stashed
 * @flow_context: 1. In case flc_type is 'DPNI_FLC_USER_DEFINED':
 *                      this value will be provided in the frame descriptor
 *                      (FD[FLC])
 *                2. In case flc_type is 'DPNI_FLC_STASH':
 *                      this value will be I/O virtual address of the
 *                      flow-context;
 *                      Must be cacheline-aligned and DMA-able memory
 */
struct dpni_flc_cfg {
        enum dpni_flc_type flc_type;
        uint32_t options;
        enum dpni_stash_size frame_data_size;
        enum dpni_stash_size flow_context_size;
        uint64_t flow_context;
};

/* DPNI queue modification options */

/* Select to modify the user's context associated with the queue */
#define DPNI_QUEUE_OPT_USER_CTX         0x00000001
/* Select to modify the queue's destination */
#define DPNI_QUEUE_OPT_DEST             0x00000002
/** Select to modify the flow-context parameters;
 * not applicable for Tx-conf/Err queues as the FD comes from the user
 */
#define DPNI_QUEUE_OPT_FLC              0x00000004
/* Select to modify the queue's order preservation */
#define DPNI_QUEUE_OPT_ORDER_PRESERVATION 0x00000008
/* Select to modify the queue's tail-drop threshold */
#define DPNI_QUEUE_OPT_TAILDROP_THRESHOLD 0x00000010

/**
 * struct dpni_queue_cfg - Structure representing queue configuration
 * @options: Flags representing the suggested modifications to the queue;
 *              Use any combination of 'DPNI_QUEUE_OPT_<X>' flags
 * @user_ctx: User context value provided in the frame descriptor of each
 *              dequeued frame; valid only if 'DPNI_QUEUE_OPT_USER_CTX'
 *              is contained in 'options'
 * @dest_cfg: Queue destination parameters;
 *              valid only if 'DPNI_QUEUE_OPT_DEST' is contained in 'options'
 * @flc_cfg: Flow context configuration; in case the TC's distribution
 *              is either NONE or HASH the FLC's settings of flow#0 are used.
 *              in the case of FS (flow-steering) the flow's FLC settings
 *              are used.
 *              valid only if 'DPNI_QUEUE_OPT_FLC' is contained in 'options'
 * @order_preservation_en: enable/disable order preservation;
 *              valid only if 'DPNI_QUEUE_OPT_ORDER_PRESERVATION' is contained
 *              in 'options'
 * @tail_drop_threshold: set the queue's tail drop threshold in bytes;
 *              '0' value disable the threshold; maximum value is 0xE000000;
 *              valid only if 'DPNI_QUEUE_OPT_TAILDROP_THRESHOLD' is contained
 *              in 'options'
 */
struct dpni_queue_cfg {
        uint32_t options;
        uint64_t user_ctx;
        struct dpni_dest_cfg dest_cfg;
        struct dpni_flc_cfg flc_cfg;
        int order_preservation_en;
        uint32_t tail_drop_threshold;
};

/**
 * struct dpni_queue_attr - Structure representing queue attributes
 * @user_ctx: User context value provided in the frame descriptor of each
 *      dequeued frame
 * @dest_cfg: Queue destination configuration
 * @flc_cfg: Flow context configuration
 * @order_preservation_en: enable/disable order preservation
 * @tail_drop_threshold: queue's tail drop threshold in bytes;
 * @fqid: Virtual fqid value to be used for dequeue operations
 */
struct dpni_queue_attr {
        uint64_t user_ctx;
        struct dpni_dest_cfg dest_cfg;
        struct dpni_flc_cfg flc_cfg;
        int order_preservation_en;
        uint32_t tail_drop_threshold;
        uint32_t fqid;
};

/* DPNI Tx flow modification options */

/* Select to modify the settings for dedicate Tx confirmation/error */
#define DPNI_TX_FLOW_OPT_TX_CONF_ERROR  0x00000001
/*!< Select to modify the L3 checksum generation setting */
#define DPNI_TX_FLOW_OPT_L3_CHKSUM_GEN  0x00000010
/*!< Select to modify the L4 checksum generation setting */
#define DPNI_TX_FLOW_OPT_L4_CHKSUM_GEN  0x00000020

/**
 * dpni_get_api_version - Retrieve DPNI Major and Minor version info.
 *
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @major_ver:  DPNI major version
 * @minor_ver:  DPNI minor version
 *
 * Return:     '0' on Success; Error code otherwise.
 */
int dpni_get_api_version(struct fsl_mc_io *mc_io,
                         u32 cmd_flags,
                         u16 *major_ver,
                         u16 *minor_ver);

/**
 * enum dpni_confirmation_mode - Defines DPNI options supported for Tx
 * confirmation
 * @DPNI_CONF_AFFINE: For each Tx queue set associated with a sender there is
 * an affine Tx Confirmation queue
 * @DPNI_CONF_SINGLE: All Tx queues are associated with a single Tx
 * confirmation queue
 * @DPNI_CONF_DISABLE: Tx frames are not confirmed.  This must be associated
 * with proper FD set-up to have buffers release to a Buffer Pool, otherwise
 * buffers will be leaked.
 */
enum dpni_confirmation_mode {
        DPNI_CONF_AFFINE,
        DPNI_CONF_SINGLE,
        DPNI_CONF_DISABLE,
};

struct dpni_tx_confirmation_mode {
        uint32_t pad;
        uint8_t confirmation_mode;
};

/**
 * struct dpni_queue - Queue structure
 * @fqid:  FQID used for enqueueing to and/or configuration of this specific FQ
 * @qdbin: Queueing bin, used to enqueue using QDID, DQBIN, QPRI. Only relevant
 *         for Tx queues.
 * @flc:   FLC value for traffic dequeued from this queue.
 * @user_context:    User data, presented to the user along with any frames
 *                   from this queue. Not relevant for Tx queues.
 */
struct dpni_queue {
        /**
        * struct destination - Destination structure
        * @id:   ID of the destination, only relevant if DEST_TYPE is > 0.
        *        Identifies either a DPIO or a DPCON object. Not relevant for Tx
        *        queues.
        * @type: May be one of the following:
        *         0 - No destination, queue can be manually queried, but won't
        *             push traffic or notifications to a DPIO;
        *         1 - The destination is DPIO. When traffic becomes available in
        *             the queue a FQDAN (FQ data available notification) will be
        *             generated to selected DPIO;
        *         2 - The destination is a DPCON. The queue is associated with a
        *             DPCON object for purpose of scheduling between multiple
        *             queues. The DPCON may be independently configured to
        *             generate notifications. Not relevant for Tx queues.
        * @hold_active: Hold active
        */
        struct {
                uint32_t id;
                enum dpni_dest type;
                char hold_active;
                char stash_ctrl;
        } destination;
        uint8_t  options;
        uint32_t fqid;
        uint16_t qdbin;
        uint64_t flc;
        uint64_t user_context;
};

/**
 * dpni_set_queue() - Set queue parameters
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @type:       Type of queue
 * @tc:         Traffic class, in range 0 to NUM_TCS - 1
 * @index:      Selects the specific queue out of the set allocated for the same
 *              TC. Value must be in range 0 to NUM_QUEUES - 1
 * @queue:      Queue structure
 *
 * Return:     '0' on Success; Error code otherwise.
 */
int dpni_set_queue(struct fsl_mc_io             *mc_io,
                   uint32_t                     cmd_flags,
                   uint16_t                     token,
                   enum dpni_queue_type         type,
                   uint8_t                      tc,
                   uint8_t                      index,
                   const struct dpni_queue      *queue);

/**
 * dpni_get_queue() - Get queue parameters
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @type:       Type of queue
 * @tc:         Traffic class, in range 0 to NUM_TCS - 1
 * @index:      Selects the specific queue out of the set allocated for the same
 *              TC. Value must be in range 0 to NUM_QUEUES - 1
 * @queue:      Queue structure
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_get_queue(struct fsl_mc_io             *mc_io,
                   uint32_t                     cmd_flags,
                   uint16_t                     token,
                   enum dpni_queue_type         type,
                   uint8_t                      tc,
                   uint8_t                      index,
                   struct dpni_queue            *queue);

/**
 * dpni_set_tx_confirmation_mode() - Set TX conf mode
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @mode:       DPNI confirmation mode type
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_set_tx_confirmation_mode(struct fsl_mc_io      *mc_io,
                                  uint32_t              cmd_flags,
                                  uint16_t              token,
                                  enum dpni_confirmation_mode mode);
struct dpni_statistics {
        /**
         * Page_0 statistics structure
         * @ingress_all_frames: Ingress frame count
         * @ingress_all_bytes: Ingress byte count
         * @ingress_multicast_frames: Ingress multicast frame count
         * @ingress_multicast_bytes: Ingress multicast byte count
         * @ingress_broadcast_frames: Ingress broadcast frame count
         * @ingress_broadcast_bytes: Ingress broadcast byte count
         *
         * Page_1 statistics structure
         * @egress_all_frames: Egress frame count
         * @egress_all_bytes: Egress byte count
         * @egress_multicast_frames: Egress multicast frame count
         * @egress_multicast_bytes: Egress multicast byte count
         * @egress_broadcast_frames: Egress broadcast frame count
         * @egress_broadcast_bytes: Egress broadcast byte count
         *
         * Page_2 statistics structure
         * @ingress_filtered_frames: Ingress filtered frame count
         * @ingress_discarded_frames: Ingress discarded frame count
         * @ingress_nobuffer_discards: Ingress discarded frame count due to
         *  lack of buffers.
         * @egress_discarded_frames: Egress discarded frame count
         * @egress_confirmed_frames: Egress confirmed frame count
         */

        uint64_t counter0;
        uint64_t counter1;
        uint64_t counter2;
        uint64_t counter3;
        uint64_t counter4;
        uint64_t counter5;
        uint64_t counter6;
};

/**
 * dpni_get_statistics() - Get DPNI statistics
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 * @page:       Selects the statistics page to retrieve, see DPNI_GET_STATISTICS
 *              output. Pages are numbered 0 to 2.
 * @stat:       Structure containing the statistics
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_get_statistics(struct fsl_mc_io *mc_io,
                        uint32_t cmd_flags,
                        uint16_t token,
                        uint8_t page,
                        struct dpni_statistics *stat);

/**
 * dpni_reset_statistics() - Clears DPNI statistics
 * @mc_io:      Pointer to MC portal's I/O object
 * @cmd_flags:  Command flags; one or more of 'MC_CMD_FLAG_'
 * @token:      Token of DPNI object
 *
 * Return:      '0' on Success; Error code otherwise.
 */
int dpni_reset_statistics(struct fsl_mc_io *mc_io,
                          uint32_t cmd_flags,
                          uint16_t token);
#endif /* _FSL_DPNI_H */