u-boot/include/fsl-mc/fsl_dpni.h
Ioana Ciornei 207c815770 net: fsl-mc: sync DPNI MC APIs
Sync the Data Path Network Interface APIs to their latest form, this
means the layout of each command is created based on structures which
clearly describe the endianness of each field rather than some macros.

The command version is kept in place, meaning that the minimum MC
version accepted is not changed in any way.

Signed-off-by: Ioana Ciornei <ioana.ciornei@nxp.com>
Signed-off-by: Peng Fan <peng.fan@nxp.com>
2023-06-15 17:58:53 +08:00

886 lines
27 KiB
C

/* SPDX-License-Identifier: GPL-2.0+ */
/*
* Copyright 2013-2016 Freescale Semiconductor, Inc.
* Copyright 2017, 2023 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_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_ADD_MAC_ADDR 0x2261
#define DPNI_CMDID_GET_STATISTICS 0x25D1
#define DPNI_CMDID_GET_QUEUE 0x25F1
#define DPNI_CMDID_SET_QUEUE 0x2601
#define DPNI_CMDID_SET_TX_CONFIRMATION_MODE 0x2661
/* Macros for accessing command fields smaller than 1byte */
#define DPNI_MASK(field) \
GENMASK(DPNI_##field##_SHIFT + DPNI_##field##_SIZE - 1, \
DPNI_##field##_SHIFT)
#define dpni_set_field(var, field, val) \
((var) |= (((val) << DPNI_##field##_SHIFT) & DPNI_MASK(field)))
#define dpni_get_field(var, field) \
(((var) & DPNI_MASK(field)) >> DPNI_##field##_SHIFT)
#pragma pack(push, 1)
struct dpni_cmd_open {
__le32 dpni_id;
};
struct dpni_cmd_create {
__le32 options;
u8 num_queues;
u8 num_tcs;
u8 mac_filter_entries;
u8 num_channels;
u8 vlan_filter_entries;
u8 pad2;
u8 qos_entries;
u8 pad3;
__le16 fs_entries;
u8 num_rx_tcs;
u8 pad4;
u8 num_cgs;
__le16 num_opr;
u8 dist_key_size;
};
struct dpni_cmd_destroy {
__le32 dpni_id;
};
#define DPNI_BACKUP_POOL(val, order) (((val) & 0x1) << (order))
struct dpni_cmd_pool {
__le16 dpbp_id;
u8 priority_mask;
u8 pad;
};
struct dpni_cmd_set_pools {
u8 num_dpbp;
u8 backup_pool_mask;
u8 pad;
u8 pool_options;
struct dpni_cmd_pool pool[8];
__le16 buffer_size[8];
};
struct dpni_rsp_get_attr {
/* response word 0 */
__le32 options;
u8 num_queues;
u8 num_rx_tcs;
u8 mac_filter_entries;
u8 num_tx_tcs;
/* response word 1 */
u8 vlan_filter_entries;
u8 num_channels;
u8 qos_entries;
u8 pad2;
__le16 fs_entries;
__le16 num_opr;
/* response word 2 */
u8 qos_key_size;
u8 fs_key_size;
__le16 wriop_version;
u8 num_cgs;
};
/* There are 3 separate commands for configuring Rx, Tx and Tx confirmation
* buffer layouts, but they all share the same parameters.
* If one of the functions changes, below structure needs to be split.
*/
#define DPNI_PASS_TS_SHIFT 0
#define DPNI_PASS_TS_SIZE 1
#define DPNI_PASS_PR_SHIFT 1
#define DPNI_PASS_PR_SIZE 1
#define DPNI_PASS_FS_SHIFT 2
#define DPNI_PASS_FS_SIZE 1
#define DPNI_PASS_SWO_SHIFT 3
#define DPNI_PASS_SWO_SIZE 1
struct dpni_cmd_set_buffer_layout {
/* cmd word 0 */
u8 qtype;
u8 pad0[3];
__le16 options;
/* from LSB: pass_timestamp:1, parser_result:1, frame_status:1 */
u8 flags;
u8 pad1;
/* cmd word 1 */
__le16 private_data_size;
__le16 data_align;
__le16 head_room;
__le16 tail_room;
};
struct dpni_cmd_get_qdid {
u8 qtype;
};
struct dpni_rsp_get_qdid {
__le16 qdid;
};
struct dpni_rsp_get_tx_data_offset {
__le16 data_offset;
};
struct dpni_cmd_set_link_cfg {
__le64 pad0;
__le32 rate;
__le32 pad1;
__le64 options;
__le64 advertising;
};
#define DPNI_LINK_STATE_SHIFT 0
#define DPNI_LINK_STATE_SIZE 1
#define DPNI_STATE_VALID_SHIFT 1
#define DPNI_STATE_VALID_SIZE 1
struct dpni_rsp_get_link_state {
__le32 pad0;
/* from LSB: up:1 */
u8 flags;
u8 pad1[3];
__le32 rate;
__le32 pad2;
__le64 options;
__le64 supported;
__le64 advertising;
};
struct dpni_cmd_add_mac_addr {
u8 flags;
u8 pad;
u8 mac_addr[6];
u8 tc_id;
u8 fq_id;
};
struct dpni_cmd_get_queue {
u8 qtype;
u8 tc;
u8 index;
u8 channel_id;
};
#define DPNI_DEST_TYPE_SHIFT 0
#define DPNI_DEST_TYPE_SIZE 4
#define DPNI_CGID_VALID_SHIFT 5
#define DPNI_CGID_VALID_SIZE 1
#define DPNI_STASH_CTRL_SHIFT 6
#define DPNI_STASH_CTRL_SIZE 1
#define DPNI_HOLD_ACTIVE_SHIFT 7
#define DPNI_HOLD_ACTIVE_SIZE 1
struct dpni_rsp_get_queue {
/* response word 0 */
__le64 pad0;
/* response word 1 */
__le32 dest_id;
__le16 pad1;
u8 dest_prio;
/* From LSB: dest_type:4, pad:1, cgid_valid:1, flc_stash_ctrl:1, hold_active:1 */
u8 flags;
/* response word 2 */
__le64 flc;
/* response word 3 */
__le64 user_context;
/* response word 4 */
__le32 fqid;
__le16 qdbin;
__le16 pad2;
/* response word 5*/
u8 cgid;
};
struct dpni_cmd_set_queue {
/* cmd word 0 */
u8 qtype;
u8 tc;
u8 index;
u8 options;
__le32 pad0;
/* cmd word 1 */
__le32 dest_id;
__le16 pad1;
u8 dest_prio;
u8 flags;
/* cmd word 2 */
__le64 flc;
/* cmd word 3 */
__le64 user_context;
/* cmd word 4 */
u8 cgid;
u8 channel_id;
};
struct dpni_tx_confirmation_mode {
u8 ceetm_ch_idx;
u8 pad1;
__le16 pad2;
u8 confirmation_mode;
};
struct dpni_cmd_get_statistics {
u8 page_number;
__le16 param;
};
struct dpni_rsp_get_statistics {
__le64 counter[7];
};
#pragma pack(pop)
/**
* 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 (u8)(-1)
/* All flows within traffic class considered; see dpni_set_rx_flow() */
#define DPNI_ALL_TC_FLOWS (u16)(-1)
/* Generate new flow ID; see dpni_set_tx_flow() */
#define DPNI_NEW_FLOW_ID (u16)(-1)
/* use for common tx-conf queue; see dpni_set_tx_conf_<x>() */
#define DPNI_COMMON_TX_CONF (u16)(-1)
int dpni_open(struct fsl_mc_io *mc_io, u32 cmd_flags, int dpni_id, u16 *token);
int dpni_close(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 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 - Structure representing DPNI configuration
* @options: Any combination of the following options:
* DPNI_OPT_TX_FRM_RELEASE
* DPNI_OPT_NO_MAC_FILTER
* DPNI_OPT_HAS_POLICING
* DPNI_OPT_SHARED_CONGESTION
* DPNI_OPT_HAS_KEY_MASKING
* DPNI_OPT_NO_FS
* DPNI_OPT_SINGLE_SENDER
* DPNI_OPT_STASHING_DIS
* @fs_entries: Number of entries in the flow steering table.
* This table is used to select the ingress queue for
* ingress traffic, targeting a GPP core or another.
* In addition it can be used to discard traffic that
* matches the set rule. It is either an exact match table
* or a TCAM table, depending on DPNI_OPT_ HAS_KEY_MASKING
* bit in OPTIONS field. This field is ignored if
* DPNI_OPT_NO_FS bit is set in OPTIONS field. Otherwise,
* value 0 defaults to 64. Maximum supported value is 1024.
* Note that the total number of entries is limited on the
* SoC to as low as 512 entries if TCAM is used.
* @vlan_filter_entries: Number of entries in the VLAN address filtering
* table. This is an exact match table used to filter
* ingress traffic based on VLAN IDs. Value 0 disables VLAN
* filtering. Maximum supported value is 16.
* @mac_filter_entries: Number of entries in the MAC address filtering
* table. This is an exact match table and allows both
* unicast and multicast entries. The primary MAC address
* of the network interface is not part of this table,
* this contains only entries in addition to it. This
* field is ignored if DPNI_OPT_ NO_MAC_FILTER is set in
* OPTIONS field. Otherwise, value 0 defaults to 80.
* Maximum supported value is 80.
* @num_queues: Number of Tx and Rx queues used for traffic
* distribution. This is orthogonal to QoS and is only
* used to distribute traffic to multiple GPP cores.
* This configuration affects the number of Tx queues
* (logical FQs, all associated with a single CEETM queue),
* Rx queues and Tx confirmation queues, if applicable.
* Value 0 defaults to one queue. Maximum supported value
* is 8.
* @num_tcs: Number of traffic classes (TCs), reserved for the DPNI.
* TCs can have different priority levels for the purpose
* of Tx scheduling (see DPNI_SET_TX_PRIORITIES), different
* BPs (DPNI_ SET_POOLS), policers. There are dedicated QM
* queues for traffic classes (including class queues on
* Tx). Value 0 defaults to one TC. Maximum supported value
* is 16. There are maximum 16 TCs for Tx and 8 TCs for Rx.
* When num_tcs>8 Tx will use this value but Rx will have
* only 8 traffic classes.
* @num_rx_tcs: if set to other value than zero represents number
* of TCs used for Rx. Maximum value is 8. If set to zero the
* number of Rx TCs will be initialized with the value provided
* in num_tcs parameter.
* @qos_entries: Number of entries in the QoS classification table. This
* table is used to select the TC for ingress traffic. It
* is either an exact match or a TCAM table, depending on
* DPNI_OPT_ HAS_KEY_MASKING bit in OPTIONS field. This
* field is ignored if the DPNI has a single TC. Otherwise,
* a value of 0 defaults to 64. Maximum supported value
* is 64.
* @num_channels: Number of egress channels used by this dpni object. If
* set to zero the dpni object will use a single CEETM channel.
*/
struct dpni_cfg {
u32 options;
u16 fs_entries;
u8 vlan_filter_entries;
u8 mac_filter_entries;
u8 num_queues;
u8 num_tcs;
u8 num_rx_tcs;
u8 qos_entries;
u8 num_cgs;
u16 num_opr;
u8 dist_key_size;
u8 num_channels;
};
/**
* 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,
u8 *cfg_buf);
int dpni_create(struct fsl_mc_io *mc_io, u16 dprc_token, u32 cmd_flags,
const struct dpni_cfg *cfg, u32 *obj_id);
int dpni_destroy(struct fsl_mc_io *mc_io, u16 dprc_token, u32 cmd_flags,
u32 object_id);
/**
* struct dpni_pools_cfg - Structure representing buffer pools configuration
* @num_dpbp: Number of DPBPs
* @pool_options: Buffer assignment options
* This field is a combination of DPNI_POOL_ASSOC_flags
* @pools: Array of buffer pools parameters; The number of valid entries
* must match 'num_dpbp' value
* @pools.dpbp_id: DPBP object ID
* @pools.priority: Priority mask that indicates TC's used with this buffer.
* I set to 0x00 MC will assume value 0xff.
* @pools.buffer_size: Buffer size
* @pools.backup_pool: Backup pool
*/
#define DPNI_POOL_ASSOC_QPRI 0
#define DPNI_POOL_ASSOC_QDBIN 1
struct dpni_pools_cfg {
u8 num_dpbp;
u8 pool_options;
struct {
int dpbp_id;
u8 priority_mask;
u16 buffer_size;
int backup_pool;
} pools[DPNI_MAX_DPBP];
};
int dpni_set_pools(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
const struct dpni_pools_cfg *cfg);
int dpni_enable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token);
int dpni_disable(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token);
int dpni_reset(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token);
/**
* struct dpni_attr - Structure representing DPNI attributes
* @options: Any combination of the following options:
* DPNI_OPT_TX_FRM_RELEASE
* DPNI_OPT_NO_MAC_FILTER
* DPNI_OPT_HAS_POLICING
* DPNI_OPT_SHARED_CONGESTION
* DPNI_OPT_HAS_KEY_MASKING
* DPNI_OPT_NO_FS
* DPNI_OPT_STASHING_DIS
* @num_queues: Number of Tx and Rx queues used for traffic distribution.
* @num_rx_tcs: Number of RX traffic classes (TCs), reserved for the DPNI.
* @num_tx_tcs: Number of TX traffic classes (TCs), reserved for the DPNI.
* @mac_filter_entries: Number of entries in the MAC address filtering
* table.
* @vlan_filter_entries: Number of entries in the VLAN address filtering
* table.
* @qos_entries: Number of entries in the QoS classification table.
* @fs_entries: Number of entries in the flow steering table.
* @qos_key_size: Size, in bytes, of the QoS look-up key. Defining a key larger
* than this when adding QoS entries will result
* in an error.
* @fs_key_size: Size, in bytes, of the flow steering look-up key. Defining a
* key larger than this when composing the hash + FS key
* will result in an error.
* @wriop_version: Version of WRIOP HW block.
* The 3 version values are stored on 6, 5, 5 bits
* respectively.
* Values returned:
* - 0x400 - WRIOP version 1.0.0, used on LS2080 and
* variants,
* - 0x421 - WRIOP version 1.1.1, used on LS2088 and
* variants,
* - 0x422 - WRIOP version 1.1.2, used on LS1088 and
* variants.
* - 0xC00 - WRIOP version 3.0.0, used on LX2160 and
* variants.
*/
struct dpni_attr {
u32 options;
u8 num_queues;
u8 num_rx_tcs;
u8 num_tx_tcs;
u8 mac_filter_entries;
u8 vlan_filter_entries;
u8 qos_entries;
u16 fs_entries;
u16 num_opr;
u8 qos_key_size;
u8 fs_key_size;
u16 wriop_version;
u8 num_cgs;
u8 num_channels;
};
int dpni_get_attributes(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
struct dpni_attr *attr);
/* 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
/* Select to modify the sw-opaque value setting */
#define DPNI_BUF_LAYOUT_OPT_SW_OPAQUE 0x00000080
/* Select to disable Scatter Gather and use single buffer */
#define DPNI_BUF_LAYOUT_OPT_NO_SG 0x00000100
/**
* 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 {
u32 options;
int pass_timestamp;
int pass_parser_result;
int pass_frame_status;
int pass_sw_opaque;
u16 private_data_size;
u16 data_align;
u16 data_head_room;
u16 data_tail_room;
};
int dpni_set_buffer_layout(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
enum dpni_queue_type qtype,
const struct dpni_buffer_layout *layout);
int dpni_get_qdid(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
enum dpni_queue_type qtype, u16 *qdid);
int dpni_get_tx_data_offset(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
u16 *data_offset);
/* Enable auto-negotiation */
#define DPNI_LINK_OPT_AUTONEG 0x0000000000000001ULL
/* Enable half-duplex mode */
#define DPNI_LINK_OPT_HALF_DUPLEX 0x0000000000000002ULL
/* Enable pause frames */
#define DPNI_LINK_OPT_PAUSE 0x0000000000000004ULL
/* Enable a-symmetric pause frames */
#define DPNI_LINK_OPT_ASYM_PAUSE 0x0000000000000008ULL
/**
* struct - Structure representing DPNI link configuration
* @rate: Rate
* @options: Mask of available options; use 'DPNI_LINK_OPT_<X>' values
* @advertising: Speeds that are advertised for autoneg (bitmap)
*/
struct dpni_link_cfg {
u32 rate;
u64 options;
u64 advertising;
};
int dpni_set_link_cfg(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 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
* @state_valid: Ignore/Update the state of the link
* @supported: Speeds capability of the phy (bitmap)
* @advertising: Speeds that are advertised for autoneg (bitmap)
*/
struct dpni_link_state {
u32 rate;
u64 options;
int up;
int state_valid;
u64 supported;
u64 advertising;
};
int dpni_get_link_state(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
struct dpni_link_state *state);
int dpni_add_mac_addr(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
const u8 mac_addr[6], u8 flags,
u8 tc_id, u8 flow_id);
int dpni_get_api_version(struct fsl_mc_io *mc_io, u32 cmd_flags,
u16 *major_ver, u16 *minor_ver);
/**
* 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
};
/* 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
/**
* 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,
};
/**
* stashes the whole annotation area (up to 192 bytes)
*/
#define DPNI_FLC_STASH_FRAME_ANNOTATION 0x00000001
/**
* struct dpni_queue - Queue structure
* @destination - Destination structure
* @destination.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.
* @destination.type: May be one of the following:
* 0 - No destination, queue can be manually
* queried, but will not push traffic or
* notifications to a DPIO;
* 1 - The destination is a 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 the
* purpose of scheduling between multiple
* queues. The DPCON may be independently
* configured to generate notifications.
* Not relevant for Tx queues.
* @destination.hold_active: Hold active, maintains a queue scheduled for longer
* in a DPIO during dequeue to reduce spread of traffic.
* Only relevant if queues are
* not affined to a single DPIO.
* @user_context: User data, presented to the user along with any frames
* from this queue. Not relevant for Tx queues.
* @flc: FD FLow Context structure
* @flc.value: Default FLC value for traffic dequeued from
* this queue. Please check description of FD
* structure for more information.
* Note that FLC values set using dpni_add_fs_entry,
* if any, take precedence over values per queue.
* @flc.stash_control: Boolean, indicates whether the 6 lowest
* - significant bits are used for stash control.
* significant bits are used for stash control. If set, the 6
* least significant bits in value are interpreted as follows:
* - bits 0-1: indicates the number of 64 byte units of context
* that are stashed. FLC value is interpreted as a memory address
* in this case, excluding the 6 LS bits.
* - bits 2-3: indicates the number of 64 byte units of frame
* annotation to be stashed. Annotation is placed at FD[ADDR].
* - bits 4-5: indicates the number of 64 byte units of frame
* data to be stashed. Frame data is placed at FD[ADDR] +
* FD[OFFSET].
* For more details check the Frame Descriptor section in the
* hardware documentation.
*@cgid :indicate the cgid to set relative to dpni
*/
struct dpni_queue {
struct {
u16 id;
enum dpni_dest type;
char hold_active;
u8 priority;
} destination;
u64 user_context;
struct {
u64 value;
char stash_control;
} flc;
int cgid;
};
/**
* struct dpni_queue_id - Queue identification, used for enqueue commands
* or queue control
* @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.
*/
struct dpni_queue_id {
u32 fqid;
u16 qdbin;
};
int dpni_set_queue(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
enum dpni_queue_type qtype, u16 param, u8 index,
u8 options, const struct dpni_queue *queue);
int dpni_get_queue(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
enum dpni_queue_type qtype, u16 param, u8 index,
struct dpni_queue *queue, struct dpni_queue_id *qid);
int dpni_set_tx_confirmation_mode(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
u8 ceetm_ch_idx, enum dpni_confirmation_mode mode);
#define DPNI_STATISTICS_CNT 7
/**
* union dpni_statistics - Union describing the DPNI statistics
* @page_0: Page_0 statistics structure
* @page_0.ingress_all_frames: Ingress frame count
* @page_0.ingress_all_bytes: Ingress byte count
* @page_0.ingress_multicast_frames: Ingress multicast frame count
* @page_0.ingress_multicast_bytes: Ingress multicast byte count
* @page_0.ingress_broadcast_frames: Ingress broadcast frame count
* @page_0.ingress_broadcast_bytes: Ingress broadcast byte count
* @page_1: Page_1 statistics structure
* @page_1.egress_all_frames: Egress frame count
* @page_1.egress_all_bytes: Egress byte count
* @page_1.egress_multicast_frames: Egress multicast frame count
* @page_1.egress_multicast_bytes: Egress multicast byte count
* @page_1.egress_broadcast_frames: Egress broadcast frame count
* @page_1.egress_broadcast_bytes: Egress broadcast byte count
* @page_2: Page_2 statistics structure
* @page_2.ingress_filtered_frames: Ingress filtered frame count
* @page_2.ingress_discarded_frames: Ingress discarded frame count
* @page_2.ingress_nobuffer_discards: Ingress discarded frame count due to
* lack of buffers
* @page_2.egress_discarded_frames: Egress discarded frame count
* @page_2.egress_confirmed_frames: Egress confirmed frame count
* @page_3: Page_3 statistics structure
* @page_3.egress_dequeue_bytes: Cumulative count of the number of bytes
* dequeued from egress FQs
* @page_3.egress_dequeue_frames: Cumulative count of the number of frames
* dequeued from egress FQs
* @page_3.egress_reject_bytes: Cumulative count of the number of bytes in
* egress frames whose enqueue was rejected
* @page_3.egress_reject_frames: Cumulative count of the number of egress
* frames whose enqueue was rejected
* @page_4: Page_4 statistics structure: congestion points
* @page_4.cgr_reject_frames: number of rejected frames due to congestion point
* @page_4.cgr_reject_bytes: number of rejected bytes due to congestion point
* @page_5: Page_5 statistics structure: policer
* @page_5.policer_cnt_red: NUmber of red colored frames
* @page_5.policer_cnt_yellow: number of yellow colored frames
* @page_5.policer_cnt_green: number of green colored frames
* @page_5.policer_cnt_re_red: number of recolored red frames
* @page_5.policer_cnt_re_yellow: number of recolored yellow frames
* @page_6: Page_6 statistics structure
* @page_6.tx_pending_frames: total number of frames pending in egress FQs
* @raw: raw statistics structure, used to index counters
*/
union dpni_statistics {
struct {
u64 ingress_all_frames;
u64 ingress_all_bytes;
u64 ingress_multicast_frames;
u64 ingress_multicast_bytes;
u64 ingress_broadcast_frames;
u64 ingress_broadcast_bytes;
} page_0;
struct {
u64 egress_all_frames;
u64 egress_all_bytes;
u64 egress_multicast_frames;
u64 egress_multicast_bytes;
u64 egress_broadcast_frames;
u64 egress_broadcast_bytes;
} page_1;
struct {
u64 ingress_filtered_frames;
u64 ingress_discarded_frames;
u64 ingress_nobuffer_discards;
u64 egress_discarded_frames;
u64 egress_confirmed_frames;
} page_2;
struct {
u64 egress_dequeue_bytes;
u64 egress_dequeue_frames;
u64 egress_reject_bytes;
u64 egress_reject_frames;
} page_3;
struct {
u64 cgr_reject_frames;
u64 cgr_reject_bytes;
} page_4;
struct {
u64 policer_cnt_red;
u64 policer_cnt_yellow;
u64 policer_cnt_green;
u64 policer_cnt_re_red;
u64 policer_cnt_re_yellow;
} page_5;
struct {
u64 tx_pending_frames;
} page_6;
struct {
u64 counter[DPNI_STATISTICS_CNT];
} raw;
};
int dpni_get_statistics(struct fsl_mc_io *mc_io, u32 cmd_flags, u16 token,
u8 page, u16 param, union dpni_statistics *stat);
#endif /* _FSL_DPNI_H */