[mirror_ubuntu-eoan-kernel.git] / include / net / dsa.h

/*
 * include/net/dsa.h - Driver for Distributed Switch Architecture switch chips
 * Copyright (c) 2008-2009 Marvell Semiconductor
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#ifndef __LINUX_NET_DSA_H
#define __LINUX_NET_DSA_H

#include <linux/if.h>
#include <linux/if_ether.h>
#include <linux/list.h>
#include <linux/notifier.h>
#include <linux/timer.h>
#include <linux/workqueue.h>
#include <linux/of.h>
#include <linux/ethtool.h>
#include <linux/net_tstamp.h>
#include <linux/phy.h>
#include <linux/platform_data/dsa.h>
#include <net/devlink.h>
#include <net/switchdev.h>

struct tc_action;
struct phy_device;
struct fixed_phy_status;
struct phylink_link_state;

enum dsa_tag_protocol {
	DSA_TAG_PROTO_NONE = 0,
	DSA_TAG_PROTO_BRCM,
	DSA_TAG_PROTO_BRCM_PREPEND,
	DSA_TAG_PROTO_DSA,
	DSA_TAG_PROTO_EDSA,
	DSA_TAG_PROTO_GSWIP,
	DSA_TAG_PROTO_KSZ9477,
	DSA_TAG_PROTO_KSZ9893,
	DSA_TAG_PROTO_LAN9303,
	DSA_TAG_PROTO_MTK,
	DSA_TAG_PROTO_QCA,
	DSA_TAG_PROTO_TRAILER,
	DSA_TAG_LAST,		/* MUST BE LAST */
};

struct packet_type;
struct dsa_switch;

struct dsa_device_ops {
	struct sk_buff *(*xmit)(struct sk_buff *skb, struct net_device *dev);
	struct sk_buff *(*rcv)(struct sk_buff *skb, struct net_device *dev,
			       struct packet_type *pt);
	int (*flow_dissect)(const struct sk_buff *skb, __be16 *proto,
			    int *offset);
	unsigned int overhead;
};

struct dsa_switch_tree {
	struct list_head	list;

	/* Notifier chain for switch-wide events */
	struct raw_notifier_head	nh;

	/* Tree identifier */
	unsigned int index;

	/* Number of switches attached to this tree */
	struct kref refcount;

	/* Has this tree been applied to the hardware? */
	bool setup;

	/*
	 * Configuration data for the platform device that owns
	 * this dsa switch tree instance.
	 */
	struct dsa_platform_data	*pd;

	/*
	 * The switch port to which the CPU is attached.
	 */
	struct dsa_port		*cpu_dp;

	/*
	 * Data for the individual switch chips.
	 */
	struct dsa_switch	*ds[DSA_MAX_SWITCHES];
};

/* TC matchall action types, only mirroring for now */
enum dsa_port_mall_action_type {
	DSA_PORT_MALL_MIRROR,
};

/* TC mirroring entry */
struct dsa_mall_mirror_tc_entry {
	u8 to_local_port;
	bool ingress;
};

/* TC matchall entry */
struct dsa_mall_tc_entry {
	struct list_head list;
	unsigned long cookie;
	enum dsa_port_mall_action_type type;
	union {
		struct dsa_mall_mirror_tc_entry mirror;
	};
};


struct dsa_port {
	/* A CPU port is physically connected to a master device.
	 * A user port exposed to userspace has a slave device.
	 */
	union {
		struct net_device *master;
		struct net_device *slave;
	};

	/* CPU port tagging operations used by master or slave devices */
	const struct dsa_device_ops *tag_ops;

	/* Copies for faster access in master receive hot path */
	struct dsa_switch_tree *dst;
	struct sk_buff *(*rcv)(struct sk_buff *skb, struct net_device *dev,
			       struct packet_type *pt);

	enum {
		DSA_PORT_TYPE_UNUSED = 0,
		DSA_PORT_TYPE_CPU,
		DSA_PORT_TYPE_DSA,
		DSA_PORT_TYPE_USER,
	} type;

	struct dsa_switch	*ds;
	unsigned int		index;
	const char		*name;
	const struct dsa_port	*cpu_dp;
	struct device_node	*dn;
	unsigned int		ageing_time;
	u8			stp_state;
	struct net_device	*bridge_dev;
	struct devlink_port	devlink_port;
	struct phylink		*pl;
	/*
	 * Original copy of the master netdev ethtool_ops
	 */
	const struct ethtool_ops *orig_ethtool_ops;

	/*
	 * Original copy of the master netdev net_device_ops
	 */
	const struct net_device_ops *orig_ndo_ops;
};

struct dsa_switch {
	struct device *dev;

	/*
	 * Parent switch tree, and switch index.
	 */
	struct dsa_switch_tree	*dst;
	unsigned int		index;

	/* Listener for switch fabric events */
	struct notifier_block	nb;

	/*
	 * Give the switch driver somewhere to hang its private data
	 * structure.
	 */
	void *priv;

	/*
	 * Configuration data for this switch.
	 */
	struct dsa_chip_data	*cd;

	/*
	 * The switch operations.
	 */
	const struct dsa_switch_ops	*ops;

	/*
	 * An array of which element [a] indicates which port on this
	 * switch should be used to send packets to that are destined
	 * for switch a. Can be NULL if there is only one switch chip.
	 */
	s8		rtable[DSA_MAX_SWITCHES];

	/*
	 * Slave mii_bus and devices for the individual ports.
	 */
	u32			phys_mii_mask;
	struct mii_bus		*slave_mii_bus;

