en/reporter_tx.o en/reporter_rx.o en/params.o en/xsk/pool.o \
en/xsk/setup.o en/xsk/rx.o en/xsk/tx.o en/devlink.o en/ptp.o \
en/qos.o en/htb.o en/trap.o en/fs_tt_redirect.o en/selq.o \
- en/mgmt_pf.o lib/crypto.o lib/sd.o
+ lib/crypto.o
#
# Netdev extra
if (is_mp_supported(dev))
return false;
- if (mlx5_core_is_mgmt_pf(dev))
- return false;
-
return true;
}
if (!mlx5_core_is_ecpf(dev))
return 0;
- if (mlx5_core_is_mgmt_pf(dev))
- return 0;
-
return mlx5_host_pf_init(dev);
}
if (!mlx5_core_is_ecpf(dev))
return;
- if (mlx5_core_is_mgmt_pf(dev))
- return;
-
mlx5_host_pf_cleanup(dev);
err = mlx5_wait_for_pages(dev, &dev->priv.page_counters[MLX5_HOST_PF]);
#include "lib/clock.h"
#include "en/rx_res.h"
#include "en/selq.h"
-#include "lib/sd.h"
extern const struct net_device_ops mlx5e_netdev_ops;
-extern const struct net_device_ops mlx5e_mgmt_netdev_ops;
struct page_pool;
#define MLX5E_METADATA_ETHER_TYPE (0x8CE4)
struct hwtstamp_config *tstamp;
DECLARE_BITMAP(state, MLX5E_CHANNEL_NUM_STATES);
int ix;
- int vec_ix;
- int sd_ix;
int cpu;
/* Sync between icosq recovery and XSK enable/disable. */
struct mutex icosq_recovery_lock;
bool tx_ptp_opened;
bool rx_ptp_opened;
struct hwtstamp_config tstamp;
- u16 q_counter[MLX5_SD_MAX_GROUP_SZ];
+ u16 q_counter;
u16 drop_rq_q_counter;
struct notifier_block events_nb;
struct notifier_block blocking_events_nb;
struct mlx5e_rq_param;
int mlx5e_open_rq(struct mlx5e_params *params, struct mlx5e_rq_param *param,
- struct mlx5e_xsk_param *xsk, int node, u16 q_counter,
+ struct mlx5e_xsk_param *xsk, int node,
struct mlx5e_rq *rq);
#define MLX5E_RQ_WQES_TIMEOUT 20000 /* msecs */
int mlx5e_wait_for_min_rx_wqes(struct mlx5e_rq *rq, int wait_time);
void mlx5e_close_rq(struct mlx5e_rq *rq);
-int mlx5e_create_rq(struct mlx5e_rq *rq, struct mlx5e_rq_param *param, u16 q_counter);
+int mlx5e_create_rq(struct mlx5e_rq *rq, struct mlx5e_rq_param *param);
void mlx5e_destroy_rq(struct mlx5e_rq *rq);
struct mlx5e_sq_param;
}
extern const struct ethtool_ops mlx5e_ethtool_ops;
-extern const struct mlx5e_profile mlx5e_mgmt_pf_nic_profile;
int mlx5e_create_mkey(struct mlx5_core_dev *mdev, u32 pdn, u32 *mkey);
-int mlx5e_create_mdev_resources(struct mlx5_core_dev *mdev, bool create_tises);
+int mlx5e_create_mdev_resources(struct mlx5_core_dev *mdev);
void mlx5e_destroy_mdev_resources(struct mlx5_core_dev *mdev);
int mlx5e_refresh_tirs(struct mlx5e_priv *priv, bool enable_uc_lb,
bool enable_mc_lb);
struct net_device *netdev,
netdev_features_t features);
int mlx5e_set_features(struct net_device *netdev, netdev_features_t features);
-void mlx5e_nic_set_rx_mode(struct mlx5e_priv *priv);
-
#ifdef CONFIG_MLX5_ESWITCH
int mlx5e_set_vf_mac(struct net_device *dev, int vf, u8 *mac);
int mlx5e_set_vf_rate(struct net_device *dev, int vf, int min_tx_rate, int max_tx_rate);
return test_bit(MLX5E_CHANNEL_STATE_XSK, c->state);
}
-void mlx5e_channels_get_regular_rqn(struct mlx5e_channels *chs, unsigned int ix, u32 *rqn,
- u32 *vhca_id)
+void mlx5e_channels_get_regular_rqn(struct mlx5e_channels *chs, unsigned int ix, u32 *rqn)
{
struct mlx5e_channel *c = mlx5e_channels_get(chs, ix);
*rqn = c->rq.rqn;
- if (vhca_id)
- *vhca_id = MLX5_CAP_GEN(c->mdev, vhca_id);
}
-void mlx5e_channels_get_xsk_rqn(struct mlx5e_channels *chs, unsigned int ix, u32 *rqn,
- u32 *vhca_id)
+void mlx5e_channels_get_xsk_rqn(struct mlx5e_channels *chs, unsigned int ix, u32 *rqn)
{
struct mlx5e_channel *c = mlx5e_channels_get(chs, ix);
WARN_ON_ONCE(!test_bit(MLX5E_CHANNEL_STATE_XSK, c->state));
*rqn = c->xskrq.rqn;
- if (vhca_id)
- *vhca_id = MLX5_CAP_GEN(c->mdev, vhca_id);
}
bool mlx5e_channels_get_ptp_rqn(struct mlx5e_channels *chs, u32 *rqn)
unsigned int mlx5e_channels_get_num(struct mlx5e_channels *chs);
bool mlx5e_channels_is_xsk(struct mlx5e_channels *chs, unsigned int ix);
-void mlx5e_channels_get_regular_rqn(struct mlx5e_channels *chs, unsigned int ix, u32 *rqn,
- u32 *vhca_id);
-void mlx5e_channels_get_xsk_rqn(struct mlx5e_channels *chs, unsigned int ix, u32 *rqn,
- u32 *vhca_id);
+void mlx5e_channels_get_regular_rqn(struct mlx5e_channels *chs, unsigned int ix, u32 *rqn);
+void mlx5e_channels_get_xsk_rqn(struct mlx5e_channels *chs, unsigned int ix, u32 *rqn);
bool mlx5e_channels_get_ptp_rqn(struct mlx5e_channels *chs, u32 *rqn);
#endif /* __MLX5_EN_CHANNELS_H__ */
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
-// Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-
-#include <linux/kernel.h>
-#include "en/params.h"
-#include "en/health.h"
-#include "lib/eq.h"
-#include "en/dcbnl.h"
-#include "en_accel/ipsec.h"
-#include "en_accel/en_accel.h"
-#include "en/trap.h"
-#include "en/monitor_stats.h"
-#include "en/hv_vhca_stats.h"
-#include "en_rep.h"
-#include "en.h"
-
-static int mgmt_pf_async_event(struct notifier_block *nb, unsigned long event, void *data)
-{
- struct mlx5e_priv *priv = container_of(nb, struct mlx5e_priv, events_nb);
- struct mlx5_eqe *eqe = data;
-
- if (event != MLX5_EVENT_TYPE_PORT_CHANGE)
- return NOTIFY_DONE;
-
- switch (eqe->sub_type) {
- case MLX5_PORT_CHANGE_SUBTYPE_DOWN:
- case MLX5_PORT_CHANGE_SUBTYPE_ACTIVE:
- queue_work(priv->wq, &priv->update_carrier_work);
- break;
- default:
- return NOTIFY_DONE;
- }
-
- return NOTIFY_OK;
-}
-
-static void mlx5e_mgmt_pf_enable_async_events(struct mlx5e_priv *priv)
-{
- priv->events_nb.notifier_call = mgmt_pf_async_event;
- mlx5_notifier_register(priv->mdev, &priv->events_nb);
-}
-
-static void mlx5e_disable_mgmt_pf_async_events(struct mlx5e_priv *priv)
-{
- mlx5_notifier_unregister(priv->mdev, &priv->events_nb);
-}
-
-static void mlx5e_modify_mgmt_pf_admin_state(struct mlx5_core_dev *mdev,
- enum mlx5_port_status state)
-{
- struct mlx5_eswitch *esw = mdev->priv.eswitch;
- int vport_admin_state;
-
- mlx5_set_port_admin_status(mdev, state);
-
- if (state == MLX5_PORT_UP)
- vport_admin_state = MLX5_VPORT_ADMIN_STATE_AUTO;
- else
- vport_admin_state = MLX5_VPORT_ADMIN_STATE_DOWN;
-
- mlx5_eswitch_set_vport_state(esw, MLX5_VPORT_UPLINK, vport_admin_state);
-}
-
-static void mlx5e_build_mgmt_pf_nic_params(struct mlx5e_priv *priv, u16 mtu)
-{
- struct mlx5e_params *params = &priv->channels.params;
- struct mlx5_core_dev *mdev = priv->mdev;
- u8 rx_cq_period_mode;
-
- params->sw_mtu = mtu;
- params->hard_mtu = MLX5E_ETH_HARD_MTU;
- params->num_channels = 1;
-
- /* SQ */
- params->log_sq_size = is_kdump_kernel() ?
- MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE :
- MLX5E_PARAMS_DEFAULT_LOG_SQ_SIZE;
- MLX5E_SET_PFLAG(params, MLX5E_PFLAG_SKB_TX_MPWQE, mlx5e_tx_mpwqe_supported(mdev));
-
- MLX5E_SET_PFLAG(params, MLX5E_PFLAG_RX_NO_CSUM_COMPLETE, false);
-
- /* RQ */
- mlx5e_build_rq_params(mdev, params);
-
- /* CQ moderation params */
- rx_cq_period_mode = MLX5_CAP_GEN(mdev, cq_period_start_from_cqe) ?
- MLX5_CQ_PERIOD_MODE_START_FROM_CQE :
- MLX5_CQ_PERIOD_MODE_START_FROM_EQE;
- params->rx_dim_enabled = MLX5_CAP_GEN(mdev, cq_moderation);
- params->tx_dim_enabled = MLX5_CAP_GEN(mdev, cq_moderation);
- mlx5e_set_rx_cq_mode_params(params, rx_cq_period_mode);
- mlx5e_set_tx_cq_mode_params(params, MLX5_CQ_PERIOD_MODE_START_FROM_EQE);
-
- /* TX inline */
- mlx5_query_min_inline(mdev, ¶ms->tx_min_inline_mode);
-}
-
-static int mlx5e_mgmt_pf_init(struct mlx5_core_dev *mdev,
- struct net_device *netdev)
-{
- struct mlx5e_priv *priv = netdev_priv(netdev);
- struct mlx5e_flow_steering *fs;
- int err;
-
- mlx5e_build_mgmt_pf_nic_params(priv, netdev->mtu);
-
- mlx5e_timestamp_init(priv);
-
- fs = mlx5e_fs_init(priv->profile, mdev,
- !test_bit(MLX5E_STATE_DESTROYING, &priv->state),
- priv->dfs_root);
- if (!fs) {
- err = -ENOMEM;
- mlx5_core_err(mdev, "FS initialization failed, %d\n", err);
- return err;
- }
- priv->fs = fs;
-
- mlx5e_health_create_reporters(priv);
-
- return 0;
-}
-
-static void mlx5e_mgmt_pf_cleanup(struct mlx5e_priv *priv)
-{
- mlx5e_health_destroy_reporters(priv);
- mlx5e_fs_cleanup(priv->fs);
- priv->fs = NULL;
-}
-
-static int mlx5e_mgmt_pf_init_rx(struct mlx5e_priv *priv)
-{
- struct mlx5_core_dev *mdev = priv->mdev;
- int err;
-
- priv->rx_res = mlx5e_rx_res_create(mdev, 0, priv->max_nch, priv->drop_rq.rqn,
- &priv->channels.params.packet_merge,
- priv->channels.params.num_channels);
- if (!priv->rx_res)
- return -ENOMEM;
-
- mlx5e_create_q_counters(priv);
-
- err = mlx5e_open_drop_rq(priv, &priv->drop_rq);
- if (err) {
- mlx5_core_err(mdev, "open drop rq failed, %d\n", err);
- goto err_destroy_q_counters;
- }
-
- err = mlx5e_create_flow_steering(priv->fs, priv->rx_res, priv->profile,
- priv->netdev);
- if (err) {
- mlx5_core_warn(mdev, "create flow steering failed, %d\n", err);
- goto err_destroy_rx_res;
- }
-
- return 0;
-
-err_destroy_rx_res:
- mlx5e_rx_res_destroy(priv->rx_res);
- priv->rx_res = NULL;
- mlx5e_close_drop_rq(&priv->drop_rq);
-err_destroy_q_counters:
- mlx5e_destroy_q_counters(priv);
- return err;
-}
-
-static void mlx5e_mgmt_pf_cleanup_rx(struct mlx5e_priv *priv)
-{
- mlx5e_destroy_flow_steering(priv->fs, !!(priv->netdev->hw_features & NETIF_F_NTUPLE),
- priv->profile);
- mlx5e_rx_res_destroy(priv->rx_res);
- priv->rx_res = NULL;
- mlx5e_close_drop_rq(&priv->drop_rq);
- mlx5e_destroy_q_counters(priv);
-}
-
-static int mlx5e_mgmt_pf_init_tx(struct mlx5e_priv *priv)
-{
- return 0;
-}
-
-static void mlx5e_mgmt_pf_cleanup_tx(struct mlx5e_priv *priv)
-{
-}
-
-static void mlx5e_mgmt_pf_enable(struct mlx5e_priv *priv)
-{
- struct net_device *netdev = priv->netdev;
- struct mlx5_core_dev *mdev = priv->mdev;
-
- mlx5e_fs_init_l2_addr(priv->fs, netdev);
-
- /* Marking the link as currently not needed by the Driver */
- if (!netif_running(netdev))
- mlx5e_modify_mgmt_pf_admin_state(mdev, MLX5_PORT_DOWN);
-
- mlx5e_set_netdev_mtu_boundaries(priv);
- mlx5e_set_dev_port_mtu(priv);
-
- mlx5e_mgmt_pf_enable_async_events(priv);
- if (mlx5e_monitor_counter_supported(priv))
- mlx5e_monitor_counter_init(priv);
-
- mlx5e_hv_vhca_stats_create(priv);
- if (netdev->reg_state != NETREG_REGISTERED)
- return;
- mlx5e_dcbnl_init_app(priv);
-
- mlx5e_nic_set_rx_mode(priv);
-
- rtnl_lock();
- if (netif_running(netdev))
- mlx5e_open(netdev);
- udp_tunnel_nic_reset_ntf(priv->netdev);
- netif_device_attach(netdev);
- rtnl_unlock();
-}
-
-static void mlx5e_mgmt_pf_disable(struct mlx5e_priv *priv)
-{
- if (priv->netdev->reg_state == NETREG_REGISTERED)
- mlx5e_dcbnl_delete_app(priv);
-
- rtnl_lock();
- if (netif_running(priv->netdev))
- mlx5e_close(priv->netdev);
- netif_device_detach(priv->netdev);
- rtnl_unlock();
-
- mlx5e_nic_set_rx_mode(priv);
-
- mlx5e_hv_vhca_stats_destroy(priv);
- if (mlx5e_monitor_counter_supported(priv))
- mlx5e_monitor_counter_cleanup(priv);
-
- mlx5e_disable_mgmt_pf_async_events(priv);
- mlx5e_ipsec_cleanup(priv);
-}
-
-static int mlx5e_mgmt_pf_update_rx(struct mlx5e_priv *priv)
-{
- return mlx5e_refresh_tirs(priv, false, false);
-}
-
-static int mlx5e_mgmt_pf_max_nch_limit(struct mlx5_core_dev *mdev)
-{
- return 1;
-}
-
-const struct mlx5e_profile mlx5e_mgmt_pf_nic_profile = {
- .init = mlx5e_mgmt_pf_init,
- .cleanup = mlx5e_mgmt_pf_cleanup,
- .init_rx = mlx5e_mgmt_pf_init_rx,
- .cleanup_rx = mlx5e_mgmt_pf_cleanup_rx,
- .init_tx = mlx5e_mgmt_pf_init_tx,
- .cleanup_tx = mlx5e_mgmt_pf_cleanup_tx,
- .enable = mlx5e_mgmt_pf_enable,
- .disable = mlx5e_mgmt_pf_disable,
- .update_rx = mlx5e_mgmt_pf_update_rx,
- .update_stats = mlx5e_stats_update_ndo_stats,
- .update_carrier = mlx5e_update_carrier,
- .rx_handlers = &mlx5e_rx_handlers_nic,
- .max_tc = 1,
- .max_nch_limit = mlx5e_mgmt_pf_max_nch_limit,
- .stats_grps = mlx5e_nic_stats_grps,
- .stats_grps_num = mlx5e_nic_stats_grps_num
-};
#define NUM_REQ_PPCNT_COUNTER_S1 MLX5_CMD_SET_MONITOR_NUM_PPCNT_COUNTER_SET1
#define NUM_REQ_Q_COUNTERS_S1 MLX5_CMD_SET_MONITOR_NUM_Q_COUNTERS_SET1
-static int mlx5e_monitor_counter_cap(struct mlx5_core_dev *mdev)
+int mlx5e_monitor_counter_supported(struct mlx5e_priv *priv)
{
+ struct mlx5_core_dev *mdev = priv->mdev;
+
if (!MLX5_CAP_GEN(mdev, max_num_of_monitor_counters))
return false;
if (MLX5_CAP_PCAM_REG(mdev, ppcnt) &&
return true;
}
-int mlx5e_monitor_counter_supported(struct mlx5e_priv *priv)
-{
- struct mlx5_core_dev *pos;
- int i;
-
- mlx5_sd_for_each_dev(i, priv->mdev, pos)
- if (!mlx5e_monitor_counter_cap(pos))
- return false;
- return true;
-}
-
-static void mlx5e_monitor_counter_arm(struct mlx5_core_dev *mdev)
+static void mlx5e_monitor_counter_arm(struct mlx5e_priv *priv)
{
u32 in[MLX5_ST_SZ_DW(arm_monitor_counter_in)] = {};
MLX5_SET(arm_monitor_counter_in, in, opcode,
MLX5_CMD_OP_ARM_MONITOR_COUNTER);
- mlx5_cmd_exec_in(mdev, arm_monitor_counter, in);
+ mlx5_cmd_exec_in(priv->mdev, arm_monitor_counter, in);
}
static void mlx5e_monitor_counters_work(struct work_struct *work)
{
struct mlx5e_priv *priv = container_of(work, struct mlx5e_priv,
monitor_counters_work);
- struct mlx5_core_dev *pos;
- int i;
mutex_lock(&priv->state_lock);
mlx5e_stats_update_ndo_stats(priv);
mutex_unlock(&priv->state_lock);
- mlx5_sd_for_each_dev(i, priv->mdev, pos)
- mlx5e_monitor_counter_arm(pos);
+ mlx5e_monitor_counter_arm(priv);
}
static int mlx5e_monitor_event_handler(struct notifier_block *nb,
}
/* check if mlx5e_monitor_counter_supported before calling this function*/
-static void mlx5e_set_monitor_counter(struct mlx5_core_dev *mdev, int q_counter)
+static void mlx5e_set_monitor_counter(struct mlx5e_priv *priv)
{
+ struct mlx5_core_dev *mdev = priv->mdev;
int max_num_of_counters = MLX5_CAP_GEN(mdev, max_num_of_monitor_counters);
int num_q_counters = MLX5_CAP_GEN(mdev, num_q_monitor_counters);
int num_ppcnt_counters = !MLX5_CAP_PCAM_REG(mdev, ppcnt) ? 0 :
MLX5_CAP_GEN(mdev, num_ppcnt_monitor_counters);
u32 in[MLX5_ST_SZ_DW(set_monitor_counter_in)] = {};
+ int q_counter = priv->q_counter;
int cnt = 0;
if (num_ppcnt_counters >= NUM_REQ_PPCNT_COUNTER_S1 &&
/* check if mlx5e_monitor_counter_supported before calling this function*/
void mlx5e_monitor_counter_init(struct mlx5e_priv *priv)
{
- struct mlx5_core_dev *pos;
- int i;
-
INIT_WORK(&priv->monitor_counters_work, mlx5e_monitor_counters_work);
MLX5_NB_INIT(&priv->monitor_counters_nb, mlx5e_monitor_event_handler,
MONITOR_COUNTER);
- mlx5_sd_for_each_dev(i, priv->mdev, pos) {
- mlx5_eq_notifier_register(pos, &priv->monitor_counters_nb);
- mlx5e_set_monitor_counter(pos, priv->q_counter[i]);
- mlx5e_monitor_counter_arm(pos);
- }
+ mlx5_eq_notifier_register(priv->mdev, &priv->monitor_counters_nb);
+
+ mlx5e_set_monitor_counter(priv);
+ mlx5e_monitor_counter_arm(priv);
queue_work(priv->wq, &priv->update_stats_work);
}
void mlx5e_monitor_counter_cleanup(struct mlx5e_priv *priv)
{
u32 in[MLX5_ST_SZ_DW(set_monitor_counter_in)] = {};
- struct mlx5_core_dev *pos;
- int i;
MLX5_SET(set_monitor_counter_in, in, opcode,
MLX5_CMD_OP_SET_MONITOR_COUNTER);
- mlx5_sd_for_each_dev(i, priv->mdev, pos) {
- mlx5_cmd_exec_in(pos, set_monitor_counter, in);
- mlx5_eq_notifier_unregister(pos, &priv->monitor_counters_nb);
- }
+ mlx5_cmd_exec_in(priv->mdev, set_monitor_counter, in);
+ mlx5_eq_notifier_unregister(priv->mdev, &priv->monitor_counters_nb);
cancel_work_sync(&priv->monitor_counters_work);
}
.napi = &c->napi,
.ch_stats = c->stats,
.node = cpu_to_node(c->cpu),
- .ix = c->vec_ix,
+ .ix = c->ix,
};
}
int mlx5e_build_rq_param(struct mlx5_core_dev *mdev,
struct mlx5e_params *params,
struct mlx5e_xsk_param *xsk,
+ u16 q_counter,
struct mlx5e_rq_param *param)
{
void *rqc = param->rqc;
MLX5_SET(wq, wq, log_wq_stride,
mlx5e_get_rqwq_log_stride(params->rq_wq_type, ndsegs));
MLX5_SET(wq, wq, pd, mdev->mlx5e_res.hw_objs.pdn);
+ MLX5_SET(rqc, rqc, counter_set_id, q_counter);
MLX5_SET(rqc, rqc, vsd, params->vlan_strip_disable);
MLX5_SET(rqc, rqc, scatter_fcs, params->scatter_fcs_en);
}
void mlx5e_build_drop_rq_param(struct mlx5_core_dev *mdev,
+ u16 q_counter,
struct mlx5e_rq_param *param)
{
void *rqc = param->rqc;
MLX5_SET(wq, wq, wq_type, MLX5_WQ_TYPE_CYCLIC);
MLX5_SET(wq, wq, log_wq_stride,
mlx5e_get_rqwq_log_stride(MLX5_WQ_TYPE_CYCLIC, 1));
+ MLX5_SET(rqc, rqc, counter_set_id, q_counter);
param->wq.buf_numa_node = dev_to_node(mlx5_core_dma_dev(mdev));
}
int mlx5e_build_channel_param(struct mlx5_core_dev *mdev,
struct mlx5e_params *params,
+ u16 q_counter,
struct mlx5e_channel_param *cparam)
{
u8 icosq_log_wq_sz, async_icosq_log_wq_sz;
int err;
- err = mlx5e_build_rq_param(mdev, params, NULL, &cparam->rq);
+ err = mlx5e_build_rq_param(mdev, params, NULL, q_counter, &cparam->rq);
if (err)
return err;
int mlx5e_build_rq_param(struct mlx5_core_dev *mdev,
struct mlx5e_params *params,
struct mlx5e_xsk_param *xsk,
+ u16 q_counter,
struct mlx5e_rq_param *param);
void mlx5e_build_drop_rq_param(struct mlx5_core_dev *mdev,
+ u16 q_counter,
struct mlx5e_rq_param *param);
void mlx5e_build_sq_param_common(struct mlx5_core_dev *mdev,
struct mlx5e_sq_param *param);
struct mlx5e_sq_param *param);
int mlx5e_build_channel_param(struct mlx5_core_dev *mdev,
struct mlx5e_params *params,
+ u16 q_counter,
struct mlx5e_channel_param *cparam);
u16 mlx5e_calc_sq_stop_room(struct mlx5_core_dev *mdev, struct mlx5e_params *params);
static void mlx5e_ptp_build_rq_param(struct mlx5_core_dev *mdev,
struct net_device *netdev,
+ u16 q_counter,
struct mlx5e_ptp_params *ptp_params)
{
struct mlx5e_rq_param *rq_params = &ptp_params->rq_param;
params->rq_wq_type = MLX5_WQ_TYPE_CYCLIC;
mlx5e_init_rq_type_params(mdev, params);
params->sw_mtu = netdev->max_mtu;
- mlx5e_build_rq_param(mdev, params, NULL, rq_params);
+ mlx5e_build_rq_param(mdev, params, NULL, q_counter, rq_params);
}
static void mlx5e_ptp_build_params(struct mlx5e_ptp *c,
/* RQ */
if (test_bit(MLX5E_PTP_STATE_RX, c->state)) {
params->vlan_strip_disable = orig->vlan_strip_disable;
- mlx5e_ptp_build_rq_param(c->mdev, c->netdev, cparams);
+ mlx5e_ptp_build_rq_param(c->mdev, c->netdev, c->priv->q_counter, cparams);
}
}
struct mlx5e_rq_param *rq_param)
{
int node = dev_to_node(c->mdev->device);
- int err, sd_ix;
- u16 q_counter;
+ int err;
err = mlx5e_init_ptp_rq(c, params, &c->rq);
if (err)
return err;
- sd_ix = mlx5_sd_ch_ix_get_dev_ix(c->mdev, MLX5E_PTP_CHANNEL_IX);
- q_counter = c->priv->q_counter[sd_ix];
- return mlx5e_open_rq(params, rq_param, NULL, node, q_counter, &c->rq);
+ return mlx5e_open_rq(params, rq_param, NULL, node, &c->rq);
}
static int mlx5e_ptp_open_queues(struct mlx5e_ptp *c,
memset(¶m_sq, 0, sizeof(param_sq));
memset(¶m_cq, 0, sizeof(param_cq));
- mlx5e_build_sq_param(c->mdev, params, ¶m_sq);
- mlx5e_build_tx_cq_param(c->mdev, params, ¶m_cq);
+ mlx5e_build_sq_param(priv->mdev, params, ¶m_sq);
+ mlx5e_build_tx_cq_param(priv->mdev, params, ¶m_cq);
err = mlx5e_open_cq(c->mdev, params->tx_cq_moderation, ¶m_cq, &ccp, &sq->cq);
if (err)
goto err_free_sq;
*/
smp_wmb();
- qos_dbg(sq->mdev, "Activate QoS SQ qid %u\n", node_qid);
+ qos_dbg(priv->mdev, "Activate QoS SQ qid %u\n", node_qid);
mlx5e_activate_txqsq(sq);
return 0;
if (!sq) /* Handle the case when the SQ failed to open. */
return;
- qos_dbg(sq->mdev, "Deactivate QoS SQ qid %u\n", qid);
+ qos_dbg(priv->mdev, "Deactivate QoS SQ qid %u\n", qid);
mlx5e_deactivate_txqsq(sq);
priv->txq2sq[mlx5e_qid_from_qos(&priv->channels, qid)] = NULL;
params = &priv->channels.params;
rq_sz = mlx5e_rqwq_get_size(rq);
- real_time = mlx5_is_real_time_rq(rq->mdev);
- rq_stride = BIT(mlx5e_mpwqe_get_log_stride_size(rq->mdev, params, NULL));
+ real_time = mlx5_is_real_time_rq(priv->mdev);
+ rq_stride = BIT(mlx5e_mpwqe_get_log_stride_size(priv->mdev, params, NULL));
mlx5e_health_fmsg_named_obj_nest_start(fmsg, "RQ");
devlink_fmsg_u8_pair_put(fmsg, "type", params->rq_wq_type);
struct mlx5e_txqsq *sq, int tc)
{
bool stopped = netif_xmit_stopped(sq->txq);
+ struct mlx5e_priv *priv = sq->priv;
u8 state;
int err;
devlink_fmsg_u32_pair_put(fmsg, "txq ix", sq->txq_ix);
devlink_fmsg_u32_pair_put(fmsg, "sqn", sq->sqn);
- err = mlx5_core_query_sq_state(sq->mdev, sq->sqn, &state);
+ err = mlx5_core_query_sq_state(priv->mdev, sq->sqn, &state);
if (!err)
devlink_fmsg_u8_pair_put(fmsg, "HW state", state);
#include "rqt.h"
#include <linux/mlx5/transobj.h>
-static bool verify_num_vhca_ids(struct mlx5_core_dev *mdev, u32 *vhca_ids,
- unsigned int size)
-{
- unsigned int max_num_vhca_id = MLX5_CAP_GEN_2(mdev, max_rqt_vhca_id);
- int i;
-
- /* Verify that all vhca_ids are in range [0, max_num_vhca_ids - 1] */
- for (i = 0; i < size; i++)
- if (vhca_ids[i] >= max_num_vhca_id)
- return false;
- return true;
-}
-
-static bool rqt_verify_vhca_ids(struct mlx5_core_dev *mdev, u32 *vhca_ids,
- unsigned int size)
-{
- if (!vhca_ids)
- return true;
-
- if (!MLX5_CAP_GEN(mdev, cross_vhca_rqt))
- return false;
- if (!verify_num_vhca_ids(mdev, vhca_ids, size))
- return false;
-
- return true;
-}
-
void mlx5e_rss_params_indir_init_uniform(struct mlx5e_rss_params_indir *indir,
unsigned int num_channels)
{
indir->table[i] = i % num_channels;
}
-static void fill_rqn_list(void *rqtc, u32 *rqns, u32 *vhca_ids, unsigned int size)
-{
- unsigned int i;
-
- if (vhca_ids) {
- MLX5_SET(rqtc, rqtc, rq_vhca_id_format, 1);
- for (i = 0; i < size; i++) {
- MLX5_SET(rqtc, rqtc, rq_vhca[i].rq_num, rqns[i]);
- MLX5_SET(rqtc, rqtc, rq_vhca[i].rq_vhca_id, vhca_ids[i]);
- }
- } else {
- for (i = 0; i < size; i++)
- MLX5_SET(rqtc, rqtc, rq_num[i], rqns[i]);
- }
-}
static int mlx5e_rqt_init(struct mlx5e_rqt *rqt, struct mlx5_core_dev *mdev,
- u16 max_size, u32 *init_rqns, u32 *init_vhca_ids, u16 init_size)
+ u16 max_size, u32 *init_rqns, u16 init_size)
{
- int entry_sz;
void *rqtc;
int inlen;
int err;
u32 *in;
-
- if (!rqt_verify_vhca_ids(mdev, init_vhca_ids, init_size))
- return -EOPNOTSUPP;
+ int i;
rqt->mdev = mdev;
rqt->size = max_size;
- entry_sz = init_vhca_ids ? MLX5_ST_SZ_BYTES(rq_vhca) : MLX5_ST_SZ_BYTES(rq_num);
- inlen = MLX5_ST_SZ_BYTES(create_rqt_in) + entry_sz * init_size;
+ inlen = MLX5_ST_SZ_BYTES(create_rqt_in) + sizeof(u32) * init_size;
in = kvzalloc(inlen, GFP_KERNEL);
if (!in)
return -ENOMEM;
rqtc = MLX5_ADDR_OF(create_rqt_in, in, rqt_context);
MLX5_SET(rqtc, rqtc, rqt_max_size, rqt->size);
- MLX5_SET(rqtc, rqtc, rqt_actual_size, init_size);
- fill_rqn_list(rqtc, init_rqns, init_vhca_ids, init_size);
+ MLX5_SET(rqtc, rqtc, rqt_actual_size, init_size);
+ for (i = 0; i < init_size; i++)
+ MLX5_SET(rqtc, rqtc, rq_num[i], init_rqns[i]);
err = mlx5_core_create_rqt(rqt->mdev, in, inlen, &rqt->rqtn);
{
u16 max_size = indir_enabled ? indir_table_size : 1;
- return mlx5e_rqt_init(rqt, mdev, max_size, &init_rqn, NULL, 1);
+ return mlx5e_rqt_init(rqt, mdev, max_size, &init_rqn, 1);
}
static int mlx5e_bits_invert(unsigned long a, int size)
return inv;
}
-static int mlx5e_calc_indir_rqns(u32 *rss_rqns, u32 *rqns, u32 *rss_vhca_ids, u32 *vhca_ids,
- unsigned int num_rqns,
+static int mlx5e_calc_indir_rqns(u32 *rss_rqns, u32 *rqns, unsigned int num_rqns,
u8 hfunc, struct mlx5e_rss_params_indir *indir)
{
unsigned int i;
*/
return -EINVAL;
rss_rqns[i] = rqns[ix];
- if (vhca_ids)
- rss_vhca_ids[i] = vhca_ids[ix];
}
return 0;
}
int mlx5e_rqt_init_indir(struct mlx5e_rqt *rqt, struct mlx5_core_dev *mdev,
- u32 *rqns, u32 *vhca_ids, unsigned int num_rqns,
+ u32 *rqns, unsigned int num_rqns,
u8 hfunc, struct mlx5e_rss_params_indir *indir)
{
- u32 *rss_rqns, *rss_vhca_ids = NULL;
+ u32 *rss_rqns;
int err;
rss_rqns = kvmalloc_array(indir->actual_table_size, sizeof(*rss_rqns), GFP_KERNEL);
if (!rss_rqns)
return -ENOMEM;
- if (vhca_ids) {
- rss_vhca_ids = kvmalloc_array(indir->actual_table_size, sizeof(*rss_vhca_ids),
- GFP_KERNEL);
- if (!rss_vhca_ids) {
- kvfree(rss_rqns);
- return -ENOMEM;
- }
- }
-
- err = mlx5e_calc_indir_rqns(rss_rqns, rqns, rss_vhca_ids, vhca_ids, num_rqns, hfunc, indir);
+ err = mlx5e_calc_indir_rqns(rss_rqns, rqns, num_rqns, hfunc, indir);
if (err)
goto out;
- err = mlx5e_rqt_init(rqt, mdev, indir->max_table_size, rss_rqns, rss_vhca_ids,
+ err = mlx5e_rqt_init(rqt, mdev, indir->max_table_size, rss_rqns,
indir->actual_table_size);
out:
- kvfree(rss_vhca_ids);
kvfree(rss_rqns);
return err;
}
mlx5_core_destroy_rqt(rqt->mdev, rqt->rqtn);
}
-static int mlx5e_rqt_redirect(struct mlx5e_rqt *rqt, u32 *rqns, u32 *vhca_ids,
- unsigned int size)
+static int mlx5e_rqt_redirect(struct mlx5e_rqt *rqt, u32 *rqns, unsigned int size)
{
- int entry_sz;
+ unsigned int i;
void *rqtc;
int inlen;
u32 *in;
int err;
- if (!rqt_verify_vhca_ids(rqt->mdev, vhca_ids, size))
- return -EINVAL;
-
- entry_sz = vhca_ids ? MLX5_ST_SZ_BYTES(rq_vhca) : MLX5_ST_SZ_BYTES(rq_num);
- inlen = MLX5_ST_SZ_BYTES(modify_rqt_in) + entry_sz * size;
+ inlen = MLX5_ST_SZ_BYTES(modify_rqt_in) + sizeof(u32) * size;
in = kvzalloc(inlen, GFP_KERNEL);
if (!in)
return -ENOMEM;
MLX5_SET(modify_rqt_in, in, bitmask.rqn_list, 1);
MLX5_SET(rqtc, rqtc, rqt_actual_size, size);
-
- fill_rqn_list(rqtc, rqns, vhca_ids, size);
+ for (i = 0; i < size; i++)
+ MLX5_SET(rqtc, rqtc, rq_num[i], rqns[i]);
err = mlx5_core_modify_rqt(rqt->mdev, rqt->rqtn, in, inlen);
return err;
}
-int mlx5e_rqt_redirect_direct(struct mlx5e_rqt *rqt, u32 rqn, u32 *vhca_id)
+int mlx5e_rqt_redirect_direct(struct mlx5e_rqt *rqt, u32 rqn)
{
- return mlx5e_rqt_redirect(rqt, &rqn, vhca_id, 1);
+ return mlx5e_rqt_redirect(rqt, &rqn, 1);
}
-int mlx5e_rqt_redirect_indir(struct mlx5e_rqt *rqt, u32 *rqns, u32 *vhca_ids,
- unsigned int num_rqns,
+int mlx5e_rqt_redirect_indir(struct mlx5e_rqt *rqt, u32 *rqns, unsigned int num_rqns,
u8 hfunc, struct mlx5e_rss_params_indir *indir)
{
- u32 *rss_rqns, *rss_vhca_ids = NULL;
+ u32 *rss_rqns;
int err;
- if (!rqt_verify_vhca_ids(rqt->mdev, vhca_ids, num_rqns))
- return -EINVAL;
-
if (WARN_ON(rqt->size != indir->max_table_size))
return -EINVAL;
if (!rss_rqns)
return -ENOMEM;
- if (vhca_ids) {
- rss_vhca_ids = kvmalloc_array(indir->actual_table_size, sizeof(*rss_vhca_ids),
- GFP_KERNEL);
- if (!rss_vhca_ids) {
- kvfree(rss_rqns);
- return -ENOMEM;
- }
- }
-
- err = mlx5e_calc_indir_rqns(rss_rqns, rqns, rss_vhca_ids, vhca_ids, num_rqns, hfunc, indir);
+ err = mlx5e_calc_indir_rqns(rss_rqns, rqns, num_rqns, hfunc, indir);
if (err)
goto out;
- err = mlx5e_rqt_redirect(rqt, rss_rqns, rss_vhca_ids, indir->actual_table_size);
+ err = mlx5e_rqt_redirect(rqt, rss_rqns, indir->actual_table_size);
out:
- kvfree(rss_vhca_ids);
kvfree(rss_rqns);
return err;
}
unsigned int num_channels);
struct mlx5e_rqt {
- struct mlx5_core_dev *mdev; /* primary */
+ struct mlx5_core_dev *mdev;
u32 rqtn;
u16 size;
};
int mlx5e_rqt_init_direct(struct mlx5e_rqt *rqt, struct mlx5_core_dev *mdev,
bool indir_enabled, u32 init_rqn, u32 indir_table_size);
int mlx5e_rqt_init_indir(struct mlx5e_rqt *rqt, struct mlx5_core_dev *mdev,
- u32 *rqns, u32 *vhca_ids, unsigned int num_rqns,
+ u32 *rqns, unsigned int num_rqns,
u8 hfunc, struct mlx5e_rss_params_indir *indir);
void mlx5e_rqt_destroy(struct mlx5e_rqt *rqt);
}
u32 mlx5e_rqt_size(struct mlx5_core_dev *mdev, unsigned int num_channels);
-int mlx5e_rqt_redirect_direct(struct mlx5e_rqt *rqt, u32 rqn, u32 *vhca_id);
-int mlx5e_rqt_redirect_indir(struct mlx5e_rqt *rqt, u32 *rqns, u32 *vhca_ids,
- unsigned int num_rqns,
+int mlx5e_rqt_redirect_direct(struct mlx5e_rqt *rqt, u32 rqn);
+int mlx5e_rqt_redirect_indir(struct mlx5e_rqt *rqt, u32 *rqns, unsigned int num_rqns,
u8 hfunc, struct mlx5e_rss_params_indir *indir);
#endif /* __MLX5_EN_RQT_H__ */
struct mlx5e_tir *tir[MLX5E_NUM_INDIR_TIRS];
struct mlx5e_tir *inner_tir[MLX5E_NUM_INDIR_TIRS];
struct mlx5e_rqt rqt;
- struct mlx5_core_dev *mdev; /* primary */
+ struct mlx5_core_dev *mdev;
u32 drop_rqn;
bool inner_ft_support;
bool enabled;
return 0;
}
-static int mlx5e_rss_apply(struct mlx5e_rss *rss, u32 *rqns, u32 *vhca_ids, unsigned int num_rqns)
+static int mlx5e_rss_apply(struct mlx5e_rss *rss, u32 *rqns, unsigned int num_rqns)
{
int err;
- err = mlx5e_rqt_redirect_indir(&rss->rqt, rqns, vhca_ids, num_rqns, rss->hash.hfunc,
- &rss->indir);
+ err = mlx5e_rqt_redirect_indir(&rss->rqt, rqns, num_rqns, rss->hash.hfunc, &rss->indir);
if (err)
mlx5e_rss_warn(rss->mdev, "Failed to redirect RQT %#x to channels: err = %d\n",
mlx5e_rqt_get_rqtn(&rss->rqt), err);
return err;
}
-void mlx5e_rss_enable(struct mlx5e_rss *rss, u32 *rqns, u32 *vhca_ids, unsigned int num_rqns)
+void mlx5e_rss_enable(struct mlx5e_rss *rss, u32 *rqns, unsigned int num_rqns)
{
rss->enabled = true;
- mlx5e_rss_apply(rss, rqns, vhca_ids, num_rqns);
+ mlx5e_rss_apply(rss, rqns, num_rqns);
}
void mlx5e_rss_disable(struct mlx5e_rss *rss)
int err;
rss->enabled = false;
- err = mlx5e_rqt_redirect_direct(&rss->rqt, rss->drop_rqn, NULL);
+ err = mlx5e_rqt_redirect_direct(&rss->rqt, rss->drop_rqn);
if (err)
mlx5e_rss_warn(rss->mdev, "Failed to redirect RQT %#x to drop RQ %#x: err = %d\n",
mlx5e_rqt_get_rqtn(&rss->rqt), rss->drop_rqn, err);
int mlx5e_rss_set_rxfh(struct mlx5e_rss *rss, const u32 *indir,
const u8 *key, const u8 *hfunc,
- u32 *rqns, u32 *vhca_ids, unsigned int num_rqns)
+ u32 *rqns, unsigned int num_rqns)
{
bool changed_indir = false;
bool changed_hash = false;
}
if (changed_indir && rss->enabled) {
- err = mlx5e_rss_apply(rss, rqns, vhca_ids, num_rqns);
+ err = mlx5e_rss_apply(rss, rqns, num_rqns);
if (err) {
mlx5e_rss_copy(rss, old_rss);
goto out;
const struct mlx5e_packet_merge_param *init_pkt_merge_param,
bool inner, u32 *tirn);
-void mlx5e_rss_enable(struct mlx5e_rss *rss, u32 *rqns, u32 *vhca_ids, unsigned int num_rqns);
+void mlx5e_rss_enable(struct mlx5e_rss *rss, u32 *rqns, unsigned int num_rqns);
void mlx5e_rss_disable(struct mlx5e_rss *rss);
int mlx5e_rss_packet_merge_set_param(struct mlx5e_rss *rss,
int mlx5e_rss_get_rxfh(struct mlx5e_rss *rss, u32 *indir, u8 *key, u8 *hfunc);
int mlx5e_rss_set_rxfh(struct mlx5e_rss *rss, const u32 *indir,
const u8 *key, const u8 *hfunc,
- u32 *rqns, u32 *vhca_ids, unsigned int num_rqns);
+ u32 *rqns, unsigned int num_rqns);
struct mlx5e_rss_params_hash mlx5e_rss_get_hash(struct mlx5e_rss *rss);
u8 mlx5e_rss_get_hash_fields(struct mlx5e_rss *rss, enum mlx5_traffic_types tt);
int mlx5e_rss_set_hash_fields(struct mlx5e_rss *rss, enum mlx5_traffic_types tt,
#define MLX5E_MAX_NUM_RSS 16
struct mlx5e_rx_res {
- struct mlx5_core_dev *mdev; /* primary */
+ struct mlx5_core_dev *mdev;
enum mlx5e_rx_res_features features;
unsigned int max_nch;
u32 drop_rqn;
struct mlx5e_rss *rss[MLX5E_MAX_NUM_RSS];
bool rss_active;
u32 *rss_rqns;
- u32 *rss_vhca_ids;
unsigned int rss_nch;
struct {
/* API for rx_res_rss_* */
-static u32 *get_vhca_ids(struct mlx5e_rx_res *res, int offset)
-{
- bool multi_vhca = res->features & MLX5E_RX_RES_FEATURE_MULTI_VHCA;
-
- return multi_vhca ? res->rss_vhca_ids + offset : NULL;
-}
-
void mlx5e_rx_res_rss_update_num_channels(struct mlx5e_rx_res *res, u32 nch)
{
int i;
return PTR_ERR(rss);
mlx5e_rss_set_indir_uniform(rss, init_nch);
- if (res->rss_active) {
- u32 *vhca_ids = get_vhca_ids(res, 0);
-
- mlx5e_rss_enable(rss, res->rss_rqns, vhca_ids, res->rss_nch);
- }
+ if (res->rss_active)
+ mlx5e_rss_enable(rss, res->rss_rqns, res->rss_nch);
res->rss[i] = rss;
*rss_idx = i;
for (i = 0; i < MLX5E_MAX_NUM_RSS; i++) {
struct mlx5e_rss *rss = res->rss[i];
- u32 *vhca_ids;
if (!rss)
continue;
- vhca_ids = get_vhca_ids(res, 0);
- mlx5e_rss_enable(rss, res->rss_rqns, vhca_ids, res->rss_nch);
+ mlx5e_rss_enable(rss, res->rss_rqns, res->rss_nch);
}
}
int mlx5e_rx_res_rss_set_rxfh(struct mlx5e_rx_res *res, u32 rss_idx,
const u32 *indir, const u8 *key, const u8 *hfunc)
{
- u32 *vhca_ids = get_vhca_ids(res, 0);
struct mlx5e_rss *rss;
if (rss_idx >= MLX5E_MAX_NUM_RSS)
if (!rss)
return -ENOENT;
- return mlx5e_rss_set_rxfh(rss, indir, key, hfunc, res->rss_rqns, vhca_ids,
- res->rss_nch);
+ return mlx5e_rss_set_rxfh(rss, indir, key, hfunc, res->rss_rqns, res->rss_nch);
}
int mlx5e_rx_res_rss_get_hash_fields(struct mlx5e_rx_res *res, u32 rss_idx,
static void mlx5e_rx_res_free(struct mlx5e_rx_res *res)
{
- kvfree(res->rss_vhca_ids);
kvfree(res->rss_rqns);
kvfree(res);
}
-static struct mlx5e_rx_res *mlx5e_rx_res_alloc(struct mlx5_core_dev *mdev, unsigned int max_nch,
- bool multi_vhca)
+static struct mlx5e_rx_res *mlx5e_rx_res_alloc(struct mlx5_core_dev *mdev, unsigned int max_nch)
{
struct mlx5e_rx_res *rx_res;
return NULL;
}
- if (multi_vhca) {
- rx_res->rss_vhca_ids = kvcalloc(max_nch, sizeof(*rx_res->rss_vhca_ids), GFP_KERNEL);
- if (!rx_res->rss_vhca_ids) {
- kvfree(rx_res->rss_rqns);
- kvfree(rx_res);
- return NULL;
- }
- }
-
return rx_res;
}
const struct mlx5e_packet_merge_param *init_pkt_merge_param,
unsigned int init_nch)
{
- bool multi_vhca = features & MLX5E_RX_RES_FEATURE_MULTI_VHCA;
struct mlx5e_rx_res *res;
int err;
- res = mlx5e_rx_res_alloc(mdev, max_nch, multi_vhca);
+ res = mlx5e_rx_res_alloc(mdev, max_nch);
if (!res)
return ERR_PTR(-ENOMEM);
struct mlx5e_channels *chs,
unsigned int ix)
{
- u32 *vhca_id = get_vhca_ids(res, ix);
u32 rqn = res->rss_rqns[ix];
int err;
- err = mlx5e_rqt_redirect_direct(&res->channels[ix].direct_rqt, rqn, vhca_id);
+ err = mlx5e_rqt_redirect_direct(&res->channels[ix].direct_rqt, rqn);
if (err)
mlx5_core_warn(res->mdev, "Failed to redirect direct RQT %#x to RQ %#x (channel %u): err = %d\n",
mlx5e_rqt_get_rqtn(&res->channels[ix].direct_rqt),
{
int err;
- err = mlx5e_rqt_redirect_direct(&res->channels[ix].direct_rqt, res->drop_rqn, NULL);
+ err = mlx5e_rqt_redirect_direct(&res->channels[ix].direct_rqt, res->drop_rqn);
if (err)
mlx5_core_warn(res->mdev, "Failed to redirect direct RQT %#x to drop RQ %#x (channel %u): err = %d\n",
mlx5e_rqt_get_rqtn(&res->channels[ix].direct_rqt),
nch = mlx5e_channels_get_num(chs);
for (ix = 0; ix < chs->num; ix++) {
- u32 *vhca_id = get_vhca_ids(res, ix);
-
if (mlx5e_channels_is_xsk(chs, ix))
- mlx5e_channels_get_xsk_rqn(chs, ix, &res->rss_rqns[ix], vhca_id);
+ mlx5e_channels_get_xsk_rqn(chs, ix, &res->rss_rqns[ix]);
else
- mlx5e_channels_get_regular_rqn(chs, ix, &res->rss_rqns[ix], vhca_id);
+ mlx5e_channels_get_regular_rqn(chs, ix, &res->rss_rqns[ix]);
}
res->rss_nch = chs->num;
if (!mlx5e_channels_get_ptp_rqn(chs, &rqn))
rqn = res->drop_rqn;
- err = mlx5e_rqt_redirect_direct(&res->ptp.rqt, rqn, NULL);
+ err = mlx5e_rqt_redirect_direct(&res->ptp.rqt, rqn);
if (err)
mlx5_core_warn(res->mdev, "Failed to redirect direct RQT %#x to RQ %#x (PTP): err = %d\n",
mlx5e_rqt_get_rqtn(&res->ptp.rqt),
mlx5e_rx_res_channel_deactivate_direct(res, ix);
if (res->features & MLX5E_RX_RES_FEATURE_PTP) {
- err = mlx5e_rqt_redirect_direct(&res->ptp.rqt, res->drop_rqn, NULL);
+ err = mlx5e_rqt_redirect_direct(&res->ptp.rqt, res->drop_rqn);
if (err)
mlx5_core_warn(res->mdev, "Failed to redirect direct RQT %#x to drop RQ %#x (PTP): err = %d\n",
mlx5e_rqt_get_rqtn(&res->ptp.rqt),
void mlx5e_rx_res_xsk_update(struct mlx5e_rx_res *res, struct mlx5e_channels *chs,
unsigned int ix, bool xsk)
{
- u32 *vhca_id = get_vhca_ids(res, ix);
-
if (xsk)
- mlx5e_channels_get_xsk_rqn(chs, ix, &res->rss_rqns[ix], vhca_id);
+ mlx5e_channels_get_xsk_rqn(chs, ix, &res->rss_rqns[ix]);
else
- mlx5e_channels_get_regular_rqn(chs, ix, &res->rss_rqns[ix], vhca_id);
+ mlx5e_channels_get_regular_rqn(chs, ix, &res->rss_rqns[ix]);
mlx5e_rx_res_rss_enable(res);
enum mlx5e_rx_res_features {
MLX5E_RX_RES_FEATURE_INNER_FT = BIT(0),
MLX5E_RX_RES_FEATURE_PTP = BIT(1),
- MLX5E_RX_RES_FEATURE_MULTI_VHCA = BIT(2),
};
/* Setup */
struct mlx5e_create_cq_param ccp = {};
struct dim_cq_moder trap_moder = {};
struct mlx5e_rq *rq = &t->rq;
- u16 q_counter;
int node;
int err;
node = dev_to_node(mdev->device);
- q_counter = priv->q_counter[0];
ccp.netdev = priv->netdev;
ccp.wq = priv->wq;
return err;
mlx5e_init_trap_rq(t, &t->params, rq);
- err = mlx5e_open_rq(&t->params, rq_param, NULL, node, q_counter, rq);
+ err = mlx5e_open_rq(&t->params, rq_param, NULL, node, rq);
if (err)
goto err_destroy_cq;
}
static void mlx5e_build_trap_params(struct mlx5_core_dev *mdev,
- int max_mtu, struct mlx5e_trap *t)
+ int max_mtu, u16 q_counter,
+ struct mlx5e_trap *t)
{
struct mlx5e_params *params = &t->params;
params->rq_wq_type = MLX5_WQ_TYPE_CYCLIC;
mlx5e_init_rq_type_params(mdev, params);
params->sw_mtu = max_mtu;
- mlx5e_build_rq_param(mdev, params, NULL, &t->rq_param);
+ mlx5e_build_rq_param(mdev, params, NULL, q_counter, &t->rq_param);
}
static struct mlx5e_trap *mlx5e_open_trap(struct mlx5e_priv *priv)
if (!t)
return ERR_PTR(-ENOMEM);
- mlx5e_build_trap_params(priv->mdev, netdev->max_mtu, t);
+ mlx5e_build_trap_params(priv->mdev, netdev->max_mtu, priv->q_counter, t);
t->priv = priv;
t->mdev = priv->mdev;
#include "setup.h"
#include "en/params.h"
-static int mlx5e_xsk_map_pool(struct mlx5_core_dev *mdev,
+static int mlx5e_xsk_map_pool(struct mlx5e_priv *priv,
struct xsk_buff_pool *pool)
{
- struct device *dev = mlx5_core_dma_dev(mdev);
+ struct device *dev = mlx5_core_dma_dev(priv->mdev);
return xsk_pool_dma_map(pool, dev, DMA_ATTR_SKIP_CPU_SYNC);
}
if (unlikely(!mlx5e_xsk_is_pool_sane(pool)))
return -EINVAL;
- err = mlx5e_xsk_map_pool(mlx5_sd_ch_ix_get_dev(priv->mdev, ix), pool);
+ err = mlx5e_xsk_map_pool(priv, pool);
if (unlikely(err))
return err;
static void mlx5e_build_xsk_cparam(struct mlx5_core_dev *mdev,
struct mlx5e_params *params,
struct mlx5e_xsk_param *xsk,
+ u16 q_counter,
struct mlx5e_channel_param *cparam)
{
- mlx5e_build_rq_param(mdev, params, xsk, &cparam->rq);
+ mlx5e_build_rq_param(mdev, params, xsk, q_counter, &cparam->rq);
mlx5e_build_xdpsq_param(mdev, params, xsk, &cparam->xdp_sq);
}
struct mlx5e_rq_param *rq_params, struct xsk_buff_pool *pool,
struct mlx5e_xsk_param *xsk)
{
- u16 q_counter = c->priv->q_counter[c->sd_ix];
struct mlx5e_rq *xskrq = &c->xskrq;
int err;
if (err)
return err;
- err = mlx5e_open_rq(params, rq_params, xsk, cpu_to_node(c->cpu), q_counter, xskrq);
+ err = mlx5e_open_rq(params, rq_params, xsk, cpu_to_node(c->cpu), xskrq);
if (err)
return err;
if (!cparam)
return -ENOMEM;
- mlx5e_build_xsk_cparam(priv->mdev, params, xsk, cparam);
+ mlx5e_build_xsk_cparam(priv->mdev, params, xsk, priv->q_counter, cparam);
err = mlx5e_open_cq(c->mdev, params->rx_cq_moderation, &cparam->rq.cqp, &ccp,
&c->xskrq.cq);
{
u8 max_sq_wqebbs = mlx5e_get_max_sq_wqebbs(mdev);
- if (is_kdump_kernel() || !MLX5_CAP_GEN(mdev, tls_rx) || mlx5_get_sd(mdev))
+ if (is_kdump_kernel() || !MLX5_CAP_GEN(mdev, tls_rx))
return false;
/* Check the possibility to post the required ICOSQ WQEs. */
#ifdef CONFIG_MLX5_EN_TLS
#include "lib/crypto.h"
-#include "lib/mlx5.h"
struct mlx5_crypto_dek *mlx5_ktls_create_key(struct mlx5_crypto_dek_pool *dek_pool,
struct tls_crypto_info *crypto_info);
static inline bool mlx5e_is_ktls_tx(struct mlx5_core_dev *mdev)
{
- return !is_kdump_kernel() && MLX5_CAP_GEN(mdev, tls_tx) &&
- !mlx5_get_sd(mdev);
+ return !is_kdump_kernel() && MLX5_CAP_GEN(mdev, tls_tx);
}
bool mlx5e_is_ktls_rx(struct mlx5_core_dev *mdev);
goto err_out;
}
- pdev = mlx5_core_dma_dev(sq->channel->mdev);
+ pdev = mlx5_core_dma_dev(sq->channel->priv->mdev);
buf->dma_addr = dma_map_single(pdev, &buf->progress,
PROGRESS_PARAMS_PADDED_SIZE, DMA_FROM_DEVICE);
if (unlikely(dma_mapping_error(pdev, buf->dma_addr))) {
{
struct mlx5e_ktls_rx_resync_buf *buf = wi->tls_get_params.buf;
struct mlx5e_ktls_offload_context_rx *priv_rx;
+ struct mlx5e_ktls_rx_resync_ctx *resync;
u8 tracker_state, auth_state, *ctx;
struct device *dev;
u32 hw_seq;
priv_rx = buf->priv_rx;
- dev = mlx5_core_dma_dev(sq->channel->mdev);
+ resync = &priv_rx->resync;
+ dev = mlx5_core_dma_dev(resync->priv->mdev);
if (unlikely(test_bit(MLX5E_PRIV_RX_FLAG_DELETING, priv_rx->flags)))
goto out;
{
int tc, i;
- for (i = 0; i < mlx5e_get_num_lag_ports(mdev); i++)
+ for (i = 0; i < MLX5_MAX_PORTS; i++)
for (tc = 0; tc < MLX5_MAX_NUM_TC; tc++)
mlx5e_destroy_tis(mdev, tisn[i][tc]);
}
int tc, i;
int err;
- for (i = 0; i < mlx5e_get_num_lag_ports(mdev); i++) {
+ for (i = 0; i < MLX5_MAX_PORTS; i++) {
for (tc = 0; tc < MLX5_MAX_NUM_TC; tc++) {
u32 in[MLX5_ST_SZ_DW(create_tis_in)] = {};
void *tisc;
return err;
}
-int mlx5e_create_mdev_resources(struct mlx5_core_dev *mdev, bool create_tises)
+int mlx5e_create_mdev_resources(struct mlx5_core_dev *mdev)
{
struct mlx5e_hw_objs *res = &mdev->mlx5e_res.hw_objs;
int err;
goto err_destroy_mkey;
}
- if (create_tises) {
- err = mlx5e_create_tises(mdev, res->tisn);
- if (err) {
- mlx5_core_err(mdev, "alloc tises failed, %d\n", err);
- goto err_destroy_bfreg;
- }
- res->tisn_valid = true;
+ err = mlx5e_create_tises(mdev, res->tisn);
+ if (err) {
+ mlx5_core_err(mdev, "alloc tises failed, %d\n", err);
+ goto err_destroy_bfreg;
}
-
INIT_LIST_HEAD(&res->td.tirs_list);
mutex_init(&res->td.list_lock);
mlx5_crypto_dek_cleanup(mdev->mlx5e_res.dek_priv);
mdev->mlx5e_res.dek_priv = NULL;
- if (res->tisn_valid)
- mlx5e_destroy_tises(mdev, res->tisn);
+ mlx5e_destroy_tises(mdev, res->tisn);
mlx5_free_bfreg(mdev, &res->bfreg);
mlx5_core_destroy_mkey(mdev, res->mkey);
mlx5_core_dealloc_transport_domain(mdev, res->td.tdn);
#include "qos.h"
#include "en/trap.h"
#include "lib/devcom.h"
-#include "lib/sd.h"
bool mlx5e_check_fragmented_striding_rq_cap(struct mlx5_core_dev *mdev, u8 page_shift,
enum mlx5e_mpwrq_umr_mode umr_mode)
mlx5_wq_destroy(&rq->wq_ctrl);
}
-int mlx5e_create_rq(struct mlx5e_rq *rq, struct mlx5e_rq_param *param, u16 q_counter)
+int mlx5e_create_rq(struct mlx5e_rq *rq, struct mlx5e_rq_param *param)
{
struct mlx5_core_dev *mdev = rq->mdev;
u8 ts_format;
MLX5_SET(rqc, rqc, cqn, rq->cq.mcq.cqn);
MLX5_SET(rqc, rqc, state, MLX5_RQC_STATE_RST);
MLX5_SET(rqc, rqc, ts_format, ts_format);
- MLX5_SET(rqc, rqc, counter_set_id, q_counter);
MLX5_SET(wq, wq, log_wq_pg_sz, rq->wq_ctrl.buf.page_shift -
MLX5_ADAPTER_PAGE_SHIFT);
MLX5_SET64(wq, wq, dbr_addr, rq->wq_ctrl.db.dma);
}
int mlx5e_open_rq(struct mlx5e_params *params, struct mlx5e_rq_param *param,
- struct mlx5e_xsk_param *xsk, int node, u16 q_counter,
+ struct mlx5e_xsk_param *xsk, int node,
struct mlx5e_rq *rq)
{
struct mlx5_core_dev *mdev = rq->mdev;
if (err)
return err;
- err = mlx5e_create_rq(rq, param, q_counter);
+ err = mlx5e_create_rq(rq, param);
if (err)
goto err_free_rq;
static int mlx5e_open_rxq_rq(struct mlx5e_channel *c, struct mlx5e_params *params,
struct mlx5e_rq_param *rq_params)
{
- u16 q_counter = c->priv->q_counter[c->sd_ix];
int err;
err = mlx5e_init_rxq_rq(c, params, rq_params->xdp_frag_size, &c->rq);
if (err)
return err;
- return mlx5e_open_rq(params, rq_params, NULL, cpu_to_node(c->cpu), q_counter, &c->rq);
+ return mlx5e_open_rq(params, rq_params, NULL, cpu_to_node(c->cpu), &c->rq);
}
static int mlx5e_open_queues(struct mlx5e_channel *c,
struct xsk_buff_pool *xsk_pool,
struct mlx5e_channel **cp)
{
+ int cpu = mlx5_comp_vector_get_cpu(priv->mdev, ix);
struct net_device *netdev = priv->netdev;
- struct mlx5_core_dev *mdev;
struct mlx5e_xsk_param xsk;
struct mlx5e_channel *c;
unsigned int irq;
- int vec_ix;
- int cpu;
int err;
- mdev = mlx5_sd_ch_ix_get_dev(priv->mdev, ix);
- vec_ix = mlx5_sd_ch_ix_get_vec_ix(mdev, ix);
- cpu = mlx5_comp_vector_get_cpu(mdev, vec_ix);
-
- err = mlx5_comp_irqn_get(mdev, vec_ix, &irq);
+ err = mlx5_comp_irqn_get(priv->mdev, ix, &irq);
if (err)
return err;
return -ENOMEM;
c->priv = priv;
- c->mdev = mdev;
+ c->mdev = priv->mdev;
c->tstamp = &priv->tstamp;
c->ix = ix;
- c->vec_ix = vec_ix;
- c->sd_ix = mlx5_sd_ch_ix_get_dev_ix(mdev, ix);
c->cpu = cpu;
- c->pdev = mlx5_core_dma_dev(mdev);
+ c->pdev = mlx5_core_dma_dev(priv->mdev);
c->netdev = priv->netdev;
- c->mkey_be = cpu_to_be32(mdev->mlx5e_res.hw_objs.mkey);
+ c->mkey_be = cpu_to_be32(priv->mdev->mlx5e_res.hw_objs.mkey);
c->num_tc = mlx5e_get_dcb_num_tc(params);
c->xdp = !!params->xdp_prog;
c->stats = &priv->channel_stats[ix]->ch;
c->aff_mask = irq_get_effective_affinity_mask(irq);
- c->lag_port = mlx5e_enumerate_lag_port(mdev, ix);
+ c->lag_port = mlx5e_enumerate_lag_port(priv->mdev, ix);
netif_napi_add(netdev, &c->napi, mlx5e_napi_poll);
if (!chs->c || !cparam)
goto err_free;
- err = mlx5e_build_channel_param(priv->mdev, &chs->params, cparam);
+ err = mlx5e_build_channel_param(priv->mdev, &chs->params, priv->q_counter, cparam);
if (err)
goto err_free;
static void mlx5e_set_default_xps_cpumasks(struct mlx5e_priv *priv,
struct mlx5e_params *params)
{
- int ix;
+ struct mlx5_core_dev *mdev = priv->mdev;
+ int num_comp_vectors, ix, irq;
- for (ix = 0; ix < params->num_channels; ix++) {
- int num_comp_vectors, irq, vec_ix;
- struct mlx5_core_dev *mdev;
+ num_comp_vectors = mlx5_comp_vectors_max(mdev);
- mdev = mlx5_sd_ch_ix_get_dev(priv->mdev, ix);
- num_comp_vectors = mlx5_comp_vectors_max(mdev);
+ for (ix = 0; ix < params->num_channels; ix++) {
cpumask_clear(priv->scratchpad.cpumask);
- vec_ix = mlx5_sd_ch_ix_get_vec_ix(mdev, ix);
- for (irq = vec_ix; irq < num_comp_vectors; irq += params->num_channels) {
+ for (irq = ix; irq < num_comp_vectors; irq += params->num_channels) {
int cpu = mlx5_comp_vector_get_cpu(mdev, irq);
cpumask_set_cpu(cpu, priv->scratchpad.cpumask);
struct mlx5e_cq *cq = &drop_rq->cq;
int err;
- mlx5e_build_drop_rq_param(mdev, &rq_param);
+ mlx5e_build_drop_rq_param(mdev, priv->drop_rq_q_counter, &rq_param);
err = mlx5e_alloc_drop_cq(priv, cq, &cq_param);
if (err)
if (err)
goto err_destroy_cq;
- err = mlx5e_create_rq(drop_rq, &rq_param, priv->drop_rq_q_counter);
+ err = mlx5e_create_rq(drop_rq, &rq_param);
if (err)
goto err_free_rq;
stats->tx_errors = stats->tx_aborted_errors + stats->tx_carrier_errors;
}
-void mlx5e_nic_set_rx_mode(struct mlx5e_priv *priv)
+static void mlx5e_nic_set_rx_mode(struct mlx5e_priv *priv)
{
if (mlx5e_is_uplink_rep(priv))
return; /* no rx mode for uplink rep */
#endif
};
-const struct net_device_ops mlx5e_mgmt_netdev_ops = {
- .ndo_open = mlx5e_open,
- .ndo_stop = mlx5e_close,
- .ndo_start_xmit = mlx5e_xmit,
- .ndo_get_stats64 = mlx5e_get_stats,
- .ndo_change_mtu = mlx5e_change_nic_mtu,
- .ndo_set_rx_mode = mlx5e_set_rx_mode,
-};
-
static u32 mlx5e_choose_lro_timeout(struct mlx5_core_dev *mdev, u32 wanted_timeout)
{
int i;
SET_NETDEV_DEV(netdev, mdev->device);
- if (mlx5_core_is_mgmt_pf(mdev))
- netdev->netdev_ops = &mlx5e_mgmt_netdev_ops;
- else
- netdev->netdev_ops = &mlx5e_netdev_ops;
-
+ netdev->netdev_ops = &mlx5e_netdev_ops;
netdev->xdp_metadata_ops = &mlx5e_xdp_metadata_ops;
netdev->xsk_tx_metadata_ops = &mlx5e_xsk_tx_metadata_ops;
u32 out[MLX5_ST_SZ_DW(alloc_q_counter_out)] = {};
u32 in[MLX5_ST_SZ_DW(alloc_q_counter_in)] = {};
struct mlx5_core_dev *mdev = priv->mdev;
- struct mlx5_core_dev *pos;
- int err, i;
+ int err;
MLX5_SET(alloc_q_counter_in, in, opcode, MLX5_CMD_OP_ALLOC_Q_COUNTER);
-
- mlx5_sd_for_each_dev(i, mdev, pos) {
- err = mlx5_cmd_exec_inout(pos, alloc_q_counter, in, out);
- if (!err)
- priv->q_counter[i] =
- MLX5_GET(alloc_q_counter_out, out, counter_set_id);
- }
+ err = mlx5_cmd_exec_inout(mdev, alloc_q_counter, in, out);
+ if (!err)
+ priv->q_counter =
+ MLX5_GET(alloc_q_counter_out, out, counter_set_id);
err = mlx5_cmd_exec_inout(mdev, alloc_q_counter, in, out);
if (!err)
void mlx5e_destroy_q_counters(struct mlx5e_priv *priv)
{
u32 in[MLX5_ST_SZ_DW(dealloc_q_counter_in)] = {};
- struct mlx5_core_dev *pos;
- int i;
MLX5_SET(dealloc_q_counter_in, in, opcode,
MLX5_CMD_OP_DEALLOC_Q_COUNTER);
- mlx5_sd_for_each_dev(i, priv->mdev, pos) {
- if (priv->q_counter[i]) {
- MLX5_SET(dealloc_q_counter_in, in, counter_set_id,
- priv->q_counter[i]);
- mlx5_cmd_exec_in(pos, dealloc_q_counter, in);
- }
+ if (priv->q_counter) {
+ MLX5_SET(dealloc_q_counter_in, in, counter_set_id,
+ priv->q_counter);
+ mlx5_cmd_exec_in(priv->mdev, dealloc_q_counter, in);
}
if (priv->drop_rq_q_counter) {
features = MLX5E_RX_RES_FEATURE_PTP;
if (mlx5_tunnel_inner_ft_supported(mdev))
features |= MLX5E_RX_RES_FEATURE_INNER_FT;
- if (mlx5_get_sd(priv->mdev))
- features |= MLX5E_RX_RES_FEATURE_MULTI_VHCA;
priv->rx_res = mlx5e_rx_res_create(priv->mdev, features, priv->max_nch, priv->drop_rq.rqn,
&priv->channels.params.packet_merge,
free_netdev(netdev);
}
-static int _mlx5e_resume(struct auxiliary_device *adev)
+static int mlx5e_resume(struct auxiliary_device *adev)
{
struct mlx5_adev *edev = container_of(adev, struct mlx5_adev, adev);
struct mlx5e_dev *mlx5e_dev = auxiliary_get_drvdata(adev);
struct mlx5e_priv *priv = mlx5e_dev->priv;
struct net_device *netdev = priv->netdev;
struct mlx5_core_dev *mdev = edev->mdev;
- struct mlx5_core_dev *pos, *to;
- int err, i;
+ int err;
if (netif_device_present(netdev))
return 0;
- mlx5_sd_for_each_dev(i, mdev, pos) {
- err = mlx5e_create_mdev_resources(pos, true);
- if (err)
- goto err_destroy_mdev_res;
- }
-
- err = mlx5e_attach_netdev(priv);
+ err = mlx5e_create_mdev_resources(mdev);
if (err)
- goto err_destroy_mdev_res;
-
- return 0;
-
-err_destroy_mdev_res:
- to = pos;
- mlx5_sd_for_each_dev_to(i, mdev, to, pos)
- mlx5e_destroy_mdev_resources(pos);
- return err;
-}
-
-static int mlx5e_resume(struct auxiliary_device *adev)
-{
- struct mlx5_adev *edev = container_of(adev, struct mlx5_adev, adev);
- struct mlx5_core_dev *mdev = edev->mdev;
- struct auxiliary_device *actual_adev;
- int err;
+ return err;
- err = mlx5_sd_init(mdev);
- if (err)
+ err = mlx5e_attach_netdev(priv);
+ if (err) {
+ mlx5e_destroy_mdev_resources(mdev);
return err;
+ }
- actual_adev = mlx5_sd_get_adev(mdev, adev, edev->idx);
- if (actual_adev)
- return _mlx5e_resume(actual_adev);
return 0;
}
struct mlx5e_priv *priv = mlx5e_dev->priv;
struct net_device *netdev = priv->netdev;
struct mlx5_core_dev *mdev = priv->mdev;
- struct mlx5_core_dev *pos;
- int i;
if (!netif_device_present(netdev)) {
if (test_bit(MLX5E_STATE_DESTROYING, &priv->state))
- mlx5_sd_for_each_dev(i, mdev, pos)
- mlx5e_destroy_mdev_resources(pos);
+ mlx5e_destroy_mdev_resources(mdev);
return -ENODEV;
}
mlx5e_detach_netdev(priv);
- mlx5_sd_for_each_dev(i, mdev, pos)
- mlx5e_destroy_mdev_resources(pos);
-
+ mlx5e_destroy_mdev_resources(mdev);
return 0;
}
static int mlx5e_suspend(struct auxiliary_device *adev, pm_message_t state)
{
- struct mlx5_adev *edev = container_of(adev, struct mlx5_adev, adev);
- struct mlx5_core_dev *mdev = edev->mdev;
- struct auxiliary_device *actual_adev;
- int err = 0;
-
- actual_adev = mlx5_sd_get_adev(mdev, adev, edev->idx);
- if (actual_adev)
- err = _mlx5e_suspend(actual_adev);
-
- mlx5_sd_cleanup(mdev);
- return err;
+ return _mlx5e_suspend(adev);
}
static int _mlx5e_probe(struct auxiliary_device *adev)
{
struct mlx5_adev *edev = container_of(adev, struct mlx5_adev, adev);
+ const struct mlx5e_profile *profile = &mlx5e_nic_profile;
struct mlx5_core_dev *mdev = edev->mdev;
- const struct mlx5e_profile *profile;
struct mlx5e_dev *mlx5e_dev;
struct net_device *netdev;
struct mlx5e_priv *priv;
int err;
- if (mlx5_core_is_mgmt_pf(mdev))
- profile = &mlx5e_mgmt_pf_nic_profile;
- else
- profile = &mlx5e_nic_profile;
-
mlx5e_dev = mlx5e_create_devlink(&adev->dev, mdev);
if (IS_ERR(mlx5e_dev))
return PTR_ERR(mlx5e_dev);
goto err_destroy_netdev;
}
- err = _mlx5e_resume(adev);
+ err = mlx5e_resume(adev);
if (err) {
- mlx5_core_err(mdev, "_mlx5e_resume failed, %d\n", err);
+ mlx5_core_err(mdev, "mlx5e_resume failed, %d\n", err);
goto err_profile_cleanup;
}
static int mlx5e_probe(struct auxiliary_device *adev,
const struct auxiliary_device_id *id)
{
- struct mlx5_adev *edev = container_of(adev, struct mlx5_adev, adev);
- struct mlx5_core_dev *mdev = edev->mdev;
- struct auxiliary_device *actual_adev;
- int err;
-
- err = mlx5_sd_init(mdev);
- if (err)
- return err;
-
- actual_adev = mlx5_sd_get_adev(mdev, adev, edev->idx);
- if (actual_adev)
- return _mlx5e_probe(actual_adev);
- return 0;
+ return _mlx5e_probe(adev);
}
-static void _mlx5e_remove(struct auxiliary_device *adev)
+static void mlx5e_remove(struct auxiliary_device *adev)
{
- struct mlx5_adev *edev = container_of(adev, struct mlx5_adev, adev);
struct mlx5e_dev *mlx5e_dev = auxiliary_get_drvdata(adev);
struct mlx5e_priv *priv = mlx5e_dev->priv;
- struct mlx5_core_dev *mdev = edev->mdev;
- mlx5_core_uplink_netdev_set(mdev, NULL);
+ mlx5_core_uplink_netdev_set(priv->mdev, NULL);
mlx5e_dcbnl_delete_app(priv);
unregister_netdev(priv->netdev);
_mlx5e_suspend(adev);
mlx5e_destroy_devlink(mlx5e_dev);
}
-static void mlx5e_remove(struct auxiliary_device *adev)
-{
- struct mlx5_adev *edev = container_of(adev, struct mlx5_adev, adev);
- struct mlx5_core_dev *mdev = edev->mdev;
- struct auxiliary_device *actual_adev;
-
- actual_adev = mlx5_sd_get_adev(mdev, adev, edev->idx);
- if (actual_adev)
- _mlx5e_remove(actual_adev);
-
- mlx5_sd_cleanup(mdev);
-}
-
static const struct auxiliary_device_id mlx5e_id_table[] = {
{ .name = MLX5_ADEV_NAME ".eth", },
{},
#define NUM_Q_COUNTERS ARRAY_SIZE(q_stats_desc)
#define NUM_DROP_RQ_COUNTERS ARRAY_SIZE(drop_rq_stats_desc)
-static bool q_counter_any(struct mlx5e_priv *priv)
-{
- struct mlx5_core_dev *pos;
- int i;
-
- mlx5_sd_for_each_dev(i, priv->mdev, pos)
- if (priv->q_counter[i++])
- return true;
-
- return false;
-}
-
static MLX5E_DECLARE_STATS_GRP_OP_NUM_STATS(qcnt)
{
int num_stats = 0;
- if (q_counter_any(priv))
+ if (priv->q_counter)
num_stats += NUM_Q_COUNTERS;
if (priv->drop_rq_q_counter)
{
int i;
- for (i = 0; i < NUM_Q_COUNTERS && q_counter_any(priv); i++)
+ for (i = 0; i < NUM_Q_COUNTERS && priv->q_counter; i++)
strcpy(data + (idx++) * ETH_GSTRING_LEN,
q_stats_desc[i].format);
{
int i;
- for (i = 0; i < NUM_Q_COUNTERS && q_counter_any(priv); i++)
+ for (i = 0; i < NUM_Q_COUNTERS && priv->q_counter; i++)
data[idx++] = MLX5E_READ_CTR32_CPU(&priv->stats.qcnt,
q_stats_desc, i);
for (i = 0; i < NUM_DROP_RQ_COUNTERS && priv->drop_rq_q_counter; i++)
struct mlx5e_qcounter_stats *qcnt = &priv->stats.qcnt;
u32 out[MLX5_ST_SZ_DW(query_q_counter_out)] = {};
u32 in[MLX5_ST_SZ_DW(query_q_counter_in)] = {};
- struct mlx5_core_dev *pos;
- u32 rx_out_of_buffer = 0;
- int ret, i;
+ int ret;
MLX5_SET(query_q_counter_in, in, opcode, MLX5_CMD_OP_QUERY_Q_COUNTER);
- mlx5_sd_for_each_dev(i, priv->mdev, pos) {
- if (priv->q_counter[i]) {
- MLX5_SET(query_q_counter_in, in, counter_set_id,
- priv->q_counter[i]);
- ret = mlx5_cmd_exec_inout(pos, query_q_counter, in, out);
- if (!ret)
- rx_out_of_buffer += MLX5_GET(query_q_counter_out,
- out, out_of_buffer);
- }
+ if (priv->q_counter) {
+ MLX5_SET(query_q_counter_in, in, counter_set_id,
+ priv->q_counter);
+ ret = mlx5_cmd_exec_inout(priv->mdev, query_q_counter, in, out);
+ if (!ret)
+ qcnt->rx_out_of_buffer = MLX5_GET(query_q_counter_out,
+ out, out_of_buffer);
}
- qcnt->rx_out_of_buffer = rx_out_of_buffer;
if (priv->drop_rq_q_counter) {
MLX5_SET(query_q_counter_in, in, counter_set_id,
return err;
mlx5e_rss_params_indir_init_uniform(&indir, hp->num_channels);
- err = mlx5e_rqt_init_indir(&hp->indir_rqt, mdev, hp->pair->rqn, NULL, hp->num_channels,
+ err = mlx5e_rqt_init_indir(&hp->indir_rqt, mdev, hp->pair->rqn, hp->num_channels,
mlx5e_rx_res_get_current_hash(priv->rx_res).hfunc,
&indir);
MLX5_CAP_GEN(priv->mdev, log_min_hairpin_wq_data_sz),
MLX5_CAP_GEN(priv->mdev, log_max_hairpin_wq_data_sz));
- params.q_counter = priv->q_counter[0];
+ params.q_counter = priv->q_counter;
err = devl_param_driverinit_value_get(
devlink, MLX5_DEVLINK_PARAM_ID_HAIRPIN_NUM_QUEUES, &val);
if (err) {
void *hca_caps;
int err;
- if (!mlx5_core_is_ecpf(dev) || mlx5_core_is_mgmt_pf(dev)) {
+ if (!mlx5_core_is_ecpf(dev)) {
*max_sfs = 0;
return 0;
}
}
/* This should only be called once per mdev */
- err = mlx5e_create_mdev_resources(mdev, false);
+ err = mlx5e_create_mdev_resources(mdev);
if (err)
goto destroy_ht;
}
MLX5_DEVCOM_ESW_OFFLOADS,
MLX5_DEVCOM_MPV,
MLX5_DEVCOM_HCA_PORTS,
- MLX5_DEVCOM_SD_GROUP,
MLX5_DEVCOM_NUM_COMPONENTS,
};
{
return mdev->mlx5e_res.uplink_netdev;
}
-
-struct mlx5_sd;
-
-static inline struct mlx5_sd *mlx5_get_sd(struct mlx5_core_dev *dev)
-{
- return dev->sd;
-}
-
-static inline void mlx5_set_sd(struct mlx5_core_dev *dev, struct mlx5_sd *sd)
-{
- dev->sd = sd;
-}
#endif
+++ /dev/null
-// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
-/* Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. */
-
-#include "lib/sd.h"
-#include "mlx5_core.h"
-#include "lib/mlx5.h"
-#include "fs_cmd.h"
-#include <linux/mlx5/vport.h>
-
-#define sd_info(__dev, format, ...) \
- dev_info((__dev)->device, "Socket-Direct: " format, ##__VA_ARGS__)
-#define sd_warn(__dev, format, ...) \
- dev_warn((__dev)->device, "Socket-Direct: " format, ##__VA_ARGS__)
-
-struct mlx5_sd {
- u32 group_id;
- u8 host_buses;
- struct mlx5_devcom_comp_dev *devcom;
- bool primary;
- union {
- struct { /* primary */
- struct mlx5_core_dev *secondaries[MLX5_SD_MAX_GROUP_SZ - 1];
- struct mlx5_flow_table *tx_ft;
- };
- struct { /* secondary */
- struct mlx5_core_dev *primary_dev;
- u32 alias_obj_id;
- };
- };
-};
-
-static int mlx5_sd_get_host_buses(struct mlx5_core_dev *dev)
-{
- struct mlx5_sd *sd = mlx5_get_sd(dev);
-
- if (!sd)
- return 1;
-
- return sd->host_buses;
-}
-
-static struct mlx5_core_dev *mlx5_sd_get_primary(struct mlx5_core_dev *dev)
-{
- struct mlx5_sd *sd = mlx5_get_sd(dev);
-
- if (!sd)
- return dev;
-
- return sd->primary ? dev : sd->primary_dev;
-}
-
-struct mlx5_core_dev *
-mlx5_sd_primary_get_peer(struct mlx5_core_dev *primary, int idx)
-{
- struct mlx5_sd *sd;
-
- if (idx == 0)
- return primary;
-
- if (idx >= mlx5_sd_get_host_buses(primary))
- return NULL;
-
- sd = mlx5_get_sd(primary);
- return sd->secondaries[idx - 1];
-}
-
-int mlx5_sd_ch_ix_get_dev_ix(struct mlx5_core_dev *dev, int ch_ix)
-{
- return ch_ix % mlx5_sd_get_host_buses(dev);
-}
-
-int mlx5_sd_ch_ix_get_vec_ix(struct mlx5_core_dev *dev, int ch_ix)
-{
- return ch_ix / mlx5_sd_get_host_buses(dev);
-}
-
-struct mlx5_core_dev *mlx5_sd_ch_ix_get_dev(struct mlx5_core_dev *primary, int ch_ix)
-{
- int mdev_idx = mlx5_sd_ch_ix_get_dev_ix(primary, ch_ix);
-
- return mlx5_sd_primary_get_peer(primary, mdev_idx);
-}
-
-static bool ft_create_alias_supported(struct mlx5_core_dev *dev)
-{
- u64 obj_allowed = MLX5_CAP_GEN_2_64(dev, allowed_object_for_other_vhca_access);
- u32 obj_supp = MLX5_CAP_GEN_2(dev, cross_vhca_object_to_object_supported);
-
- if (!(obj_supp &
- MLX5_CROSS_VHCA_OBJ_TO_OBJ_SUPPORTED_LOCAL_FLOW_TABLE_ROOT_TO_REMOTE_FLOW_TABLE))
- return false;
-
- if (!(obj_allowed & MLX5_ALLOWED_OBJ_FOR_OTHER_VHCA_ACCESS_FLOW_TABLE))
- return false;
-
- return true;
-}
-
-static bool mlx5_sd_is_supported(struct mlx5_core_dev *dev, u8 host_buses)
-{
- /* Feature is currently implemented for PFs only */
- if (!mlx5_core_is_pf(dev))
- return false;
-
- /* Honor the SW implementation limit */
- if (host_buses > MLX5_SD_MAX_GROUP_SZ)
- return false;
-
- /* Disconnect secondaries from the network */
- if (!MLX5_CAP_GEN(dev, eswitch_manager))
- return false;
- if (!MLX5_CAP_GEN(dev, silent_mode))
- return false;
-
- /* RX steering from primary to secondaries */
- if (!MLX5_CAP_GEN(dev, cross_vhca_rqt))
- return false;
- if (host_buses > MLX5_CAP_GEN_2(dev, max_rqt_vhca_id))
- return false;
-
- /* TX steering from secondaries to primary */
- if (!ft_create_alias_supported(dev))
- return false;
- if (!MLX5_CAP_FLOWTABLE_NIC_TX(dev, reset_root_to_default))
- return false;
-
- return true;
-}
-
-static int mlx5_query_sd(struct mlx5_core_dev *dev, bool *sdm,
- u8 *host_buses, u8 *sd_group)
-{
- u32 out[MLX5_ST_SZ_DW(mpir_reg)];
- int err;
-
- err = mlx5_query_mpir_reg(dev, out);
- if (err)
- return err;
-
- err = mlx5_query_nic_vport_sd_group(dev, sd_group);
- if (err)
- return err;
-
- *sdm = MLX5_GET(mpir_reg, out, sdm);
- *host_buses = MLX5_GET(mpir_reg, out, host_buses);
-
- return 0;
-}
-
-static u32 mlx5_sd_group_id(struct mlx5_core_dev *dev, u8 sd_group)
-{
- return (u32)((MLX5_CAP_GEN(dev, native_port_num) << 8) | sd_group);
-}
-
-static int sd_init(struct mlx5_core_dev *dev)
-{
- u8 host_buses, sd_group;
- struct mlx5_sd *sd;
- u32 group_id;
- bool sdm;
- int err;
-
- err = mlx5_query_sd(dev, &sdm, &host_buses, &sd_group);
- if (err)
- return err;
-
- if (!sdm)
- return 0;
-
- if (!sd_group)
- return 0;
-
- group_id = mlx5_sd_group_id(dev, sd_group);
-
- if (!mlx5_sd_is_supported(dev, host_buses)) {
- sd_warn(dev, "can't support requested netdev combining for group id 0x%x), skipping\n",
- group_id);
- return 0;
- }
-
- sd = kzalloc(sizeof(*sd), GFP_KERNEL);
- if (!sd)
- return -ENOMEM;
-
- sd->host_buses = host_buses;
- sd->group_id = group_id;
-
- mlx5_set_sd(dev, sd);
-
- return 0;
-}
-
-static void sd_cleanup(struct mlx5_core_dev *dev)
-{
- struct mlx5_sd *sd = mlx5_get_sd(dev);
-
- mlx5_set_sd(dev, NULL);
- kfree(sd);
-}
-
-static int sd_register(struct mlx5_core_dev *dev)
-{
- struct mlx5_devcom_comp_dev *devcom, *pos;
- struct mlx5_core_dev *peer, *primary;
- struct mlx5_sd *sd, *primary_sd;
- int err, i;
-
- sd = mlx5_get_sd(dev);
- devcom = mlx5_devcom_register_component(dev->priv.devc, MLX5_DEVCOM_SD_GROUP,
- sd->group_id, NULL, dev);
- if (!devcom)
- return -ENOMEM;
-
- sd->devcom = devcom;
-
- if (mlx5_devcom_comp_get_size(devcom) != sd->host_buses)
- return 0;
-
- mlx5_devcom_comp_lock(devcom);
- mlx5_devcom_comp_set_ready(devcom, true);
- mlx5_devcom_comp_unlock(devcom);
-
- if (!mlx5_devcom_for_each_peer_begin(devcom)) {
- err = -ENODEV;
- goto err_devcom_unreg;
- }
-
- primary = dev;
- mlx5_devcom_for_each_peer_entry(devcom, peer, pos)
- if (peer->pdev->bus->number < primary->pdev->bus->number)
- primary = peer;
-
- primary_sd = mlx5_get_sd(primary);
- primary_sd->primary = true;
- i = 0;
- /* loop the secondaries */
- mlx5_devcom_for_each_peer_entry(primary_sd->devcom, peer, pos) {
- struct mlx5_sd *peer_sd = mlx5_get_sd(peer);
-
- primary_sd->secondaries[i++] = peer;
- peer_sd->primary = false;
- peer_sd->primary_dev = primary;
- }
-
- mlx5_devcom_for_each_peer_end(devcom);
- return 0;
-
-err_devcom_unreg:
- mlx5_devcom_comp_lock(sd->devcom);
- mlx5_devcom_comp_set_ready(sd->devcom, false);
- mlx5_devcom_comp_unlock(sd->devcom);
- mlx5_devcom_unregister_component(sd->devcom);
- return err;
-}
-
-static void sd_unregister(struct mlx5_core_dev *dev)
-{
- struct mlx5_sd *sd = mlx5_get_sd(dev);
-
- mlx5_devcom_comp_lock(sd->devcom);
- mlx5_devcom_comp_set_ready(sd->devcom, false);
- mlx5_devcom_comp_unlock(sd->devcom);
- mlx5_devcom_unregister_component(sd->devcom);
-}
-
-static int sd_cmd_set_primary(struct mlx5_core_dev *primary, u8 *alias_key)
-{
- struct mlx5_cmd_allow_other_vhca_access_attr allow_attr = {};
- struct mlx5_sd *sd = mlx5_get_sd(primary);
- struct mlx5_flow_table_attr ft_attr = {};
- struct mlx5_flow_namespace *nic_ns;
- struct mlx5_flow_table *ft;
- int err;
-
- nic_ns = mlx5_get_flow_namespace(primary, MLX5_FLOW_NAMESPACE_EGRESS);
- if (!nic_ns)
- return -EOPNOTSUPP;
-
- ft = mlx5_create_flow_table(nic_ns, &ft_attr);
- if (IS_ERR(ft)) {
- err = PTR_ERR(ft);
- return err;
- }
- sd->tx_ft = ft;
- memcpy(allow_attr.access_key, alias_key, ACCESS_KEY_LEN);
- allow_attr.obj_type = MLX5_GENERAL_OBJECT_TYPES_FLOW_TABLE_ALIAS;
- allow_attr.obj_id = (ft->type << FT_ID_FT_TYPE_OFFSET) | ft->id;
-
- err = mlx5_cmd_allow_other_vhca_access(primary, &allow_attr);
- if (err) {
- mlx5_core_err(primary, "Failed to allow other vhca access err=%d\n",
- err);
- mlx5_destroy_flow_table(ft);
- return err;
- }
-
- return 0;
-}
-
-static void sd_cmd_unset_primary(struct mlx5_core_dev *primary)
-{
- struct mlx5_sd *sd = mlx5_get_sd(primary);
-
- mlx5_destroy_flow_table(sd->tx_ft);
-}
-
-static int sd_secondary_create_alias_ft(struct mlx5_core_dev *secondary,
- struct mlx5_core_dev *primary,
- struct mlx5_flow_table *ft,
- u32 *obj_id, u8 *alias_key)
-{
- u32 aliased_object_id = (ft->type << FT_ID_FT_TYPE_OFFSET) | ft->id;
- u16 vhca_id_to_be_accessed = MLX5_CAP_GEN(primary, vhca_id);
- struct mlx5_cmd_alias_obj_create_attr alias_attr = {};
- int ret;
-
- memcpy(alias_attr.access_key, alias_key, ACCESS_KEY_LEN);
- alias_attr.obj_id = aliased_object_id;
- alias_attr.obj_type = MLX5_GENERAL_OBJECT_TYPES_FLOW_TABLE_ALIAS;
- alias_attr.vhca_id = vhca_id_to_be_accessed;
- ret = mlx5_cmd_alias_obj_create(secondary, &alias_attr, obj_id);
- if (ret) {
- mlx5_core_err(secondary, "Failed to create alias object err=%d\n",
- ret);
- return ret;
- }
-
- return 0;
-}
-
-static void sd_secondary_destroy_alias_ft(struct mlx5_core_dev *secondary)
-{
- struct mlx5_sd *sd = mlx5_get_sd(secondary);
-
- mlx5_cmd_alias_obj_destroy(secondary, sd->alias_obj_id,
- MLX5_GENERAL_OBJECT_TYPES_FLOW_TABLE_ALIAS);
-}
-
-static int sd_cmd_set_secondary(struct mlx5_core_dev *secondary,
- struct mlx5_core_dev *primary,
- u8 *alias_key)
-{
- struct mlx5_sd *primary_sd = mlx5_get_sd(primary);
- struct mlx5_sd *sd = mlx5_get_sd(secondary);
- int err;
-
- err = mlx5_fs_cmd_set_l2table_entry_silent(secondary, 1);
- if (err)
- return err;
-
- err = sd_secondary_create_alias_ft(secondary, primary, primary_sd->tx_ft,
- &sd->alias_obj_id, alias_key);
- if (err)
- goto err_unset_silent;
-
- err = mlx5_fs_cmd_set_tx_flow_table_root(secondary, sd->alias_obj_id, false);
- if (err)
- goto err_destroy_alias_ft;
-
- return 0;
-
-err_destroy_alias_ft:
- sd_secondary_destroy_alias_ft(secondary);
-err_unset_silent:
- mlx5_fs_cmd_set_l2table_entry_silent(secondary, 0);
- return err;
-}
-
-static void sd_cmd_unset_secondary(struct mlx5_core_dev *secondary)
-{
- mlx5_fs_cmd_set_tx_flow_table_root(secondary, 0, true);
- sd_secondary_destroy_alias_ft(secondary);
- mlx5_fs_cmd_set_l2table_entry_silent(secondary, 0);
-}
-
-static void sd_print_group(struct mlx5_core_dev *primary)
-{
- struct mlx5_sd *sd = mlx5_get_sd(primary);
- struct mlx5_core_dev *pos;
- int i;
-
- sd_info(primary, "group id %#x, primary %s, vhca %u\n",
- sd->group_id, pci_name(primary->pdev),
- MLX5_CAP_GEN(primary, vhca_id));
- mlx5_sd_for_each_secondary(i, primary, pos)
- sd_info(primary, "group id %#x, secondary#%d %s, vhca %u\n",
- sd->group_id, i - 1, pci_name(pos->pdev),
- MLX5_CAP_GEN(pos, vhca_id));
-}
-
-int mlx5_sd_init(struct mlx5_core_dev *dev)
-{
- struct mlx5_core_dev *primary, *pos, *to;
- struct mlx5_sd *sd = mlx5_get_sd(dev);
- u8 alias_key[ACCESS_KEY_LEN];
- int err, i;
-
- err = sd_init(dev);
- if (err)
- return err;
-
- sd = mlx5_get_sd(dev);
- if (!sd)
- return 0;
-
- err = sd_register(dev);
- if (err)
- goto err_sd_cleanup;
-
- if (!mlx5_devcom_comp_is_ready(sd->devcom))
- return 0;
-
- primary = mlx5_sd_get_primary(dev);
-
- for (i = 0; i < ACCESS_KEY_LEN; i++)
- alias_key[i] = get_random_u8();
-
- err = sd_cmd_set_primary(primary, alias_key);
- if (err)
- goto err_sd_unregister;
-
- mlx5_sd_for_each_secondary(i, primary, pos) {
- err = sd_cmd_set_secondary(pos, primary, alias_key);
- if (err)
- goto err_unset_secondaries;
- }
-
- sd_info(primary, "group id %#x, size %d, combined\n",
- sd->group_id, mlx5_devcom_comp_get_size(sd->devcom));
- sd_print_group(primary);
-
- return 0;
-
-err_unset_secondaries:
- to = pos;
- mlx5_sd_for_each_secondary_to(i, primary, to, pos)
- sd_cmd_unset_secondary(pos);
- sd_cmd_unset_primary(primary);
-err_sd_unregister:
- sd_unregister(dev);
-err_sd_cleanup:
- sd_cleanup(dev);
- return err;
-}
-
-void mlx5_sd_cleanup(struct mlx5_core_dev *dev)
-{
- struct mlx5_sd *sd = mlx5_get_sd(dev);
- struct mlx5_core_dev *primary, *pos;
- int i;
-
- if (!sd)
- return;
-
- if (!mlx5_devcom_comp_is_ready(sd->devcom))
- goto out;
-
- primary = mlx5_sd_get_primary(dev);
- mlx5_sd_for_each_secondary(i, primary, pos)
- sd_cmd_unset_secondary(pos);
- sd_cmd_unset_primary(primary);
-
- sd_info(primary, "group id %#x, uncombined\n", sd->group_id);
-out:
- sd_unregister(dev);
- sd_cleanup(dev);
-}
-
-struct auxiliary_device *mlx5_sd_get_adev(struct mlx5_core_dev *dev,
- struct auxiliary_device *adev,
- int idx)
-{
- struct mlx5_sd *sd = mlx5_get_sd(dev);
- struct mlx5_core_dev *primary;
-
- if (!sd)
- return adev;
-
- if (!mlx5_devcom_comp_is_ready(sd->devcom))
- return NULL;
-
- primary = mlx5_sd_get_primary(dev);
- if (dev == primary)
- return adev;
-
- return &primary->priv.adev[idx]->adev;
-}
+++ /dev/null
-/* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB */
-/* Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved. */
-
-#ifndef __MLX5_LIB_SD_H__
-#define __MLX5_LIB_SD_H__
-
-#define MLX5_SD_MAX_GROUP_SZ 2
-
-struct mlx5_sd;
-
-struct mlx5_core_dev *mlx5_sd_primary_get_peer(struct mlx5_core_dev *primary, int idx);
-int mlx5_sd_ch_ix_get_dev_ix(struct mlx5_core_dev *dev, int ch_ix);
-int mlx5_sd_ch_ix_get_vec_ix(struct mlx5_core_dev *dev, int ch_ix);
-struct mlx5_core_dev *mlx5_sd_ch_ix_get_dev(struct mlx5_core_dev *primary, int ch_ix);
-struct auxiliary_device *mlx5_sd_get_adev(struct mlx5_core_dev *dev,
- struct auxiliary_device *adev,
- int idx);
-
-int mlx5_sd_init(struct mlx5_core_dev *dev);
-void mlx5_sd_cleanup(struct mlx5_core_dev *dev);
-
-#define mlx5_sd_for_each_dev_from_to(i, primary, ix_from, to, pos) \
- for (i = ix_from; \
- (pos = mlx5_sd_primary_get_peer(primary, i)) && pos != (to); i++)
-
-#define mlx5_sd_for_each_dev(i, primary, pos) \
- mlx5_sd_for_each_dev_from_to(i, primary, 0, NULL, pos)
-
-#define mlx5_sd_for_each_dev_to(i, primary, to, pos) \
- mlx5_sd_for_each_dev_from_to(i, primary, 0, to, pos)
-
-#define mlx5_sd_for_each_secondary(i, primary, pos) \
- mlx5_sd_for_each_dev_from_to(i, primary, 1, NULL, pos)
-
-#define mlx5_sd_for_each_secondary_to(i, primary, to, pos) \
- mlx5_sd_for_each_dev_from_to(i, primary, 1, to, pos)
-
-#endif /* __MLX5_LIB_SD_H__ */
}
EXPORT_SYMBOL_GPL(mlx5_query_nic_vport_system_image_guid);
-int mlx5_query_nic_vport_sd_group(struct mlx5_core_dev *mdev, u8 *sd_group)
-{
- int outlen = MLX5_ST_SZ_BYTES(query_nic_vport_context_out);
- u32 *out;
- int err;
-
- out = kvzalloc(outlen, GFP_KERNEL);
- if (!out)
- return -ENOMEM;
-
- err = mlx5_query_nic_vport_context(mdev, 0, out);
- if (err)
- goto out;
-
- *sd_group = MLX5_GET(query_nic_vport_context_out, out,
- nic_vport_context.sd_group);
-out:
- kvfree(out);
- return err;
-}
-
int mlx5_query_nic_vport_node_guid(struct mlx5_core_dev *mdev, u64 *node_guid)
{
u32 *out;
struct mlx5_sq_bfreg bfreg;
#define MLX5_MAX_NUM_TC 8
u32 tisn[MLX5_MAX_PORTS][MLX5_MAX_NUM_TC];
- bool tisn_valid;
} hw_objs;
struct net_device *uplink_netdev;
struct mutex uplink_netdev_lock;
struct blocking_notifier_head macsec_nh;
#endif
u64 num_ipsec_offloads;
- struct mlx5_sd *sd;
};
struct mlx5_db {
return dev->caps.embedded_cpu;
}
-static inline bool mlx5_core_is_mgmt_pf(const struct mlx5_core_dev *dev)
-{
- if (!MLX5_CAP_GEN_2(dev, local_mng_port_valid))
- return false;
-
- return MLX5_CAP_GEN_2(dev, local_mng_port);
-}
-
static inline bool
mlx5_core_is_ecpf_esw_manager(const struct mlx5_core_dev *dev)
{
struct mlx5_ifc_cmd_hca_cap_2_bits {
u8 reserved_at_0[0x80];
- u8 migratable[0x1];
- u8 reserved_at_81[0x19];
- u8 local_mng_port[0x1];
- u8 reserved_at_9b[0x5];
+ u8 migratable[0x1];
+ u8 reserved_at_81[0x1f];
u8 max_reformat_insert_size[0x8];
u8 max_reformat_insert_offset[0x8];
u8 allowed_object_for_other_vhca_access[0x40];
- u8 reserved_at_140[0x20];
-
- u8 reserved_at_160[0xa];
- u8 local_mng_port_valid[0x1];
- u8 reserved_at_16b[0x15];
-
- u8 reserved_at_180[0x20];
+ u8 reserved_at_140[0x60];
u8 flow_table_type_2_type[0x8];
u8 reserved_at_1a8[0x3];
u8 affiliation_criteria[0x4];
u8 affiliated_vhca_id[0x10];
- u8 reserved_at_60[0xa0];
+ u8 reserved_at_60[0xd0];
- u8 reserved_at_100[0x1];
- u8 sd_group[0x3];
- u8 reserved_at_104[0x1c];
-
- u8 reserved_at_120[0x10];
u8 mtu[0x10];
u8 system_image_guid[0x40];
u8 reserved_at_20[0x20];
u8 local_port[0x8];
- u8 reserved_at_28[0x18];
+ u8 reserved_at_28[0x15];
+ u8 sd_group[0x3];
u8 reserved_at_60[0x20];
};
int mlx5_modify_nic_vport_mtu(struct mlx5_core_dev *mdev, u16 mtu);
int mlx5_query_nic_vport_system_image_guid(struct mlx5_core_dev *mdev,
u64 *system_image_guid);
-int mlx5_query_nic_vport_sd_group(struct mlx5_core_dev *mdev, u8 *sd_group);
int mlx5_query_nic_vport_node_guid(struct mlx5_core_dev *mdev, u64 *node_guid);
int mlx5_modify_nic_vport_node_guid(struct mlx5_core_dev *mdev,
u16 vport, u64 node_guid);
projects / linux-stable / commitdiff