Commit eb690ef8 authored by Alexander Duyck's avatar Alexander Duyck Committed by Jakub Kicinski
Browse files

eth: fbnic: Add L2 address programming 



Program the Rx TCAM to control L2 forwarding. Since we are in full
control of the NIC we need to make sure we include BMC forwarding
in the rules. When host is not present BMC will program the TCAM
to get onto the network but once we take ownership it's up to
Linux driver to make sure BMC L2 addresses are handled correctly.

Co-developed-by: default avatarSanman Pradhan <sanmanpradhan@meta.com>
Signed-off-by: default avatarSanman Pradhan <sanmanpradhan@meta.com>
Signed-off-by: default avatarAlexander Duyck <alexanderduyck@fb.com>
Link: https://patch.msgid.link/172079943202.1778861.4410412697614789017.stgit@ahduyck-xeon-server.home.arpa


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parent a29b8eb6

drivers/net/ethernet/meta/fbnic/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -14,5 +14,6 @@ fbnic-y := fbnic_devlink.o \ 
	   fbnic_netdev.o \

	   fbnic_pci.o \

	   fbnic_phylink.o \

	   fbnic_rpc.o \

	   fbnic_tlv.o \

	   fbnic_txrx.o

drivers/net/ethernet/meta/fbnic/fbnic.h

+5 −0
Original line number Diff line number Diff line
@@ -12,6 +12,7 @@ 
#include "fbnic_csr.h"

#include "fbnic_fw.h"

#include "fbnic_mac.h"

#include "fbnic_rpc.h"



struct fbnic_dev {

	struct device *dev;
@@ -39,6 +40,10 @@ struct fbnic_dev { 
	u32 mps;

	u32 readrq;



	/* Local copy of the devices TCAM */

	struct fbnic_mac_addr mac_addr[FBNIC_RPC_TCAM_MACDA_NUM_ENTRIES];

	u8 mac_addr_boundary;



	/* Number of TCQs/RCQs available on hardware */

	u16 max_num_queues;

};

drivers/net/ethernet/meta/fbnic/fbnic_csr.h

+14 −0
Original line number Diff line number Diff line
@@ -537,8 +537,22 @@ enum { 
#define FBNIC_RPC_RMI_CONFIG_FCS_PRESENT	CSR_BIT(8)

#define FBNIC_RPC_RMI_CONFIG_ENABLE		CSR_BIT(12)

#define FBNIC_RPC_RMI_CONFIG_MTU		CSR_GENMASK(31, 16)

#define FBNIC_RPC_TCAM_MACDA_VALIDATE	0x0852d		/* 0x214b4 */

#define FBNIC_CSR_END_RPC		0x0856b	/* CSR section delimiter */



/* RPC RAM Registers */



#define FBNIC_CSR_START_RPC_RAM		0x08800	/* CSR section delimiter */

#define FBNIC_RPC_ACT_TBL_NUM_ENTRIES		64



/* TCAM Tables */

#define FBNIC_RPC_TCAM_VALIDATE			CSR_BIT(31)

#define FBNIC_RPC_TCAM_MACDA(m, n) \

	(0x08b80 + 0x20 * (n) + (m))		/* 0x022e00 + 128*n + 4*m */

#define FBNIC_RPC_TCAM_MACDA_VALUE		CSR_GENMASK(15, 0)

#define FBNIC_RPC_TCAM_MACDA_MASK		CSR_GENMASK(31, 16)

#define FBNIC_CSR_END_RPC_RAM		0x08f1f	/* CSR section delimiter */



/* Fab Registers */

#define FBNIC_CSR_START_FAB		0x0C000 /* CSR section delimiter */

#define FBNIC_FAB_AXI4_AR_SPACER_2_CFG		0x0C005		/* 0x30014 */

drivers/net/ethernet/meta/fbnic/fbnic_devlink.c

+2 −0
Original line number Diff line number Diff line
@@ -68,6 +68,8 @@ struct fbnic_dev *fbnic_devlink_alloc(struct pci_dev *pdev) 
	fbd->mps = pcie_get_mps(pdev);

	fbd->readrq = pcie_get_readrq(pdev);



	fbd->mac_addr_boundary = FBNIC_RPC_TCAM_MACDA_DEFAULT_BOUNDARY;



	return fbd;

}

drivers/net/ethernet/meta/fbnic/fbnic_netdev.c

+230 −0
Original line number Diff line number Diff line
@@ -48,6 +48,8 @@ int __fbnic_open(struct fbnic_net *fbn) 
	err = fbnic_pcs_irq_enable(fbd);

	if (err)

		goto release_ownership;

	/* Pull the BMC config and initialize the RPC */

	fbnic_bmc_rpc_init(fbd);



	return 0;

release_ownership:
@@ -86,12 +88,240 @@ static int fbnic_stop(struct net_device *netdev) 
	return 0;

}