	/* Ageing Time limits in msecs */
	unsigned int ageing_time_min;
	unsigned int ageing_time_max;

	/* devlink used to represent this switch device */
	struct devlink		*devlink;

	/* Number of switch port queues */
	unsigned int		num_tx_queues;

	unsigned long		*bitmap;
	unsigned long		_bitmap;

	/* Dynamically allocated ports, keep last */
	size_t num_ports;
	struct dsa_port ports[];
};

static inline const struct dsa_port *dsa_to_port(struct dsa_switch *ds, int p)
{
	return &ds->ports[p];
}

static inline bool dsa_is_unused_port(struct dsa_switch *ds, int p)
{
	return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_UNUSED;
}

static inline bool dsa_is_cpu_port(struct dsa_switch *ds, int p)
{
	return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_CPU;
}

static inline bool dsa_is_dsa_port(struct dsa_switch *ds, int p)
{
	return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_DSA;
}

static inline bool dsa_is_user_port(struct dsa_switch *ds, int p)
{
	return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_USER;
}

static inline u32 dsa_user_ports(struct dsa_switch *ds)
{
	u32 mask = 0;
	int p;

	for (p = 0; p < ds->num_ports; p++)
		if (dsa_is_user_port(ds, p))
			mask |= BIT(p);

	return mask;
}

/* Return the local port used to reach an arbitrary switch port */
static inline unsigned int dsa_towards_port(struct dsa_switch *ds, int device,
					    int port)
{
	if (device == ds->index)
		return port;
	else
		return ds->rtable[device];
}

/* Return the local port used to reach the dedicated CPU port */
static inline unsigned int dsa_upstream_port(struct dsa_switch *ds, int port)
{
	const struct dsa_port *dp = dsa_to_port(ds, port);
	const struct dsa_port *cpu_dp = dp->cpu_dp;

	if (!cpu_dp)
		return port;

	return dsa_towards_port(ds, cpu_dp->ds->index, cpu_dp->index);
}

typedef int dsa_fdb_dump_cb_t(const unsigned char *addr, u16 vid,
			      bool is_static, void *data);
struct dsa_switch_ops {
#if IS_ENABLED(CONFIG_NET_DSA_LEGACY)
	/*
	 * Legacy probing.
	 */
	const char	*(*probe)(struct device *dsa_dev,
				  struct device *host_dev, int sw_addr,
				  void **priv);
#endif

	enum dsa_tag_protocol (*get_tag_protocol)(struct dsa_switch *ds,
						  int port);

	int	(*setup)(struct dsa_switch *ds);
	u32	(*get_phy_flags)(struct dsa_switch *ds, int port);

	/*
	 * Access to the switch's PHY registers.
	 */
	int	(*phy_read)(struct dsa_switch *ds, int port, int regnum);
	int	(*phy_write)(struct dsa_switch *ds, int port,
			     int regnum, u16 val);

	/*
	 * Link state adjustment (called from libphy)
	 */
	void	(*adjust_link)(struct dsa_switch *ds, int port,
				struct phy_device *phydev);
	void	(*fixed_link_update)(struct dsa_switch *ds, int port,
				struct fixed_phy_status *st);

	/*
	 * PHYLINK integration
	 */
	void	(*phylink_validate)(struct dsa_switch *ds, int port,
				    unsigned long *supported,
				    struct phylink_link_state *state);
	int	(*phylink_mac_link_state)(struct dsa_switch *ds, int port,
					  struct phylink_link_state *state);
	void	(*phylink_mac_config)(struct dsa_switch *ds, int port,
				      unsigned int mode,
				      const struct phylink_link_state *state);
	void	(*phylink_mac_an_restart)(struct dsa_switch *ds, int port);
	void	(*phylink_mac_link_down)(struct dsa_switch *ds, int port,
					 unsigned int mode,
					 phy_interface_t interface);
	void	(*phylink_mac_link_up)(struct dsa_switch *ds, int port,
				       unsigned int mode,
				       phy_interface_t interface,
				       struct phy_device *phydev);
	void	(*phylink_fixed_state)(struct dsa_switch *ds, int port,
				       struct phylink_link_state *state);
	/*
	 * ethtool hardware statistics.
	 */
	void	(*get_strings)(struct dsa_switch *ds, int port,
			       u32 stringset, uint8_t *data);
	void	(*get_ethtool_stats)(struct dsa_switch *ds,
				     int port, uint64_t *data);
	int	(*get_sset_count)(struct dsa_switch *ds, int port, int sset);
	void	(*get_ethtool_phy_stats)(struct dsa_switch *ds,
					 int port, uint64_t *data);

	/*
	 * ethtool Wake-on-LAN
	 */
	void	(*get_wol)(struct dsa_switch *ds, int port,
			   struct ethtool_wolinfo *w);
	int	(*set_wol)(struct dsa_switch *ds, int port,
			   struct ethtool_wolinfo *w);

	/*
	 * ethtool timestamp info
	 */
	int	(*get_ts_info)(struct dsa_switch *ds, int port,
			       struct ethtool_ts_info *ts);

	/*
	 * Suspend and resume
	 */
	int	(*suspend)(struct dsa_switch *ds);
	int	(*resume)(struct dsa_switch *ds);

	/*
	 * Port enable/disable
	 */
	int	(*port_enable)(struct dsa_switch *ds, int port,
			       struct phy_device *phy);
	void	(*port_disable)(struct dsa_switch *ds, int port);

	/*
	 * Port's MAC EEE settings
	 */
	int	(*set_mac_eee)(struct dsa_switch *ds, int port,
			       struct ethtool_eee *e);
	int	(*get_mac_eee)(struct dsa_switch *ds, int port,
			       struct ethtool_eee *e);

