/* 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_() */ #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__ * @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_' 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_' 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_' 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_' 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_' 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 */