static int fbnic_uc_sync(struct net_device *netdev, const unsigned char *addr)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	struct fbnic_mac_addr *avail_addr;



	if (WARN_ON(!is_valid_ether_addr(addr)))

		return -EADDRNOTAVAIL;



	avail_addr = __fbnic_uc_sync(fbn->fbd, addr);

	if (!avail_addr)

		return -ENOSPC;



	/* Add type flag indicating this address is in use by the host */

	set_bit(FBNIC_MAC_ADDR_T_UNICAST, avail_addr->act_tcam);



	return 0;

}



static int fbnic_uc_unsync(struct net_device *netdev, const unsigned char *addr)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	struct fbnic_dev *fbd = fbn->fbd;

	int i, ret;



	/* Scan from middle of list to bottom, filling bottom up.

	 * Skip the first entry which is reserved for dev_addr and

	 * leave the last entry to use for promiscuous filtering.

	 */

	for (i = fbd->mac_addr_boundary, ret = -ENOENT;

	     i < FBNIC_RPC_TCAM_MACDA_HOST_ADDR_IDX && ret; i++) {

		struct fbnic_mac_addr *mac_addr = &fbd->mac_addr[i];



		if (!ether_addr_equal(mac_addr->value.addr8, addr))

			continue;



		ret = __fbnic_uc_unsync(mac_addr);

	}



	return ret;

}



static int fbnic_mc_sync(struct net_device *netdev, const unsigned char *addr)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	struct fbnic_mac_addr *avail_addr;



	if (WARN_ON(!is_multicast_ether_addr(addr)))

		return -EADDRNOTAVAIL;



	avail_addr = __fbnic_mc_sync(fbn->fbd, addr);

	if (!avail_addr)

		return -ENOSPC;



	/* Add type flag indicating this address is in use by the host */

	set_bit(FBNIC_MAC_ADDR_T_MULTICAST, avail_addr->act_tcam);



	return 0;

}



static int fbnic_mc_unsync(struct net_device *netdev, const unsigned char *addr)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	struct fbnic_dev *fbd = fbn->fbd;

	int i, ret;



	/* Scan from middle of list to top, filling top down.

	 * Skip over the address reserved for the BMC MAC and

	 * exclude index 0 as that belongs to the broadcast address

	 */

	for (i = fbd->mac_addr_boundary, ret = -ENOENT;

	     --i > FBNIC_RPC_TCAM_MACDA_BROADCAST_IDX && ret;) {

		struct fbnic_mac_addr *mac_addr = &fbd->mac_addr[i];



		if (!ether_addr_equal(mac_addr->value.addr8, addr))

			continue;



		ret = __fbnic_mc_unsync(mac_addr);

	}



	return ret;

}



