drivers/net/ethernet/microchip/lan966x/lan966x_mac.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0+

 #include <net/switchdev.h>
 #include "lan966x_main.h"

 #define LAN966X_MAC_COLUMNS		4
 #define MACACCESS_CMD_IDLE		0
 #define MACACCESS_CMD_LEARN		1
 #define MACACCESS_CMD_FORGET		2
 #define MACACCESS_CMD_AGE		3
 #define MACACCESS_CMD_GET_NEXT		4
 #define MACACCESS_CMD_INIT		5
 #define MACACCESS_CMD_READ		6
 #define MACACCESS_CMD_WRITE		7
 #define MACACCESS_CMD_SYNC_GET_NEXT	8

 #define LAN966X_MAC_INVALID_ROW		-1

 struct lan966x_mac_entry {
 	struct list_head list;
 	unsigned char mac[ETH_ALEN] __aligned(2);
 	u16 vid;
 	u16 port_index;
 	int row;
 	bool lag;
 };

 struct lan966x_mac_raw_entry {
 	u32 mach;
 	u32 macl;
 	u32 maca;
 	bool processed;
 };

 static int lan966x_mac_get_status(struct lan966x *lan966x)
 {
 	return lan_rd(lan966x, ANA_MACACCESS);
 }

 static int lan966x_mac_wait_for_completion(struct lan966x *lan966x)
 {
 	u32 val;

 	return readx_poll_timeout_atomic(lan966x_mac_get_status,
 					 lan966x, val,
 					 (ANA_MACACCESS_MAC_TABLE_CMD_GET(val)) ==
 					 MACACCESS_CMD_IDLE,
 					 TABLE_UPDATE_SLEEP_US,
 					 TABLE_UPDATE_TIMEOUT_US);
 }

 static void lan966x_mac_select(struct lan966x *lan966x,
 			       const unsigned char mac[ETH_ALEN],
 			       unsigned int vid)
 {
 	u32 macl = 0, mach = 0;

 	/* Set the MAC address to handle and the vlan associated in a format
 	 * understood by the hardware.
 	 */
 	mach |= vid    << 16;
 	mach |= mac[0] << 8;
 	mach |= mac[1] << 0;
 	macl |= mac[2] << 24;
 	macl |= mac[3] << 16;
 	macl |= mac[4] << 8;
 	macl |= mac[5] << 0;

 	lan_wr(macl, lan966x, ANA_MACLDATA);
 	lan_wr(mach, lan966x, ANA_MACHDATA);
 }

 static int __lan966x_mac_learn_locked(struct lan966x *lan966x, int pgid,
 				      bool cpu_copy,
 				      const unsigned char mac[ETH_ALEN],
 				      unsigned int vid,
 				      enum macaccess_entry_type type)
 {
 	lockdep_assert_held(&lan966x->mac_lock);

 	lan966x_mac_select(lan966x, mac, vid);

 	/* Issue a write command */
 	lan_wr(ANA_MACACCESS_VALID_SET(1) |
 	       ANA_MACACCESS_CHANGE2SW_SET(0) |
 	       ANA_MACACCESS_MAC_CPU_COPY_SET(cpu_copy) |
 	       ANA_MACACCESS_DEST_IDX_SET(pgid) |
 	       ANA_MACACCESS_ENTRYTYPE_SET(type) |
 	       ANA_MACACCESS_MAC_TABLE_CMD_SET(MACACCESS_CMD_LEARN),
 	       lan966x, ANA_MACACCESS);

 	return lan966x_mac_wait_for_completion(lan966x);
 }

 static int __lan966x_mac_learn(struct lan966x *lan966x, int pgid,
 			       bool cpu_copy,
 			       const unsigned char mac[ETH_ALEN],
 			       unsigned int vid,
 			       enum macaccess_entry_type type)
 {
 	int ret;

 	spin_lock(&lan966x->mac_lock);
 	ret = __lan966x_mac_learn_locked(lan966x, pgid, cpu_copy, mac, vid, type);
 	spin_unlock(&lan966x->mac_lock);

 	return ret;
 }

 /* The mask of the front ports is encoded inside the mac parameter via a call
  * to lan966x_mdb_encode_mac().
  */
 int lan966x_mac_ip_learn(struct lan966x *lan966x,
 			 bool cpu_copy,
 			 const unsigned char mac[ETH_ALEN],
 			 unsigned int vid,
 			 enum macaccess_entry_type type)
 {
 	WARN_ON(type != ENTRYTYPE_MACV4 && type != ENTRYTYPE_MACV6);

 	return __lan966x_mac_learn(lan966x, 0, cpu_copy, mac, vid, type);
 }

 int lan966x_mac_learn(struct lan966x *lan966x, int port,
 		      const unsigned char mac[ETH_ALEN],
 		      unsigned int vid,
 		      enum macaccess_entry_type type)
 {
 	WARN_ON(type != ENTRYTYPE_NORMAL && type != ENTRYTYPE_LOCKED);

 	return __lan966x_mac_learn(lan966x, port, false, mac, vid, type);
 }

 static int lan966x_mac_learn_locked(struct lan966x *lan966x, int port,
 				    const unsigned char mac[ETH_ALEN],
 				    unsigned int vid,
 				    enum macaccess_entry_type type)
 {
 	WARN_ON(type != ENTRYTYPE_NORMAL && type != ENTRYTYPE_LOCKED);

 	return __lan966x_mac_learn_locked(lan966x, port, false, mac, vid, type);
 }

 static int lan966x_mac_forget_locked(struct lan966x *lan966x,
 				     const unsigned char mac[ETH_ALEN],
 				     unsigned int vid,
 				     enum macaccess_entry_type type)
 {
 	lockdep_assert_held(&lan966x->mac_lock);

 	lan966x_mac_select(lan966x, mac, vid);

 	/* Issue a forget command */
 	lan_wr(ANA_MACACCESS_ENTRYTYPE_SET(type) |
 	       ANA_MACACCESS_MAC_TABLE_CMD_SET(MACACCESS_CMD_FORGET),
 	       lan966x, ANA_MACACCESS);

 	return lan966x_mac_wait_for_completion(lan966x);
 }

 int lan966x_mac_forget(struct lan966x *lan966x,
 		       const unsigned char mac[ETH_ALEN],
 		       unsigned int vid,
 		       enum macaccess_entry_type type)
 {
 	int ret;

 	spin_lock(&lan966x->mac_lock);
 	ret = lan966x_mac_forget_locked(lan966x, mac, vid, type);
 	spin_unlock(&lan966x->mac_lock);

 	return ret;
 }

 int lan966x_mac_cpu_learn(struct lan966x *lan966x, const char *addr, u16 vid)
 {
 	return lan966x_mac_learn(lan966x, PGID_CPU, addr, vid, ENTRYTYPE_LOCKED);
 }

 int lan966x_mac_cpu_forget(struct lan966x *lan966x, const char *addr, u16 vid)
 {
 	return lan966x_mac_forget(lan966x, addr, vid, ENTRYTYPE_LOCKED);
 }

 void lan966x_mac_set_ageing(struct lan966x *lan966x,
 			    u32 ageing)
 {
 	lan_rmw(ANA_AUTOAGE_AGE_PERIOD_SET(ageing / 2),
 		ANA_AUTOAGE_AGE_PERIOD,
 		lan966x, ANA_AUTOAGE);
 }

 void lan966x_mac_init(struct lan966x *lan966x)
 {
 	/* Clear the MAC table */
 	lan_wr(MACACCESS_CMD_INIT, lan966x, ANA_MACACCESS);
 	lan966x_mac_wait_for_completion(lan966x);

 	spin_lock_init(&lan966x->mac_lock);
 	INIT_LIST_HEAD(&lan966x->mac_entries);
 }

 static struct lan966x_mac_entry *lan966x_mac_alloc_entry(struct lan966x_port *port,
 							 const unsigned char *mac,
 							 u16 vid)
 {
 	struct lan966x_mac_entry *mac_entry;

 	mac_entry = kzalloc(sizeof(*mac_entry), GFP_ATOMIC);
 	if (!mac_entry)
 		return NULL;

 	memcpy(mac_entry->mac, mac, ETH_ALEN);
 	mac_entry->vid = vid;
 	mac_entry->port_index = port->chip_port;
 	mac_entry->row = LAN966X_MAC_INVALID_ROW;
 	mac_entry->lag = port->bond ? true : false;
 	return mac_entry;
 }

 static struct lan966x_mac_entry *lan966x_mac_find_entry(struct lan966x *lan966x,
 							const unsigned char *mac,
 							u16 vid, u16 port_index)
 {
 	struct lan966x_mac_entry *res = NULL;
 	struct lan966x_mac_entry *mac_entry;

 	list_for_each_entry(mac_entry, &lan966x->mac_entries, list) {
 		if (mac_entry->vid == vid &&
 		    ether_addr_equal(mac, mac_entry->mac) &&
 		    mac_entry->port_index == port_index) {
 			res = mac_entry;
 			break;
 		}
 	}

 	return res;
 }

 static int lan966x_mac_lookup(struct lan966x *lan966x,
 			      const unsigned char mac[ETH_ALEN],
 			      unsigned int vid, enum macaccess_entry_type type)
 {
 	int ret;

 	lan966x_mac_select(lan966x, mac, vid);

 	/* Issue a read command */
 	lan_wr(ANA_MACACCESS_ENTRYTYPE_SET(type) |
 	       ANA_MACACCESS_VALID_SET(1) |
 	       ANA_MACACCESS_MAC_TABLE_CMD_SET(MACACCESS_CMD_READ),
 	       lan966x, ANA_MACACCESS);

 	ret = lan966x_mac_wait_for_completion(lan966x);
 	if (ret)
 		return ret;

 	return ANA_MACACCESS_VALID_GET(lan_rd(lan966x, ANA_MACACCESS));
 }

 static void lan966x_fdb_call_notifiers(enum switchdev_notifier_type type,
 				       const char *mac, u16 vid,
 				       struct net_device *dev)
 {
 	struct switchdev_notifier_fdb_info info = { 0 };

 	info.addr = mac;
 	info.vid = vid;
 	info.offloaded = true;
 	call_switchdev_notifiers(type, dev, &info.info, NULL);
 }

 int lan966x_mac_add_entry(struct lan966x *lan966x, struct lan966x_port *port,
 			  const unsigned char *addr, u16 vid)
 {
 	struct lan966x_mac_entry *mac_entry;

 	spin_lock(&lan966x->mac_lock);
 	if (lan966x_mac_lookup(lan966x, addr, vid, ENTRYTYPE_NORMAL)) {
 		spin_unlock(&lan966x->mac_lock);
 		return 0;
 	}

 	/* In case the entry already exists, don't add it again to SW,
 	 * just update HW, but we need to look in the actual HW because
 	 * it is possible for an entry to be learn by HW and before we
 	 * get the interrupt the frame will reach CPU and the CPU will
 	 * add the entry but without the extern_learn flag.
 	 */
 	mac_entry = lan966x_mac_find_entry(lan966x, addr, vid, port->chip_port);
 	if (mac_entry) {
 		spin_unlock(&lan966x->mac_lock);
 		goto mac_learn;
 	}

 	mac_entry = lan966x_mac_alloc_entry(port, addr, vid);
 	if (!mac_entry) {
 		spin_unlock(&lan966x->mac_lock);
 		return -ENOMEM;
 	}

 	list_add_tail(&mac_entry->list, &lan966x->mac_entries);
 	spin_unlock(&lan966x->mac_lock);

 	lan966x_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED, addr, vid,
 				   port->bond ?: port->dev);

 mac_learn:
 	lan966x_mac_learn(lan966x, port->chip_port, addr, vid, ENTRYTYPE_LOCKED);

 	return 0;
 }

 int lan966x_mac_del_entry(struct lan966x *lan966x, const unsigned char *addr,
 			  u16 vid)
 {
 	struct lan966x_mac_entry *mac_entry, *tmp;

 	spin_lock(&lan966x->mac_lock);
 	list_for_each_entry_safe(mac_entry, tmp, &lan966x->mac_entries,
 				 list) {
 		if (mac_entry->vid == vid &&
 		    ether_addr_equal(addr, mac_entry->mac)) {
 			lan966x_mac_forget_locked(lan966x, mac_entry->mac,
 						  mac_entry->vid,
 						  ENTRYTYPE_LOCKED);

 			list_del(&mac_entry->list);
 			kfree(mac_entry);
 		}
 	}
 	spin_unlock(&lan966x->mac_lock);

 	return 0;
 }

 void lan966x_mac_lag_replace_port_entry(struct lan966x *lan966x,
 					struct lan966x_port *src,
 					struct lan966x_port *dst)
 {
 	struct lan966x_mac_entry *mac_entry;

 	spin_lock(&lan966x->mac_lock);
 	list_for_each_entry(mac_entry, &lan966x->mac_entries, list) {
 		if (mac_entry->port_index == src->chip_port &&
 		    mac_entry->lag) {
 			lan966x_mac_forget_locked(lan966x, mac_entry->mac,
 						  mac_entry->vid,
 						  ENTRYTYPE_LOCKED);

 			lan966x_mac_learn_locked(lan966x, dst->chip_port,
 						 mac_entry->mac, mac_entry->vid,
 						 ENTRYTYPE_LOCKED);
 			mac_entry->port_index = dst->chip_port;
 		}
 	}
 	spin_unlock(&lan966x->mac_lock);
 }

 void lan966x_mac_lag_remove_port_entry(struct lan966x *lan966x,
 				       struct lan966x_port *src)
 {
 	struct lan966x_mac_entry *mac_entry, *tmp;

 	spin_lock(&lan966x->mac_lock);
 	list_for_each_entry_safe(mac_entry, tmp, &lan966x->mac_entries,
 				 list) {
 		if (mac_entry->port_index == src->chip_port &&
 		    mac_entry->lag) {
 			lan966x_mac_forget_locked(lan966x, mac_entry->mac,
 						  mac_entry->vid,
 						  ENTRYTYPE_LOCKED);

 			list_del(&mac_entry->list);
 			kfree(mac_entry);
 		}
 	}
 	spin_unlock(&lan966x->mac_lock);
 }

 void lan966x_mac_purge_entries(struct lan966x *lan966x)
 {
 	struct lan966x_mac_entry *mac_entry, *tmp;

 	spin_lock(&lan966x->mac_lock);
 	list_for_each_entry_safe(mac_entry, tmp, &lan966x->mac_entries,
 				 list) {
 		lan966x_mac_forget_locked(lan966x, mac_entry->mac,
 					  mac_entry->vid, ENTRYTYPE_LOCKED);

 		list_del(&mac_entry->list);
 		kfree(mac_entry);
 	}
 	spin_unlock(&lan966x->mac_lock);
 }

 static void lan966x_mac_notifiers(enum switchdev_notifier_type type,
 				  unsigned char *mac, u32 vid,
 				  struct net_device *dev)
 {
 	rtnl_lock();
 	lan966x_fdb_call_notifiers(type, mac, vid, dev);
 	rtnl_unlock();
 }

 static void lan966x_mac_process_raw_entry(struct lan966x_mac_raw_entry *raw_entry,
 					  u8 *mac, u16 *vid, u32 *dest_idx)
 {
 	mac[0] = (raw_entry->mach >> 8)  & 0xff;
 	mac[1] = (raw_entry->mach >> 0)  & 0xff;
 	mac[2] = (raw_entry->macl >> 24) & 0xff;
 	mac[3] = (raw_entry->macl >> 16) & 0xff;
 	mac[4] = (raw_entry->macl >> 8)  & 0xff;
 	mac[5] = (raw_entry->macl >> 0)  & 0xff;

 	*vid = (raw_entry->mach >> 16) & 0xfff;
 	*dest_idx = ANA_MACACCESS_DEST_IDX_GET(raw_entry->maca);
 }

 static void lan966x_mac_irq_process(struct lan966x *lan966x, u32 row,
 				    struct lan966x_mac_raw_entry *raw_entries)
 {
 	struct lan966x_mac_entry *mac_entry, *tmp;
 	unsigned char mac[ETH_ALEN] __aligned(2);
 	struct list_head mac_deleted_entries;
 	struct lan966x_port *port;
 	u32 dest_idx;
 	u32 column;
 	u16 vid;

 	INIT_LIST_HEAD(&mac_deleted_entries);

 	spin_lock(&lan966x->mac_lock);
 	list_for_each_entry_safe(mac_entry, tmp, &lan966x->mac_entries, list) {
 		bool found = false;

 		if (mac_entry->row != row)
 			continue;

 		for (column = 0; column < LAN966X_MAC_COLUMNS; ++column) {
 			/* All the valid entries are at the start of the row,
 			 * so when get one invalid entry it can just skip the
 			 * rest of the columns
 			 */
 			if (!ANA_MACACCESS_VALID_GET(raw_entries[column].maca))
 				break;

 			lan966x_mac_process_raw_entry(&raw_entries[column],
 						      mac, &vid, &dest_idx);
 			if (WARN_ON(dest_idx >= lan966x->num_phys_ports))
 				continue;

 			/* If the entry in SW is found, then there is nothing
 			 * to do
 			 */
 			if (mac_entry->vid == vid &&
 			    ether_addr_equal(mac_entry->mac, mac) &&
 			    mac_entry->port_index == dest_idx) {
 				raw_entries[column].processed = true;
 				found = true;
 				break;
 			}
 		}

 		if (!found) {
 			list_del(&mac_entry->list);
 			/* Move the entry from SW list to a tmp list such that
 			 * it would be deleted later
 			 */
 			list_add_tail(&mac_entry->list, &mac_deleted_entries);
 		}
 	}
 	spin_unlock(&lan966x->mac_lock);

 	list_for_each_entry_safe(mac_entry, tmp, &mac_deleted_entries, list) {
 		/* Notify the bridge that the entry doesn't exist
 		 * anymore in the HW
 		 */
 		port = lan966x->ports[mac_entry->port_index];
 		lan966x_mac_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE,
 				      mac_entry->mac, mac_entry->vid,
 				      port->bond ?: port->dev);
 		list_del(&mac_entry->list);
 		kfree(mac_entry);
 	}

 	/* Now go to the list of columns and see if any entry was not in the SW
 	 * list, then that means that the entry is new so it needs to notify the
 	 * bridge.
 	 */
 	for (column = 0; column < LAN966X_MAC_COLUMNS; ++column) {
 		/* All the valid entries are at the start of the row, so when
 		 * get one invalid entry it can just skip the rest of the columns
 		 */
 		if (!ANA_MACACCESS_VALID_GET(raw_entries[column].maca))
 			break;

 		/* If the entry already exists then don't do anything */
 		if (raw_entries[column].processed)
 			continue;

 		lan966x_mac_process_raw_entry(&raw_entries[column],
 					      mac, &vid, &dest_idx);
 		if (WARN_ON(dest_idx >= lan966x->num_phys_ports))
 			continue;

 		spin_lock(&lan966x->mac_lock);
 		mac_entry = lan966x_mac_find_entry(lan966x, mac, vid, dest_idx);
 		if (mac_entry) {
 			spin_unlock(&lan966x->mac_lock);
 			continue;
 		}

 		port = lan966x->ports[dest_idx];
 		mac_entry = lan966x_mac_alloc_entry(port, mac, vid);
 		if (!mac_entry) {
 			spin_unlock(&lan966x->mac_lock);
 			return;
 		}

 		mac_entry->row = row;
 		list_add_tail(&mac_entry->list, &lan966x->mac_entries);
 		spin_unlock(&lan966x->mac_lock);

 		lan966x_mac_notifiers(SWITCHDEV_FDB_ADD_TO_BRIDGE,
 				      mac, vid, port->bond ?: port->dev);
 	}
 }

 irqreturn_t lan966x_mac_irq_handler(struct lan966x *lan966x)
 {
 	struct lan966x_mac_raw_entry entry[LAN966X_MAC_COLUMNS] = { 0 };
 	u32 index, column;
 	bool stop = true;
 	u32 val;

 	/* Start the scan from 0, 0 */
 	lan_wr(ANA_MACTINDX_M_INDEX_SET(0) |
 	       ANA_MACTINDX_BUCKET_SET(0),
 	       lan966x, ANA_MACTINDX);

 	while (1) {
 		spin_lock(&lan966x->mac_lock);
 		lan_rmw(ANA_MACACCESS_MAC_TABLE_CMD_SET(MACACCESS_CMD_SYNC_GET_NEXT),
 			ANA_MACACCESS_MAC_TABLE_CMD,
 			lan966x, ANA_MACACCESS);
 		lan966x_mac_wait_for_completion(lan966x);

 		val = lan_rd(lan966x, ANA_MACTINDX);
 		index = ANA_MACTINDX_M_INDEX_GET(val);
 		column = ANA_MACTINDX_BUCKET_GET(val);

 		/* The SYNC-GET-NEXT returns all the entries(4) in a row in
 		 * which is suffered a change. By change it means that new entry
 		 * was added or an entry was removed because of ageing.
 		 * It would return all the columns for that row. And after that
 		 * it would return the next row The stop conditions of the
 		 * SYNC-GET-NEXT is when it reaches 'directly' to row 0
 		 * column 3. So if SYNC-GET-NEXT returns row 0 and column 0
 		 * then it is required to continue to read more even if it
 		 * reaches row 0 and column 3.
 		 */
 		if (index == 0 && column == 0)
 			stop = false;

 		if (column == LAN966X_MAC_COLUMNS - 1 &&
 		    index == 0 && stop) {
 			spin_unlock(&lan966x->mac_lock);
 			break;
 		}

 		entry[column].mach = lan_rd(lan966x, ANA_MACHDATA);
 		entry[column].macl = lan_rd(lan966x, ANA_MACLDATA);
 		entry[column].maca = lan_rd(lan966x, ANA_MACACCESS);
 		spin_unlock(&lan966x->mac_lock);

 		/* Once all the columns are read process them */
 		if (column == LAN966X_MAC_COLUMNS - 1) {
 			lan966x_mac_irq_process(lan966x, index, entry);
 			/* A row was processed so it is safe to assume that the
 			 * next row/column can be the stop condition
 			 */
 			stop = true;
 		}
 	}

 	lan_rmw(ANA_ANAINTR_INTR_SET(0),
 		ANA_ANAINTR_INTR,
 		lan966x, ANA_ANAINTR);

 	return IRQ_HANDLED;
 }
	// SPDX-License-Identifier: GPL-2.0+

	#include <net/switchdev.h>
	#include "lan966x_main.h"

	#define LAN966X_MAC_COLUMNS 4
	#define MACACCESS_CMD_IDLE 0
	#define MACACCESS_CMD_LEARN 1
	#define MACACCESS_CMD_FORGET 2
	#define MACACCESS_CMD_AGE 3
	#define MACACCESS_CMD_GET_NEXT 4
	#define MACACCESS_CMD_INIT 5
	#define MACACCESS_CMD_READ 6
	#define MACACCESS_CMD_WRITE 7
	#define MACACCESS_CMD_SYNC_GET_NEXT 8

	#define LAN966X_MAC_INVALID_ROW -1

	struct lan966x_mac_entry {
	struct list_head list;
	unsigned char mac[ETH_ALEN] __aligned(2);
	u16 vid;
	u16 port_index;
	int row;
	bool lag;
	};

	struct lan966x_mac_raw_entry {
	u32 mach;
	u32 macl;
	u32 maca;
	bool processed;
	};

	static int lan966x_mac_get_status(struct lan966x *lan966x)
	{
	return lan_rd(lan966x, ANA_MACACCESS);
	}

	static int lan966x_mac_wait_for_completion(struct lan966x *lan966x)
	{
	u32 val;

	return readx_poll_timeout_atomic(lan966x_mac_get_status,
	lan966x, val,
	(ANA_MACACCESS_MAC_TABLE_CMD_GET(val)) ==
	MACACCESS_CMD_IDLE,
	TABLE_UPDATE_SLEEP_US,
	TABLE_UPDATE_TIMEOUT_US);
	}

	static void lan966x_mac_select(struct lan966x *lan966x,
	const unsigned char mac[ETH_ALEN],
	unsigned int vid)
	{
	u32 macl = 0, mach = 0;

	/* Set the MAC address to handle and the vlan associated in a format
	* understood by the hardware.
	*/
	mach \|= vid << 16;
	mach \|= mac[0] << 8;
	mach \|= mac[1] << 0;
	macl \|= mac[2] << 24;
	macl \|= mac[3] << 16;
	macl \|= mac[4] << 8;
	macl \|= mac[5] << 0;

	lan_wr(macl, lan966x, ANA_MACLDATA);
	lan_wr(mach, lan966x, ANA_MACHDATA);
	}

	static int __lan966x_mac_learn_locked(struct lan966x *lan966x, int pgid,
	bool cpu_copy,
	const unsigned char mac[ETH_ALEN],
	unsigned int vid,
	enum macaccess_entry_type type)
	{
	lockdep_assert_held(&lan966x->mac_lock);

	lan966x_mac_select(lan966x, mac, vid);

	/* Issue a write command */
	lan_wr(ANA_MACACCESS_VALID_SET(1) \|
	ANA_MACACCESS_CHANGE2SW_SET(0) \|
	ANA_MACACCESS_MAC_CPU_COPY_SET(cpu_copy) \|
	ANA_MACACCESS_DEST_IDX_SET(pgid) \|
	ANA_MACACCESS_ENTRYTYPE_SET(type) \|
	ANA_MACACCESS_MAC_TABLE_CMD_SET(MACACCESS_CMD_LEARN),
	lan966x, ANA_MACACCESS);

	return lan966x_mac_wait_for_completion(lan966x);
	}

	static int __lan966x_mac_learn(struct lan966x *lan966x, int pgid,
	bool cpu_copy,
	const unsigned char mac[ETH_ALEN],
	unsigned int vid,
	enum macaccess_entry_type type)
	{
	int ret;

	spin_lock(&lan966x->mac_lock);
	ret = __lan966x_mac_learn_locked(lan966x, pgid, cpu_copy, mac, vid, type);
	spin_unlock(&lan966x->mac_lock);

	return ret;
	}

	/* The mask of the front ports is encoded inside the mac parameter via a call
	* to lan966x_mdb_encode_mac().
	*/
	int lan966x_mac_ip_learn(struct lan966x *lan966x,
	bool cpu_copy,
	const unsigned char mac[ETH_ALEN],
	unsigned int vid,
	enum macaccess_entry_type type)
	{
	WARN_ON(type != ENTRYTYPE_MACV4 && type != ENTRYTYPE_MACV6);

	return __lan966x_mac_learn(lan966x, 0, cpu_copy, mac, vid, type);
	}

	int lan966x_mac_learn(struct lan966x *lan966x, int port,
	const unsigned char mac[ETH_ALEN],
	unsigned int vid,
	enum macaccess_entry_type type)
	{
	WARN_ON(type != ENTRYTYPE_NORMAL && type != ENTRYTYPE_LOCKED);

	return __lan966x_mac_learn(lan966x, port, false, mac, vid, type);
	}

	static int lan966x_mac_learn_locked(struct lan966x *lan966x, int port,
	const unsigned char mac[ETH_ALEN],
	unsigned int vid,
	enum macaccess_entry_type type)
	{
	WARN_ON(type != ENTRYTYPE_NORMAL && type != ENTRYTYPE_LOCKED);

	return __lan966x_mac_learn_locked(lan966x, port, false, mac, vid, type);
	}

	static int lan966x_mac_forget_locked(struct lan966x *lan966x,
	const unsigned char mac[ETH_ALEN],
	unsigned int vid,
	enum macaccess_entry_type type)
	{
	lockdep_assert_held(&lan966x->mac_lock);

	lan966x_mac_select(lan966x, mac, vid);

	/* Issue a forget command */
	lan_wr(ANA_MACACCESS_ENTRYTYPE_SET(type) \|
	ANA_MACACCESS_MAC_TABLE_CMD_SET(MACACCESS_CMD_FORGET),
	lan966x, ANA_MACACCESS);

	return lan966x_mac_wait_for_completion(lan966x);
	}

	int lan966x_mac_forget(struct lan966x *lan966x,
	const unsigned char mac[ETH_ALEN],
	unsigned int vid,
	enum macaccess_entry_type type)
	{
	int ret;

	spin_lock(&lan966x->mac_lock);
	ret = lan966x_mac_forget_locked(lan966x, mac, vid, type);
	spin_unlock(&lan966x->mac_lock);

	return ret;
	}

	int lan966x_mac_cpu_learn(struct lan966x lan966x, const char addr, u16 vid)
	{
	return lan966x_mac_learn(lan966x, PGID_CPU, addr, vid, ENTRYTYPE_LOCKED);
	}

	int lan966x_mac_cpu_forget(struct lan966x lan966x, const char addr, u16 vid)
	{
	return lan966x_mac_forget(lan966x, addr, vid, ENTRYTYPE_LOCKED);
	}

	void lan966x_mac_set_ageing(struct lan966x *lan966x,
	u32 ageing)
	{
	lan_rmw(ANA_AUTOAGE_AGE_PERIOD_SET(ageing / 2),
	ANA_AUTOAGE_AGE_PERIOD,
	lan966x, ANA_AUTOAGE);
	}

	void lan966x_mac_init(struct lan966x *lan966x)
	{
	/* Clear the MAC table */
	lan_wr(MACACCESS_CMD_INIT, lan966x, ANA_MACACCESS);
	lan966x_mac_wait_for_completion(lan966x);

	spin_lock_init(&lan966x->mac_lock);
	INIT_LIST_HEAD(&lan966x->mac_entries);
	}

	static struct lan966x_mac_entry lan966x_mac_alloc_entry(struct lan966x_port port,
	const unsigned char *mac,
	u16 vid)
	{
	struct lan966x_mac_entry *mac_entry;

	mac_entry = kzalloc(sizeof(*mac_entry), GFP_ATOMIC);
	if (!mac_entry)
	return NULL;

	memcpy(mac_entry->mac, mac, ETH_ALEN);
	mac_entry->vid = vid;
	mac_entry->port_index = port->chip_port;
	mac_entry->row = LAN966X_MAC_INVALID_ROW;
	mac_entry->lag = port->bond ? true : false;
	return mac_entry;
	}

	static struct lan966x_mac_entry lan966x_mac_find_entry(struct lan966x lan966x,
	const unsigned char *mac,
	u16 vid, u16 port_index)
	{
	struct lan966x_mac_entry *res = NULL;
	struct lan966x_mac_entry *mac_entry;

	list_for_each_entry(mac_entry, &lan966x->mac_entries, list) {
	if (mac_entry->vid == vid &&
	ether_addr_equal(mac, mac_entry->mac) &&
	mac_entry->port_index == port_index) {
	res = mac_entry;
	break;
	}
	}

	return res;
	}

	static int lan966x_mac_lookup(struct lan966x *lan966x,
	const unsigned char mac[ETH_ALEN],
	unsigned int vid, enum macaccess_entry_type type)
	{
	int ret;

	lan966x_mac_select(lan966x, mac, vid);

	/* Issue a read command */
	lan_wr(ANA_MACACCESS_ENTRYTYPE_SET(type) \|
	ANA_MACACCESS_VALID_SET(1) \|
	ANA_MACACCESS_MAC_TABLE_CMD_SET(MACACCESS_CMD_READ),
	lan966x, ANA_MACACCESS);

	ret = lan966x_mac_wait_for_completion(lan966x);
	if (ret)
	return ret;

	return ANA_MACACCESS_VALID_GET(lan_rd(lan966x, ANA_MACACCESS));
	}

	static void lan966x_fdb_call_notifiers(enum switchdev_notifier_type type,
	const char *mac, u16 vid,
	struct net_device *dev)
	{
	struct switchdev_notifier_fdb_info info = { 0 };

	info.addr = mac;
	info.vid = vid;
	info.offloaded = true;
	call_switchdev_notifiers(type, dev, &info.info, NULL);
	}

	int lan966x_mac_add_entry(struct lan966x lan966x, struct lan966x_port port,
	const unsigned char *addr, u16 vid)
	{
	struct lan966x_mac_entry *mac_entry;

	spin_lock(&lan966x->mac_lock);
	if (lan966x_mac_lookup(lan966x, addr, vid, ENTRYTYPE_NORMAL)) {
	spin_unlock(&lan966x->mac_lock);
	return 0;
	}

	/* In case the entry already exists, don't add it again to SW,
	* just update HW, but we need to look in the actual HW because
	* it is possible for an entry to be learn by HW and before we
	* get the interrupt the frame will reach CPU and the CPU will
	* add the entry but without the extern_learn flag.
	*/
	mac_entry = lan966x_mac_find_entry(lan966x, addr, vid, port->chip_port);
	if (mac_entry) {
	spin_unlock(&lan966x->mac_lock);
	goto mac_learn;
	}

	mac_entry = lan966x_mac_alloc_entry(port, addr, vid);
	if (!mac_entry) {
	spin_unlock(&lan966x->mac_lock);
	return -ENOMEM;
	}

	list_add_tail(&mac_entry->list, &lan966x->mac_entries);
	spin_unlock(&lan966x->mac_lock);

	lan966x_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED, addr, vid,
	port->bond ?: port->dev);

	mac_learn:
	lan966x_mac_learn(lan966x, port->chip_port, addr, vid, ENTRYTYPE_LOCKED);

	return 0;
	}

	int lan966x_mac_del_entry(struct lan966x lan966x, const unsigned char addr,
	u16 vid)
	{
	struct lan966x_mac_entry mac_entry, tmp;

	spin_lock(&lan966x->mac_lock);
	list_for_each_entry_safe(mac_entry, tmp, &lan966x->mac_entries,
	list) {
	if (mac_entry->vid == vid &&
	ether_addr_equal(addr, mac_entry->mac)) {
	lan966x_mac_forget_locked(lan966x, mac_entry->mac,
	mac_entry->vid,
	ENTRYTYPE_LOCKED);

	list_del(&mac_entry->list);
	kfree(mac_entry);
	}
	}
	spin_unlock(&lan966x->mac_lock);

	return 0;
	}

	void lan966x_mac_lag_replace_port_entry(struct lan966x *lan966x,
	struct lan966x_port *src,
	struct lan966x_port *dst)
	{
	struct lan966x_mac_entry *mac_entry;

	spin_lock(&lan966x->mac_lock);
	list_for_each_entry(mac_entry, &lan966x->mac_entries, list) {
	if (mac_entry->port_index == src->chip_port &&
	mac_entry->lag) {
	lan966x_mac_forget_locked(lan966x, mac_entry->mac,
	mac_entry->vid,
	ENTRYTYPE_LOCKED);

	lan966x_mac_learn_locked(lan966x, dst->chip_port,
	mac_entry->mac, mac_entry->vid,
	ENTRYTYPE_LOCKED);
	mac_entry->port_index = dst->chip_port;
	}
	}
	spin_unlock(&lan966x->mac_lock);
	}

	void lan966x_mac_lag_remove_port_entry(struct lan966x *lan966x,
	struct lan966x_port *src)
	{
	struct lan966x_mac_entry mac_entry, tmp;

	spin_lock(&lan966x->mac_lock);
	list_for_each_entry_safe(mac_entry, tmp, &lan966x->mac_entries,
	list) {
	if (mac_entry->port_index == src->chip_port &&
	mac_entry->lag) {
	lan966x_mac_forget_locked(lan966x, mac_entry->mac,
	mac_entry->vid,
	ENTRYTYPE_LOCKED);

	list_del(&mac_entry->list);
	kfree(mac_entry);
	}
	}
	spin_unlock(&lan966x->mac_lock);
	}

	void lan966x_mac_purge_entries(struct lan966x *lan966x)
	{
	struct lan966x_mac_entry mac_entry, tmp;

	spin_lock(&lan966x->mac_lock);
	list_for_each_entry_safe(mac_entry, tmp, &lan966x->mac_entries,
	list) {
	lan966x_mac_forget_locked(lan966x, mac_entry->mac,
	mac_entry->vid, ENTRYTYPE_LOCKED);

	list_del(&mac_entry->list);
	kfree(mac_entry);
	}
	spin_unlock(&lan966x->mac_lock);
	}

	static void lan966x_mac_notifiers(enum switchdev_notifier_type type,
	unsigned char *mac, u32 vid,
	struct net_device *dev)
	{
	rtnl_lock();
	lan966x_fdb_call_notifiers(type, mac, vid, dev);
	rtnl_unlock();
	}

	static void lan966x_mac_process_raw_entry(struct lan966x_mac_raw_entry *raw_entry,
	u8 mac, u16 vid, u32 *dest_idx)
	{
	mac[0] = (raw_entry->mach >> 8) & 0xff;
	mac[1] = (raw_entry->mach >> 0) & 0xff;
	mac[2] = (raw_entry->macl >> 24) & 0xff;
	mac[3] = (raw_entry->macl >> 16) & 0xff;
	mac[4] = (raw_entry->macl >> 8) & 0xff;
	mac[5] = (raw_entry->macl >> 0) & 0xff;

	*vid = (raw_entry->mach >> 16) & 0xfff;
	*dest_idx = ANA_MACACCESS_DEST_IDX_GET(raw_entry->maca);
	}

	static void lan966x_mac_irq_process(struct lan966x *lan966x, u32 row,
	struct lan966x_mac_raw_entry *raw_entries)
	{
	struct lan966x_mac_entry mac_entry, tmp;
	unsigned char mac[ETH_ALEN] __aligned(2);
	struct list_head mac_deleted_entries;
	struct lan966x_port *port;
	u32 dest_idx;
	u32 column;
	u16 vid;

	INIT_LIST_HEAD(&mac_deleted_entries);

	spin_lock(&lan966x->mac_lock);
	list_for_each_entry_safe(mac_entry, tmp, &lan966x->mac_entries, list) {
	bool found = false;

	if (mac_entry->row != row)
	continue;

	for (column = 0; column < LAN966X_MAC_COLUMNS; ++column) {
	/* All the valid entries are at the start of the row,
	* so when get one invalid entry it can just skip the
	* rest of the columns
	*/
	if (!ANA_MACACCESS_VALID_GET(raw_entries[column].maca))
	break;

	lan966x_mac_process_raw_entry(&raw_entries[column],
	mac, &vid, &dest_idx);
	if (WARN_ON(dest_idx >= lan966x->num_phys_ports))
	continue;

	/* If the entry in SW is found, then there is nothing
	* to do
	*/
	if (mac_entry->vid == vid &&
	ether_addr_equal(mac_entry->mac, mac) &&
	mac_entry->port_index == dest_idx) {
	raw_entries[column].processed = true;
	found = true;
	break;
	}
	}

	if (!found) {
	list_del(&mac_entry->list);
	/* Move the entry from SW list to a tmp list such that
	* it would be deleted later
	*/
	list_add_tail(&mac_entry->list, &mac_deleted_entries);
	}
	}
	spin_unlock(&lan966x->mac_lock);

	list_for_each_entry_safe(mac_entry, tmp, &mac_deleted_entries, list) {
	/* Notify the bridge that the entry doesn't exist
	* anymore in the HW
	*/
	port = lan966x->ports[mac_entry->port_index];
	lan966x_mac_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE,
	mac_entry->mac, mac_entry->vid,
	port->bond ?: port->dev);
	list_del(&mac_entry->list);
	kfree(mac_entry);
	}

	/* Now go to the list of columns and see if any entry was not in the SW
	* list, then that means that the entry is new so it needs to notify the
	* bridge.
	*/
	for (column = 0; column < LAN966X_MAC_COLUMNS; ++column) {
	/* All the valid entries are at the start of the row, so when
	* get one invalid entry it can just skip the rest of the columns
	*/
	if (!ANA_MACACCESS_VALID_GET(raw_entries[column].maca))
	break;

	/* If the entry already exists then don't do anything */
	if (raw_entries[column].processed)
	continue;

	lan966x_mac_process_raw_entry(&raw_entries[column],
	mac, &vid, &dest_idx);
	if (WARN_ON(dest_idx >= lan966x->num_phys_ports))
	continue;

	spin_lock(&lan966x->mac_lock);
	mac_entry = lan966x_mac_find_entry(lan966x, mac, vid, dest_idx);
	if (mac_entry) {
	spin_unlock(&lan966x->mac_lock);
	continue;
	}

	port = lan966x->ports[dest_idx];
	mac_entry = lan966x_mac_alloc_entry(port, mac, vid);
	if (!mac_entry) {
	spin_unlock(&lan966x->mac_lock);
	return;
	}

	mac_entry->row = row;
	list_add_tail(&mac_entry->list, &lan966x->mac_entries);
	spin_unlock(&lan966x->mac_lock);

	lan966x_mac_notifiers(SWITCHDEV_FDB_ADD_TO_BRIDGE,
	mac, vid, port->bond ?: port->dev);
	}
	}

	irqreturn_t lan966x_mac_irq_handler(struct lan966x *lan966x)
	{
	struct lan966x_mac_raw_entry entry[LAN966X_MAC_COLUMNS] = { 0 };
	u32 index, column;
	bool stop = true;
	u32 val;

	/* Start the scan from 0, 0 */
	lan_wr(ANA_MACTINDX_M_INDEX_SET(0) \|
	ANA_MACTINDX_BUCKET_SET(0),
	lan966x, ANA_MACTINDX);

	while (1) {
	spin_lock(&lan966x->mac_lock);
	lan_rmw(ANA_MACACCESS_MAC_TABLE_CMD_SET(MACACCESS_CMD_SYNC_GET_NEXT),
	ANA_MACACCESS_MAC_TABLE_CMD,
	lan966x, ANA_MACACCESS);
	lan966x_mac_wait_for_completion(lan966x);

	val = lan_rd(lan966x, ANA_MACTINDX);
	index = ANA_MACTINDX_M_INDEX_GET(val);
	column = ANA_MACTINDX_BUCKET_GET(val);

	/* The SYNC-GET-NEXT returns all the entries(4) in a row in
	* which is suffered a change. By change it means that new entry
	* was added or an entry was removed because of ageing.
	* It would return all the columns for that row. And after that
	* it would return the next row The stop conditions of the
	* SYNC-GET-NEXT is when it reaches 'directly' to row 0
	* column 3. So if SYNC-GET-NEXT returns row 0 and column 0
	* then it is required to continue to read more even if it
	* reaches row 0 and column 3.
	*/
	if (index == 0 && column == 0)
	stop = false;

	if (column == LAN966X_MAC_COLUMNS - 1 &&
	index == 0 && stop) {
	spin_unlock(&lan966x->mac_lock);
	break;
	}

	entry[column].mach = lan_rd(lan966x, ANA_MACHDATA);
	entry[column].macl = lan_rd(lan966x, ANA_MACLDATA);
	entry[column].maca = lan_rd(lan966x, ANA_MACACCESS);
	spin_unlock(&lan966x->mac_lock);

	/* Once all the columns are read process them */
	if (column == LAN966X_MAC_COLUMNS - 1) {
	lan966x_mac_irq_process(lan966x, index, entry);
	/* A row was processed so it is safe to assume that the
	* next row/column can be the stop condition
	*/
	stop = true;
	}
	}

	lan_rmw(ANA_ANAINTR_INTR_SET(0),
	ANA_ANAINTR_INTR,
	lan966x, ANA_ANAINTR);

	return IRQ_HANDLED;
	}