/** * struct idpf_mac_filter * @list: list member field * @macaddr: MAC address * @remove: filter should be removed (virtchnl) * @add: filter should be added (virtchnl)
*/ struct idpf_mac_filter { struct list_head list;
u8 macaddr[ETH_ALEN]; bool remove; bool add;
};
/** * enum idpf_state - State machine to handle bring up * @__IDPF_VER_CHECK: Negotiate virtchnl version * @__IDPF_GET_CAPS: Negotiate capabilities * @__IDPF_INIT_SW: Init based on given capabilities * @__IDPF_STATE_LAST: Must be last, used to determine size
*/ enum idpf_state {
__IDPF_VER_CHECK,
__IDPF_GET_CAPS,
__IDPF_INIT_SW,
__IDPF_STATE_LAST,
};
/** * enum idpf_flags - Hard reset causes. * @IDPF_HR_FUNC_RESET: Hard reset when TxRx timeout * @IDPF_HR_DRV_LOAD: Set on driver load for a clean HW * @IDPF_HR_RESET_IN_PROG: Reset in progress * @IDPF_REMOVE_IN_PROG: Driver remove in progress * @IDPF_MB_INTR_MODE: Mailbox in interrupt mode * @IDPF_VC_CORE_INIT: virtchnl core has been init * @IDPF_FLAGS_NBITS: Must be last
*/ enum idpf_flags {
IDPF_HR_FUNC_RESET,
IDPF_HR_DRV_LOAD,
IDPF_HR_RESET_IN_PROG,
IDPF_REMOVE_IN_PROG,
IDPF_MB_INTR_MODE,
IDPF_VC_CORE_INIT,
IDPF_FLAGS_NBITS,
};
/** * enum idpf_cap_field - Offsets into capabilities struct for specific caps * @IDPF_BASE_CAPS: generic base capabilities * @IDPF_CSUM_CAPS: checksum offload capabilities * @IDPF_SEG_CAPS: segmentation offload capabilities * @IDPF_RSS_CAPS: RSS offload capabilities * @IDPF_HSPLIT_CAPS: Header split capabilities * @IDPF_RSC_CAPS: RSC offload capabilities * @IDPF_OTHER_CAPS: miscellaneous offloads * * Used when checking for a specific capability flag since different capability * sets are not mutually exclusive numerically, the caller must specify which * type of capability they are checking for.
*/ enum idpf_cap_field {
IDPF_BASE_CAPS = -1,
IDPF_CSUM_CAPS = offsetof(struct virtchnl2_get_capabilities,
csum_caps),
IDPF_SEG_CAPS = offsetof(struct virtchnl2_get_capabilities,
seg_caps),
IDPF_RSS_CAPS = offsetof(struct virtchnl2_get_capabilities,
rss_caps),
IDPF_HSPLIT_CAPS = offsetof(struct virtchnl2_get_capabilities,
hsplit_caps),
IDPF_RSC_CAPS = offsetof(struct virtchnl2_get_capabilities,
rsc_caps),
IDPF_OTHER_CAPS = offsetof(struct virtchnl2_get_capabilities,
other_caps),
};
/** * enum idpf_vport_state - Current vport state * @__IDPF_VPORT_DOWN: Vport is down * @__IDPF_VPORT_UP: Vport is up * @__IDPF_VPORT_STATE_LAST: Must be last, number of states
*/ enum idpf_vport_state {
__IDPF_VPORT_DOWN,
__IDPF_VPORT_UP,
__IDPF_VPORT_STATE_LAST,
};
/** * struct idpf_netdev_priv - Struct to store vport back pointer * @adapter: Adapter back pointer * @vport: Vport back pointer * @vport_id: Vport identifier * @link_speed_mbps: Link speed in mbps * @vport_idx: Relative vport index * @max_tx_hdr_size: Max header length hardware can support * @tx_max_bufs: Max buffers that can be transmitted with scatter-gather * @state: See enum idpf_vport_state * @netstats: Packet and byte stats * @stats_lock: Lock to protect stats update
*/ struct idpf_netdev_priv { struct idpf_adapter *adapter; struct idpf_vport *vport;
u32 vport_id;
u32 link_speed_mbps;
u16 vport_idx;
u16 max_tx_hdr_size;
u16 tx_max_bufs; enum idpf_vport_state state; struct rtnl_link_stats64 netstats;
spinlock_t stats_lock;
};
/** * struct idpf_vport_max_q - Queue limits * @max_rxq: Maximum number of RX queues supported * @max_txq: Maixmum number of TX queues supported * @max_bufq: In splitq, maximum number of buffer queues supported * @max_complq: In splitq, maximum number of completion queues supported
*/ struct idpf_vport_max_q {
u16 max_rxq;
u16 max_txq;
u16 max_bufq;
u16 max_complq;
};
/** * struct idpf_vport - Handle for netdevices and queue resources * @num_txq: Number of allocated TX queues * @num_complq: Number of allocated completion queues * @txq_desc_count: TX queue descriptor count * @complq_desc_count: Completion queue descriptor count * @compln_clean_budget: Work budget for completion clean * @num_txq_grp: Number of TX queue groups * @txq_grps: Array of TX queue groups * @txq_model: Split queue or single queue queuing model * @txqs: Used only in hotpath to get to the right queue very fast * @crc_enable: Enable CRC insertion offload * @num_rxq: Number of allocated RX queues * @num_bufq: Number of allocated buffer queues * @rxq_desc_count: RX queue descriptor count. *MUST* have enough descriptors * to complete all buffer descriptors for all buffer queues in * the worst case. * @num_bufqs_per_qgrp: Buffer queues per RX queue in a given grouping * @bufq_desc_count: Buffer queue descriptor count * @num_rxq_grp: Number of RX queues in a group * @rxq_grps: Total number of RX groups. Number of groups * number of RX per * group will yield total number of RX queues. * @rxq_model: Splitq queue or single queue queuing model * @rx_ptype_lkup: Lookup table for ptypes on RX * @vdev_info: IDC vport device info pointer * @adapter: back pointer to associated adapter * @netdev: Associated net_device. Each vport should have one and only one * associated netdev. * @flags: See enum idpf_vport_flags * @vport_type: Default SRIOV, SIOV, etc. * @vport_id: Device given vport identifier * @idx: Software index in adapter vports struct * @default_vport: Use this vport if one isn't specified * @base_rxd: True if the driver should use base descriptors instead of flex * @num_q_vectors: Number of IRQ vectors allocated * @q_vectors: Array of queue vectors * @q_vector_idxs: Starting index of queue vectors * @max_mtu: device given max possible MTU * @default_mac_addr: device will give a default MAC to use * @rx_itr_profile: RX profiles for Dynamic Interrupt Moderation * @tx_itr_profile: TX profiles for Dynamic Interrupt Moderation * @port_stats: per port csum, header split, and other offload stats * @link_up: True if link is up * @sw_marker_wq: workqueue for marker packets * @tx_tstamp_caps: Capabilities negotiated for Tx timestamping * @tstamp_config: The Tx tstamp config * @tstamp_task: Tx timestamping task
*/ struct idpf_vport {
u16 num_txq;
u16 num_complq;
u32 txq_desc_count;
u32 complq_desc_count;
u32 compln_clean_budget;
u16 num_txq_grp; struct idpf_txq_group *txq_grps;
u32 txq_model; struct idpf_tx_queue **txqs; bool crc_enable;
/** * struct idpf_q_coalesce - User defined coalescing configuration values for * a single queue. * @tx_intr_mode: Dynamic TX ITR or not * @rx_intr_mode: Dynamic RX ITR or not * @tx_coalesce_usecs: TX interrupt throttling rate * @rx_coalesce_usecs: RX interrupt throttling rate * * Used to restore user coalescing configuration after a reset.
*/ struct idpf_q_coalesce {
u32 tx_intr_mode;
u32 rx_intr_mode;
u32 tx_coalesce_usecs;
u32 rx_coalesce_usecs;
};
/** * struct idpf_vport_user_config_data - User defined configuration values for * each vport. * @rss_data: See struct idpf_rss_data * @q_coalesce: Array of per queue coalescing data * @num_req_tx_qs: Number of user requested TX queues through ethtool * @num_req_rx_qs: Number of user requested RX queues through ethtool * @num_req_txq_desc: Number of user requested TX queue descriptors through * ethtool * @num_req_rxq_desc: Number of user requested RX queue descriptors through * ethtool * @user_flags: User toggled config flags * @mac_filter_list: List of MAC filters * @num_fsteer_fltrs: number of flow steering filters * @flow_steer_list: list of flow steering filters * * Used to restore configuration after a reset as the vport will get wiped.
*/ struct idpf_vport_user_config_data { struct idpf_rss_data rss_data; struct idpf_q_coalesce *q_coalesce;
u16 num_req_tx_qs;
u16 num_req_rx_qs;
u32 num_req_txq_desc;
u32 num_req_rxq_desc;
DECLARE_BITMAP(user_flags, __IDPF_USER_FLAGS_NBITS); struct list_head mac_filter_list;
u32 num_fsteer_fltrs; struct list_head flow_steer_list;
};
/** * enum idpf_vport_config_flags - Vport config flags * @IDPF_VPORT_REG_NETDEV: Register netdev * @IDPF_VPORT_UP_REQUESTED: Set if interface up is requested on core reset * @IDPF_VPORT_CONFIG_FLAGS_NBITS: Must be last
*/ enum idpf_vport_config_flags {
IDPF_VPORT_REG_NETDEV,
IDPF_VPORT_UP_REQUESTED,
IDPF_VPORT_CONFIG_FLAGS_NBITS,
};
/** * struct idpf_avail_queue_info * @avail_rxq: Available RX queues * @avail_txq: Available TX queues * @avail_bufq: Available buffer queues * @avail_complq: Available completion queues * * Maintain total queues available after allocating max queues to each vport.
*/ struct idpf_avail_queue_info {
u16 avail_rxq;
u16 avail_txq;
u16 avail_bufq;
u16 avail_complq;
};
/** * struct idpf_vector_info - Utility structure to pass function arguments as a * structure * @num_req_vecs: Vectors required based on the number of queues updated by the * user via ethtool * @num_curr_vecs: Current number of vectors, must be >= @num_req_vecs * @index: Relative starting index for vectors * @default_vport: Vectors are for default vport
*/ struct idpf_vector_info {
u16 num_req_vecs;
u16 num_curr_vecs;
u16 index; bool default_vport;
};
/** * struct idpf_vector_lifo - Stack to maintain vector indexes used for vector * distribution algorithm * @top: Points to stack top i.e. next available vector index * @base: Always points to start of the free pool * @size: Total size of the vector stack * @vec_idx: Array to store all the vector indexes * * Vector stack maintains all the relative vector indexes at the *adapter* * level. This stack is divided into 2 parts, first one is called as 'default * pool' and other one is called 'free pool'. Vector distribution algorithm * gives priority to default vports in a way that at least IDPF_MIN_Q_VEC * vectors are allocated per default vport and the relative vector indexes for * those are maintained in default pool. Free pool contains all the unallocated * vector indexes which can be allocated on-demand basis. Mailbox vector index * is maintained in the default pool of the stack.
*/ struct idpf_vector_lifo {
u16 top;
u16 base;
u16 size;
u16 *vec_idx;
};
/** * struct idpf_vport_config - Vport configuration data * @user_config: see struct idpf_vport_user_config_data * @max_q: Maximum possible queues * @req_qs_chunks: Queue chunk data for requested queues * @mac_filter_list_lock: Lock to protect mac filters * @flags: See enum idpf_vport_config_flags
*/ struct idpf_vport_config { struct idpf_vport_user_config_data user_config; struct idpf_vport_max_q max_q; struct virtchnl2_add_queues *req_qs_chunks;
spinlock_t mac_filter_list_lock;
DECLARE_BITMAP(flags, IDPF_VPORT_CONFIG_FLAGS_NBITS);
};
/** * struct idpf_adapter - Device data struct generated on probe * @pdev: PCI device struct given on probe * @virt_ver_maj: Virtchnl version major * @virt_ver_min: Virtchnl version minor * @msg_enable: Debug message level enabled * @mb_wait_count: Number of times mailbox was attempted initialization * @state: Init state machine * @flags: See enum idpf_flags * @reset_reg: See struct idpf_reset_reg * @hw: Device access data * @num_avail_msix: Available number of MSIX vectors * @num_msix_entries: Number of entries in MSIX table * @msix_entries: MSIX table * @num_rdma_msix_entries: Available number of MSIX vectors for RDMA * @rdma_msix_entries: RDMA MSIX table * @req_vec_chunks: Requested vector chunk data * @mb_vector: Mailbox vector data * @vector_stack: Stack to store the msix vector indexes * @irq_mb_handler: Handler for hard interrupt for mailbox * @tx_timeout_count: Number of TX timeouts that have occurred * @avail_queues: Device given queue limits * @vports: Array to store vports created by the driver * @netdevs: Associated Vport netdevs * @vport_params_reqd: Vport params requested * @vport_params_recvd: Vport params received * @vport_ids: Array of device given vport identifiers * @vport_config: Vport config parameters * @max_vports: Maximum vports that can be allocated * @num_alloc_vports: Current number of vports allocated * @next_vport: Next free slot in pf->vport[] - 0-based! * @init_task: Initialization task * @init_wq: Workqueue for initialization task * @serv_task: Periodically recurring maintenance task * @serv_wq: Workqueue for service task * @mbx_task: Task to handle mailbox interrupts * @mbx_wq: Workqueue for mailbox responses * @vc_event_task: Task to handle out of band virtchnl event notifications * @vc_event_wq: Workqueue for virtchnl events * @stats_task: Periodic statistics retrieval task * @stats_wq: Workqueue for statistics task * @caps: Negotiated capabilities with device * @vcxn_mngr: Virtchnl transaction manager * @dev_ops: See idpf_dev_ops * @cdev_info: IDC core device info pointer * @num_vfs: Number of allocated VFs through sysfs. PF does not directly talk * to VFs but is used to initialize them * @crc_enable: Enable CRC insertion offload * @req_tx_splitq: TX split or single queue model to request * @req_rx_splitq: RX split or single queue model to request * @vport_ctrl_lock: Lock to protect the vport control flow * @vector_lock: Lock to protect vector distribution * @queue_lock: Lock to protect queue distribution * @vc_buf_lock: Lock to protect virtchnl buffer * @ptp: Storage for PTP-related data
*/ struct idpf_adapter { struct pci_dev *pdev;
u32 virt_ver_maj;
u32 virt_ver_min;
/** * idpf_is_queue_model_split - check if queue model is split * @q_model: queue model single or split * * Returns true if queue model is split else false
*/ staticinlineint idpf_is_queue_model_split(u16 q_model)
{ return !IS_ENABLED(CONFIG_IDPF_SINGLEQ) ||
q_model == VIRTCHNL2_QUEUE_MODEL_SPLIT;
}
/** * idpf_get_reserved_rdma_vecs - Get reserved RDMA vectors * @adapter: private data struct * * Return: number of vectors reserved for RDMA
*/ staticinline u16 idpf_get_reserved_rdma_vecs(struct idpf_adapter *adapter)
{ return le16_to_cpu(adapter->caps.num_rdma_allocated_vectors);
}
/** * idpf_get_default_vports - Get default number of vports * @adapter: private data struct
*/ staticinline u16 idpf_get_default_vports(struct idpf_adapter *adapter)
{ return le16_to_cpu(adapter->caps.default_num_vports);
}
/** * idpf_get_max_vports - Get max number of vports * @adapter: private data struct
*/ staticinline u16 idpf_get_max_vports(struct idpf_adapter *adapter)
{ return le16_to_cpu(adapter->caps.max_vports);
}
/** * idpf_get_max_tx_bufs - Get max scatter-gather buffers supported by the device * @adapter: private data struct
*/ staticinlineunsignedint idpf_get_max_tx_bufs(struct idpf_adapter *adapter)
{ return adapter->caps.max_sg_bufs_per_tx_pkt;
}
/** * idpf_get_min_tx_pkt_len - Get min packet length supported by the device * @adapter: private data struct
*/ staticinline u8 idpf_get_min_tx_pkt_len(struct idpf_adapter *adapter)
{
u8 pkt_len = adapter->caps.min_sso_packet_len;
return pkt_len ? pkt_len : IDPF_TX_MIN_PKT_LEN;
}
/** * idpf_get_mbx_reg_addr - Get BAR0 mailbox register address * @adapter: private data struct * @reg_offset: register offset value * * Return: BAR0 mailbox register address based on register offset.
*/ staticinlinevoid __iomem *idpf_get_mbx_reg_addr(struct idpf_adapter *adapter,
resource_size_t reg_offset)
{ return adapter->hw.mbx.vaddr + reg_offset;
}
/** * idpf_get_rstat_reg_addr - Get BAR0 rstat register address * @adapter: private data struct * @reg_offset: register offset value * * Return: BAR0 rstat register address based on register offset.
*/ staticinlinevoid __iomem *idpf_get_rstat_reg_addr(struct idpf_adapter *adapter,
resource_size_t reg_offset)
{
reg_offset -= adapter->dev_ops.static_reg_info[1].start;
return adapter->hw.rstat.vaddr + reg_offset;
}
/** * idpf_get_reg_addr - Get BAR0 register address * @adapter: private data struct * @reg_offset: register offset value * * Based on the register offset, return the actual BAR0 register address
*/ staticinlinevoid __iomem *idpf_get_reg_addr(struct idpf_adapter *adapter,
resource_size_t reg_offset)
{ struct idpf_hw *hw = &adapter->hw;
for (int i = 0; i < hw->num_lan_regs; i++) { struct idpf_mmio_reg *region = &hw->lan_regs[i];
if (reg_offset >= region->addr_start &&
reg_offset < (region->addr_start + region->addr_len)) { /* Convert the offset so that it is relative to the * start of the region. Then add the base address of * the region to get the final address.
*/
reg_offset -= region->addr_start;
return region->vaddr + reg_offset;
}
}
/* It's impossible to hit this case with offsets from the CP. But if we * do for any other reason, the kernel will panic on that register * access. Might as well do it here to make it clear what's happening.
*/
BUG();
return NULL;
}
/** * idpf_is_reset_detected - check if we were reset at some point * @adapter: driver specific private structure * * Returns true if we are either in reset currently or were previously reset.
*/ staticinlinebool idpf_is_reset_detected(struct idpf_adapter *adapter)
{ if (!adapter->hw.arq) returntrue;
/** * idpf_is_reset_in_prog - check if reset is in progress * @adapter: driver specific private structure * * Returns true if hard reset is in progress, false otherwise
*/ staticinlinebool idpf_is_reset_in_prog(struct idpf_adapter *adapter)
{ return (test_bit(IDPF_HR_RESET_IN_PROG, adapter->flags) ||
test_bit(IDPF_HR_FUNC_RESET, adapter->flags) ||
test_bit(IDPF_HR_DRV_LOAD, adapter->flags));
}
/** * idpf_netdev_to_vport - get a vport handle from a netdev * @netdev: network interface device structure
*/ staticinlinestruct idpf_vport *idpf_netdev_to_vport(struct net_device *netdev)
{ struct idpf_netdev_priv *np = netdev_priv(netdev);
return np->vport;
}
/** * idpf_netdev_to_adapter - Get adapter handle from a netdev * @netdev: Network interface device structure
*/ staticinlinestruct idpf_adapter *idpf_netdev_to_adapter(struct net_device *netdev)
{ struct idpf_netdev_priv *np = netdev_priv(netdev);
return np->adapter;
}
/** * idpf_is_feature_ena - Determine if a particular feature is enabled * @vport: Vport to check * @feature: Netdev flag to check * * Returns true or false if a particular feature is enabled.
*/ staticinlinebool idpf_is_feature_ena(conststruct idpf_vport *vport,
netdev_features_t feature)
{ return vport->netdev->features & feature;
}
/** * idpf_get_max_tx_hdr_size -- get the size of tx header * @adapter: Driver specific private structure
*/ staticinline u16 idpf_get_max_tx_hdr_size(struct idpf_adapter *adapter)
{ return le16_to_cpu(adapter->caps.max_tx_hdr_size);
}
/** * idpf_vport_ctrl_lock - Acquire the vport control lock * @netdev: Network interface device structure * * This lock should be used by non-datapath code to protect against vport * destruction.
*/ staticinlinevoid idpf_vport_ctrl_lock(struct net_device *netdev)
{ struct idpf_netdev_priv *np = netdev_priv(netdev);
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