void __fbnic_set_rx_mode(struct net_device *netdev)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	bool uc_promisc = false, mc_promisc = false;

	struct fbnic_dev *fbd = fbn->fbd;

	struct fbnic_mac_addr *mac_addr;

	int err;



	/* Populate host address from dev_addr */

	mac_addr = &fbd->mac_addr[FBNIC_RPC_TCAM_MACDA_HOST_ADDR_IDX];

	if (!ether_addr_equal(mac_addr->value.addr8, netdev->dev_addr) ||

	    mac_addr->state != FBNIC_TCAM_S_VALID) {

		ether_addr_copy(mac_addr->value.addr8, netdev->dev_addr);

		mac_addr->state = FBNIC_TCAM_S_UPDATE;

		set_bit(FBNIC_MAC_ADDR_T_UNICAST, mac_addr->act_tcam);

	}



	/* Populate broadcast address if broadcast is enabled */

	mac_addr = &fbd->mac_addr[FBNIC_RPC_TCAM_MACDA_BROADCAST_IDX];

	if (netdev->flags & IFF_BROADCAST) {

		if (!is_broadcast_ether_addr(mac_addr->value.addr8) ||

		    mac_addr->state != FBNIC_TCAM_S_VALID) {

			eth_broadcast_addr(mac_addr->value.addr8);

			mac_addr->state = FBNIC_TCAM_S_ADD;

		}

		set_bit(FBNIC_MAC_ADDR_T_BROADCAST, mac_addr->act_tcam);

	} else if (mac_addr->state == FBNIC_TCAM_S_VALID) {

		__fbnic_xc_unsync(mac_addr, FBNIC_MAC_ADDR_T_BROADCAST);

	}



	/* Synchronize unicast and multicast address lists */

	err = __dev_uc_sync(netdev, fbnic_uc_sync, fbnic_uc_unsync);

	if (err == -ENOSPC)

		uc_promisc = true;

	err = __dev_mc_sync(netdev, fbnic_mc_sync, fbnic_mc_unsync);

	if (err == -ENOSPC)

		mc_promisc = true;



	uc_promisc |= !!(netdev->flags & IFF_PROMISC);

	mc_promisc |= !!(netdev->flags & IFF_ALLMULTI) || uc_promisc;



	/* Populate last TCAM entry with promiscuous entry and 0/1 bit mask */

	mac_addr = &fbd->mac_addr[FBNIC_RPC_TCAM_MACDA_PROMISC_IDX];

	if (uc_promisc) {

		if (!is_zero_ether_addr(mac_addr->value.addr8) ||

		    mac_addr->state != FBNIC_TCAM_S_VALID) {

			eth_zero_addr(mac_addr->value.addr8);

			eth_broadcast_addr(mac_addr->mask.addr8);

			clear_bit(FBNIC_MAC_ADDR_T_ALLMULTI,

				  mac_addr->act_tcam);

			set_bit(FBNIC_MAC_ADDR_T_PROMISC,

				mac_addr->act_tcam);

			mac_addr->state = FBNIC_TCAM_S_ADD;

		}

	} else if (mc_promisc &&

		   (!fbnic_bmc_present(fbd) || !fbd->fw_cap.all_multi)) {

		/* We have to add a special handler for multicast as the

		 * BMC may have an all-multi rule already in place. As such

		 * adding a rule ourselves won't do any good so we will have

		 * to modify the rules for the ALL MULTI below if the BMC

		 * already has the rule in place.

		 */

		if (!is_multicast_ether_addr(mac_addr->value.addr8) ||

		    mac_addr->state != FBNIC_TCAM_S_VALID) {

			eth_zero_addr(mac_addr->value.addr8);

			eth_broadcast_addr(mac_addr->mask.addr8);

			mac_addr->value.addr8[0] ^= 1;

			mac_addr->mask.addr8[0] ^= 1;

			set_bit(FBNIC_MAC_ADDR_T_ALLMULTI,

				mac_addr->act_tcam);

			clear_bit(FBNIC_MAC_ADDR_T_PROMISC,

				  mac_addr->act_tcam);

			mac_addr->state = FBNIC_TCAM_S_ADD;

		}

	} else if (mac_addr->state == FBNIC_TCAM_S_VALID) {

		if (test_bit(FBNIC_MAC_ADDR_T_BMC, mac_addr->act_tcam)) {

			clear_bit(FBNIC_MAC_ADDR_T_ALLMULTI,

				  mac_addr->act_tcam);

			clear_bit(FBNIC_MAC_ADDR_T_PROMISC,

				  mac_addr->act_tcam);

		} else {

			mac_addr->state = FBNIC_TCAM_S_DELETE;

		}

	}



	/* Add rules for BMC all multicast if it is enabled */

	fbnic_bmc_rpc_all_multi_config(fbd, mc_promisc);



	/* Sift out any unshared BMC rules and place them in BMC only section */

	fbnic_sift_macda(fbd);



	/* Write updates to hardware */

	fbnic_write_macda(fbd);

}



static void fbnic_set_rx_mode(struct net_device *netdev)

{

	/* No need to update the hardware if we are not running */

	if (netif_running(netdev))

		__fbnic_set_rx_mode(netdev);

}



static int fbnic_set_mac(struct net_device *netdev, void *p)

{

	struct sockaddr *addr = p;



	if (!is_valid_ether_addr(addr->sa_data))

		return -EADDRNOTAVAIL;



	eth_hw_addr_set(netdev, addr->sa_data);



	fbnic_set_rx_mode(netdev);



	return 0;

}



void fbnic_clear_rx_mode(struct net_device *netdev)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	struct fbnic_dev *fbd = fbn->fbd;

	int idx;



	for (idx = ARRAY_SIZE(fbd->mac_addr); idx--;) {

		struct fbnic_mac_addr *mac_addr = &fbd->mac_addr[idx];



		if (mac_addr->state != FBNIC_TCAM_S_VALID)

			continue;



		bitmap_clear(mac_addr->act_tcam,

			     FBNIC_MAC_ADDR_T_HOST_START,

			     FBNIC_MAC_ADDR_T_HOST_LEN);



		if (bitmap_empty(mac_addr->act_tcam,

				 FBNIC_RPC_TCAM_ACT_NUM_ENTRIES))

			mac_addr->state = FBNIC_TCAM_S_DELETE;

	}



	/* Write updates to hardware */

	fbnic_write_macda(fbd);



	__dev_uc_unsync(netdev, NULL);

	__dev_mc_unsync(netdev, NULL);

}



static const struct net_device_ops fbnic_netdev_ops = {

	.ndo_open		= fbnic_open,

	.ndo_stop		= fbnic_stop,

	.ndo_validate_addr	= eth_validate_addr,

	.ndo_start_xmit		= fbnic_xmit_frame,

	.ndo_features_check	= fbnic_features_check,

	.ndo_set_mac_address	= fbnic_set_mac,

	.ndo_set_rx_mode	= fbnic_set_rx_mode,

};



void fbnic_reset_queues(struct fbnic_net *fbn,