Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d75d5f97 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'hinic-add-rss-support-and-rss-parameters-configuration' 



Xue Chaojing says:

====================
hinic: add rss support and rss parameters configuration

This series add rss support for HINIC driver and implement the ethtool
interface related to rss parameter configuration. user can use ethtool
configure rss parameters or show rss parameters.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 760f1dc2 4fdc51bb

drivers/net/ethernet/huawei/hinic/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -4,4 +4,4 @@ obj-$(CONFIG_HINIC) += hinic.o 
hinic-y := hinic_main.o hinic_tx.o hinic_rx.o hinic_port.o hinic_hw_dev.o \

	   hinic_hw_io.o hinic_hw_qp.o hinic_hw_cmdq.o hinic_hw_wq.o \

	   hinic_hw_mgmt.o hinic_hw_api_cmd.o hinic_hw_eqs.o hinic_hw_if.o \

	   hinic_common.o
 
	   hinic_common.o hinic_ethtool.o

drivers/net/ethernet/huawei/hinic/hinic_dev.h

+28 −0
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
enum hinic_flags {

	HINIC_LINK_UP = BIT(0),

	HINIC_INTF_UP = BIT(1),

	HINIC_RSS_ENABLE = BIT(2),

};



struct hinic_rx_mode_work {
@@ -29,6 +30,23 @@ struct hinic_rx_mode_work { 
	u32                     rx_mode;

};



struct hinic_rss_type {

	u8 tcp_ipv6_ext;

	u8 ipv6_ext;

	u8 tcp_ipv6;

	u8 ipv6;

	u8 tcp_ipv4;

	u8 ipv4;

	u8 udp_ipv6;

	u8 udp_ipv4;

};



enum hinic_rss_hash_type {

	HINIC_RSS_HASH_ENGINE_TYPE_XOR,

	HINIC_RSS_HASH_ENGINE_TYPE_TOEP,

	HINIC_RSS_HASH_ENGINE_TYPE_MAX,

};



struct hinic_dev {

	struct net_device               *netdev;

