| // 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; |
| } |