/* SPDX-License-Identifier: GPL-2.0-or-later */
#ifndef __MXL862XX_H
#define __MXL862XX_H
#include <asm/byteorder.h>
#include <linux/mdio.h>
#include <linux/workqueue.h>
#include <net/dsa.h>
struct mxl862xx_priv;
#define MXL862XX_MAX_PORTS 17
#define MXL862XX_FIRST_SERDES_PORT 9
#define MXL862XX_SERDES_SLOTS 4
#define MXL862XX_DEFAULT_BRIDGE 0
#define MXL862XX_MAX_BRIDGES 48
#define MXL862XX_MAX_BRIDGE_PORTS 128
#define MXL862XX_TOTAL_EVLAN_ENTRIES 1024
#define MXL862XX_TOTAL_VF_ENTRIES 1024
/* Number of __le16 words in a firmware portmap (128-bit bitmap). */
#define MXL862XX_FW_PORTMAP_WORDS (MXL862XX_MAX_BRIDGE_PORTS / 16)
/**
* mxl862xx_fw_portmap_set_bit - set a single port bit in a firmware portmap
* @map: firmware portmap array (MXL862XX_FW_PORTMAP_WORDS entries)
* @port: port index (0..MXL862XX_MAX_BRIDGE_PORTS-1)
*/
static inline void mxl862xx_fw_portmap_set_bit(__le16 *map, int port)
{
map[port / 16] |= cpu_to_le16(BIT(port % 16));
}
/**
* mxl862xx_fw_portmap_clear_bit - clear a single port bit in a firmware portmap
* @map: firmware portmap array (MXL862XX_FW_PORTMAP_WORDS entries)
* @port: port index (0..MXL862XX_MAX_BRIDGE_PORTS-1)
*/
static inline void mxl862xx_fw_portmap_clear_bit(__le16 *map, int port)
{
map[port / 16] &= ~cpu_to_le16(BIT(port % 16));
}
/**
* mxl862xx_fw_portmap_is_empty - check whether a firmware portmap has no
* bits set
* @map: firmware portmap array (MXL862XX_FW_PORTMAP_WORDS entries)
*
* Return: true if every word in @map is zero.
*/
static inline bool mxl862xx_fw_portmap_is_empty(const __le16 *map)
{
int i;
for (i = 0; i < MXL862XX_FW_PORTMAP_WORDS; i++)
if (map[i])
return false;
return true;
}
/**
* struct mxl862xx_vf_vid - Per-VID entry within a VLAN Filter block
* @list: Linked into &mxl862xx_vf_block.vids
* @vid: VLAN ID
* @index: Entry index within the VLAN Filter HW block
* @untagged: Strip tag on egress for this VID (drives EVLAN tag-stripping)
*/
struct mxl862xx_vf_vid {
struct list_head list;
u16 vid;
u16 index;
bool untagged;
};
/**
* struct mxl862xx_vf_block - Per-port VLAN Filter block
* @allocated: Whether the HW block has been allocated via VLANFILTER_ALLOC
* @block_id: HW VLAN Filter block ID from VLANFILTER_ALLOC
* @block_size: Total entries allocated in this block
* @active_count: Number of ALLOW entries at indices [0, active_count).
* The bridge port config sends max(active_count, 1) as
* block_size to narrow the HW scan window.
* discard_unmatched_tagged handles frames outside this range.
* @vids: List of &mxl862xx_vf_vid entries programmed in this block
*/
struct mxl862xx_vf_block {
bool allocated;
u16 block_id;
u16 block_size;
u16 active_count;
struct list_head vids;
};
/**
* struct mxl862xx_evlan_block - Per-port per-direction extended VLAN block
* @allocated: Whether the HW block has been allocated via EXTENDEDVLAN_ALLOC.
* Guards alloc/free idempotency--the block_id is only valid
* while allocated is true.
* @in_use: Whether the EVLAN engine should be enabled for this block
* on the bridge port (sent as the enable flag in
* set_bridge_port). Can be false while allocated is still
* true -- e.g. when all egress VIDs are removed (idx == 0 in
* evlan_program_egress) the block stays allocated for
* potential reuse, but the engine is disabled so an empty
* rule set does not discard all traffic.
* @block_id: HW block ID from EXTENDEDVLAN_ALLOC
* @block_size: Total entries allocated
* @n_active: Number of HW entries currently written. The bridge port
* config sends this as the egress scan window, so entries
* beyond n_active are never scanned. Always equals
* block_size for ingress blocks (fixed catchall rules).
*/
struct mxl862xx_evlan_block {
bool allocated;
bool in_use;
u16 block_id;
u16 block_size;
u16 n_active;
};
/**
* struct mxl862xx_port_stats - 64-bit accumulated hardware port statistics
* @rx_packets: total received packets
* @tx_packets: total transmitted packets
* @rx_bytes: total received bytes
* @tx_bytes: total transmitted bytes
* @rx_errors: total receive errors
* @tx_errors: total transmit errors
* @rx_dropped: total received packets dropped
* @tx_dropped: total transmitted packets dropped
* @multicast: total received multicast packets
* @collisions: total transmit collisions
* @rx_length_errors: received length errors (undersize + oversize)
* @rx_crc_errors: received FCS errors
* @rx_frame_errors: received alignment errors
* @prev_rx_good_pkts: previous snapshot of rx good packet counter
* @prev_tx_good_pkts: previous snapshot of tx good packet counter
* @prev_rx_good_bytes: previous snapshot of rx good byte counter
* @prev_tx_good_bytes: previous snapshot of tx good byte counter
* @prev_rx_fcserror_pkts: previous snapshot of rx FCS error counter
* @prev_rx_under_size_error_pkts: previous snapshot of rx undersize
* error counter
* @prev_rx_oversize_error_pkts: previous snapshot of rx oversize
* error counter
* @prev_rx_align_error_pkts: previous snapshot of rx alignment
* error counter
* @prev_tx_dropped_pkts: previous snapshot of tx dropped counter
* @prev_rx_dropped_pkts: previous snapshot of rx dropped counter
* @prev_rx_evlan_discard_pkts: previous snapshot of extended VLAN
* discard counter
* @prev_mtu_exceed_discard_pkts: previous snapshot of MTU exceed
* discard counter
* @prev_tx_acm_dropped_pkts: previous snapshot of tx ACM dropped
* counter
* @prev_rx_multicast_pkts: previous snapshot of rx multicast counter
* @prev_tx_coll_count: previous snapshot of tx collision counter
*
* The firmware RMON counters are 32-bit free-running (64-bit for byte
* counters). This structure holds 64-bit accumulators alongside the
* previous raw snapshot so that deltas can be computed across polls,
* handling 32-bit wrap correctly via unsigned subtraction.
*/
struct mxl862xx_port_stats {
u64 rx_packets;
u64 tx_packets;
u64 rx_bytes;
u64 tx_bytes;
u64 rx_errors;
u64 tx_errors;
u64 rx_dropped;
u64 tx_dropped;
u64 multicast;
u64 collisions;
u64 rx_length_errors;
u64 rx_crc_errors;
u64 rx_frame_errors;
u32 prev_rx_good_pkts;
u32 prev_tx_good_pkts;
u64 prev_rx_good_bytes;
u64 prev_tx_good_bytes;
u32 prev_rx_fcserror_pkts;
u32 prev_rx_under_size_error_pkts;
u32 prev_rx_oversize_error_pkts;
u32 prev_rx_align_error_pkts;
u32 prev_tx_dropped_pkts;
u32 prev_rx_dropped_pkts;
u32 prev_rx_evlan_discard_pkts;
u32 prev_mtu_exceed_discard_pkts;
u32 prev_tx_acm_dropped_pkts;
u32 prev_rx_multicast_pkts;
u32 prev_tx_coll_count;
};
/**
* struct mxl862xx_port - per-port state tracked by the driver
* @priv: back-pointer to switch private data; needed by
* deferred work handlers to access ds and priv
* @fid: firmware FID for the permanent single-port bridge;
* kept alive for the lifetime of the port so traffic is
* never forwarded while the port is unbridged
* @flood_block: bitmask of firmware meter indices that are currently
* rate-limiting flood traffic on this port (zero-rate
* meters used to block flooding)
* @learning: true when address learning is enabled on this port
* @setup_done: set at end of port_setup, cleared at start of
* port_teardown; guards deferred work against
* acting on torn-down state
* @pvid: port VLAN ID (native VLAN) assigned to untagged traffic
* @vlan_filtering: true when VLAN filtering is enabled on this port
* @vf: per-port VLAN Filter block state
* @ingress_evlan: ingress extended VLAN block state
* @egress_evlan: egress extended VLAN block state
* @host_flood_uc: desired host unicast flood state (true = flood);
* updated atomically by port_set_host_flood, consumed
* by the deferred host_flood_work
* @host_flood_mc: desired host multicast flood state (true = flood)
* @host_flood_work: deferred work for applying host flood changes;
* port_set_host_flood runs in atomic context (under
* netif_addr_lock) so firmware calls must be deferred.
* The worker acquires rtnl_lock() to serialize with
* DSA callbacks and checks @setup_done to avoid
* acting on torn-down ports.
* @stats: 64-bit accumulated hardware statistics; updated
* periodically by the stats polling work
* @stats_lock: protects accumulator reads in .get_stats64 against
* concurrent updates from the polling work
*/
struct mxl862xx_port {
struct mxl862xx_priv *priv;
u16 fid;
unsigned long flood_block;
bool learning;
bool setup_done;
u16 pvid;
bool vlan_filtering;
struct mxl862xx_vf_block vf;
struct mxl862xx_evlan_block ingress_evlan;
struct mxl862xx_evlan_block egress_evlan;
bool host_flood_uc;
bool host_flood_mc;
struct work_struct host_flood_work;
struct mxl862xx_port_stats stats;
spinlock_t stats_lock; /* protects stats accumulators */
};
/**
* struct mxl862xx_pcs - link SerDes interfaces to bridge ports
* @pcs: &struct phylink_pcs instance
* @priv: pointer to &struct mxl862xx_priv
* @serdes_id: SerDes instance index (0 or 1)
* @slot: slot within the SerDes (0-3 for QSGMII/QUSXGMII, 0 otherwise)
* @interface: cached PHY interface, last value passed to pcs_config().
* %PHY_INTERFACE_MODE_NA before the first successful
* pcs_config(). Used by pcs_an_restart() to populate the
* firmware command and by pcs_disable() to skip the
* firmware power-down for shared (QSGMII/QUSXGMII) modes.
*/
struct mxl862xx_pcs {
struct phylink_pcs pcs;
struct mxl862xx_priv *priv;
int serdes_id;
int slot;
phy_interface_t interface;
};
/**
* struct mxl862xx_fw_version - firmware version for comparison and display
* @major: firmware major version
* @minor: firmware minor version
* @revision: firmware revision number
*/
struct mxl862xx_fw_version {
u8 major;
u8 minor;
u16 revision;
};
#define MXL862XX_FW_VER(maj, min, rev) \
(((u32)(maj) << 24) | ((u32)(min) << 16) | (rev))
#define MXL862XX_FW_VER_MIN(priv, maj, min, rev) \
(MXL862XX_FW_VER((priv)->fw_version.major, (priv)->fw_version.minor, \
(priv)->fw_version.revision) >= \
MXL862XX_FW_VER(maj, min, rev))
/* Bit indices for struct mxl862xx_priv::flags */
#define MXL862XX_FLAG_CRC_ERR 0
#define MXL862XX_FLAG_WORK_STOPPED 1
/**
* struct mxl862xx_priv - driver private data for an MxL862xx switch
* @ds: pointer to the DSA switch instance
* @mdiodev: MDIO device used to communicate with the switch firmware
* @crc_err_work: deferred work for shutting down all ports on MDIO CRC
* errors
* @flags: atomic status flags; %MXL862XX_FLAG_CRC_ERR is set
* before CRC-triggered shutdown and cleared after;
* %MXL862XX_FLAG_WORK_STOPPED is set before cancelling
* stats_work to prevent rescheduling during teardown
* @drop_meter: index of the single shared zero-rate firmware meter
* used to unconditionally drop traffic (used to block
* flooding)
* @fw_version: cached firmware version, populated at probe and
* compared with MXL862XX_FW_VER_MIN()
* @serdes_ports: SerDes interfaces incl. sub-interfaces in case of
* 10G_QXGMII or QSGMII
* @serdes_refcount: per-XPCS count of sub-ports enabled by phylink;
* pcs_disable powers an XPCS down when the count
* reaches zero. Protected by @serdes_lock.
* @serdes_lock: serializes the @serdes_refcount transitions with
* the XPCS power-down so a sibling sub-port enable
* cannot race a power-down to zero
* @ports: per-port state, indexed by switch port number
* @bridges: maps DSA bridge number to firmware bridge ID;
* zero means no firmware bridge allocated for that
* DSA bridge number. Indexed by dsa_bridge.num
* (0 .. ds->max_num_bridges).
* @evlan_ingress_size: per-port ingress Extended VLAN block size
* @evlan_egress_size: per-port egress Extended VLAN block size
* @vf_block_size: per-port VLAN Filter block size
* @stats_work: periodic work item that polls RMON hardware counters
* and accumulates them into 64-bit per-port stats
*/
struct mxl862xx_priv {
struct dsa_switch *ds;
struct mdio_device *mdiodev;
struct work_struct crc_err_work;
unsigned long flags;
u16 drop_meter;
struct mxl862xx_fw_version fw_version;
struct mxl862xx_pcs serdes_ports[8];
int serdes_refcount[2];
struct mutex serdes_lock;
struct mxl862xx_port ports[MXL862XX_MAX_PORTS];
u16 bridges[MXL862XX_MAX_BRIDGES + 1];
u16 evlan_ingress_size;
u16 evlan_egress_size;
u16 vf_block_size;
struct delayed_work stats_work;
};
#endif /* __MXL862XX_H */
