337 lines
8.9 KiB
C
337 lines
8.9 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
// Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
|
|
|
|
#include <linux/ethtool.h>
|
|
|
|
#include "hinic3_cmdq.h"
|
|
#include "hinic3_hwdev.h"
|
|
#include "hinic3_hwif.h"
|
|
#include "hinic3_mbox.h"
|
|
#include "hinic3_nic_cfg.h"
|
|
#include "hinic3_nic_dev.h"
|
|
#include "hinic3_rss.h"
|
|
|
|
static void hinic3_fillout_indir_tbl(struct net_device *netdev, u16 *indir)
|
|
{
|
|
struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
|
|
u16 i, num_qps;
|
|
|
|
num_qps = nic_dev->q_params.num_qps;
|
|
for (i = 0; i < L2NIC_RSS_INDIR_SIZE; i++)
|
|
indir[i] = ethtool_rxfh_indir_default(i, num_qps);
|
|
}
|
|
|
|
static int hinic3_rss_cfg(struct hinic3_hwdev *hwdev, u8 rss_en, u16 num_qps)
|
|
{
|
|
struct mgmt_msg_params msg_params = {};
|
|
struct l2nic_cmd_cfg_rss rss_cfg = {};
|
|
int err;
|
|
|
|
rss_cfg.func_id = hinic3_global_func_id(hwdev);
|
|
rss_cfg.rss_en = rss_en;
|
|
rss_cfg.rq_priority_number = 0;
|
|
rss_cfg.num_qps = num_qps;
|
|
|
|
mgmt_msg_params_init_default(&msg_params, &rss_cfg, sizeof(rss_cfg));
|
|
|
|
err = hinic3_send_mbox_to_mgmt(hwdev, MGMT_MOD_L2NIC,
|
|
L2NIC_CMD_CFG_RSS, &msg_params);
|
|
if (err || rss_cfg.msg_head.status) {
|
|
dev_err(hwdev->dev, "Failed to set rss cfg, err: %d, status: 0x%x\n",
|
|
err, rss_cfg.msg_head.status);
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void hinic3_init_rss_parameters(struct net_device *netdev)
|
|
{
|
|
struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
|
|
|
|
nic_dev->rss_hash_type = HINIC3_RSS_HASH_ENGINE_TYPE_XOR;
|
|
nic_dev->rss_type.tcp_ipv6_ext = 1;
|
|
nic_dev->rss_type.ipv6_ext = 1;
|
|
nic_dev->rss_type.tcp_ipv6 = 1;
|
|
nic_dev->rss_type.ipv6 = 1;
|
|
nic_dev->rss_type.tcp_ipv4 = 1;
|
|
nic_dev->rss_type.ipv4 = 1;
|
|
nic_dev->rss_type.udp_ipv6 = 1;
|
|
nic_dev->rss_type.udp_ipv4 = 1;
|
|
}
|
|
|
|
static void decide_num_qps(struct net_device *netdev)
|
|
{
|
|
struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
|
|
unsigned int dev_cpus;
|
|
|
|
dev_cpus = netif_get_num_default_rss_queues();
|
|
nic_dev->q_params.num_qps = min(dev_cpus, nic_dev->max_qps);
|
|
}
|
|
|
|
static int alloc_rss_resource(struct net_device *netdev)
|
|
{
|
|
struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
|
|
|
|
nic_dev->rss_hkey = kmalloc_array(L2NIC_RSS_KEY_SIZE,
|
|
sizeof(nic_dev->rss_hkey[0]),
|
|
GFP_KERNEL);
|
|
if (!nic_dev->rss_hkey)
|
|
return -ENOMEM;
|
|
|
|
netdev_rss_key_fill(nic_dev->rss_hkey, L2NIC_RSS_KEY_SIZE);
|
|
|
|
nic_dev->rss_indir = kcalloc(L2NIC_RSS_INDIR_SIZE, sizeof(u16),
|
|
GFP_KERNEL);
|
|
if (!nic_dev->rss_indir) {
|
|
kfree(nic_dev->rss_hkey);
|
|
nic_dev->rss_hkey = NULL;
|
|
return -ENOMEM;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int hinic3_rss_set_indir_tbl(struct hinic3_hwdev *hwdev,
|
|
const u16 *indir_table)
|
|
{
|
|
struct l2nic_cmd_rss_set_indir_tbl *indir_tbl;
|
|
struct hinic3_cmd_buf *cmd_buf;
|
|
__le64 out_param;
|
|
int err;
|
|
u32 i;
|
|
|
|
cmd_buf = hinic3_alloc_cmd_buf(hwdev);
|
|
if (!cmd_buf) {
|
|
dev_err(hwdev->dev, "Failed to allocate cmd buf\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
cmd_buf->size = cpu_to_le16(sizeof(struct l2nic_cmd_rss_set_indir_tbl));
|
|
indir_tbl = cmd_buf->buf;
|
|
memset(indir_tbl, 0, sizeof(*indir_tbl));
|
|
|
|
for (i = 0; i < L2NIC_RSS_INDIR_SIZE; i++)
|
|
indir_tbl->entry[i] = cpu_to_le16(indir_table[i]);
|
|
|
|
hinic3_cmdq_buf_swab32(indir_tbl, sizeof(*indir_tbl));
|
|
|
|
err = hinic3_cmdq_direct_resp(hwdev, MGMT_MOD_L2NIC,
|
|
L2NIC_UCODE_CMD_SET_RSS_INDIR_TBL,
|
|
cmd_buf, &out_param);
|
|
if (err || out_param) {
|
|
dev_err(hwdev->dev, "Failed to set rss indir table\n");
|
|
err = -EFAULT;
|
|
}
|
|
|
|
hinic3_free_cmd_buf(hwdev, cmd_buf);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int hinic3_set_rss_type(struct hinic3_hwdev *hwdev,
|
|
struct hinic3_rss_type rss_type)
|
|
{
|
|
struct l2nic_cmd_set_rss_ctx_tbl ctx_tbl = {};
|
|
struct mgmt_msg_params msg_params = {};
|
|
u32 ctx;
|
|
int err;
|
|
|
|
ctx_tbl.func_id = hinic3_global_func_id(hwdev);
|
|
ctx = L2NIC_RSS_TYPE_SET(1, VALID) |
|
|
L2NIC_RSS_TYPE_SET(rss_type.ipv4, IPV4) |
|
|
L2NIC_RSS_TYPE_SET(rss_type.ipv6, IPV6) |
|
|
L2NIC_RSS_TYPE_SET(rss_type.ipv6_ext, IPV6_EXT) |
|
|
L2NIC_RSS_TYPE_SET(rss_type.tcp_ipv4, TCP_IPV4) |
|
|
L2NIC_RSS_TYPE_SET(rss_type.tcp_ipv6, TCP_IPV6) |
|
|
L2NIC_RSS_TYPE_SET(rss_type.tcp_ipv6_ext, TCP_IPV6_EXT) |
|
|
L2NIC_RSS_TYPE_SET(rss_type.udp_ipv4, UDP_IPV4) |
|
|
L2NIC_RSS_TYPE_SET(rss_type.udp_ipv6, UDP_IPV6);
|
|
ctx_tbl.context = ctx;
|
|
|
|
mgmt_msg_params_init_default(&msg_params, &ctx_tbl, sizeof(ctx_tbl));
|
|
|
|
err = hinic3_send_mbox_to_mgmt(hwdev, MGMT_MOD_L2NIC,
|
|
L2NIC_CMD_SET_RSS_CTX_TBL, &msg_params);
|
|
|
|
if (ctx_tbl.msg_head.status == MGMT_STATUS_CMD_UNSUPPORTED) {
|
|
return MGMT_STATUS_CMD_UNSUPPORTED;
|
|
} else if (err || ctx_tbl.msg_head.status) {
|
|
dev_err(hwdev->dev, "mgmt Failed to set rss context offload, err: %d, status: 0x%x\n",
|
|
err, ctx_tbl.msg_head.status);
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int hinic3_rss_cfg_hash_type(struct hinic3_hwdev *hwdev, u8 opcode,
|
|
enum hinic3_rss_hash_type *type)
|
|
{
|
|
struct l2nic_cmd_cfg_rss_engine hash_type_cmd = {};
|
|
struct mgmt_msg_params msg_params = {};
|
|
int err;
|
|
|
|
hash_type_cmd.func_id = hinic3_global_func_id(hwdev);
|
|
hash_type_cmd.opcode = opcode;
|
|
|
|
if (opcode == MGMT_MSG_CMD_OP_SET)
|
|
hash_type_cmd.hash_engine = *type;
|
|
|
|
mgmt_msg_params_init_default(&msg_params, &hash_type_cmd,
|
|
sizeof(hash_type_cmd));
|
|
|
|
err = hinic3_send_mbox_to_mgmt(hwdev, MGMT_MOD_L2NIC,
|
|
L2NIC_CMD_CFG_RSS_HASH_ENGINE,
|
|
&msg_params);
|
|
if (err || hash_type_cmd.msg_head.status) {
|
|
dev_err(hwdev->dev, "Failed to %s hash engine, err: %d, status: 0x%x\n",
|
|
opcode == MGMT_MSG_CMD_OP_SET ? "set" : "get",
|
|
err, hash_type_cmd.msg_head.status);
|
|
return -EIO;
|
|
}
|
|
|
|
if (opcode == MGMT_MSG_CMD_OP_GET)
|
|
*type = hash_type_cmd.hash_engine;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int hinic3_rss_set_hash_type(struct hinic3_hwdev *hwdev,
|
|
enum hinic3_rss_hash_type type)
|
|
{
|
|
return hinic3_rss_cfg_hash_type(hwdev, MGMT_MSG_CMD_OP_SET, &type);
|
|
}
|
|
|
|
static int hinic3_config_rss_hw_resource(struct net_device *netdev,
|
|
u16 *indir_tbl)
|
|
{
|
|
struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
|
|
int err;
|
|
|
|
err = hinic3_rss_set_indir_tbl(nic_dev->hwdev, indir_tbl);
|
|
if (err)
|
|
return err;
|
|
|
|
err = hinic3_set_rss_type(nic_dev->hwdev, nic_dev->rss_type);
|
|
if (err)
|
|
return err;
|
|
|
|
return hinic3_rss_set_hash_type(nic_dev->hwdev, nic_dev->rss_hash_type);
|
|
}
|
|
|
|
static int hinic3_rss_cfg_hash_key(struct hinic3_hwdev *hwdev, u8 opcode,
|
|
u8 *key)
|
|
{
|
|
struct l2nic_cmd_cfg_rss_hash_key hash_key = {};
|
|
struct mgmt_msg_params msg_params = {};
|
|
int err;
|
|
|
|
hash_key.func_id = hinic3_global_func_id(hwdev);
|
|
hash_key.opcode = opcode;
|
|
|
|
if (opcode == MGMT_MSG_CMD_OP_SET)
|
|
memcpy(hash_key.key, key, L2NIC_RSS_KEY_SIZE);
|
|
|
|
mgmt_msg_params_init_default(&msg_params, &hash_key, sizeof(hash_key));
|
|
|
|
err = hinic3_send_mbox_to_mgmt(hwdev, MGMT_MOD_L2NIC,
|
|
L2NIC_CMD_CFG_RSS_HASH_KEY, &msg_params);
|
|
if (err || hash_key.msg_head.status) {
|
|
dev_err(hwdev->dev, "Failed to %s hash key, err: %d, status: 0x%x\n",
|
|
opcode == MGMT_MSG_CMD_OP_SET ? "set" : "get",
|
|
err, hash_key.msg_head.status);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (opcode == MGMT_MSG_CMD_OP_GET)
|
|
memcpy(key, hash_key.key, L2NIC_RSS_KEY_SIZE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int hinic3_rss_set_hash_key(struct hinic3_hwdev *hwdev, u8 *key)
|
|
{
|
|
return hinic3_rss_cfg_hash_key(hwdev, MGMT_MSG_CMD_OP_SET, key);
|
|
}
|
|
|
|
static int hinic3_set_hw_rss_parameters(struct net_device *netdev, u8 rss_en)
|
|
{
|
|
struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
|
|
int err;
|
|
|
|
err = hinic3_rss_set_hash_key(nic_dev->hwdev, nic_dev->rss_hkey);
|
|
if (err)
|
|
return err;
|
|
|
|
hinic3_fillout_indir_tbl(netdev, nic_dev->rss_indir);
|
|
|
|
err = hinic3_config_rss_hw_resource(netdev, nic_dev->rss_indir);
|
|
if (err)
|
|
return err;
|
|
|
|
err = hinic3_rss_cfg(nic_dev->hwdev, rss_en, nic_dev->q_params.num_qps);
|
|
if (err)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int hinic3_rss_init(struct net_device *netdev)
|
|
{
|
|
return hinic3_set_hw_rss_parameters(netdev, 1);
|
|
}
|
|
|
|
void hinic3_rss_uninit(struct net_device *netdev)
|
|
{
|
|
struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
|
|
|
|
hinic3_rss_cfg(nic_dev->hwdev, 0, 0);
|
|
}
|
|
|
|
void hinic3_clear_rss_config(struct net_device *netdev)
|
|
{
|
|
struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
|
|
|
|
kfree(nic_dev->rss_hkey);
|
|
nic_dev->rss_hkey = NULL;
|
|
|
|
kfree(nic_dev->rss_indir);
|
|
nic_dev->rss_indir = NULL;
|
|
}
|
|
|
|
void hinic3_try_to_enable_rss(struct net_device *netdev)
|
|
{
|
|
struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
|
|
struct hinic3_hwdev *hwdev = nic_dev->hwdev;
|
|
int err;
|
|
|
|
nic_dev->max_qps = hinic3_func_max_qnum(hwdev);
|
|
if (nic_dev->max_qps <= 1 ||
|
|
!hinic3_test_support(nic_dev, HINIC3_NIC_F_RSS))
|
|
goto err_reset_q_params;
|
|
|
|
err = alloc_rss_resource(netdev);
|
|
if (err) {
|
|
nic_dev->max_qps = 1;
|
|
goto err_reset_q_params;
|
|
}
|
|
|
|
set_bit(HINIC3_RSS_ENABLE, &nic_dev->flags);
|
|
decide_num_qps(netdev);
|
|
hinic3_init_rss_parameters(netdev);
|
|
err = hinic3_set_hw_rss_parameters(netdev, 0);
|
|
if (err) {
|
|
dev_err(hwdev->dev, "Failed to set hardware rss parameters\n");
|
|
hinic3_clear_rss_config(netdev);
|
|
nic_dev->max_qps = 1;
|
|
goto err_reset_q_params;
|
|
}
|
|
|
|
return;
|
|
|
|
err_reset_q_params:
|
|
clear_bit(HINIC3_RSS_ENABLE, &nic_dev->flags);
|
|
nic_dev->q_params.num_qps = nic_dev->max_qps;
|
|
}
|