	struct hinic_hwdev              *hwdev;
@@ -36,6 +54,8 @@ struct hinic_dev { 
	u32                             msg_enable;

	unsigned int                    tx_weight;

	unsigned int                    rx_weight;

	u16				num_qps;

	u16				max_qps;



	unsigned int                    flags;
@@ -50,6 +70,14 @@ struct hinic_dev { 


	struct hinic_txq_stats          tx_stats;

	struct hinic_rxq_stats          rx_stats;



	u8				rss_tmpl_idx;

	u8				rss_hash_engine;

	u16				num_rss;

	u16				rss_limit;

	struct hinic_rss_type		rss_type;

	u8				*rss_hkey_user;

	s32				*rss_indir_user;

};



#endif

drivers/net/ethernet/huawei/hinic/hinic_ethtool.c

0 → 100644
+458 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Huawei HiNIC PCI Express Linux driver

 * Copyright(c) 2017 Huawei Technologies Co., Ltd

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU General Public License,

 * version 2, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * for more details.

 *

 */



#include <linux/kernel.h>

#include <linux/pci.h>

#include <linux/device.h>

#include <linux/module.h>

#include <linux/types.h>

#include <linux/errno.h>

#include <linux/interrupt.h>

#include <linux/etherdevice.h>

#include <linux/netdevice.h>

#include <linux/if_vlan.h>

#include <linux/ethtool.h>

#include <linux/vmalloc.h>



#include "hinic_hw_qp.h"

#include "hinic_hw_dev.h"

#include "hinic_port.h"

#include "hinic_tx.h"

#include "hinic_rx.h"

#include "hinic_dev.h"



static void set_link_speed(struct ethtool_link_ksettings *link_ksettings,

			   enum hinic_speed speed)

{

	switch (speed) {

	case HINIC_SPEED_10MB_LINK:

		link_ksettings->base.speed = SPEED_10;

		break;



	case HINIC_SPEED_100MB_LINK:

		link_ksettings->base.speed = SPEED_100;

		break;



	case HINIC_SPEED_1000MB_LINK:

		link_ksettings->base.speed = SPEED_1000;

		break;



	case HINIC_SPEED_10GB_LINK:

		link_ksettings->base.speed = SPEED_10000;

		break;



	case HINIC_SPEED_25GB_LINK:

		link_ksettings->base.speed = SPEED_25000;

		break;



	case HINIC_SPEED_40GB_LINK:

		link_ksettings->base.speed = SPEED_40000;

		break;



	case HINIC_SPEED_100GB_LINK:

		link_ksettings->base.speed = SPEED_100000;

		break;



	default:

		link_ksettings->base.speed = SPEED_UNKNOWN;

		break;

	}

}



static int hinic_get_link_ksettings(struct net_device *netdev,

				    struct ethtool_link_ksettings

				    *link_ksettings)

{

	struct hinic_dev *nic_dev = netdev_priv(netdev);

	enum hinic_port_link_state link_state;

	struct hinic_port_cap port_cap;

	int err;



	ethtool_link_ksettings_zero_link_mode(link_ksettings, advertising);

	ethtool_link_ksettings_add_link_mode(link_ksettings, supported,

					     Autoneg);



	link_ksettings->base.speed = SPEED_UNKNOWN;

	link_ksettings->base.autoneg = AUTONEG_DISABLE;

	link_ksettings->base.duplex = DUPLEX_UNKNOWN;



	err = hinic_port_get_cap(nic_dev, &port_cap);

	if (err)

		return err;



	err = hinic_port_link_state(nic_dev, &link_state);

	if (err)

		return err;



	if (link_state != HINIC_LINK_STATE_UP)

		return err;



	set_link_speed(link_ksettings, port_cap.speed);



	if (!!(port_cap.autoneg_cap & HINIC_AUTONEG_SUPPORTED))

		ethtool_link_ksettings_add_link_mode(link_ksettings,

						     advertising, Autoneg);



	if (port_cap.autoneg_state == HINIC_AUTONEG_ACTIVE)

		link_ksettings->base.autoneg = AUTONEG_ENABLE;



	link_ksettings->base.duplex = (port_cap.duplex == HINIC_DUPLEX_FULL) ?

					   DUPLEX_FULL : DUPLEX_HALF;

	return 0;

}



static void hinic_get_drvinfo(struct net_device *netdev,

			      struct ethtool_drvinfo *info)

{

	struct hinic_dev *nic_dev = netdev_priv(netdev);

	struct hinic_hwdev *hwdev = nic_dev->hwdev;

	struct hinic_hwif *hwif = hwdev->hwif;



	strlcpy(info->driver, HINIC_DRV_NAME, sizeof(info->driver));

	strlcpy(info->bus_info, pci_name(hwif->pdev), sizeof(info->bus_info));

}



static void hinic_get_ringparam(struct net_device *netdev,

				struct ethtool_ringparam *ring)

{

	ring->rx_max_pending = HINIC_RQ_DEPTH;

	ring->tx_max_pending = HINIC_SQ_DEPTH;

	ring->rx_pending = HINIC_RQ_DEPTH;

	ring->tx_pending = HINIC_SQ_DEPTH;

}



static void hinic_get_channels(struct net_device *netdev,

			       struct ethtool_channels *channels)

{

	struct hinic_dev *nic_dev = netdev_priv(netdev);

	struct hinic_hwdev *hwdev = nic_dev->hwdev;



	channels->max_rx = hwdev->nic_cap.max_qps;

	channels->max_tx = hwdev->nic_cap.max_qps;

	channels->max_other = 0;

	channels->max_combined = 0;

	channels->rx_count = hinic_hwdev_num_qps(hwdev);

	channels->tx_count = hinic_hwdev_num_qps(hwdev);

	channels->other_count = 0;

	channels->combined_count = 0;

}



static int hinic_get_rss_hash_opts(struct hinic_dev *nic_dev,

				   struct ethtool_rxnfc *cmd)

{

	struct hinic_rss_type rss_type = { 0 };

	int err;



	cmd->data = 0;



	if (!(nic_dev->flags & HINIC_RSS_ENABLE))

		return 0;



	err = hinic_get_rss_type(nic_dev, nic_dev->rss_tmpl_idx,

				 &rss_type);

	if (err)

		return err;



	cmd->data = RXH_IP_SRC | RXH_IP_DST;

	switch (cmd->flow_type) {

	case TCP_V4_FLOW:

		if (rss_type.tcp_ipv4)

			cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;

		break;

	case TCP_V6_FLOW:

		if (rss_type.tcp_ipv6)

			cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;

		break;

	case UDP_V4_FLOW:

		if (rss_type.udp_ipv4)

			cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;

		break;

	case UDP_V6_FLOW:

		if (rss_type.udp_ipv6)

			cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;

		break;

	case IPV4_FLOW:

	case IPV6_FLOW:

		break;

	default:

		cmd->data = 0;

		return -EINVAL;

	}



	return 0;

}



static int set_l4_rss_hash_ops(struct ethtool_rxnfc *cmd,

			       struct hinic_rss_type *rss_type)

{

	u8 rss_l4_en = 0;



	switch (cmd->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {

	case 0:

		rss_l4_en = 0;

		break;

	case (RXH_L4_B_0_1 | RXH_L4_B_2_3):

		rss_l4_en = 1;

		break;

	default:

		return -EINVAL;

	}



	switch (cmd->flow_type) {

	case TCP_V4_FLOW:

		rss_type->tcp_ipv4 = rss_l4_en;

		break;

	case TCP_V6_FLOW:

		rss_type->tcp_ipv6 = rss_l4_en;

		break;

	case UDP_V4_FLOW:

		rss_type->udp_ipv4 = rss_l4_en;

		break;

	case UDP_V6_FLOW:

		rss_type->udp_ipv6 = rss_l4_en;

		break;

	default:

		return -EINVAL;

	}



	return 0;

}



static int hinic_set_rss_hash_opts(struct hinic_dev *nic_dev,

				   struct ethtool_rxnfc *cmd)

{

	struct hinic_rss_type *rss_type = &nic_dev->rss_type;

	int err;



	if (!(nic_dev->flags & HINIC_RSS_ENABLE)) {

		cmd->data = 0;

		return -EOPNOTSUPP;

	}



	/* RSS does not support anything other than hashing

	 * to queues on src and dst IPs and ports

	 */

	if (cmd->data & ~(RXH_IP_SRC | RXH_IP_DST | RXH_L4_B_0_1 |

		RXH_L4_B_2_3))

		return -EINVAL;



	/* We need at least the IP SRC and DEST fields for hashing */

	if (!(cmd->data & RXH_IP_SRC) || !(cmd->data & RXH_IP_DST))

		return -EINVAL;



	err = hinic_get_rss_type(nic_dev,

				 nic_dev->rss_tmpl_idx, rss_type);

	if (err)

		return -EFAULT;



	switch (cmd->flow_type) {

	case TCP_V4_FLOW:

	case TCP_V6_FLOW:

	case UDP_V4_FLOW:

	case UDP_V6_FLOW:

		err = set_l4_rss_hash_ops(cmd, rss_type);

		if (err)

			return err;

		break;

	case IPV4_FLOW:

		rss_type->ipv4 = 1;

		break;

	case IPV6_FLOW:

		rss_type->ipv6 = 1;

		break;

	default:

		return -EINVAL;

	}



	err = hinic_set_rss_type(nic_dev, nic_dev->rss_tmpl_idx,

				 *rss_type);

	if (err)

		return -EFAULT;



	return 0;

}



static int __set_rss_rxfh(struct net_device *netdev,

			  const u32 *indir, const u8 *key)

{

	struct hinic_dev *nic_dev = netdev_priv(netdev);

	int err;



	if (indir) {

		if (!nic_dev->rss_indir_user) {

			nic_dev->rss_indir_user =

				kzalloc(sizeof(u32) * HINIC_RSS_INDIR_SIZE,

					GFP_KERNEL);

			if (!nic_dev->rss_indir_user)

				return -ENOMEM;

		}



		memcpy(nic_dev->rss_indir_user, indir,

		       sizeof(u32) * HINIC_RSS_INDIR_SIZE);



		err = hinic_rss_set_indir_tbl(nic_dev,

					      nic_dev->rss_tmpl_idx, indir);

		if (err)

			return -EFAULT;

	}



	if (key) {

		if (!nic_dev->rss_hkey_user) {

			nic_dev->rss_hkey_user =

				kzalloc(HINIC_RSS_KEY_SIZE * 2, GFP_KERNEL);



			if (!nic_dev->rss_hkey_user)

				return -ENOMEM;

		}



		memcpy(nic_dev->rss_hkey_user, key, HINIC_RSS_KEY_SIZE);



		err = hinic_rss_set_template_tbl(nic_dev,

						 nic_dev->rss_tmpl_idx, key);

		if (err)

			return -EFAULT;

	}



	return 0;

}



static int hinic_get_rxnfc(struct net_device *netdev,

			   struct ethtool_rxnfc *cmd, u32 *rule_locs)

{

	struct hinic_dev *nic_dev = netdev_priv(netdev);

	int err = 0;



	switch (cmd->cmd) {

	case ETHTOOL_GRXRINGS:

		cmd->data = nic_dev->num_qps;

		break;

	case ETHTOOL_GRXFH:

		err = hinic_get_rss_hash_opts(nic_dev, cmd);

		break;

	default:

		err = -EOPNOTSUPP;

		break;

	}



	return err;

}



static int hinic_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd)

{

	struct hinic_dev *nic_dev = netdev_priv(netdev);

	int err = 0;



	switch (cmd->cmd) {

	case ETHTOOL_SRXFH:

		err = hinic_set_rss_hash_opts(nic_dev, cmd);

		break;

	default:

		err = -EOPNOTSUPP;

		break;

	}



	return err;

}



static int hinic_get_rxfh(struct net_device *netdev,

			  u32 *indir, u8 *key, u8 *hfunc)

{

	struct hinic_dev *nic_dev = netdev_priv(netdev);

	u8 hash_engine_type = 0;

	int err = 0;



	if (!(nic_dev->flags & HINIC_RSS_ENABLE))

		return -EOPNOTSUPP;



	if (hfunc) {

		err = hinic_rss_get_hash_engine(nic_dev,

						nic_dev->rss_tmpl_idx,

						&hash_engine_type);

		if (err)

			return -EFAULT;



		*hfunc = hash_engine_type ? ETH_RSS_HASH_TOP : ETH_RSS_HASH_XOR;

	}



	if (indir) {

		err = hinic_rss_get_indir_tbl(nic_dev,

					      nic_dev->rss_tmpl_idx, indir);

		if (err)

			return -EFAULT;

	}



	if (key)

		err = hinic_rss_get_template_tbl(nic_dev,

						 nic_dev->rss_tmpl_idx, key);



	return err;

}



static int hinic_set_rxfh(struct net_device *netdev, const u32 *indir,

			  const u8 *key, const u8 hfunc)

{

	struct hinic_dev *nic_dev = netdev_priv(netdev);

	int err = 0;



	if (!(nic_dev->flags & HINIC_RSS_ENABLE))

		return -EOPNOTSUPP;



	if (hfunc != ETH_RSS_HASH_NO_CHANGE) {

		if (hfunc != ETH_RSS_HASH_TOP && hfunc != ETH_RSS_HASH_XOR)

			return -EOPNOTSUPP;



		nic_dev->rss_hash_engine = (hfunc == ETH_RSS_HASH_XOR) ?

			HINIC_RSS_HASH_ENGINE_TYPE_XOR :

			HINIC_RSS_HASH_ENGINE_TYPE_TOEP;

		err = hinic_rss_set_hash_engine

			(nic_dev, nic_dev->rss_tmpl_idx,

			nic_dev->rss_hash_engine);

		if (err)

			return -EFAULT;

	}



	err = __set_rss_rxfh(netdev, indir, key);



	return err;

}



static u32 hinic_get_rxfh_key_size(struct net_device *netdev)

{

	return HINIC_RSS_KEY_SIZE;

}



static u32 hinic_get_rxfh_indir_size(struct net_device *netdev)

{

	return HINIC_RSS_INDIR_SIZE;

}



static const struct ethtool_ops hinic_ethtool_ops = {

	.get_link_ksettings = hinic_get_link_ksettings,

	.get_drvinfo = hinic_get_drvinfo,

	.get_link = ethtool_op_get_link,

	.get_ringparam = hinic_get_ringparam,

	.get_channels = hinic_get_channels,

	.get_rxnfc = hinic_get_rxnfc,

	.set_rxnfc = hinic_set_rxnfc,

	.get_rxfh_key_size = hinic_get_rxfh_key_size,

	.get_rxfh_indir_size = hinic_get_rxfh_indir_size,

	.get_rxfh = hinic_get_rxfh,

	.set_rxfh = hinic_set_rxfh,

};



void hinic_set_ethtool_ops(struct net_device *netdev)

{

	netdev->ethtool_ops = &hinic_ethtool_ops;

}

drivers/net/ethernet/huawei/hinic/hinic_hw_dev.c

+7 −3
Original line number Diff line number Diff line
@@ -89,9 +89,6 @@ static int get_capability(struct hinic_hwdev *hwdev, 
	if (nic_cap->num_qps > HINIC_Q_CTXT_MAX)

		nic_cap->num_qps = HINIC_Q_CTXT_MAX;



	/* num_qps must be power of 2 */

	nic_cap->num_qps = BIT(fls(nic_cap->num_qps) - 1);



	nic_cap->max_qps = dev_cap->max_sqs + 1;

	if (nic_cap->max_qps != (dev_cap->max_rqs + 1))

		return -EFAULT;
@@ -874,6 +871,13 @@ void hinic_free_hwdev(struct hinic_hwdev *hwdev) 
	hinic_free_hwif(hwdev->hwif);

}



int hinic_hwdev_max_num_qps(struct hinic_hwdev *hwdev)

{

	struct hinic_cap *nic_cap = &hwdev->nic_cap;



	return nic_cap->max_qps;

}



/**

 * hinic_hwdev_num_qps - return the number QPs available for use

 * @hwdev: the NIC HW device

drivers/net/ethernet/huawei/hinic/hinic_hw_dev.h

+36 −0
Original line number Diff line number Diff line
@@ -45,8 +45,26 @@ enum hinic_port_cmd { 


	HINIC_PORT_CMD_SET_RX_CSUM	= 26,



	HINIC_PORT_CMD_GET_RSS_TEMPLATE_INDIR_TBL = 37,



	HINIC_PORT_CMD_SET_PORT_STATE   = 41,



	HINIC_PORT_CMD_SET_RSS_TEMPLATE_TBL = 43,



	HINIC_PORT_CMD_GET_RSS_TEMPLATE_TBL = 44,



	HINIC_PORT_CMD_SET_RSS_HASH_ENGINE = 45,



	HINIC_PORT_CMD_GET_RSS_HASH_ENGINE = 46,



	HINIC_PORT_CMD_GET_RSS_CTX_TBL  = 47,



	HINIC_PORT_CMD_SET_RSS_CTX_TBL  = 48,



	HINIC_PORT_CMD_RSS_TEMP_MGR	= 49,



	HINIC_PORT_CMD_RSS_CFG		= 66,



	HINIC_PORT_CMD_FWCTXT_INIT      = 69,



	HINIC_PORT_CMD_SET_FUNC_STATE   = 93,
@@ -62,6 +80,22 @@ enum hinic_port_cmd { 
	HINIC_PORT_CMD_SET_LRO_TIMER	= 244,

};



enum hinic_ucode_cmd {

	HINIC_UCODE_CMD_MODIFY_QUEUE_CONTEXT    = 0,

	HINIC_UCODE_CMD_CLEAN_QUEUE_CONTEXT,

	HINIC_UCODE_CMD_ARM_SQ,

	HINIC_UCODE_CMD_ARM_RQ,

	HINIC_UCODE_CMD_SET_RSS_INDIR_TABLE,

	HINIC_UCODE_CMD_SET_RSS_CONTEXT_TABLE,

	HINIC_UCODE_CMD_GET_RSS_INDIR_TABLE,

	HINIC_UCODE_CMD_GET_RSS_CONTEXT_TABLE,

	HINIC_UCODE_CMD_SET_IQ_ENABLE,

	HINIC_UCODE_CMD_SET_RQ_FLUSH            = 10

};



#define NIC_RSS_CMD_TEMP_ALLOC  0x01

#define NIC_RSS_CMD_TEMP_FREE   0x02



enum hinic_mgmt_msg_cmd {

	HINIC_MGMT_MSG_CMD_BASE         = 160,
@@ -221,6 +255,8 @@ struct hinic_hwdev *hinic_init_hwdev(struct pci_dev *pdev); 


void hinic_free_hwdev(struct hinic_hwdev *hwdev);



int hinic_hwdev_max_num_qps(struct hinic_hwdev *hwdev);



int hinic_hwdev_num_qps(struct hinic_hwdev *hwdev);



struct hinic_sq *hinic_hwdev_get_sq(struct hinic_hwdev *hwdev, int i);