	/* EEPROM access */
	int	(*get_eeprom_len)(struct dsa_switch *ds);
	int	(*get_eeprom)(struct dsa_switch *ds,
			      struct ethtool_eeprom *eeprom, u8 *data);
	int	(*set_eeprom)(struct dsa_switch *ds,
			      struct ethtool_eeprom *eeprom, u8 *data);

	/*
	 * Register access.
	 */
	int	(*get_regs_len)(struct dsa_switch *ds, int port);
	void	(*get_regs)(struct dsa_switch *ds, int port,
			    struct ethtool_regs *regs, void *p);

	/*
	 * Bridge integration
	 */
	int	(*set_ageing_time)(struct dsa_switch *ds, unsigned int msecs);
	int	(*port_bridge_join)(struct dsa_switch *ds, int port,
				    struct net_device *bridge);
	void	(*port_bridge_leave)(struct dsa_switch *ds, int port,
				     struct net_device *bridge);
	void	(*port_stp_state_set)(struct dsa_switch *ds, int port,
				      u8 state);
	void	(*port_fast_age)(struct dsa_switch *ds, int port);
	int	(*port_egress_floods)(struct dsa_switch *ds, int port,
				      bool unicast, bool multicast);

	/*
	 * VLAN support
	 */
	int	(*port_vlan_filtering)(struct dsa_switch *ds, int port,
				       bool vlan_filtering);
	int (*port_vlan_prepare)(struct dsa_switch *ds, int port,
				 const struct switchdev_obj_port_vlan *vlan);
	void (*port_vlan_add)(struct dsa_switch *ds, int port,
			      const struct switchdev_obj_port_vlan *vlan);
	int	(*port_vlan_del)(struct dsa_switch *ds, int port,
				 const struct switchdev_obj_port_vlan *vlan);
	/*
	 * Forwarding database
	 */
	int	(*port_fdb_add)(struct dsa_switch *ds, int port,
				const unsigned char *addr, u16 vid);
	int	(*port_fdb_del)(struct dsa_switch *ds, int port,
				const unsigned char *addr, u16 vid);
	int	(*port_fdb_dump)(struct dsa_switch *ds, int port,
				 dsa_fdb_dump_cb_t *cb, void *data);

	/*
	 * Multicast database
	 */
	int (*port_mdb_prepare)(struct dsa_switch *ds, int port,
				const struct switchdev_obj_port_mdb *mdb);
	void (*port_mdb_add)(struct dsa_switch *ds, int port,
			     const struct switchdev_obj_port_mdb *mdb);
	int	(*port_mdb_del)(struct dsa_switch *ds, int port,
				const struct switchdev_obj_port_mdb *mdb);
	/*
	 * RXNFC
	 */
	int	(*get_rxnfc)(struct dsa_switch *ds, int port,
			     struct ethtool_rxnfc *nfc, u32 *rule_locs);
	int	(*set_rxnfc)(struct dsa_switch *ds, int port,
			     struct ethtool_rxnfc *nfc);

	/*
	 * TC integration
	 */
	int	(*port_mirror_add)(struct dsa_switch *ds, int port,
				   struct dsa_mall_mirror_tc_entry *mirror,
				   bool ingress);
	void	(*port_mirror_del)(struct dsa_switch *ds, int port,
				   struct dsa_mall_mirror_tc_entry *mirror);

	/*
	 * Cross-chip operations
	 */
	int	(*crosschip_bridge_join)(struct dsa_switch *ds, int sw_index,
					 int port, struct net_device *br);
	void	(*crosschip_bridge_leave)(struct dsa_switch *ds, int sw_index,
					  int port, struct net_device *br);

	/*
	 * PTP functionality
	 */
	int	(*port_hwtstamp_get)(struct dsa_switch *ds, int port,
				     struct ifreq *ifr);
	int	(*port_hwtstamp_set)(struct dsa_switch *ds, int port,
				     struct ifreq *ifr);
	bool	(*port_txtstamp)(struct dsa_switch *ds, int port,
				 struct sk_buff *clone, unsigned int type);
	bool	(*port_rxtstamp)(struct dsa_switch *ds, int port,
				 struct sk_buff *skb, unsigned int type);
};

struct dsa_switch_driver {
	struct list_head	list;
	const struct dsa_switch_ops *ops;
};

#if IS_ENABLED(CONFIG_NET_DSA_LEGACY)
/* Legacy driver registration */
void register_switch_driver(struct dsa_switch_driver *type);
void unregister_switch_driver(struct dsa_switch_driver *type);
struct mii_bus *dsa_host_dev_to_mii_bus(struct device *dev);

#else
static inline void register_switch_driver(struct dsa_switch_driver *type) { }
static inline void unregister_switch_driver(struct dsa_switch_driver *type) { }
static inline struct mii_bus *dsa_host_dev_to_mii_bus(struct device *dev)
{
	return NULL;
}
#endif
struct net_device *dsa_dev_to_net_device(struct device *dev);

/* Keep inline for faster access in hot path */
static inline bool netdev_uses_dsa(struct net_device *dev)
{
#if IS_ENABLED(CONFIG_NET_DSA)
	return dev->dsa_ptr && dev->dsa_ptr->rcv;
#endif
	return false;
}

