linux/drivers/net/ethernet/broadcom/bcmsysport.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Broadcom BCM7xxx System Port Ethernet MAC driver
 *
 * Copyright (C) 2014 Broadcom Corporation
 */

#define pr_fmt(fmt)

#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/dsa/brcm.h>
#include <linux/etherdevice.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_net.h>
#include <linux/of_mdio.h>
#include <linux/phy.h>
#include <linux/phy_fixed.h>
#include <net/dsa.h>
#include <linux/clk.h>
#include <net/ip.h>
#include <net/ipv6.h>

#include "bcmsysport.h"

/* I/O accessors register helpers */
#define BCM_SYSPORT_IO_MACRO(name, offset)									\

BCM_SYSPORT_IO_MACRO(intrl2_0, SYS_PORT_INTRL2_0_OFFSET);
BCM_SYSPORT_IO_MACRO(intrl2_1, SYS_PORT_INTRL2_1_OFFSET);
BCM_SYSPORT_IO_MACRO(umac, SYS_PORT_UMAC_OFFSET);
BCM_SYSPORT_IO_MACRO(gib, SYS_PORT_GIB_OFFSET);
BCM_SYSPORT_IO_MACRO(tdma, SYS_PORT_TDMA_OFFSET);
BCM_SYSPORT_IO_MACRO(rxchk, SYS_PORT_RXCHK_OFFSET);
BCM_SYSPORT_IO_MACRO(txchk, SYS_PORT_TXCHK_OFFSET);
BCM_SYSPORT_IO_MACRO(rbuf, SYS_PORT_RBUF_OFFSET);
BCM_SYSPORT_IO_MACRO(tbuf, SYS_PORT_TBUF_OFFSET);
BCM_SYSPORT_IO_MACRO(topctrl, SYS_PORT_TOPCTRL_OFFSET);

/* On SYSTEMPORT Lite, any register after RDMA_STATUS has the exact
 * same layout, except it has been moved by 4 bytes up, *sigh*
 */
static inline u32 rdma_readl(struct bcm_sysport_priv *priv, u32 off)
{}

static inline void rdma_writel(struct bcm_sysport_priv *priv, u32 val, u32 off)
{}

static inline u32 tdma_control_bit(struct bcm_sysport_priv *priv, u32 bit)
{}

/* L2-interrupt masking/unmasking helpers, does automatic saving of the applied
 * mask in a software copy to avoid CPU_MASK_STATUS reads in hot-paths.
  */
#define BCM_SYSPORT_INTR_L2(which)									\

BCM_SYSPORT_INTR_L2()
BCM_SYSPORT_INTR_L2()

/* Register accesses to GISB/RBUS registers are expensive (few hundred
 * nanoseconds), so keep the check for 64-bits explicit here to save
 * one register write per-packet on 32-bits platforms.
 */
static inline void dma_desc_set_addr(struct bcm_sysport_priv *priv,
				     void __iomem *d,
				     dma_addr_t addr)
{}

/* Ethtool operations */
static void bcm_sysport_set_rx_csum(struct net_device *dev,
				    netdev_features_t wanted)
{}

static void bcm_sysport_set_tx_csum(struct net_device *dev,
				    netdev_features_t wanted)
{}

static int bcm_sysport_set_features(struct net_device *dev,
				    netdev_features_t features)
{}

/* Hardware counters must be kept in sync because the order/offset
 * is important here (order in structure declaration = order in hardware)
 */
static const struct bcm_sysport_stats bcm_sysport_gstrings_stats[] =;

#define BCM_SYSPORT_STATS_LEN

static void bcm_sysport_get_drvinfo(struct net_device *dev,
				    struct ethtool_drvinfo *info)
{}

static u32 bcm_sysport_get_msglvl(struct net_device *dev)
{}

static void bcm_sysport_set_msglvl(struct net_device *dev, u32 enable)
{}

static inline bool bcm_sysport_lite_stat_valid(enum bcm_sysport_stat_type type)
{}

static int bcm_sysport_get_sset_count(struct net_device *dev, int string_set)
{}

static void bcm_sysport_get_strings(struct net_device *dev,
				    u32 stringset, u8 *data)
{}

static void bcm_sysport_update_mib_counters(struct bcm_sysport_priv *priv)
{}

