blob: f396dc304fe2a77c1f4b3f35734256969694264d [file] [log] [blame]
/*
* Copyright (C) 2013-2015 Freescale Semiconductor
*
* SPDX-License-Identifier: GPL-2.0+
*/
#ifndef _FSL_DPNI_H
#define _FSL_DPNI_H
/* DPNI Version */
#define DPNI_VER_MAJOR 6
#define DPNI_VER_MINOR 0
/* Command IDs */
#define DPNI_CMDID_OPEN 0x801
#define DPNI_CMDID_CLOSE 0x800
#define DPNI_CMDID_CREATE 0x901
#define DPNI_CMDID_DESTROY 0x900
#define DPNI_CMDID_ENABLE 0x002
#define DPNI_CMDID_DISABLE 0x003
#define DPNI_CMDID_GET_ATTR 0x004
#define DPNI_CMDID_RESET 0x005
#define DPNI_CMDID_SET_POOLS 0x200
#define DPNI_CMDID_GET_RX_BUFFER_LAYOUT 0x201
#define DPNI_CMDID_SET_RX_BUFFER_LAYOUT 0x202
#define DPNI_CMDID_GET_TX_BUFFER_LAYOUT 0x203
#define DPNI_CMDID_SET_TX_BUFFER_LAYOUT 0x204
#define DPNI_CMDID_SET_TX_CONF_BUFFER_LAYOUT 0x205
#define DPNI_CMDID_GET_TX_CONF_BUFFER_LAYOUT 0x206
#define DPNI_CMDID_SET_ERRORS_BEHAVIOR 0x20B
#define DPNI_CMDID_GET_QDID 0x210
#define DPNI_CMDID_GET_TX_DATA_OFFSET 0x212
#define DPNI_CMDID_GET_COUNTER 0x213
#define DPNI_CMDID_SET_COUNTER 0x214
#define DPNI_CMDID_GET_LINK_STATE 0x215
#define DPNI_CMDID_SET_LINK_CFG 0x21A
#define DPNI_CMDID_SET_PRIM_MAC 0x224
#define DPNI_CMDID_GET_PRIM_MAC 0x225
#define DPNI_CMDID_ADD_MAC_ADDR 0x226
#define DPNI_CMDID_REMOVE_MAC_ADDR 0x227
#define DPNI_CMDID_SET_TX_FLOW 0x236
#define DPNI_CMDID_GET_TX_FLOW 0x237
#define DPNI_CMDID_SET_RX_FLOW 0x238
#define DPNI_CMDID_GET_RX_FLOW 0x239
#define DPNI_CMDID_SET_TX_CONF 0x257
#define DPNI_CMDID_GET_TX_CONF 0x258
/* cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_OPEN(cmd, dpni_id) \
MC_CMD_OP(cmd, 0, 0, 32, int, dpni_id)
#define DPNI_PREP_EXTENDED_CFG(ext, cfg) \
do { \
MC_PREP_OP(ext, 0, 0, 16, uint16_t, cfg->tc_cfg[0].max_dist); \
MC_PREP_OP(ext, 0, 16, 16, uint16_t, cfg->tc_cfg[0].max_fs_entries); \
MC_PREP_OP(ext, 0, 32, 16, uint16_t, cfg->tc_cfg[1].max_dist); \
MC_PREP_OP(ext, 0, 48, 16, uint16_t, cfg->tc_cfg[1].max_fs_entries); \
MC_PREP_OP(ext, 1, 0, 16, uint16_t, cfg->tc_cfg[2].max_dist); \
MC_PREP_OP(ext, 1, 16, 16, uint16_t, cfg->tc_cfg[2].max_fs_entries); \
MC_PREP_OP(ext, 1, 32, 16, uint16_t, cfg->tc_cfg[3].max_dist); \
MC_PREP_OP(ext, 1, 48, 16, uint16_t, cfg->tc_cfg[3].max_fs_entries); \
MC_PREP_OP(ext, 2, 0, 16, uint16_t, cfg->tc_cfg[4].max_dist); \
MC_PREP_OP(ext, 2, 16, 16, uint16_t, cfg->tc_cfg[4].max_fs_entries); \
MC_PREP_OP(ext, 2, 32, 16, uint16_t, cfg->tc_cfg[5].max_dist); \
MC_PREP_OP(ext, 2, 48, 16, uint16_t, cfg->tc_cfg[5].max_fs_entries); \
MC_PREP_OP(ext, 3, 0, 16, uint16_t, cfg->tc_cfg[6].max_dist); \
MC_PREP_OP(ext, 3, 16, 16, uint16_t, cfg->tc_cfg[6].max_fs_entries); \
MC_PREP_OP(ext, 3, 32, 16, uint16_t, cfg->tc_cfg[7].max_dist); \
MC_PREP_OP(ext, 3, 48, 16, uint16_t, cfg->tc_cfg[7].max_fs_entries); \
MC_PREP_OP(ext, 4, 0, 16, uint16_t, \
cfg->ipr_cfg.max_open_frames_ipv4); \
MC_PREP_OP(ext, 4, 16, 16, uint16_t, \
cfg->ipr_cfg.max_open_frames_ipv6); \
MC_PREP_OP(ext, 4, 32, 16, uint16_t, \
cfg->ipr_cfg.max_reass_frm_size); \
MC_PREP_OP(ext, 5, 0, 16, uint16_t, \
cfg->ipr_cfg.min_frag_size_ipv4); \
MC_PREP_OP(ext, 5, 16, 16, uint16_t, \
cfg->ipr_cfg.min_frag_size_ipv6); \
} while (0)
#define DPNI_EXT_EXTENDED_CFG(ext, cfg) \
do { \
MC_EXT_OP(ext, 0, 0, 16, uint16_t, cfg->tc_cfg[0].max_dist); \
MC_EXT_OP(ext, 0, 16, 16, uint16_t, cfg->tc_cfg[0].max_fs_entries); \
MC_EXT_OP(ext, 0, 32, 16, uint16_t, cfg->tc_cfg[1].max_dist); \
MC_EXT_OP(ext, 0, 48, 16, uint16_t, cfg->tc_cfg[1].max_fs_entries); \
MC_EXT_OP(ext, 1, 0, 16, uint16_t, cfg->tc_cfg[2].max_dist); \
MC_EXT_OP(ext, 1, 16, 16, uint16_t, cfg->tc_cfg[2].max_fs_entries); \
MC_EXT_OP(ext, 1, 32, 16, uint16_t, cfg->tc_cfg[3].max_dist); \
MC_EXT_OP(ext, 1, 48, 16, uint16_t, cfg->tc_cfg[3].max_fs_entries); \
MC_EXT_OP(ext, 2, 0, 16, uint16_t, cfg->tc_cfg[4].max_dist); \
MC_EXT_OP(ext, 2, 16, 16, uint16_t, cfg->tc_cfg[4].max_fs_entries); \
MC_EXT_OP(ext, 2, 32, 16, uint16_t, cfg->tc_cfg[5].max_dist); \
MC_EXT_OP(ext, 2, 48, 16, uint16_t, cfg->tc_cfg[5].max_fs_entries); \
MC_EXT_OP(ext, 3, 0, 16, uint16_t, cfg->tc_cfg[6].max_dist); \
MC_EXT_OP(ext, 3, 16, 16, uint16_t, cfg->tc_cfg[6].max_fs_entries); \
MC_EXT_OP(ext, 3, 32, 16, uint16_t, cfg->tc_cfg[7].max_dist); \
MC_EXT_OP(ext, 3, 48, 16, uint16_t, cfg->tc_cfg[7].max_fs_entries); \
MC_EXT_OP(ext, 4, 0, 16, uint16_t, \
cfg->ipr_cfg.max_open_frames_ipv4); \
MC_EXT_OP(ext, 4, 16, 16, uint16_t, \
cfg->ipr_cfg.max_open_frames_ipv6); \
MC_EXT_OP(ext, 4, 32, 16, uint16_t, \
cfg->ipr_cfg.max_reass_frm_size); \
MC_EXT_OP(ext, 5, 0, 16, uint16_t, \
cfg->ipr_cfg.min_frag_size_ipv4); \
MC_EXT_OP(ext, 5, 16, 16, uint16_t, \
cfg->ipr_cfg.min_frag_size_ipv6); \
} while (0)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_CREATE(cmd, cfg) \
do { \
MC_CMD_OP(cmd, 0, 0, 8, uint8_t, cfg->adv.max_tcs); \
MC_CMD_OP(cmd, 0, 8, 8, uint8_t, cfg->adv.max_senders); \
MC_CMD_OP(cmd, 0, 16, 8, uint8_t, cfg->mac_addr[5]); \
MC_CMD_OP(cmd, 0, 24, 8, uint8_t, cfg->mac_addr[4]); \
MC_CMD_OP(cmd, 0, 32, 8, uint8_t, cfg->mac_addr[3]); \
MC_CMD_OP(cmd, 0, 40, 8, uint8_t, cfg->mac_addr[2]); \
MC_CMD_OP(cmd, 0, 48, 8, uint8_t, cfg->mac_addr[1]); \
MC_CMD_OP(cmd, 0, 56, 8, uint8_t, cfg->mac_addr[0]); \
MC_CMD_OP(cmd, 1, 0, 32, uint32_t, cfg->adv.options); \
MC_CMD_OP(cmd, 2, 0, 8, uint8_t, cfg->adv.max_unicast_filters); \
MC_CMD_OP(cmd, 2, 8, 8, uint8_t, cfg->adv.max_multicast_filters); \
MC_CMD_OP(cmd, 2, 16, 8, uint8_t, cfg->adv.max_vlan_filters); \
MC_CMD_OP(cmd, 2, 24, 8, uint8_t, cfg->adv.max_qos_entries); \
MC_CMD_OP(cmd, 2, 32, 8, uint8_t, cfg->adv.max_qos_key_size); \
MC_CMD_OP(cmd, 2, 48, 8, uint8_t, cfg->adv.max_dist_key_size); \
MC_CMD_OP(cmd, 2, 56, 8, enum net_prot, cfg->adv.start_hdr); \
MC_CMD_OP(cmd, 4, 48, 8, uint8_t, cfg->adv.max_policers); \
MC_CMD_OP(cmd, 4, 56, 8, uint8_t, cfg->adv.max_congestion_ctrl); \
MC_CMD_OP(cmd, 5, 0, 64, uint64_t, cfg->adv.ext_cfg_iova); \
} 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_CMD_GET_ATTR(cmd, attr) \
MC_CMD_OP(cmd, 6, 0, 64, uint64_t, attr->ext_cfg_iova)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_RSP_GET_ATTR(cmd, attr) \
do { \
MC_RSP_OP(cmd, 0, 0, 32, int, attr->id);\
MC_RSP_OP(cmd, 0, 32, 8, uint8_t, attr->max_tcs); \
MC_RSP_OP(cmd, 0, 40, 8, uint8_t, attr->max_senders); \
MC_RSP_OP(cmd, 0, 48, 8, enum net_prot, attr->start_hdr); \
MC_RSP_OP(cmd, 1, 0, 32, uint32_t, attr->options); \
MC_RSP_OP(cmd, 2, 0, 8, uint8_t, attr->max_unicast_filters); \
MC_RSP_OP(cmd, 2, 8, 8, uint8_t, attr->max_multicast_filters);\
MC_RSP_OP(cmd, 2, 16, 8, uint8_t, attr->max_vlan_filters); \
MC_RSP_OP(cmd, 2, 24, 8, uint8_t, attr->max_qos_entries); \
MC_RSP_OP(cmd, 2, 32, 8, uint8_t, attr->max_qos_key_size); \
MC_RSP_OP(cmd, 2, 40, 8, uint8_t, attr->max_dist_key_size); \
MC_RSP_OP(cmd, 4, 48, 8, uint8_t, attr->max_policers); \
MC_RSP_OP(cmd, 4, 56, 8, uint8_t, attr->max_congestion_ctrl); \
MC_RSP_OP(cmd, 5, 32, 16, uint16_t, attr->version.major);\
MC_RSP_OP(cmd, 5, 48, 16, uint16_t, attr->version.minor);\
} 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_RSP_GET_RX_BUFFER_LAYOUT(cmd, layout) \
do { \
MC_RSP_OP(cmd, 0, 0, 16, uint16_t, layout->private_data_size); \
MC_RSP_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \
MC_RSP_OP(cmd, 1, 0, 1, int, layout->pass_timestamp); \
MC_RSP_OP(cmd, 1, 1, 1, int, layout->pass_parser_result); \
MC_RSP_OP(cmd, 1, 2, 1, int, layout->pass_frame_status); \
MC_RSP_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \
MC_RSP_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \
} while (0)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_SET_RX_BUFFER_LAYOUT(cmd, layout) \
do { \
MC_CMD_OP(cmd, 0, 0, 16, uint16_t, layout->private_data_size); \
MC_CMD_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \
MC_CMD_OP(cmd, 0, 32, 32, uint32_t, layout->options); \
MC_CMD_OP(cmd, 1, 0, 1, int, layout->pass_timestamp); \
MC_CMD_OP(cmd, 1, 1, 1, int, layout->pass_parser_result); \
MC_CMD_OP(cmd, 1, 2, 1, int, layout->pass_frame_status); \
MC_CMD_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \
MC_CMD_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \
} while (0)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_RSP_GET_TX_BUFFER_LAYOUT(cmd, layout) \
do { \
MC_RSP_OP(cmd, 0, 0, 16, uint16_t, layout->private_data_size); \
MC_RSP_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \
MC_RSP_OP(cmd, 1, 0, 1, int, layout->pass_timestamp); \
MC_RSP_OP(cmd, 1, 1, 1, int, layout->pass_parser_result); \
MC_RSP_OP(cmd, 1, 2, 1, int, layout->pass_frame_status); \
MC_RSP_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \
MC_RSP_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \
} while (0)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_SET_TX_BUFFER_LAYOUT(cmd, layout) \
do { \
MC_CMD_OP(cmd, 0, 0, 16, uint16_t, layout->private_data_size); \
MC_CMD_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \
MC_CMD_OP(cmd, 0, 32, 32, uint32_t, layout->options); \
MC_CMD_OP(cmd, 1, 0, 1, int, layout->pass_timestamp); \
MC_CMD_OP(cmd, 1, 1, 1, int, layout->pass_parser_result); \
MC_CMD_OP(cmd, 1, 2, 1, int, layout->pass_frame_status); \
MC_CMD_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \
MC_CMD_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \
} while (0)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_RSP_GET_TX_CONF_BUFFER_LAYOUT(cmd, layout) \
do { \
MC_RSP_OP(cmd, 0, 0, 16, uint16_t, layout->private_data_size); \
MC_RSP_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \
MC_RSP_OP(cmd, 1, 0, 1, int, layout->pass_timestamp); \
MC_RSP_OP(cmd, 1, 1, 1, int, layout->pass_parser_result); \
MC_RSP_OP(cmd, 1, 2, 1, int, layout->pass_frame_status); \
MC_RSP_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \
MC_RSP_OP(cmd, 1, 32, 16, uint16_t, layout->data_tail_room); \
} while (0)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_SET_TX_CONF_BUFFER_LAYOUT(cmd, layout) \
do { \
MC_CMD_OP(cmd, 0, 0, 16, uint16_t, layout->private_data_size); \
MC_CMD_OP(cmd, 0, 16, 16, uint16_t, layout->data_align); \
MC_CMD_OP(cmd, 0, 32, 32, uint32_t, layout->options); \
MC_CMD_OP(cmd, 1, 0, 1, int, layout->pass_timestamp); \
MC_CMD_OP(cmd, 1, 1, 1, int, layout->pass_parser_result); \
MC_CMD_OP(cmd, 1, 2, 1, int, layout->pass_frame_status); \
MC_CMD_OP(cmd, 1, 16, 16, uint16_t, layout->data_head_room); \
MC_CMD_OP(cmd, 1, 32, 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_GET_COUNTER(cmd, counter) \
MC_CMD_OP(cmd, 0, 0, 16, enum dpni_counter, counter)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_RSP_GET_COUNTER(cmd, value) \
MC_RSP_OP(cmd, 1, 0, 64, uint64_t, value)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_SET_COUNTER(cmd, counter, value) \
do { \
MC_CMD_OP(cmd, 0, 0, 16, enum dpni_counter, counter); \
MC_CMD_OP(cmd, 1, 0, 64, uint64_t, value); \
} while (0)
/* 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)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_SET_TX_FLOW(cmd, flow_id, cfg) \
do { \
MC_CMD_OP(cmd, 0, 43, 1, int, cfg->l3_chksum_gen);\
MC_CMD_OP(cmd, 0, 44, 1, int, cfg->l4_chksum_gen);\
MC_CMD_OP(cmd, 0, 45, 1, int, cfg->use_common_tx_conf_queue);\
MC_CMD_OP(cmd, 0, 48, 16, uint16_t, flow_id);\
MC_CMD_OP(cmd, 2, 0, 32, uint32_t, cfg->options);\
} while (0)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_RSP_SET_TX_FLOW(cmd, flow_id) \
MC_RSP_OP(cmd, 0, 48, 16, uint16_t, flow_id)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_GET_TX_FLOW(cmd, flow_id) \
MC_CMD_OP(cmd, 0, 48, 16, uint16_t, flow_id)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_RSP_GET_TX_FLOW(cmd, attr) \
do { \
MC_RSP_OP(cmd, 0, 43, 1, int, attr->l3_chksum_gen);\
MC_RSP_OP(cmd, 0, 44, 1, int, attr->l4_chksum_gen);\
MC_RSP_OP(cmd, 0, 45, 1, int, attr->use_common_tx_conf_queue);\
} while (0)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_SET_RX_FLOW(cmd, tc_id, flow_id, cfg) \
do { \
MC_CMD_OP(cmd, 0, 0, 32, int, cfg->dest_cfg.dest_id); \
MC_CMD_OP(cmd, 0, 32, 8, uint8_t, cfg->dest_cfg.priority);\
MC_CMD_OP(cmd, 0, 40, 2, enum dpni_dest, cfg->dest_cfg.dest_type);\
MC_CMD_OP(cmd, 0, 42, 1, int, cfg->order_preservation_en);\
MC_CMD_OP(cmd, 0, 48, 16, uint16_t, flow_id); \
MC_CMD_OP(cmd, 1, 0, 64, uint64_t, cfg->user_ctx); \
MC_CMD_OP(cmd, 2, 16, 8, uint8_t, tc_id); \
MC_CMD_OP(cmd, 2, 32, 32, uint32_t, cfg->options); \
MC_CMD_OP(cmd, 3, 0, 4, enum dpni_flc_type, cfg->flc_cfg.flc_type); \
MC_CMD_OP(cmd, 3, 4, 4, enum dpni_stash_size, \
cfg->flc_cfg.frame_data_size);\
MC_CMD_OP(cmd, 3, 8, 4, enum dpni_stash_size, \
cfg->flc_cfg.flow_context_size);\
MC_CMD_OP(cmd, 3, 32, 32, uint32_t, cfg->flc_cfg.options);\
MC_CMD_OP(cmd, 4, 0, 64, uint64_t, cfg->flc_cfg.flow_context);\
MC_CMD_OP(cmd, 5, 0, 32, uint32_t, cfg->tail_drop_threshold); \
} while (0)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_CMD_GET_RX_FLOW(cmd, tc_id, flow_id) \
do { \
MC_CMD_OP(cmd, 0, 16, 8, uint8_t, tc_id); \
MC_CMD_OP(cmd, 0, 48, 16, uint16_t, flow_id); \
} while (0)
/* cmd, param, offset, width, type, arg_name */
#define DPNI_RSP_GET_RX_FLOW(cmd, attr) \
do { \
MC_RSP_OP(cmd, 0, 0, 32, int, attr->dest_cfg.dest_id); \
MC_RSP_OP(cmd, 0, 32, 8, uint8_t, attr->dest_cfg.priority);\
MC_RSP_OP(cmd, 0, 40, 2, enum dpni_dest, attr->dest_cfg.dest_type); \
MC_RSP_OP(cmd, 0, 42, 1, int, attr->order_preservation_en);\
MC_RSP_OP(cmd, 1, 0, 64, uint64_t, attr->user_ctx); \
MC_RSP_OP(cmd, 2, 0, 32, uint32_t, attr->tail_drop_threshold); \
MC_RSP_OP(cmd, 2, 32, 32, uint32_t, attr->fqid); \
MC_RSP_OP(cmd, 3, 0, 4, enum dpni_flc_type, attr->flc_cfg.flc_type); \
MC_RSP_OP(cmd, 3, 4, 4, enum dpni_stash_size, \
attr->flc_cfg.frame_data_size);\
MC_RSP_OP(cmd, 3, 8, 4, enum dpni_stash_size, \
attr->flc_cfg.flow_context_size);\
MC_RSP_OP(cmd, 3, 32, 32, uint32_t, attr->flc_cfg.options);\
MC_RSP_OP(cmd, 4, 0, 64, uint64_t, attr->flc_cfg.flow_context);\
} while (0)
#define DPNI_CMD_SET_TX_CONF(cmd, flow_id, cfg) \
do { \
MC_CMD_OP(cmd, 0, 32, 8, uint8_t, cfg->queue_cfg.dest_cfg.priority); \
MC_CMD_OP(cmd, 0, 40, 2, enum dpni_dest, \
cfg->queue_cfg.dest_cfg.dest_type); \
MC_CMD_OP(cmd, 0, 42, 1, int, cfg->errors_only); \
MC_CMD_OP(cmd, 0, 46, 1, int, cfg->queue_cfg.order_preservation_en); \
MC_CMD_OP(cmd, 0, 48, 16, uint16_t, flow_id); \
MC_CMD_OP(cmd, 1, 0, 64, uint64_t, cfg->queue_cfg.user_ctx); \
MC_CMD_OP(cmd, 2, 0, 32, uint32_t, cfg->queue_cfg.options); \
MC_CMD_OP(cmd, 2, 32, 32, int, cfg->queue_cfg.dest_cfg.dest_id); \
MC_CMD_OP(cmd, 3, 0, 32, uint32_t, \
cfg->queue_cfg.tail_drop_threshold); \
MC_CMD_OP(cmd, 4, 0, 4, enum dpni_flc_type, \
cfg->queue_cfg.flc_cfg.flc_type); \
MC_CMD_OP(cmd, 4, 4, 4, enum dpni_stash_size, \
cfg->queue_cfg.flc_cfg.frame_data_size); \
MC_CMD_OP(cmd, 4, 8, 4, enum dpni_stash_size, \
cfg->queue_cfg.flc_cfg.flow_context_size); \
MC_CMD_OP(cmd, 4, 32, 32, uint32_t, cfg->queue_cfg.flc_cfg.options); \
MC_CMD_OP(cmd, 5, 0, 64, uint64_t, \
cfg->queue_cfg.flc_cfg.flow_context); \
} while (0)
#define DPNI_CMD_GET_TX_CONF(cmd, flow_id) \
MC_CMD_OP(cmd, 0, 48, 16, uint16_t, flow_id)
#define DPNI_RSP_GET_TX_CONF(cmd, attr) \
do { \
MC_RSP_OP(cmd, 0, 32, 8, uint8_t, \
attr->queue_attr.dest_cfg.priority); \
MC_RSP_OP(cmd, 0, 40, 2, enum dpni_dest, \
attr->queue_attr.dest_cfg.dest_type); \
MC_RSP_OP(cmd, 0, 42, 1, int, attr->errors_only); \
MC_RSP_OP(cmd, 0, 46, 1, int, \
attr->queue_attr.order_preservation_en); \
MC_RSP_OP(cmd, 1, 0, 64, uint64_t, attr->queue_attr.user_ctx); \
MC_RSP_OP(cmd, 2, 32, 32, int, attr->queue_attr.dest_cfg.dest_id); \
MC_RSP_OP(cmd, 3, 0, 32, uint32_t, \
attr->queue_attr.tail_drop_threshold); \
MC_RSP_OP(cmd, 3, 32, 32, uint32_t, attr->queue_attr.fqid); \
MC_RSP_OP(cmd, 4, 0, 4, enum dpni_flc_type, \
attr->queue_attr.flc_cfg.flc_type); \
MC_RSP_OP(cmd, 4, 4, 4, enum dpni_stash_size, \
attr->queue_attr.flc_cfg.frame_data_size); \
MC_RSP_OP(cmd, 4, 8, 4, enum dpni_stash_size, \
attr->queue_attr.flc_cfg.flow_context_size); \
MC_RSP_OP(cmd, 4, 32, 32, uint32_t, attr->queue_attr.flc_cfg.options); \
MC_RSP_OP(cmd, 5, 0, 64, uint64_t, \
attr->queue_attr.flc_cfg.flow_context); \
} 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
/**
* 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_extended_cfg() - function prepare extended parameters
* @cfg: extended structure
* @ext_cfg_buf: Zeroed 256 bytes of memory before mapping it to DMA
*
* This function has to be called before dpni_create()
*/
int dpni_prepare_extended_cfg(const struct dpni_extended_cfg *cfg,
uint8_t *ext_cfg_buf);
/**
* struct dpni_cfg - Structure representing DPNI configuration
* @mac_addr: Primary MAC address
* @adv: Advanced parameters; default is all zeros;
* use this structure to change default settings
*/
struct dpni_cfg {
uint8_t mac_addr[6];
/**
* struct adv - Advanced parameters
* @options: Mask of available options; use 'DPNI_OPT_<X>' values
* @start_hdr: Selects the packet starting header for parsing;
* 'NET_PROT_NONE' is treated as default: 'NET_PROT_ETH'
* @max_senders: Maximum number of different senders; used as the number
* of dedicated Tx flows; Non-power-of-2 values are rounded
* up to the next power-of-2 value as hardware demands it;
* '0' will be treated as '1'
* @max_tcs: Maximum number of traffic classes (for both Tx and Rx);
* '0' will e treated as '1'
* @max_unicast_filters: Maximum number of unicast filters;
* '0' is treated as '16'
* @max_multicast_filters: Maximum number of multicast filters;
* '0' is treated as '64'
* @max_qos_entries: if 'max_tcs > 1', declares the maximum entries in
* the QoS table; '0' is treated as '64'
* @max_qos_key_size: Maximum key size for the QoS look-up;
* '0' is treated as '24' which is enough for IPv4
* 5-tuple
* @max_dist_key_size: Maximum key size for the distribution;
* '0' is treated as '24' which is enough for IPv4 5-tuple
* @max_policers: Maximum number of policers;
* should be between '0' and max_tcs
* @max_congestion_ctrl: Maximum number of congestion control groups
* (CGs); covers early drop and congestion notification
* requirements;
* should be between '0' and ('max_tcs' + 'max_senders')
* @ext_cfg_iova: I/O virtual address of 256 bytes DMA-able memory
* filled with the extended configuration by calling
* dpni_prepare_extended_cfg()
*/
struct {
uint32_t options;
enum net_prot start_hdr;
uint8_t max_senders;
uint8_t max_tcs;
uint8_t max_unicast_filters;
uint8_t max_multicast_filters;
uint8_t max_vlan_filters;
uint8_t max_qos_entries;
uint8_t max_qos_key_size;
uint8_t max_dist_key_size;
uint8_t max_policers;
uint8_t max_congestion_ctrl;
uint64_t ext_cfg_iova;
} adv;
};
/**
* dpni_create() - Create the DPNI object
* @mc_io: Pointer to MC portal's I/O object
* @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
* @cfg: Configuration structure
* @token: Returned token; 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,
uint32_t cmd_flags,
const struct dpni_cfg *cfg,
uint16_t *token);
/**
* dpni_destroy() - Destroy the DPNI object and release all its resources.
* @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_destroy(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token);
/**
* 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
* @id: DPNI object ID
* @version: DPNI version
* @start_hdr: Indicates the packet starting header for parsing
* @options: Mask of available options; reflects the value as was given in
* object's creation
* @max_senders: Maximum number of different senders; used as the number
* of dedicated Tx flows;
* @max_tcs: 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_filters: Maximum number of VLAN filters
* @max_qos_entries: if 'max_tcs > 1', declares the maximum entries in QoS table
* @max_qos_key_size: Maximum key size for the QoS look-up
* @max_dist_key_size: Maximum key size for the distribution look-up
* @max_policers: Maximum number of policers;
* @max_congestion_ctrl: Maximum number of congestion control groups (CGs);
* @ext_cfg_iova: I/O virtual address of 256 bytes DMA-able memory;
* call dpni_extract_extended_cfg() to extract the extended configuration
*/
struct dpni_attr {
int id;
/**
* struct version - DPNI version
* @major: DPNI major version
* @minor: DPNI minor version
*/
struct {
uint16_t major;
uint16_t minor;
} version;
enum net_prot start_hdr;
uint32_t options;
uint8_t max_senders;
uint8_t max_tcs;
uint8_t max_unicast_filters;
uint8_t max_multicast_filters;
uint8_t max_vlan_filters;
uint8_t max_qos_entries;
uint8_t max_qos_key_size;
uint8_t max_dist_key_size;
uint8_t max_policers;
uint8_t max_congestion_ctrl;
uint64_t ext_cfg_iova;
};
/**
* 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_extended_cfg() - extract the extended parameters
* @cfg: extended structure
* @ext_cfg_buf: 256 bytes of DMA-able memory
*
* This function has to be called after dpni_get_attributes()
*/
int dpni_extract_extended_cfg(struct dpni_extended_cfg *cfg,
const uint8_t *ext_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 {
uint32_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_rx_buffer_layout() - Retrieve Rx 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
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_get_rx_buffer_layout(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
struct dpni_buffer_layout *layout);
/**
* dpni_set_rx_buffer_layout() - Set Rx 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
*
* Return: '0' on Success; Error code otherwise.
*
* @warning Allowed only when DPNI is disabled
*/
int dpni_set_rx_buffer_layout(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
const struct dpni_buffer_layout *layout);
/**
* dpni_get_tx_buffer_layout() - Retrieve Tx 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
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_get_tx_buffer_layout(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
struct dpni_buffer_layout *layout);
/**
* dpni_set_tx_buffer_layout() - Set Tx 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
*
* Return: '0' on Success; Error code otherwise.
*
* @warning Allowed only when DPNI is disabled
*/
int dpni_set_tx_buffer_layout(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
const struct dpni_buffer_layout *layout);
/**
* dpni_get_tx_conf_buffer_layout() - Retrieve Tx confirmation 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
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_get_tx_conf_buffer_layout(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
struct dpni_buffer_layout *layout);
/**
* dpni_set_tx_conf_buffer_layout() - Set Tx confirmation 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
*
* Return: '0' on Success; Error code otherwise.
*
* @warning Allowed only when DPNI is disabled
*/
int dpni_set_tx_conf_buffer_layout(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
const struct dpni_buffer_layout *layout);
/**
* 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);
/**
* enum dpni_counter - DPNI counter types
* @DPNI_CNT_ING_FRAME: Counts ingress frames
* @DPNI_CNT_ING_BYTE: Counts ingress bytes
* @DPNI_CNT_ING_FRAME_DROP: Counts ingress frames dropped due to explicit
* 'drop' setting
* @DPNI_CNT_ING_FRAME_DISCARD: Counts ingress frames discarded due to errors
* @DPNI_CNT_ING_MCAST_FRAME: Counts ingress multicast frames
* @DPNI_CNT_ING_MCAST_BYTE: Counts ingress multicast bytes
* @DPNI_CNT_ING_BCAST_FRAME: Counts ingress broadcast frames
* @DPNI_CNT_ING_BCAST_BYTES: Counts ingress broadcast bytes
* @DPNI_CNT_EGR_FRAME: Counts egress frames
* @DPNI_CNT_EGR_BYTE: Counts egress bytes
* @DPNI_CNT_EGR_FRAME_DISCARD: Counts egress frames discarded due to errors
*/
enum dpni_counter {
DPNI_CNT_ING_FRAME = 0x0,
DPNI_CNT_ING_BYTE = 0x1,
DPNI_CNT_ING_FRAME_DROP = 0x2,
DPNI_CNT_ING_FRAME_DISCARD = 0x3,
DPNI_CNT_ING_MCAST_FRAME = 0x4,
DPNI_CNT_ING_MCAST_BYTE = 0x5,
DPNI_CNT_ING_BCAST_FRAME = 0x6,
DPNI_CNT_ING_BCAST_BYTES = 0x7,
DPNI_CNT_EGR_FRAME = 0x8,
DPNI_CNT_EGR_BYTE = 0x9,
DPNI_CNT_EGR_FRAME_DISCARD = 0xa
};
/**
* dpni_get_counter() - Read a specific DPNI counter
* @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
* @counter: The requested counter
* @value: Returned counter's current value
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_get_counter(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
enum dpni_counter counter,
uint64_t *value);
/**
* dpni_set_counter() - Set (or clear) a specific DPNI counter
* @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
* @counter: The requested counter
* @value: New counter value; typically pass '0' for resetting
* the counter.
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_set_counter(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
enum dpni_counter counter,
uint64_t value);
/* 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
/**
* struct dpni_tx_flow_cfg - Structure representing Tx flow configuration
* @options: Flags representing the suggested modifications to the Tx flow;
* Use any combination 'DPNI_TX_FLOW_OPT_<X>' flags
* @use_common_tx_conf_queue: Set to '1' to use the common (default) Tx
* confirmation and error queue; Set to '0' to use the private
* Tx confirmation and error queue; valid only if
* 'DPNI_OPT_PRIVATE_TX_CONF_ERROR_DISABLED' wasn't set at DPNI creation
* and 'DPNI_TX_FLOW_OPT_TX_CONF_ERROR' is contained in 'options'
* @l3_chksum_gen: Set to '1' to enable L3 checksum generation; '0' to disable;
* valid only if 'DPNI_TX_FLOW_OPT_L3_CHKSUM_GEN' is contained in 'options'
* @l4_chksum_gen: Set to '1' to enable L4 checksum generation; '0' to disable;
* valid only if 'DPNI_TX_FLOW_OPT_L4_CHKSUM_GEN' is contained in 'options'
*/
struct dpni_tx_flow_cfg {
uint32_t options;
int use_common_tx_conf_queue;
int l3_chksum_gen;
int l4_chksum_gen;
};
/**
* dpni_set_tx_flow() - Set Tx flow 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
* @flow_id: Provides (or returns) the sender's flow ID;
* for each new sender set (*flow_id) to 'DPNI_NEW_FLOW_ID' to generate
* a new flow_id; this ID should be used as the QDBIN argument
* in enqueue operations
* @cfg: Tx flow configuration
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_set_tx_flow(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
uint16_t *flow_id,
const struct dpni_tx_flow_cfg *cfg);
/**
* struct dpni_tx_flow_attr - Structure representing Tx flow attributes
* @use_common_tx_conf_queue: '1' if using common (default) Tx confirmation and
* error queue; '0' if using private Tx confirmation and error queue
* @l3_chksum_gen: '1' if L3 checksum generation is enabled; '0' if disabled
* @l4_chksum_gen: '1' if L4 checksum generation is enabled; '0' if disabled
*/
struct dpni_tx_flow_attr {
int use_common_tx_conf_queue;
int l3_chksum_gen;
int l4_chksum_gen;
};
/**
* dpni_get_tx_flow() - Get Tx flow 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
* @flow_id: The sender's flow ID, as returned by the
* dpni_set_tx_flow() function
* @attr: Returned Tx flow attributes
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_get_tx_flow(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
uint16_t flow_id,
struct dpni_tx_flow_attr *attr);
/**
* struct dpni_tx_conf_cfg - Structure representing Tx conf configuration
* @errors_only: Set to '1' to report back only error frames;
* Set to '0' to confirm transmission/error for all transmitted frames;
* @queue_cfg: Queue configuration
*/
struct dpni_tx_conf_cfg {
int errors_only;
struct dpni_queue_cfg queue_cfg;
};
/**
* dpni_set_tx_conf() - Set Tx confirmation and error queue 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
* @flow_id: The sender's flow ID, as returned by the
* dpni_set_tx_flow() function;
* use 'DPNI_COMMON_TX_CONF' for common tx-conf
* @cfg: Queue configuration
*
* If either 'DPNI_OPT_TX_CONF_DISABLED' or
* 'DPNI_OPT_PRIVATE_TX_CONF_ERROR_DISABLED' were selected at DPNI creation,
* this function can ONLY be used with 'flow_id == DPNI_COMMON_TX_CONF';
* i.e. only serve the common tx-conf-err queue;
* if 'DPNI_OPT_TX_CONF_DISABLED' was selected, only error frames are reported
* back - successfully transmitted frames are not confirmed. Otherwise, all
* transmitted frames are sent for confirmation.
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_set_tx_conf(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
uint16_t flow_id,
const struct dpni_tx_conf_cfg *cfg);
/**
* struct dpni_tx_conf_attr - Structure representing Tx conf attributes
* @errors_only: '1' if only error frames are reported back; '0' if all
* transmitted frames are confirmed
* @queue_attr: Queue attributes
*/
struct dpni_tx_conf_attr {
int errors_only;
struct dpni_queue_attr queue_attr;
};
/**
* dpni_get_tx_conf() - Get Tx confirmation and error queue 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
* @flow_id: The sender's flow ID, as returned by the
* dpni_set_tx_flow() function;
* use 'DPNI_COMMON_TX_CONF' for common tx-conf
* @attr: Returned tx-conf attributes
*
* If either 'DPNI_OPT_TX_CONF_DISABLED' or
* 'DPNI_OPT_PRIVATE_TX_CONF_ERROR_DISABLED' were selected at DPNI creation,
* this function can ONLY be used with 'flow_id == DPNI_COMMON_TX_CONF';
* i.e. only serve the common tx-conf-err queue;
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_get_tx_conf(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
uint16_t flow_id,
struct dpni_tx_conf_attr *attr);
/**
* dpni_set_rx_flow() - Set Rx flow 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
* @tc_id: Traffic class selection (0-7);
* use 'DPNI_ALL_TCS' to set all TCs and all flows
* @flow_id: Rx flow id within the traffic class; use
* 'DPNI_ALL_TC_FLOWS' to set all flows within
* this tc_id; ignored if tc_id is set to
* 'DPNI_ALL_TCS';
* @cfg: Rx flow configuration
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_set_rx_flow(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
uint8_t tc_id,
uint16_t flow_id,
const struct dpni_queue_cfg *cfg);
/**
* dpni_get_rx_flow() - Get Rx flow 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
* @tc_id: Traffic class selection (0-7)
* @flow_id: Rx flow id within the traffic class
* @attr: Returned Rx flow attributes
*
* Return: '0' on Success; Error code otherwise.
*/
int dpni_get_rx_flow(struct fsl_mc_io *mc_io,
uint32_t cmd_flags,
uint16_t token,
uint8_t tc_id,
uint16_t flow_id,
struct dpni_queue_attr *attr);
#endif /* _FSL_DPNI_H */