kernel/linux/kni/ethtool/igb/igb_vmdq.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*******************************************************************************
   3
   4   Intel(R) Gigabit Ethernet Linux driver
   5   Copyright(c) 2007-2013 Intel Corporation.
   6
   7   Contact Information:
   8   e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
   9   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  10
  11 *******************************************************************************/
  12
  13
  14 #include <linux/tcp.h>
  15
  16 #include "igb.h"
  17 #include "igb_vmdq.h"
  18 #include <linux/if_vlan.h>
  19
  20 #ifdef CONFIG_IGB_VMDQ_NETDEV
  21 int igb_vmdq_open(struct net_device *dev)
  22 {
  23         struct igb_vmdq_adapter *vadapter = netdev_priv(dev);
  24         struct igb_adapter *adapter = vadapter->real_adapter;
  25         struct net_device *main_netdev = adapter->netdev;
  26         int hw_queue = vadapter->rx_ring->queue_index +
  27                        adapter->vfs_allocated_count;
  28
  29         if (test_bit(__IGB_DOWN, &adapter->state)) {
  30                 DPRINTK(DRV, WARNING,
  31                         "Open %s before opening this device.\n",
  32                         main_netdev->name);
  33                 return -EAGAIN;
  34         }
  35         netif_carrier_off(dev);
  36         vadapter->tx_ring->vmdq_netdev = dev;
  37         vadapter->rx_ring->vmdq_netdev = dev;
  38         if (is_valid_ether_addr(dev->dev_addr)) {
  39                 igb_del_mac_filter(adapter, dev->dev_addr, hw_queue);
  40                 igb_add_mac_filter(adapter, dev->dev_addr, hw_queue);
  41         }
  42         netif_carrier_on(dev);
  43         return 0;
  44 }
  45
  46 int igb_vmdq_close(struct net_device *dev)
  47 {
  48         struct igb_vmdq_adapter *vadapter = netdev_priv(dev);
  49         struct igb_adapter *adapter = vadapter->real_adapter;
  50         int hw_queue = vadapter->rx_ring->queue_index +
  51                        adapter->vfs_allocated_count;
  52
  53         netif_carrier_off(dev);
  54         igb_del_mac_filter(adapter, dev->dev_addr, hw_queue);
  55
  56         vadapter->tx_ring->vmdq_netdev = NULL;
  57         vadapter->rx_ring->vmdq_netdev = NULL;
  58         return 0;
  59 }
  60
  61 netdev_tx_t igb_vmdq_xmit_frame(struct sk_buff *skb, struct net_device *dev)
  62 {
  63         struct igb_vmdq_adapter *vadapter = netdev_priv(dev);
  64
  65         return igb_xmit_frame_ring(skb, vadapter->tx_ring);
  66 }
  67
  68 struct net_device_stats *igb_vmdq_get_stats(struct net_device *dev)
  69 {
  70         struct igb_vmdq_adapter *vadapter = netdev_priv(dev);
  71         struct igb_adapter *adapter = vadapter->real_adapter;
  72         struct e1000_hw *hw = &adapter->hw;
  73         int hw_queue = vadapter->rx_ring->queue_index +
  74                        adapter->vfs_allocated_count;
  75
  76         vadapter->net_stats.rx_packets +=
  77                         E1000_READ_REG(hw, E1000_PFVFGPRC(hw_queue));
  78         E1000_WRITE_REG(hw, E1000_PFVFGPRC(hw_queue), 0);
  79         vadapter->net_stats.tx_packets +=
  80                         E1000_READ_REG(hw, E1000_PFVFGPTC(hw_queue));
  81         E1000_WRITE_REG(hw, E1000_PFVFGPTC(hw_queue), 0);
  82         vadapter->net_stats.rx_bytes +=
  83                         E1000_READ_REG(hw, E1000_PFVFGORC(hw_queue));
  84         E1000_WRITE_REG(hw, E1000_PFVFGORC(hw_queue), 0);
  85         vadapter->net_stats.tx_bytes +=
  86                         E1000_READ_REG(hw, E1000_PFVFGOTC(hw_queue));
  87         E1000_WRITE_REG(hw, E1000_PFVFGOTC(hw_queue), 0);
  88         vadapter->net_stats.multicast +=
  89                         E1000_READ_REG(hw, E1000_PFVFMPRC(hw_queue));
  90         E1000_WRITE_REG(hw, E1000_PFVFMPRC(hw_queue), 0);
  91         /* only return the current stats */
  92         return &vadapter->net_stats;
  93 }
  94
  95 /**
  96  * igb_write_vm_addr_list - write unicast addresses to RAR table
  97  * @netdev: network interface device structure
  98  *
  99  * Writes unicast address list to the RAR table.
 100  * Returns: -ENOMEM on failure/insufficient address space
 101  *                0 on no addresses written
 102  *                X on writing X addresses to the RAR table
 103  **/
 104 static int igb_write_vm_addr_list(struct net_device *netdev)
 105 {
 106         struct igb_vmdq_adapter *vadapter = netdev_priv(netdev);
 107         struct igb_adapter *adapter = vadapter->real_adapter;
 108         int count = 0;
 109         int hw_queue = vadapter->rx_ring->queue_index +
 110                        adapter->vfs_allocated_count;
 111
 112         /* return ENOMEM indicating insufficient memory for addresses */
 113         if (netdev_uc_count(netdev) > igb_available_rars(adapter))
 114                 return -ENOMEM;
 115
 116         if (!netdev_uc_empty(netdev)) {
 117 #ifdef NETDEV_HW_ADDR_T_UNICAST
 118                 struct netdev_hw_addr *ha;
 119 #else
 120                 struct dev_mc_list *ha;
 121 #endif
 122                 netdev_for_each_uc_addr(ha, netdev) {
 123 #ifdef NETDEV_HW_ADDR_T_UNICAST
 124                         igb_del_mac_filter(adapter, ha->addr, hw_queue);
 125                         igb_add_mac_filter(adapter, ha->addr, hw_queue);
 126 #else
 127                         igb_del_mac_filter(adapter, ha->da_addr, hw_queue);
 128                         igb_add_mac_filter(adapter, ha->da_addr, hw_queue);
 129 #endif
 130                         count++;
 131                 }
 132         }
 133         return count;
 134 }
 135
 136
 137 #define E1000_VMOLR_UPE         0x20000000 /* Unicast promiscuous mode */
 138 void igb_vmdq_set_rx_mode(struct net_device *dev)
 139 {
 140         struct igb_vmdq_adapter *vadapter = netdev_priv(dev);
 141         struct igb_adapter *adapter = vadapter->real_adapter;
 142         struct e1000_hw *hw = &adapter->hw;
 143         u32 vmolr, rctl;
 144         int hw_queue = vadapter->rx_ring->queue_index +
 145                        adapter->vfs_allocated_count;
 146
 147         /* Check for Promiscuous and All Multicast modes */
 148         vmolr = E1000_READ_REG(hw, E1000_VMOLR(hw_queue));
 149
 150         /* clear the affected bits */
 151         vmolr &= ~(E1000_VMOLR_UPE | E1000_VMOLR_MPME |
 152                    E1000_VMOLR_ROPE | E1000_VMOLR_ROMPE);
 153
 154         if (dev->flags & IFF_PROMISC) {
 155                 vmolr |= E1000_VMOLR_UPE;
 156                 rctl = E1000_READ_REG(hw, E1000_RCTL);
 157                 rctl |= E1000_RCTL_UPE;
 158                 E1000_WRITE_REG(hw, E1000_RCTL, rctl);
 159         } else {
 160                 rctl = E1000_READ_REG(hw, E1000_RCTL);
 161                 rctl &= ~E1000_RCTL_UPE;
 162                 E1000_WRITE_REG(hw, E1000_RCTL, rctl);
 163                 if (dev->flags & IFF_ALLMULTI) {
 164                         vmolr |= E1000_VMOLR_MPME;
 165                 } else {
 166                         /*
 167                          * Write addresses to the MTA, if the attempt fails
 168                          * then we should just turn on promiscuous mode so
 169                          * that we can at least receive multicast traffic
 170                          */
 171                         if (igb_write_mc_addr_list(adapter->netdev) != 0)
 172                                 vmolr |= E1000_VMOLR_ROMPE;
 173                 }
 174 #ifdef HAVE_SET_RX_MODE
 175                 /*
 176                  * Write addresses to available RAR registers, if there is not
 177                  * sufficient space to store all the addresses then enable
 178                  * unicast promiscuous mode
 179                  */
 180                 if (igb_write_vm_addr_list(dev) < 0)
 181                         vmolr |= E1000_VMOLR_UPE;
 182 #endif
 183         }
 184         E1000_WRITE_REG(hw, E1000_VMOLR(hw_queue), vmolr);
 185
 186         return;
 187 }
 188
 189 int igb_vmdq_set_mac(struct net_device *dev, void *p)
 190 {
 191         struct sockaddr *addr = p;
 192         struct igb_vmdq_adapter *vadapter = netdev_priv(dev);
 193         struct igb_adapter *adapter = vadapter->real_adapter;
 194         int hw_queue = vadapter->rx_ring->queue_index +
 195                        adapter->vfs_allocated_count;
 196
 197         igb_del_mac_filter(adapter, dev->dev_addr, hw_queue);
 198         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
 199         return igb_add_mac_filter(adapter, dev->dev_addr, hw_queue);
 200 }
 201
 202 int igb_vmdq_change_mtu(struct net_device *dev, int new_mtu)
 203 {
 204         struct igb_vmdq_adapter *vadapter = netdev_priv(dev);
 205         struct igb_adapter *adapter = vadapter->real_adapter;
 206
 207         if (adapter->netdev->mtu < new_mtu) {
 208                 DPRINTK(PROBE, INFO,
 209                         "Set MTU on %s to >= %d "
 210                         "before changing MTU on %s\n",
 211                         adapter->netdev->name, new_mtu, dev->name);
 212                 return -EINVAL;
 213         }
 214         dev->mtu = new_mtu;
 215         return 0;
 216 }
 217
 218 void igb_vmdq_tx_timeout(struct net_device *dev)
 219 {
 220         return;
 221 }
 222
 223 void igb_vmdq_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
 224 {
 225         struct igb_vmdq_adapter *vadapter = netdev_priv(dev);
 226         struct igb_adapter *adapter = vadapter->real_adapter;
 227         struct e1000_hw *hw = &adapter->hw;
 228         int hw_queue = vadapter->rx_ring->queue_index +
 229                        adapter->vfs_allocated_count;
 230
 231         vadapter->vlgrp = grp;
 232
 233         igb_enable_vlan_tags(adapter);
 234         E1000_WRITE_REG(hw, E1000_VMVIR(hw_queue), 0);
 235
 236         return;
 237 }
 238 void igb_vmdq_vlan_rx_add_vid(struct net_device *dev, unsigned short vid)
 239 {
 240         struct igb_vmdq_adapter *vadapter = netdev_priv(dev);
 241         struct igb_adapter *adapter = vadapter->real_adapter;
 242 #ifndef HAVE_NETDEV_VLAN_FEATURES
 243         struct net_device *v_netdev;
 244 #endif
 245         int hw_queue = vadapter->rx_ring->queue_index +
 246                        adapter->vfs_allocated_count;
 247
 248         /* attempt to add filter to vlvf array */
 249         igb_vlvf_set(adapter, vid, TRUE, hw_queue);
 250
 251 #ifndef HAVE_NETDEV_VLAN_FEATURES
 252
 253         /* Copy feature flags from netdev to the vlan netdev for this vid.
 254          * This allows things like TSO to bubble down to our vlan device.
 255          */
 256         v_netdev = vlan_group_get_device(vadapter->vlgrp, vid);
 257         v_netdev->features |= adapter->netdev->features;
 258         vlan_group_set_device(vadapter->vlgrp, vid, v_netdev);
 259 #endif
 260
 261         return;
 262 }
 263 void igb_vmdq_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
 264 {
 265         struct igb_vmdq_adapter *vadapter = netdev_priv(dev);
 266         struct igb_adapter *adapter = vadapter->real_adapter;
 267         int hw_queue = vadapter->rx_ring->queue_index +
 268                        adapter->vfs_allocated_count;
 269
 270         vlan_group_set_device(vadapter->vlgrp, vid, NULL);
 271         /* remove vlan from VLVF table array */
 272         igb_vlvf_set(adapter, vid, FALSE, hw_queue);
 273
 274
 275         return;
 276 }
 277
 278 static int igb_vmdq_get_settings(struct net_device *netdev,
 279                                    struct ethtool_cmd *ecmd)
 280 {
 281         struct igb_vmdq_adapter *vadapter = netdev_priv(netdev);
 282         struct igb_adapter *adapter = vadapter->real_adapter;
 283         struct e1000_hw *hw = &adapter->hw;
 284         u32 status;
 285
 286         if (hw->phy.media_type == e1000_media_type_copper) {
 287
 288                 ecmd->supported = (SUPPORTED_10baseT_Half |
 289                                    SUPPORTED_10baseT_Full |
 290                                    SUPPORTED_100baseT_Half |
 291                                    SUPPORTED_100baseT_Full |
 292                                    SUPPORTED_1000baseT_Full|
 293                                    SUPPORTED_Autoneg |
 294                                    SUPPORTED_TP);
 295                 ecmd->advertising = ADVERTISED_TP;
 296
 297                 if (hw->mac.autoneg == 1) {
 298                         ecmd->advertising |= ADVERTISED_Autoneg;
 299                         /* the e1000 autoneg seems to match ethtool nicely */
 300                         ecmd->advertising |= hw->phy.autoneg_advertised;
 301                 }
 302
 303                 ecmd->port = PORT_TP;
 304                 ecmd->phy_address = hw->phy.addr;
 305         } else {
 306                 ecmd->supported   = (SUPPORTED_1000baseT_Full |
 307                                      SUPPORTED_FIBRE |
 308                                      SUPPORTED_Autoneg);
 309
 310                 ecmd->advertising = (ADVERTISED_1000baseT_Full |
 311                                      ADVERTISED_FIBRE |
 312                                      ADVERTISED_Autoneg);
 313
 314                 ecmd->port = PORT_FIBRE;
 315         }
 316
 317         ecmd->transceiver = XCVR_INTERNAL;
 318
 319         status = E1000_READ_REG(hw, E1000_STATUS);
 320
 321         if (status & E1000_STATUS_LU) {
 322
 323                 if ((status & E1000_STATUS_SPEED_1000) ||
 324                     hw->phy.media_type != e1000_media_type_copper)
 325                         ecmd->speed = SPEED_1000;
 326                 else if (status & E1000_STATUS_SPEED_100)
 327                         ecmd->speed = SPEED_100;
 328                 else
 329                         ecmd->speed = SPEED_10;
 330
 331                 if ((status & E1000_STATUS_FD) ||
 332                     hw->phy.media_type != e1000_media_type_copper)
 333                         ecmd->duplex = DUPLEX_FULL;
 334                 else
 335                         ecmd->duplex = DUPLEX_HALF;
 336         } else {
 337                 ecmd->speed = -1;
 338                 ecmd->duplex = -1;
 339         }
 340
 341         ecmd->autoneg = hw->mac.autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE;
 342         return 0;
 343 }
 344
 345
 346 static u32 igb_vmdq_get_msglevel(struct net_device *netdev)
 347 {
 348         struct igb_vmdq_adapter *vadapter = netdev_priv(netdev);
 349         struct igb_adapter *adapter = vadapter->real_adapter;
 350         return adapter->msg_enable;
 351 }
 352
 353 static void igb_vmdq_get_drvinfo(struct net_device *netdev,
 354                                    struct ethtool_drvinfo *drvinfo)
 355 {
 356         struct igb_vmdq_adapter *vadapter = netdev_priv(netdev);
 357         struct igb_adapter *adapter = vadapter->real_adapter;
 358         struct net_device *main_netdev = adapter->netdev;
 359
 360         strncpy(drvinfo->driver, igb_driver_name, 32);
 361         strncpy(drvinfo->version, igb_driver_version, 32);
 362
 363         strncpy(drvinfo->fw_version, "N/A", 4);
 364         snprintf(drvinfo->bus_info, 32, "%s VMDQ %d", main_netdev->name,
 365                  vadapter->rx_ring->queue_index);
 366         drvinfo->n_stats = 0;
 367         drvinfo->testinfo_len = 0;
 368         drvinfo->regdump_len = 0;
 369 }
 370
 371 static void igb_vmdq_get_ringparam(struct net_device *netdev,
 372                                      struct ethtool_ringparam *ring)
 373 {
 374         struct igb_vmdq_adapter *vadapter = netdev_priv(netdev);
 375
 376         struct igb_ring *tx_ring = vadapter->tx_ring;
 377         struct igb_ring *rx_ring = vadapter->rx_ring;
 378
 379         ring->rx_max_pending = IGB_MAX_RXD;
 380         ring->tx_max_pending = IGB_MAX_TXD;
 381         ring->rx_mini_max_pending = 0;
 382         ring->rx_jumbo_max_pending = 0;
 383         ring->rx_pending = rx_ring->count;
 384         ring->tx_pending = tx_ring->count;
 385         ring->rx_mini_pending = 0;
 386         ring->rx_jumbo_pending = 0;
 387 }
 388 static u32 igb_vmdq_get_rx_csum(struct net_device *netdev)
 389 {
 390         struct igb_vmdq_adapter *vadapter = netdev_priv(netdev);
 391         struct igb_adapter *adapter = vadapter->real_adapter;
 392
 393         return test_bit(IGB_RING_FLAG_RX_CSUM, &adapter->rx_ring[0]->flags);
 394 }
 395
 396
 397 static struct ethtool_ops igb_vmdq_ethtool_ops = {
 398         .get_settings           = igb_vmdq_get_settings,
 399         .get_drvinfo            = igb_vmdq_get_drvinfo,
 400         .get_link               = ethtool_op_get_link,
 401         .get_ringparam          = igb_vmdq_get_ringparam,
 402         .get_rx_csum            = igb_vmdq_get_rx_csum,
 403         .get_tx_csum            = ethtool_op_get_tx_csum,
 404         .get_sg                 = ethtool_op_get_sg,
 405         .set_sg                 = ethtool_op_set_sg,
 406         .get_msglevel           = igb_vmdq_get_msglevel,
 407 #ifdef NETIF_F_TSO
 408         .get_tso                = ethtool_op_get_tso,
 409 #endif
 410 #ifdef HAVE_ETHTOOL_GET_PERM_ADDR
 411         .get_perm_addr          = ethtool_op_get_perm_addr,
 412 #endif
 413 };
 414
 415 void igb_vmdq_set_ethtool_ops(struct net_device *netdev)
 416 {
 417         SET_ETHTOOL_OPS(netdev, &igb_vmdq_ethtool_ops);
 418 }
 419
 420
 421 #endif /* CONFIG_IGB_VMDQ_NETDEV */