cxgb4/cxgb4vf: Add set VF mac address support
authorHariprasad Shenai <hariprasad@chelsio.com>
Thu, 11 Aug 2016 15:36:24 +0000 (21:06 +0530)
committerDavid S. Miller <davem@davemloft.net>
Mon, 15 Aug 2016 04:16:57 +0000 (21:16 -0700)
Add ndo_set_vf_mac support which allows to set the MAC address
for cxgb4vf interfaces from the host

Signed-off-by: Hariprasad Shenai <hariprasad@chelsio.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c
drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
drivers/net/ethernet/chelsio/cxgb4vf/cxgb4vf_main.c
drivers/net/ethernet/chelsio/cxgb4vf/t4vf_common.h
drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c

index 2e2aa9fec9bbbeaec23fbe8196bd35c3875ff1b7..bcfa51226b46ab773a03ed7a9022e606a9c980ca 100644 (file)
@@ -1521,4 +1521,7 @@ void t4_idma_monitor_init(struct adapter *adapter,
 void t4_idma_monitor(struct adapter *adapter,
                     struct sge_idma_monitor_state *idma,
                     int hz, int ticks);
+int t4_set_vf_mac_acl(struct adapter *adapter, unsigned int vf,
+                     unsigned int naddr, u8 *addr);
+
 #endif /* __CXGB4_H__ */
index b7e932ec689429a367820b7a8af16d40a10ba081..2bb804c936881212d892214a752a6ba0c5b075fd 100644 (file)
@@ -3078,6 +3078,26 @@ static int cxgb_change_mtu(struct net_device *dev, int new_mtu)
        return ret;
 }
 
+#ifdef CONFIG_PCI_IOV
+static int cxgb_set_vf_mac(struct net_device *dev, int vf, u8 *mac)
+{
+       struct port_info *pi = netdev_priv(dev);
+       struct adapter *adap = pi->adapter;
+
+       /* verify MAC addr is valid */
+       if (!is_valid_ether_addr(mac)) {
+               dev_err(pi->adapter->pdev_dev,
+                       "Invalid Ethernet address %pM for VF %d\n",
+                       mac, vf);
+               return -EINVAL;
+       }
+
+       dev_info(pi->adapter->pdev_dev,
+                "Setting MAC %pM on VF %d\n", mac, vf);
+       return t4_set_vf_mac_acl(adap, vf + 1, 1, mac);
+}
+#endif
+
 static int cxgb_set_mac_addr(struct net_device *dev, void *p)
 {
        int ret;
@@ -3136,10 +3156,12 @@ static const struct net_device_ops cxgb4_netdev_ops = {
 #ifdef CONFIG_NET_RX_BUSY_POLL
        .ndo_busy_poll        = cxgb_busy_poll,
 #endif
-
 };
 
 static const struct net_device_ops cxgb4_mgmt_netdev_ops = {
+#ifdef CONFIG_PCI_IOV
+       .ndo_set_vf_mac       = cxgb_set_vf_mac,
+#endif
 };
 
 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
index dc92c80a75f481c5825fe34e92b41b3f1b4fb07b..2a476cc4e0738d0ece6ea2a62f65561488925f96 100644 (file)
@@ -8264,3 +8264,44 @@ void t4_idma_monitor(struct adapter *adapter,
                t4_sge_decode_idma_state(adapter, idma->idma_state[i]);
        }
 }