static void bcm_sysport_update_tx_stats(struct bcm_sysport_priv *priv,
					u64 *tx_bytes, u64 *tx_packets)
{}

static void bcm_sysport_get_stats(struct net_device *dev,
				  struct ethtool_stats *stats, u64 *data)
{}

static void bcm_sysport_get_wol(struct net_device *dev,
				struct ethtool_wolinfo *wol)
{}

static int bcm_sysport_set_wol(struct net_device *dev,
			       struct ethtool_wolinfo *wol)
{}

static void bcm_sysport_set_rx_coalesce(struct bcm_sysport_priv *priv,
					u32 usecs, u32 pkts)
{}

static void bcm_sysport_set_tx_coalesce(struct bcm_sysport_tx_ring *ring,
					struct ethtool_coalesce *ec)
{}

static int bcm_sysport_get_coalesce(struct net_device *dev,
				    struct ethtool_coalesce *ec,
				    struct kernel_ethtool_coalesce *kernel_coal,
				    struct netlink_ext_ack *extack)
{}

static int bcm_sysport_set_coalesce(struct net_device *dev,
				    struct ethtool_coalesce *ec,
				    struct kernel_ethtool_coalesce *kernel_coal,
				    struct netlink_ext_ack *extack)
{}

static void bcm_sysport_free_cb(struct bcm_sysport_cb *cb)
{}

static struct sk_buff *bcm_sysport_rx_refill(struct bcm_sysport_priv *priv,
					     struct bcm_sysport_cb *cb)
{}

static int bcm_sysport_alloc_rx_bufs(struct bcm_sysport_priv *priv)
{}

/* Poll the hardware for up to budget packets to process */
static unsigned int bcm_sysport_desc_rx(struct bcm_sysport_priv *priv,
					unsigned int budget)
{}

static void bcm_sysport_tx_reclaim_one(struct bcm_sysport_tx_ring *ring,
				       struct bcm_sysport_cb *cb,
				       unsigned int *bytes_compl,
				       unsigned int *pkts_compl)
{}

/* Reclaim queued SKBs for transmission completion, lockless version */
static unsigned int __bcm_sysport_tx_reclaim(struct bcm_sysport_priv *priv,
					     struct bcm_sysport_tx_ring *ring)
{}

/* Locked version of the per-ring TX reclaim routine */
static unsigned int bcm_sysport_tx_reclaim(struct bcm_sysport_priv *priv,
					   struct bcm_sysport_tx_ring *ring)
{}

/* Locked version of the per-ring TX reclaim, but does not wake the queue */
static void bcm_sysport_tx_clean(struct bcm_sysport_priv *priv,
				 struct bcm_sysport_tx_ring *ring)
{}

static int bcm_sysport_tx_poll(struct napi_struct *napi, int budget)
{}

static void bcm_sysport_tx_reclaim_all(struct bcm_sysport_priv *priv)
{}

static int bcm_sysport_poll(struct napi_struct *napi, int budget)
{}

static void mpd_enable_set(struct bcm_sysport_priv *priv, bool enable)
{}

static void bcm_sysport_resume_from_wol(struct bcm_sysport_priv *priv)
{}

static void bcm_sysport_dim_work(struct work_struct *work)
{}

/* RX and misc interrupt routine */
static irqreturn_t bcm_sysport_rx_isr(int irq, void *dev_id)
{}

/* TX interrupt service routine */
static irqreturn_t bcm_sysport_tx_isr(int irq, void *dev_id)
{}

static irqreturn_t bcm_sysport_wol_isr(int irq, void *dev_id)
{}

#ifdef CONFIG_NET_POLL_CONTROLLER
static void bcm_sysport_poll_controller(struct net_device *dev)
{}
#endif

static struct sk_buff *bcm_sysport_insert_tsb(struct sk_buff *skb,
					      struct net_device *dev)
{}

static netdev_tx_t bcm_sysport_xmit(struct sk_buff *skb,
				    struct net_device *dev)
{}

static void bcm_sysport_tx_timeout(struct net_device *dev, unsigned int txqueue)
{}

/* phylib adjust link callback */
static void bcm_sysport_adj_link(struct net_device *dev)
{}

static void bcm_sysport_init_dim(struct bcm_sysport_priv *priv,
				 void (*cb)(struct work_struct *work))
{}

static void bcm_sysport_init_rx_coalesce(struct bcm_sysport_priv *priv)
{}