struct dsa_switch *dsa_switch_alloc(struct device *dev, size_t n);
void dsa_unregister_switch(struct dsa_switch *ds);
int dsa_register_switch(struct dsa_switch *ds);
#ifdef CONFIG_PM_SLEEP
int dsa_switch_suspend(struct dsa_switch *ds);
int dsa_switch_resume(struct dsa_switch *ds);
#else
static inline int dsa_switch_suspend(struct dsa_switch *ds)
{
	return 0;
}
static inline int dsa_switch_resume(struct dsa_switch *ds)
{
	return 0;
}
#endif /* CONFIG_PM_SLEEP */

enum dsa_notifier_type {
	DSA_PORT_REGISTER,
	DSA_PORT_UNREGISTER,
};

struct dsa_notifier_info {
	struct net_device *dev;
};

struct dsa_notifier_register_info {
	struct dsa_notifier_info info;	/* must be first */
	struct net_device *master;
	unsigned int port_number;
	unsigned int switch_number;
};

static inline struct net_device *
dsa_notifier_info_to_dev(const struct dsa_notifier_info *info)
{
	return info->dev;
}

#if IS_ENABLED(CONFIG_NET_DSA)
int register_dsa_notifier(struct notifier_block *nb);
int unregister_dsa_notifier(struct notifier_block *nb);
int call_dsa_notifiers(unsigned long val, struct net_device *dev,
		       struct dsa_notifier_info *info);
#else
static inline int register_dsa_notifier(struct notifier_block *nb)
{
	return 0;
}

static inline int unregister_dsa_notifier(struct notifier_block *nb)
{
	return 0;
}

static inline int call_dsa_notifiers(unsigned long val, struct net_device *dev,
				     struct dsa_notifier_info *info)
{
	return NOTIFY_DONE;
}
#endif

/* Broadcom tag specific helpers to insert and extract queue/port number */
#define BRCM_TAG_SET_PORT_QUEUE(p, q)	((p) << 8 | q)
#define BRCM_TAG_GET_PORT(v)		((v) >> 8)
#define BRCM_TAG_GET_QUEUE(v)		((v) & 0xff)


int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data);
int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data);
int dsa_port_get_phy_sset_count(struct dsa_port *dp);
void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up);

#endif
Commit	Line	Data
91da11f8 LB	1	/*
91da11f8 LB	2	* include/net/dsa.h - Driver for Distributed Switch Architecture switch chips
e84665c9	3	* Copyright (c) 2008-2009 Marvell Semiconductor
91da11f8 LB	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*/
	10
	11	#ifndef __LINUX_NET_DSA_H
	12	#define __LINUX_NET_DSA_H
	13
4d56a29f	14	#include <linux/if.h>
ea1f51be	15	#include <linux/if_ether.h>
c8f0b869	16	#include <linux/list.h>
f515f192	17	#include <linux/notifier.h>
cf50dcc2 BH	18	#include <linux/timer.h>
cf50dcc2 BH	19	#include <linux/workqueue.h>
fa981d9a	20	#include <linux/of.h>
a2820543	21	#include <linux/ethtool.h>
0336369d	22	#include <linux/net_tstamp.h>
11d8f3dd	23	#include <linux/phy.h>
ecfc9372	24	#include <linux/platform_data/dsa.h>
96567d5d	25	#include <net/devlink.h>
f0c24ccf	26	#include <net/switchdev.h>
cf50dcc2	27
f50f2127	28	struct tc_action;
4d56a29f RK	29	struct phy_device;
4d56a29f RK	30	struct fixed_phy_status;
11d8f3dd	31	struct phylink_link_state;
f50f2127	32
ac7a04c3 FF	33	enum dsa_tag_protocol {
ac7a04c3 FF	34	DSA_TAG_PROTO_NONE = 0,
eb7b7211	35	DSA_TAG_PROTO_BRCM,
b74b70c4	36	DSA_TAG_PROTO_BRCM_PREPEND,
ac7a04c3	37	DSA_TAG_PROTO_DSA,
ac7a04c3	38	DSA_TAG_PROTO_EDSA,
79691192	39	DSA_TAG_PROTO_GSWIP,
39d6b96f	40	DSA_TAG_PROTO_KSZ9477,
88b573af	41	DSA_TAG_PROTO_KSZ9893,
e8fe177a	42	DSA_TAG_PROTO_LAN9303,
eb7b7211 AL	43	DSA_TAG_PROTO_MTK,
	44	DSA_TAG_PROTO_QCA,
	45	DSA_TAG_PROTO_TRAILER,
39a7f2a4	46	DSA_TAG_LAST, /* MUST BE LAST */
ac7a04c3	47	};
5037d532	48
5075314e	49	struct packet_type;
90af1059	50	struct dsa_switch;
3e8a72d1	51
68277a2c JC	52	struct dsa_device_ops {
	53	struct sk_buff (xmit)(struct sk_buff skb, struct net_device dev);
	54	struct sk_buff (rcv)(struct sk_buff skb, struct net_device dev,
89e49506	55	struct packet_type *pt);
598a9680 JC	56	int (flow_dissect)(const struct sk_buff skb, __be16 *proto,
598a9680 JC	57	int *offset);
a5dd3087	58	unsigned int overhead;
68277a2c JC	59	};
68277a2c JC	60
cf50dcc2	61	struct dsa_switch_tree {
83c0afae AL	62	struct list_head list;
83c0afae AL	63
f515f192 VD	64	/* Notifier chain for switch-wide events */
	65	struct raw_notifier_head nh;
	66
83c0afae	67	/* Tree identifier */
49463b7f	68	unsigned int index;
83c0afae AL	69
	70	/* Number of switches attached to this tree */
	71	struct kref refcount;
	72
	73	/* Has this tree been applied to the hardware? */
ec15dd42	74	bool setup;
83c0afae	75
cf50dcc2 BH	76	/*
	77	* Configuration data for the platform device that owns
	78	* this dsa switch tree instance.
	79	*/
	80	struct dsa_platform_data *pd;
	81
cf50dcc2	82	/*
8b0d3ea5	83	* The switch port to which the CPU is attached.
cf50dcc2	84	*/
8b0d3ea5	85	struct dsa_port *cpu_dp;
cf50dcc2	86
cf50dcc2 BH	87	/*
	88	* Data for the individual switch chips.
	89	*/
	90	struct dsa_switch *ds[DSA_MAX_SWITCHES];
	91	};
	92