+
+/**
+ *     t4_set_vf_mac - Set MAC address for the specified VF
+ *     @adapter: The adapter
+ *     @vf: one of the VFs instantiated by the specified PF
+ *     @naddr: the number of MAC addresses
+ *     @addr: the MAC address(es) to be set to the specified VF
+ */
+int t4_set_vf_mac_acl(struct adapter *adapter, unsigned int vf,
+                     unsigned int naddr, u8 *addr)
+{
+       struct fw_acl_mac_cmd cmd;
+
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_ACL_MAC_CMD) |
+                                   FW_CMD_REQUEST_F |
+                                   FW_CMD_WRITE_F |
+                                   FW_ACL_MAC_CMD_PFN_V(adapter->pf) |
+                                   FW_ACL_MAC_CMD_VFN_V(vf));
+
+       /* Note: Do not enable the ACL */
+       cmd.en_to_len16 = cpu_to_be32((unsigned int)FW_LEN16(cmd));
+       cmd.nmac = naddr;
+
+       switch (adapter->pf) {
+       case 3:
+               memcpy(cmd.macaddr3, addr, sizeof(cmd.macaddr3));
+               break;
+       case 2:
+               memcpy(cmd.macaddr2, addr, sizeof(cmd.macaddr2));
+               break;
+       case 1:
+               memcpy(cmd.macaddr1, addr, sizeof(cmd.macaddr1));
+               break;
+       case 0:
+               memcpy(cmd.macaddr0, addr, sizeof(cmd.macaddr0));
+               break;
+       }
+
+       return t4_wr_mbox(adapter, adapter->mbox, &cmd, sizeof(cmd), &cmd);
+}
index e116bb8d1729a4eb5f0fcf860818bc899d041cb9..f2951bf689922233ac4865e1cc5611d8270080a7 100644 (file)
@@ -2777,6 +2777,7 @@ static int cxgb4vf_pci_probe(struct pci_dev *pdev,
        struct adapter *adapter;
        struct port_info *pi;
        struct net_device *netdev;
+       unsigned int pf;
 
        /*
         * Print our driver banner the first time we're called to initialize a
@@ -2903,8 +2904,11 @@ static int cxgb4vf_pci_probe(struct pci_dev *pdev,
         * Allocate our "adapter ports" and stitch everything together.
         */
        pmask = adapter->params.vfres.pmask;
+       pf = t4vf_get_pf_from_vf(adapter);
        for_each_port(adapter, pidx) {
                int port_id, viid;
+               u8 mac[ETH_ALEN];
+               unsigned int naddr = 1;
 
                /*
                 * We simplistically allocate our virtual interfaces
@@ -2975,6 +2979,26 @@ static int cxgb4vf_pci_probe(struct pci_dev *pdev,
                                pidx);
                        goto err_free_dev;
                }
+
+               err = t4vf_get_vf_mac_acl(adapter, pf, &naddr, mac);
+               if (err) {
+                       dev_err(&pdev->dev,
+                               "unable to determine MAC ACL address, "
+                               "continuing anyway.. (status %d)\n", err);
+               } else if (naddr && adapter->params.vfres.nvi == 1) {
+                       struct sockaddr addr;
+
+                       ether_addr_copy(addr.sa_data, mac);
+                       err = cxgb4vf_set_mac_addr(netdev, &addr);
+                       if (err) {
+                               dev_err(&pdev->dev,
+                                       "unable to set MAC address %pM\n",
+                                       mac);
+                               goto err_free_dev;
+                       }
+                       dev_info(&pdev->dev,
+                                "Using assigned MAC ACL: %pM\n", mac);
+               }
        }
 
        /* See what interrupts we'll be using.  If we've been configured to
index 8ee541431e8b321baacb008840844a5a7f49c048..8067424ad4a807263d3ea6e138bcd428b93cd15f 100644 (file)
@@ -347,6 +347,7 @@ int t4vf_bar2_sge_qregs(struct adapter *adapter,
                        u64 *pbar2_qoffset,
                        unsigned int *pbar2_qid);
 
+unsigned int t4vf_get_pf_from_vf(struct adapter *);
 int t4vf_get_sge_params(struct adapter *);
 int t4vf_get_vpd_params(struct adapter *);
 int t4vf_get_dev_params(struct adapter *);
@@ -381,5 +382,7 @@ int t4vf_eth_eq_free(struct adapter *, unsigned int);
 
 int t4vf_handle_fw_rpl(struct adapter *, const __be64 *);
 int t4vf_prep_adapter(struct adapter *);
+int t4vf_get_vf_mac_acl(struct adapter *adapter, unsigned int pf,
+                       unsigned int *naddr, u8 *addr);
 
 #endif /* __T4VF_COMMON_H__ */
index 427bfa71388b3a000cdaf5689d10e65fb1e3b8f4..879f4c52b3d5165eac0301c9707ff6bde096b3c8 100644 (file)
@@ -639,6 +639,15 @@ int t4vf_bar2_sge_qregs(struct adapter *adapter,
        return 0;
 }
 
+unsigned int t4vf_get_pf_from_vf(struct adapter *adapter)
+{
+       u32 whoami;
+
+       whoami = t4_read_reg(adapter, T4VF_PL_BASE_ADDR + PL_VF_WHOAMI_A);
+       return (CHELSIO_CHIP_VERSION(adapter->params.chip) <= CHELSIO_T5 ?
+                       SOURCEPF_G(whoami) : T6_SOURCEPF_G(whoami));
+}
+
 /**
  *     t4vf_get_sge_params - retrieve adapter Scatter gather Engine parameters
  *     @adapter: the adapter
@@ -716,7 +725,6 @@ int t4vf_get_sge_params(struct adapter *adapter)
         * read.
         */
        if (!is_t4(adapter->params.chip)) {
-               u32 whoami;
                unsigned int pf, s_hps, s_qpp;
 
                params[0] = (FW_PARAMS_MNEM_V(FW_PARAMS_MNEM_REG) |
@@ -740,11 +748,7 @@ int t4vf_get_sge_params(struct adapter *adapter)
                 * register we just read. Do it once here so other code in
                 * the driver can just use it.
                 */
-               whoami = t4_read_reg(adapter,
-                                    T4VF_PL_BASE_ADDR + PL_VF_WHOAMI_A);
-               pf = CHELSIO_CHIP_VERSION(adapter->params.chip) <= CHELSIO_T5 ?
-                       SOURCEPF_G(whoami) : T6_SOURCEPF_G(whoami);
-
+               pf = t4vf_get_pf_from_vf(adapter);
                s_hps = (HOSTPAGESIZEPF0_S +
                         (HOSTPAGESIZEPF1_S - HOSTPAGESIZEPF0_S) * pf);
                sge_params->sge_vf_hps =
@@ -1807,3 +1811,50 @@ int t4vf_prep_adapter(struct adapter *adapter)
 
        return 0;
 }
+
+/**
+ *     t4vf_get_vf_mac_acl - Get the MAC address to be set to
+ *                           the VI of this VF.
+ *     @adapter: The adapter
+ *     @pf: The pf associated with vf
+ *     @naddr: the number of ACL MAC addresses returned in addr
+ *     @addr: Placeholder for MAC addresses
+ *
+ *     Find the MAC address to be set to the VF's VI. The requested MAC address
+ *     is from the host OS via callback in the PF driver.
+ */
+int t4vf_get_vf_mac_acl(struct adapter *adapter, unsigned int pf,
+                       unsigned int *naddr, u8 *addr)
+{
+       struct fw_acl_mac_cmd cmd;
+       int ret;
+
+       memset(&cmd, 0, sizeof(cmd));
+       cmd.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_ACL_MAC_CMD) |
+                                   FW_CMD_REQUEST_F |
+                                   FW_CMD_READ_F);
+       cmd.en_to_len16 = cpu_to_be32((unsigned int)FW_LEN16(cmd));
+       ret = t4vf_wr_mbox(adapter, &cmd, sizeof(cmd), &cmd);
+       if (ret)
+               return ret;
+
+       if (cmd.nmac < *naddr)
+               *naddr = cmd.nmac;
+
+       switch (pf) {
+       case 3:
+               memcpy(addr, cmd.macaddr3, sizeof(cmd.macaddr3));
+               break;
+       case 2:
+               memcpy(addr, cmd.macaddr2, sizeof(cmd.macaddr2));
+               break;
+       case 1:
+               memcpy(addr, cmd.macaddr1, sizeof(cmd.macaddr1));
+               break;
+       case 0:
+               memcpy(addr, cmd.macaddr0, sizeof(cmd.macaddr0));
+               break;
+       }
+
+       return ret;
+}