static int bcm_sysport_init_tx_ring(struct bcm_sysport_priv *priv,
				    unsigned int index)
{}

static void bcm_sysport_fini_tx_ring(struct bcm_sysport_priv *priv,
				     unsigned int index)
{}

/* RDMA helper */
static inline int rdma_enable_set(struct bcm_sysport_priv *priv,
				  unsigned int enable)
{}

/* TDMA helper */
static inline int tdma_enable_set(struct bcm_sysport_priv *priv,
				  unsigned int enable)
{}

static int bcm_sysport_init_rx_ring(struct bcm_sysport_priv *priv)
{}

static void bcm_sysport_fini_rx_ring(struct bcm_sysport_priv *priv)
{}

static void bcm_sysport_set_rx_mode(struct net_device *dev)
{}

static inline void umac_enable_set(struct bcm_sysport_priv *priv,
				   u32 mask, unsigned int enable)
{}

static inline void umac_reset(struct bcm_sysport_priv *priv)
{}

static void umac_set_hw_addr(struct bcm_sysport_priv *priv,
			     const unsigned char *addr)
{}

static void topctrl_flush(struct bcm_sysport_priv *priv)
{}

static int bcm_sysport_change_mac(struct net_device *dev, void *p)
{}

static void bcm_sysport_get_stats64(struct net_device *dev,
				    struct rtnl_link_stats64 *stats)
{}

static void bcm_sysport_netif_start(struct net_device *dev)
{}

static void rbuf_init(struct bcm_sysport_priv *priv)
{}

static inline void bcm_sysport_mask_all_intrs(struct bcm_sysport_priv *priv)
{}

static inline void gib_set_pad_extension(struct bcm_sysport_priv *priv)
{}

static int bcm_sysport_open(struct net_device *dev)
{}

static void bcm_sysport_netif_stop(struct net_device *dev)
{}

static int bcm_sysport_stop(struct net_device *dev)
{}

static int bcm_sysport_rule_find(struct bcm_sysport_priv *priv,
				 u64 location)
{}

static int bcm_sysport_rule_get(struct bcm_sysport_priv *priv,
				struct ethtool_rxnfc *nfc)
{}

static int bcm_sysport_rule_set(struct bcm_sysport_priv *priv,
				struct ethtool_rxnfc *nfc)
{}

static int bcm_sysport_rule_del(struct bcm_sysport_priv *priv,
				u64 location)
{}

static int bcm_sysport_get_rxnfc(struct net_device *dev,
				 struct ethtool_rxnfc *nfc, u32 *rule_locs)
{}

static int bcm_sysport_set_rxnfc(struct net_device *dev,
				 struct ethtool_rxnfc *nfc)
{}

static const struct ethtool_ops bcm_sysport_ethtool_ops =;

static u16 bcm_sysport_select_queue(struct net_device *dev, struct sk_buff *skb,
				    struct net_device *sb_dev)
{}

static const struct net_device_ops bcm_sysport_netdev_ops =;

static int bcm_sysport_map_queues(struct net_device *dev,
				  struct net_device *slave_dev)
{}

static int bcm_sysport_unmap_queues(struct net_device *dev,
				    struct net_device *slave_dev)
{}

static int bcm_sysport_netdevice_event(struct notifier_block *nb,
				       unsigned long event, void *ptr)
{}

#define REV_FMT

static const struct bcm_sysport_hw_params bcm_sysport_params[] =;

static const struct of_device_id bcm_sysport_of_match[] =;
MODULE_DEVICE_TABLE(of, bcm_sysport_of_match);

static int bcm_sysport_probe(struct platform_device *pdev)
{}

static void bcm_sysport_remove(struct platform_device *pdev)
{}

static int bcm_sysport_suspend_to_wol(struct bcm_sysport_priv *priv)
{}

static int __maybe_unused bcm_sysport_suspend(struct device *d)
{}

static int __maybe_unused bcm_sysport_resume(struct device *d)
{}

static SIMPLE_DEV_PM_OPS(bcm_sysport_pm_ops,
		bcm_sysport_suspend, bcm_sysport_resume);

static struct platform_driver bcm_sysport_driver =;
module_platform_driver();

MODULE_AUTHOR();
MODULE_DESCRIPTION();
MODULE_ALIAS();
MODULE_LICENSE();