f50f2127 FF	93	/* TC matchall action types, only mirroring for now */
	94	enum dsa_port_mall_action_type {
	95	DSA_PORT_MALL_MIRROR,
	96	};
	97
	98	/* TC mirroring entry */
	99	struct dsa_mall_mirror_tc_entry {
	100	u8 to_local_port;
	101	bool ingress;
	102	};
	103
	104	/* TC matchall entry */
	105	struct dsa_mall_tc_entry {
	106	struct list_head list;
	107	unsigned long cookie;
	108	enum dsa_port_mall_action_type type;
	109	union {
	110	struct dsa_mall_mirror_tc_entry mirror;
	111	};
	112	};
	113
	114
c8b09808	115	struct dsa_port {
f8b8b1cd VD	116	/* A CPU port is physically connected to a master device.
	117	* A user port exposed to userspace has a slave device.
	118	*/
	119	union {
	120	struct net_device *master;
	121	struct net_device *slave;
	122	};
	123
15240248 VD	124	/* CPU port tagging operations used by master or slave devices */
	125	const struct dsa_device_ops *tag_ops;
	126
3e41f93b VD	127	/* Copies for faster access in master receive hot path */
	128	struct dsa_switch_tree *dst;
	129	struct sk_buff (rcv)(struct sk_buff skb, struct net_device dev,
	130	struct packet_type *pt);
	131
057cad2c VD	132	enum {
	133	DSA_PORT_TYPE_UNUSED = 0,
	134	DSA_PORT_TYPE_CPU,
	135	DSA_PORT_TYPE_DSA,
	136	DSA_PORT_TYPE_USER,
	137	} type;
	138
818be848 VD	139	struct dsa_switch *ds;
818be848 VD	140	unsigned int index;
71e0bbde	141	const char *name;
24a9332a	142	const struct dsa_port *cpu_dp;
189b0d93	143	struct device_node *dn;
34a79f63	144	unsigned int ageing_time;
732f794c	145	u8 stp_state;
a5e9a02e	146	struct net_device *bridge_dev;
96567d5d	147	struct devlink_port devlink_port;
aab9c406	148	struct phylink *pl;
67dbb9d4 FF	149	/*
	150	* Original copy of the master netdev ethtool_ops
	151	*/
67dbb9d4	152	const struct ethtool_ops *orig_ethtool_ops;
da7b9e9b FF	153
	154	/*
	155	* Original copy of the master netdev net_device_ops
	156	*/
	157	const struct net_device_ops *orig_ndo_ops;
c8b09808 AL	158	};
c8b09808 AL	159
c8f0b869	160	struct dsa_switch {
c33063d6 AL	161	struct device *dev;
c33063d6 AL	162
c8f0b869 BH	163	/*
	164	* Parent switch tree, and switch index.
	165	*/
	166	struct dsa_switch_tree *dst;
99feaafc	167	unsigned int index;
c8f0b869	168
f515f192 VD	169	/* Listener for switch fabric events */
	170	struct notifier_block nb;
	171
7543a6d5 AL	172	/*
	173	* Give the switch driver somewhere to hang its private data
	174	* structure.
	175	*/
	176	void *priv;
	177
c8f0b869 BH	178	/*
	179	* Configuration data for this switch.
	180	*/
ff04955c	181	struct dsa_chip_data *cd;
c8f0b869 BH	182
c8f0b869 BH	183	/*
9d490b4e	184	* The switch operations.
c8f0b869	185	*/
a82f67af	186	const struct dsa_switch_ops *ops;
c8f0b869	187
66472fc0 AL	188	/*
	189	* An array of which element [a] indicates which port on this
	190	* switch should be used to send packets to that are destined
	191	* for switch a. Can be NULL if there is only one switch chip.
	192	*/
	193	s8 rtable[DSA_MAX_SWITCHES];
	194
c8f0b869 BH	195	/*
	196	* Slave mii_bus and devices for the individual ports.
	197	*/
0d8bcdd3	198	u32 phys_mii_mask;
c8f0b869	199	struct mii_bus *slave_mii_bus;
a0c02161	200
0f3da6af VD	201	/* Ageing Time limits in msecs */
	202	unsigned int ageing_time_min;
	203	unsigned int ageing_time_max;
	204
96567d5d AL	205	/* devlink used to represent this switch device */
	206	struct devlink *devlink;
	207
55199df6 FF	208	/* Number of switch port queues */
	209	unsigned int num_tx_queues;
	210
0015b80a SM	211	unsigned long *bitmap;
	212	unsigned long _bitmap;
	213
a0c02161 VD	214	/* Dynamically allocated ports, keep last */
	215	size_t num_ports;
	216	struct dsa_port ports[];
c8f0b869 BH	217	};
c8f0b869 BH	218
c38c5a66	219	static inline const struct dsa_port dsa_to_port(struct dsa_switch ds, int p)
bff7b688	220	{
c38c5a66 VD	221	return &ds->ports[p];
c38c5a66 VD	222	}
bff7b688	223
c38c5a66 VD	224	static inline bool dsa_is_unused_port(struct dsa_switch *ds, int p)
	225	{
	226	return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_UNUSED;
bff7b688 VD	227	}
bff7b688 VD	228
c8f0b869 BH	229	static inline bool dsa_is_cpu_port(struct dsa_switch *ds, int p)
c8f0b869 BH	230	{
c38c5a66	231	return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_CPU;
c8f0b869 BH	232	}
c8f0b869 BH	233
60045cbf AL	234	static inline bool dsa_is_dsa_port(struct dsa_switch *ds, int p)
60045cbf AL	235	{
c38c5a66	236	return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_DSA;
60045cbf AL	237	}
60045cbf AL	238
2b3e9891	239	static inline bool dsa_is_user_port(struct dsa_switch *ds, int p)
6cd456f3	240	{
c38c5a66	241	return dsa_to_port(ds, p)->type == DSA_PORT_TYPE_USER;
6cd456f3 VD	242	}
6cd456f3 VD	243
02bc6e54 VD	244	static inline u32 dsa_user_ports(struct dsa_switch *ds)
02bc6e54 VD	245	{
c38c5a66 VD	246	u32 mask = 0;
c38c5a66 VD	247	int p;
02bc6e54	248
c38c5a66 VD	249	for (p = 0; p < ds->num_ports; p++)
	250	if (dsa_is_user_port(ds, p))
	251	mask \|= BIT(p);
	252
	253	return mask;
c8652c83 VD	254	}
c8652c83 VD	255
3b8fac5d VD	256	/* Return the local port used to reach an arbitrary switch port */
	257	static inline unsigned int dsa_towards_port(struct dsa_switch *ds, int device,
	258	int port)
	259	{
	260	if (device == ds->index)
	261	return port;
	262	else
	263	return ds->rtable[device];
	264	}
	265
	266	/* Return the local port used to reach the dedicated CPU port */
07073c79	267	static inline unsigned int dsa_upstream_port(struct dsa_switch *ds, int port)
c8f0b869	268	{
07073c79 VD	269	const struct dsa_port *dp = dsa_to_port(ds, port);
	270	const struct dsa_port *cpu_dp = dp->cpu_dp;
	271
	272	if (!cpu_dp)
	273	return port;
c8f0b869	274
3b8fac5d	275	return dsa_towards_port(ds, cpu_dp->ds->index, cpu_dp->index);
c8f0b869 BH	276	}
c8f0b869 BH	277
2bedde1a AS	278	typedef int dsa_fdb_dump_cb_t(const unsigned char *addr, u16 vid,
2bedde1a AS	279	bool is_static, void *data);
9d490b4e	280	struct dsa_switch_ops {
2a93c1a3	281	#if IS_ENABLED(CONFIG_NET_DSA_LEGACY)
c8f0b869	282	/*
a6a71f19	283	* Legacy probing.
c8f0b869	284	*/
0209d144 VD	285	const char (probe)(struct device *dsa_dev,
	286	struct device *host_dev, int sw_addr,
	287	void **priv);
2a93c1a3	288	#endif
7b314362	289
5ed4e3eb FF	290	enum dsa_tag_protocol (get_tag_protocol)(struct dsa_switch ds,
5ed4e3eb FF	291	int port);
7b314362	292
c8f0b869	293	int (setup)(struct dsa_switch ds);
6819563e	294	u32 (get_phy_flags)(struct dsa_switch ds, int port);
c8f0b869 BH	295
	296	/*
	297	* Access to the switch's PHY registers.
	298	*/
	299	int (phy_read)(struct dsa_switch ds, int port, int regnum);
	300	int (phy_write)(struct dsa_switch ds, int port,
	301	int regnum, u16 val);
	302
ec9436ba FF	303	/*
	304	* Link state adjustment (called from libphy)
	305	*/
	306	void (adjust_link)(struct dsa_switch ds, int port,
	307	struct phy_device *phydev);
ce31b31c FF	308	void (fixed_link_update)(struct dsa_switch ds, int port,
ce31b31c FF	309	struct fixed_phy_status *st);
ec9436ba	310
11d8f3dd FF	311	/*
	312	* PHYLINK integration
	313	*/
	314	void (phylink_validate)(struct dsa_switch ds, int port,
	315	unsigned long *supported,
	316	struct phylink_link_state *state);
	317	int (phylink_mac_link_state)(struct dsa_switch ds, int port,
	318	struct phylink_link_state *state);
	319	void (phylink_mac_config)(struct dsa_switch ds, int port,
	320	unsigned int mode,
	321	const struct phylink_link_state *state);
	322	void (phylink_mac_an_restart)(struct dsa_switch ds, int port);
	323	void (phylink_mac_link_down)(struct dsa_switch ds, int port,
	324	unsigned int mode,
	325	phy_interface_t interface);
	326	void (phylink_mac_link_up)(struct dsa_switch ds, int port,
	327	unsigned int mode,
	328	phy_interface_t interface,
	329	struct phy_device *phydev);
	330	void (phylink_fixed_state)(struct dsa_switch ds, int port,
	331	struct phylink_link_state *state);
c8f0b869 BH	332	/*
	333	* ethtool hardware statistics.
	334	*/
89f09048 FF	335	void (get_strings)(struct dsa_switch ds, int port,
89f09048 FF	336	u32 stringset, uint8_t *data);
c8f0b869 BH	337	void (get_ethtool_stats)(struct dsa_switch ds,
c8f0b869 BH	338	int port, uint64_t *data);
89f09048	339	int (get_sset_count)(struct dsa_switch ds, int port, int sset);
cf963573 FF	340	void (get_ethtool_phy_stats)(struct dsa_switch ds,
cf963573 FF	341	int port, uint64_t *data);
24462549	342
19e57c4e FF	343	/*
	344	* ethtool Wake-on-LAN
	345	*/
	346	void (get_wol)(struct dsa_switch ds, int port,
	347	struct ethtool_wolinfo *w);
	348	int (set_wol)(struct dsa_switch ds, int port,
	349	struct ethtool_wolinfo *w);
	350
0336369d BS	351	/*
	352	* ethtool timestamp info
	353	*/
	354	int (get_ts_info)(struct dsa_switch ds, int port,
	355	struct ethtool_ts_info *ts);
	356
24462549 FF	357	/*
	358	* Suspend and resume
	359	*/
	360	int (suspend)(struct dsa_switch ds);
	361	int (resume)(struct dsa_switch ds);
b2f2af21 FF	362
	363	/*
	364	* Port enable/disable
	365	*/
	366	int (port_enable)(struct dsa_switch ds, int port,
	367	struct phy_device *phy);
75104db0	368	void (port_disable)(struct dsa_switch ds, int port);
7905288f FF	369
7905288f FF	370	/*
08f50061	371	* Port's MAC EEE settings
7905288f	372	*/
08f50061 VD	373	int (set_mac_eee)(struct dsa_switch ds, int port,
	374	struct ethtool_eee *e);
	375	int (get_mac_eee)(struct dsa_switch ds, int port,
	376	struct ethtool_eee *e);
51579c3f	377
6793abb4 GR	378	/* EEPROM access */
	379	int (get_eeprom_len)(struct dsa_switch ds);
	380	int (get_eeprom)(struct dsa_switch ds,
	381	struct ethtool_eeprom eeprom, u8 data);
	382	int (set_eeprom)(struct dsa_switch ds,
	383	struct ethtool_eeprom eeprom, u8 data);
3d762a0f GR	384
	385	/*
	386	* Register access.
	387	*/
	388	int (get_regs_len)(struct dsa_switch ds, int port);
	389	void (get_regs)(struct dsa_switch ds, int port,
	390	struct ethtool_regs regs, void p);
b73adef6 FF	391
	392	/*
	393	* Bridge integration
	394	*/
34a79f63	395	int (set_ageing_time)(struct dsa_switch ds, unsigned int msecs);
71327a4e	396	int (port_bridge_join)(struct dsa_switch ds, int port,
a6692754	397	struct net_device *bridge);
f123f2fb VD	398	void (port_bridge_leave)(struct dsa_switch ds, int port,
f123f2fb VD	399	struct net_device *bridge);
43c44a9f VD	400	void (port_stp_state_set)(struct dsa_switch ds, int port,
43c44a9f VD	401	u8 state);
732f794c	402	void (port_fast_age)(struct dsa_switch ds, int port);
57652796 RK	403	int (port_egress_floods)(struct dsa_switch ds, int port,
57652796 RK	404	bool unicast, bool multicast);
2a778e1b	405
11149536 VD	406	/*
	407	* VLAN support
	408	*/
fb2dabad VD	409	int (port_vlan_filtering)(struct dsa_switch ds, int port,
fb2dabad VD	410	bool vlan_filtering);
80e02360 VD	411	int (port_vlan_prepare)(struct dsa_switch ds, int port,
	412	const struct switchdev_obj_port_vlan *vlan);
	413	void (port_vlan_add)(struct dsa_switch ds, int port,
	414	const struct switchdev_obj_port_vlan *vlan);
76e398a6 VD	415	int (port_vlan_del)(struct dsa_switch ds, int port,
76e398a6 VD	416	const struct switchdev_obj_port_vlan *vlan);
2a778e1b VD	417	/*
	418	* Forwarding database
	419	*/
1b6dd556	420	int (port_fdb_add)(struct dsa_switch ds, int port,
6c2c1dcb	421	const unsigned char *addr, u16 vid);
2a778e1b	422	int (port_fdb_del)(struct dsa_switch ds, int port,
6c2c1dcb	423	const unsigned char *addr, u16 vid);
ea70ba98	424	int (port_fdb_dump)(struct dsa_switch ds, int port,
2bedde1a	425	dsa_fdb_dump_cb_t cb, void data);
8df30255 VD	426
	427	/*
	428	* Multicast database
	429	*/
3709aadc VD	430	int (port_mdb_prepare)(struct dsa_switch ds, int port,
	431	const struct switchdev_obj_port_mdb *mdb);
	432	void (port_mdb_add)(struct dsa_switch ds, int port,
	433	const struct switchdev_obj_port_mdb *mdb);
8df30255 VD	434	int (port_mdb_del)(struct dsa_switch ds, int port,
8df30255 VD	435	const struct switchdev_obj_port_mdb *mdb);
bf9f2648 FF	436	/*
	437	* RXNFC
	438	*/
	439	int (get_rxnfc)(struct dsa_switch ds, int port,
	440	struct ethtool_rxnfc nfc, u32 rule_locs);
	441	int (set_rxnfc)(struct dsa_switch ds, int port,
	442	struct ethtool_rxnfc *nfc);
f50f2127 FF	443
	444	/*
	445	* TC integration
	446	*/
	447	int (port_mirror_add)(struct dsa_switch ds, int port,
	448	struct dsa_mall_mirror_tc_entry *mirror,
	449	bool ingress);
	450	void (port_mirror_del)(struct dsa_switch ds, int port,
	451	struct dsa_mall_mirror_tc_entry *mirror);
40ef2c93 VD	452
	453	/*
	454	* Cross-chip operations
	455	*/
	456	int (crosschip_bridge_join)(struct dsa_switch ds, int sw_index,
	457	int port, struct net_device *br);
	458	void (crosschip_bridge_leave)(struct dsa_switch ds, int sw_index,
	459	int port, struct net_device *br);
0336369d BS	460
	461	/*
	462	* PTP functionality
	463	*/
	464	int (port_hwtstamp_get)(struct dsa_switch ds, int port,
	465	struct ifreq *ifr);
	466	int (port_hwtstamp_set)(struct dsa_switch ds, int port,
	467	struct ifreq *ifr);
90af1059 BS	468	bool (port_txtstamp)(struct dsa_switch ds, int port,
	469	struct sk_buff *clone, unsigned int type);
	470	bool (port_rxtstamp)(struct dsa_switch ds, int port,
	471	struct sk_buff *skb, unsigned int type);
c8f0b869 BH	472	};
c8f0b869 BH	473
ab3d408d FF	474	struct dsa_switch_driver {
ab3d408d FF	475	struct list_head list;
a82f67af	476	const struct dsa_switch_ops *ops;
ab3d408d FF	477	};
ab3d408d FF	478
2a93c1a3	479	#if IS_ENABLED(CONFIG_NET_DSA_LEGACY)
a6a71f19	480	/* Legacy driver registration */
ab3d408d FF	481	void register_switch_driver(struct dsa_switch_driver *type);
ab3d408d FF	482	void unregister_switch_driver(struct dsa_switch_driver *type);
b4d2394d	483	struct mii_bus dsa_host_dev_to_mii_bus(struct device dev);
a6a71f19	484
2a93c1a3 FF	485	#else
	486	static inline void register_switch_driver(struct dsa_switch_driver *type) { }
	487	static inline void unregister_switch_driver(struct dsa_switch_driver *type) { }
	488	static inline struct mii_bus dsa_host_dev_to_mii_bus(struct device dev)
	489	{
	490	return NULL;
	491	}
	492	#endif
14b89f36	493	struct net_device dsa_dev_to_net_device(struct device dev);
c8f0b869	494
73a7ece8	495	/* Keep inline for faster access in hot path */
c6e970a0 AL	496	static inline bool netdev_uses_dsa(struct net_device *dev)
	497	{
	498	#if IS_ENABLED(CONFIG_NET_DSA)
717ffbfb	499	return dev->dsa_ptr && dev->dsa_ptr->rcv;
c6e970a0 AL	500	#endif
	501	return false;
	502	}
	503
a0c02161	504	struct dsa_switch dsa_switch_alloc(struct device dev, size_t n);
83c0afae	505	void dsa_unregister_switch(struct dsa_switch *ds);
23c9ee49	506	int dsa_register_switch(struct dsa_switch *ds);
ea825e70 FF	507	#ifdef CONFIG_PM_SLEEP
	508	int dsa_switch_suspend(struct dsa_switch *ds);
	509	int dsa_switch_resume(struct dsa_switch *ds);
	510	#else
	511	static inline int dsa_switch_suspend(struct dsa_switch *ds)
	512	{
	513	return 0;
	514	}
	515	static inline int dsa_switch_resume(struct dsa_switch *ds)
	516	{
	517	return 0;
	518	}
	519	#endif /* CONFIG_PM_SLEEP */
	520
60724d4b FF	521	enum dsa_notifier_type {
	522	DSA_PORT_REGISTER,
	523	DSA_PORT_UNREGISTER,
	524	};
	525
	526	struct dsa_notifier_info {
	527	struct net_device *dev;
	528	};
	529
	530	struct dsa_notifier_register_info {
	531	struct dsa_notifier_info info; /* must be first */
	532	struct net_device *master;
	533	unsigned int port_number;
	534	unsigned int switch_number;
	535	};
	536
	537	static inline struct net_device *
	538	dsa_notifier_info_to_dev(const struct dsa_notifier_info *info)
	539	{
	540	return info->dev;
	541	}
	542
	543	#if IS_ENABLED(CONFIG_NET_DSA)
	544	int register_dsa_notifier(struct notifier_block *nb);
	545	int unregister_dsa_notifier(struct notifier_block *nb);
	546	int call_dsa_notifiers(unsigned long val, struct net_device *dev,
	547	struct dsa_notifier_info *info);
	548	#else
	549	static inline int register_dsa_notifier(struct notifier_block *nb)
	550	{
	551	return 0;
	552	}
	553
	554	static inline int unregister_dsa_notifier(struct notifier_block *nb)
	555	{
	556	return 0;
	557	}
	558
	559	static inline int call_dsa_notifiers(unsigned long val, struct net_device *dev,
	560	struct dsa_notifier_info *info)
	561	{
	562	return NOTIFY_DONE;
	563	}
	564	#endif
	565
0a5f14ce FF	566	/* Broadcom tag specific helpers to insert and extract queue/port number */
	567	#define BRCM_TAG_SET_PORT_QUEUE(p, q) ((p) << 8 \| q)
	568	#define BRCM_TAG_GET_PORT(v) ((v) >> 8)
	569	#define BRCM_TAG_GET_QUEUE(v) ((v) & 0xff)
	570
cf963573 FF	571
	572	int dsa_port_get_phy_strings(struct dsa_port dp, uint8_t data);
	573	int dsa_port_get_ethtool_phy_stats(struct dsa_port dp, uint64_t data);
	574	int dsa_port_get_phy_sset_count(struct dsa_port *dp);
11d8f3dd	575	void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up);
cf963573	576
91da11f8	577	#endif