be2net: cleanup and refactor stats code (ac124ff9) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/net/benet/be.h

+51 −59

Original line number	Original line	Diff line number	Diff line
	@@ -167,15 +167,13 @@ struct be_mcc_obj {
	};		};

	struct be_tx_stats {		struct be_tx_stats {
	u32 be_tx_reqs; /* number of TX requests initiated */		u64 tx_bytes;
	u32 be_tx_stops; /* number of times TX Q was stopped */		u64 tx_pkts;
	u32 be_tx_wrbs; /* number of tx WRBs used */		u64 tx_reqs;
	u32 be_tx_compl; /* number of tx completion entries processed */		u64 tx_wrbs;
	ulong be_tx_jiffies;		u64 tx_compl;
	u64 be_tx_bytes;		ulong tx_jiffies;
	u64 be_tx_bytes_prev;		u32 tx_stops;
	u64 be_tx_pkts;
	u32 be_tx_rate;
	};		};

	struct be_tx_obj {		struct be_tx_obj {
	@@ -195,22 +193,19 @@ struct be_rx_page_info {
	};		};

	struct be_rx_stats {		struct be_rx_stats {
	u32 rx_post_fail;/* number of ethrx buffer alloc failures */
	u32 rx_polls; /* number of times NAPI called poll function */
	u32 rx_events; /* number of ucast rx completion events */
	u32 rx_compl; /* number of rx completion entries processed */
	ulong rx_dropped; /* number of skb allocation errors */
	ulong rx_jiffies;
	u64 rx_bytes;		u64 rx_bytes;
	u64 rx_bytes_prev;
	u64 rx_pkts;		u64 rx_pkts;
	u32 rx_rate;		u64 rx_pkts_prev;
			ulong rx_jiffies;
			u32 rx_drops_no_skbs; /* skb allocation errors */
			u32 rx_drops_no_frags; /* HW has no fetched frags */
			u32 rx_post_fail; /* page post alloc failures */
			u32 rx_polls; /* NAPI calls */
			u32 rx_events;
			u32 rx_compl;
	u32 rx_mcast_pkts;		u32 rx_mcast_pkts;
	u32 rxcp_err; /* Num rx completion entries w/ err set. */		u32 rx_compl_err; /* completions with err set */
	ulong rx_fps_jiffies; /* jiffies at last FPS calc */		u32 rx_pps; /* pkts per second */
	u32 rx_frags;
	u32 prev_rx_frags;
	u32 rx_fps; /* Rx frags per second */
	};		};

	struct be_rx_compl_info {		struct be_rx_compl_info {
	@@ -247,43 +242,40 @@ struct be_rx_obj {

	struct be_drv_stats {		struct be_drv_stats {
	u8 be_on_die_temperature;		u8 be_on_die_temperature;
	u64 be_tx_events;		u32 tx_events;
	u64 eth_red_drops;		u32 eth_red_drops;
	u64 rx_drops_no_pbuf;		u32 rx_drops_no_pbuf;
	u64 rx_drops_no_txpb;		u32 rx_drops_no_txpb;
	u64 rx_drops_no_erx_descr;		u32 rx_drops_no_erx_descr;
	u64 rx_drops_no_tpre_descr;		u32 rx_drops_no_tpre_descr;
	u64 rx_drops_too_many_frags;		u32 rx_drops_too_many_frags;
	u64 rx_drops_invalid_ring;		u32 rx_drops_invalid_ring;
	u64 forwarded_packets;		u32 forwarded_packets;
	u64 rx_drops_mtu;		u32 rx_drops_mtu;
	u64 rx_crc_errors;		u32 rx_crc_errors;
	u64 rx_alignment_symbol_errors;		u32 rx_alignment_symbol_errors;
	u64 rx_pause_frames;		u32 rx_pause_frames;
	u64 rx_priority_pause_frames;		u32 rx_priority_pause_frames;
	u64 rx_control_frames;		u32 rx_control_frames;
	u64 rx_in_range_errors;		u32 rx_in_range_errors;
	u64 rx_out_range_errors;		u32 rx_out_range_errors;
	u64 rx_frame_too_long;		u32 rx_frame_too_long;
	u64 rx_address_match_errors;		u32 rx_address_match_errors;
	u64 rx_dropped_too_small;		u32 rx_dropped_too_small;
	u64 rx_dropped_too_short;		u32 rx_dropped_too_short;
	u64 rx_dropped_header_too_small;		u32 rx_dropped_header_too_small;
	u64 rx_dropped_tcp_length;		u32 rx_dropped_tcp_length;
	u64 rx_dropped_runt;		u32 rx_dropped_runt;
	u64 rx_ip_checksum_errs;		u32 rx_ip_checksum_errs;
	u64 rx_tcp_checksum_errs;		u32 rx_tcp_checksum_errs;
	u64 rx_udp_checksum_errs;		u32 rx_udp_checksum_errs;
	u64 rx_switched_unicast_packets;		u32 tx_pauseframes;
	u64 rx_switched_multicast_packets;		u32 tx_priority_pauseframes;
	u64 rx_switched_broadcast_packets;		u32 tx_controlframes;
	u64 tx_pauseframes;		u32 rxpp_fifo_overflow_drop;
	u64 tx_priority_pauseframes;		u32 rx_input_fifo_overflow_drop;
	u64 tx_controlframes;		u32 pmem_fifo_overflow_drop;
	u64 rxpp_fifo_overflow_drop;		u32 jabber_events;
	u64 rx_input_fifo_overflow_drop;
	u64 pmem_fifo_overflow_drop;
	u64 jabber_events;
	};		};

	struct be_vf_cfg {		struct be_vf_cfg {

drivers/net/benet/be_cmds.c

+0 −20

Original line number	Original line	Diff line number	Diff line
	@@ -82,26 +82,6 @@ static int be_mcc_compl_process(struct be_adapter *adapter,
	if (((compl->tag0 == OPCODE_ETH_GET_STATISTICS) \|\|		if (((compl->tag0 == OPCODE_ETH_GET_STATISTICS) \|\|
	(compl->tag0 == OPCODE_ETH_GET_PPORT_STATS)) &&		(compl->tag0 == OPCODE_ETH_GET_PPORT_STATS)) &&
	(compl->tag1 == CMD_SUBSYSTEM_ETH)) {		(compl->tag1 == CMD_SUBSYSTEM_ETH)) {
	if (adapter->generation == BE_GEN3) {
	if (lancer_chip(adapter)) {
	struct lancer_cmd_resp_pport_stats
	*resp = adapter->stats_cmd.va;
	be_dws_le_to_cpu(&resp->pport_stats,
	sizeof(resp->pport_stats));
	} else {
	struct be_cmd_resp_get_stats_v1 *resp =
	adapter->stats_cmd.va;

	be_dws_le_to_cpu(&resp->hw_stats,
	sizeof(resp->hw_stats));
	}
	} else {
	struct be_cmd_resp_get_stats_v0 *resp =
	adapter->stats_cmd.va;

	be_dws_le_to_cpu(&resp->hw_stats,
	sizeof(resp->hw_stats));
	}
	be_parse_stats(adapter);		be_parse_stats(adapter);
	netdev_stats_update(adapter);		netdev_stats_update(adapter);
	adapter->stats_cmd_sent = false;		adapter->stats_cmd_sent = false;

drivers/net/benet/be_cmds.h

+5 −48

Original line number	Original line	Diff line number	Diff line
	@@ -693,8 +693,7 @@ struct be_cmd_resp_get_stats_v0 {
	struct be_hw_stats_v0 hw_stats;		struct be_hw_stats_v0 hw_stats;
	};		};

	#define make_64bit_val(hi_32, lo_32) (((u64)hi_32<<32) \| lo_32)		struct lancer_pport_stats {
	struct lancer_cmd_pport_stats {
	u32 tx_packets_lo;		u32 tx_packets_lo;
	u32 tx_packets_hi;		u32 tx_packets_hi;
	u32 tx_unicast_packets_lo;		u32 tx_unicast_packets_lo;
	@@ -871,16 +870,16 @@ struct lancer_cmd_req_pport_stats {
	struct be_cmd_req_hdr hdr;		struct be_cmd_req_hdr hdr;
	union {		union {
	struct pport_stats_params params;		struct pport_stats_params params;
	u8 rsvd[sizeof(struct lancer_cmd_pport_stats)];		u8 rsvd[sizeof(struct lancer_pport_stats)];
	} cmd_params;		} cmd_params;
	};		};

	struct lancer_cmd_resp_pport_stats {		struct lancer_cmd_resp_pport_stats {
	struct be_cmd_resp_hdr hdr;		struct be_cmd_resp_hdr hdr;
	struct lancer_cmd_pport_stats pport_stats;		struct lancer_pport_stats pport_stats;
	};		};

	static inline struct lancer_cmd_pport_stats*		static inline struct lancer_pport_stats*
	pport_stats_from_cmd(struct be_adapter *adapter)		pport_stats_from_cmd(struct be_adapter *adapter)
	{		{
	struct lancer_cmd_resp_pport_stats *cmd = adapter->stats_cmd.va;		struct lancer_cmd_resp_pport_stats *cmd = adapter->stats_cmd.va;
	@@ -1383,8 +1382,7 @@ struct be_cmd_resp_get_stats_v1 {
	struct be_hw_stats_v1 hw_stats;		struct be_hw_stats_v1 hw_stats;
	};		};

	static inline void *		static inline void hw_stats_from_cmd(struct be_adapter adapter)
	hw_stats_from_cmd(struct be_adapter *adapter)
	{		{
	if (adapter->generation == BE_GEN3) {		if (adapter->generation == BE_GEN3) {
	struct be_cmd_resp_get_stats_v1 *cmd = adapter->stats_cmd.va;		struct be_cmd_resp_get_stats_v1 *cmd = adapter->stats_cmd.va;
	@@ -1397,34 +1395,6 @@ hw_stats_from_cmd(struct be_adapter *adapter)
	}		}
	}		}

	static inline void be_port_rxf_stats_from_cmd(struct be_adapter adapter)
	{
	if (adapter->generation == BE_GEN3) {
	struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);
	struct be_rxf_stats_v1 *rxf_stats = &hw_stats->rxf;

	return &rxf_stats->port[adapter->port_num];
	} else {
	struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);
	struct be_rxf_stats_v0 *rxf_stats = &hw_stats->rxf;

	return &rxf_stats->port[adapter->port_num];
	}
	}

	static inline void be_rxf_stats_from_cmd(struct be_adapter adapter)
	{
	if (adapter->generation == BE_GEN3) {
	struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);

	return &hw_stats->rxf;
	} else {
	struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);

	return &hw_stats->rxf;
	}
	}

	static inline void be_erx_stats_from_cmd(struct be_adapter adapter)		static inline void be_erx_stats_from_cmd(struct be_adapter adapter)
	{		{
	if (adapter->generation == BE_GEN3) {		if (adapter->generation == BE_GEN3) {
	@@ -1438,19 +1408,6 @@ static inline void be_erx_stats_from_cmd(struct be_adapter adapter)
	}		}
	}		}

	static inline void be_pmem_stats_from_cmd(struct be_adapter adapter)
	{
	if (adapter->generation == BE_GEN3) {
	struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);

	return &hw_stats->pmem;
	} else {
	struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);

	return &hw_stats->pmem;
	}
	}

	extern int be_pci_fnum_get(struct be_adapter *adapter);		extern int be_pci_fnum_get(struct be_adapter *adapter);
	extern int be_cmd_POST(struct be_adapter *adapter);		extern int be_cmd_POST(struct be_adapter *adapter);
	extern int be_cmd_mac_addr_query(struct be_adapter adapter, u8 mac_addr,		extern int be_cmd_mac_addr_query(struct be_adapter adapter, u8 mac_addr,

drivers/net/benet/be_ethtool.c

+15 −50

Original line number	Original line	Diff line number	Diff line
	@@ -26,33 +26,18 @@ struct be_ethtool_stat {
	int offset;		int offset;
	};		};

	enum {NETSTAT, DRVSTAT_TX, DRVSTAT_RX, ERXSTAT,		enum {DRVSTAT_TX, DRVSTAT_RX, DRVSTAT};
	DRVSTAT};
	#define FIELDINFO(_struct, field) FIELD_SIZEOF(_struct, field), \		#define FIELDINFO(_struct, field) FIELD_SIZEOF(_struct, field), \
	offsetof(_struct, field)		offsetof(_struct, field)
	#define NETSTAT_INFO(field) #field, NETSTAT,\
	FIELDINFO(struct net_device_stats,\
	field)
	#define DRVSTAT_TX_INFO(field) #field, DRVSTAT_TX,\		#define DRVSTAT_TX_INFO(field) #field, DRVSTAT_TX,\
	FIELDINFO(struct be_tx_stats, field)		FIELDINFO(struct be_tx_stats, field)
	#define DRVSTAT_RX_INFO(field) #field, DRVSTAT_RX,\		#define DRVSTAT_RX_INFO(field) #field, DRVSTAT_RX,\
	FIELDINFO(struct be_rx_stats, field)		FIELDINFO(struct be_rx_stats, field)
	#define ERXSTAT_INFO(field) #field, ERXSTAT,\
	FIELDINFO(struct be_erx_stats_v1, field)
	#define DRVSTAT_INFO(field) #field, DRVSTAT,\		#define DRVSTAT_INFO(field) #field, DRVSTAT,\
	FIELDINFO(struct be_drv_stats, \		FIELDINFO(struct be_drv_stats, field)
	field)

	static const struct be_ethtool_stat et_stats[] = {		static const struct be_ethtool_stat et_stats[] = {
	{NETSTAT_INFO(rx_packets)},		{DRVSTAT_INFO(tx_events)},
	{NETSTAT_INFO(tx_packets)},
	{NETSTAT_INFO(rx_bytes)},
	{NETSTAT_INFO(tx_bytes)},
	{NETSTAT_INFO(rx_errors)},
	{NETSTAT_INFO(tx_errors)},
	{NETSTAT_INFO(rx_dropped)},
	{NETSTAT_INFO(tx_dropped)},
	{DRVSTAT_INFO(be_tx_events)},
	{DRVSTAT_INFO(rx_crc_errors)},		{DRVSTAT_INFO(rx_crc_errors)},
	{DRVSTAT_INFO(rx_alignment_symbol_errors)},		{DRVSTAT_INFO(rx_alignment_symbol_errors)},
	{DRVSTAT_INFO(rx_pause_frames)},		{DRVSTAT_INFO(rx_pause_frames)},
	@@ -71,9 +56,6 @@ static const struct be_ethtool_stat et_stats[] = {
	{DRVSTAT_INFO(rx_ip_checksum_errs)},		{DRVSTAT_INFO(rx_ip_checksum_errs)},
	{DRVSTAT_INFO(rx_tcp_checksum_errs)},		{DRVSTAT_INFO(rx_tcp_checksum_errs)},
	{DRVSTAT_INFO(rx_udp_checksum_errs)},		{DRVSTAT_INFO(rx_udp_checksum_errs)},
	{DRVSTAT_INFO(rx_switched_unicast_packets)},
	{DRVSTAT_INFO(rx_switched_multicast_packets)},
	{DRVSTAT_INFO(rx_switched_broadcast_packets)},
	{DRVSTAT_INFO(tx_pauseframes)},		{DRVSTAT_INFO(tx_pauseframes)},
	{DRVSTAT_INFO(tx_controlframes)},		{DRVSTAT_INFO(tx_controlframes)},
	{DRVSTAT_INFO(rx_priority_pause_frames)},		{DRVSTAT_INFO(rx_priority_pause_frames)},
	@@ -96,24 +78,24 @@ static const struct be_ethtool_stat et_stats[] = {
	static const struct be_ethtool_stat et_rx_stats[] = {		static const struct be_ethtool_stat et_rx_stats[] = {
	{DRVSTAT_RX_INFO(rx_bytes)},		{DRVSTAT_RX_INFO(rx_bytes)},
	{DRVSTAT_RX_INFO(rx_pkts)},		{DRVSTAT_RX_INFO(rx_pkts)},
	{DRVSTAT_RX_INFO(rx_rate)},
	{DRVSTAT_RX_INFO(rx_polls)},		{DRVSTAT_RX_INFO(rx_polls)},
	{DRVSTAT_RX_INFO(rx_events)},		{DRVSTAT_RX_INFO(rx_events)},
	{DRVSTAT_RX_INFO(rx_compl)},		{DRVSTAT_RX_INFO(rx_compl)},
	{DRVSTAT_RX_INFO(rx_mcast_pkts)},		{DRVSTAT_RX_INFO(rx_mcast_pkts)},
	{DRVSTAT_RX_INFO(rx_post_fail)},		{DRVSTAT_RX_INFO(rx_post_fail)},
	{DRVSTAT_RX_INFO(rx_dropped)},		{DRVSTAT_RX_INFO(rx_drops_no_skbs)},
	{ERXSTAT_INFO(rx_drops_no_fragments)}		{DRVSTAT_RX_INFO(rx_drops_no_frags)}
	};		};
	#define ETHTOOL_RXSTATS_NUM (ARRAY_SIZE(et_rx_stats))		#define ETHTOOL_RXSTATS_NUM (ARRAY_SIZE(et_rx_stats))

	/* Stats related to multi TX queues */		/* Stats related to multi TX queues */
	static const struct be_ethtool_stat et_tx_stats[] = {		static const struct be_ethtool_stat et_tx_stats[] = {
	{DRVSTAT_TX_INFO(be_tx_rate)},		{DRVSTAT_TX_INFO(tx_bytes)},
	{DRVSTAT_TX_INFO(be_tx_reqs)},		{DRVSTAT_TX_INFO(tx_pkts)},
	{DRVSTAT_TX_INFO(be_tx_wrbs)},		{DRVSTAT_TX_INFO(tx_reqs)},
	{DRVSTAT_TX_INFO(be_tx_stops)},		{DRVSTAT_TX_INFO(tx_wrbs)},
	{DRVSTAT_TX_INFO(be_tx_compl)}		{DRVSTAT_TX_INFO(tx_compl)},
			{DRVSTAT_TX_INFO(tx_stops)}
	};		};
	#define ETHTOOL_TXSTATS_NUM (ARRAY_SIZE(et_tx_stats))		#define ETHTOOL_TXSTATS_NUM (ARRAY_SIZE(et_tx_stats))

	@@ -260,20 +242,11 @@ be_get_ethtool_stats(struct net_device *netdev,
	struct be_adapter *adapter = netdev_priv(netdev);		struct be_adapter *adapter = netdev_priv(netdev);
	struct be_rx_obj *rxo;		struct be_rx_obj *rxo;
	struct be_tx_obj *txo;		struct be_tx_obj *txo;
	void *p = NULL;		void *p;
	int i, j, base;		int i, j, base;

	for (i = 0; i < ETHTOOL_STATS_NUM; i++) {		for (i = 0; i < ETHTOOL_STATS_NUM; i++) {
	switch (et_stats[i].type) {		p = (u8 *)&adapter->drv_stats + et_stats[i].offset;
	case NETSTAT:
	p = &netdev->stats;
	break;
	case DRVSTAT:
	p = &adapter->drv_stats;
	break;
	}

	p = (u8 *)p + et_stats[i].offset;
	data[i] = (et_stats[i].size == sizeof(u64)) ?		data[i] = (et_stats[i].size == sizeof(u64)) ?
	(u64 )p: (u32 )p;		(u64 )p: (u32 )p;
	}		}
	@@ -281,15 +254,7 @@ be_get_ethtool_stats(struct net_device *netdev,
	base = ETHTOOL_STATS_NUM;		base = ETHTOOL_STATS_NUM;
	for_all_rx_queues(adapter, rxo, j) {		for_all_rx_queues(adapter, rxo, j) {
	for (i = 0; i < ETHTOOL_RXSTATS_NUM; i++) {		for (i = 0; i < ETHTOOL_RXSTATS_NUM; i++) {
	switch (et_rx_stats[i].type) {		p = (u8 *)rx_stats(rxo) + et_rx_stats[i].offset;
	case DRVSTAT_RX:
	p = (u8 *)&rxo->stats + et_rx_stats[i].offset;
	break;
	case ERXSTAT:
	p = (u32 *)be_erx_stats_from_cmd(adapter) +
	rxo->q.id;
	break;
	}
	data[base + j * ETHTOOL_RXSTATS_NUM + i] =		data[base + j * ETHTOOL_RXSTATS_NUM + i] =
	(et_rx_stats[i].size == sizeof(u64)) ?		(et_rx_stats[i].size == sizeof(u64)) ?
	(u64 )p: (u32 )p;		(u64 )p: (u32 )p;
	@@ -299,7 +264,7 @@ be_get_ethtool_stats(struct net_device *netdev,
	base = ETHTOOL_STATS_NUM + adapter->num_rx_qs * ETHTOOL_RXSTATS_NUM;		base = ETHTOOL_STATS_NUM + adapter->num_rx_qs * ETHTOOL_RXSTATS_NUM;
	for_all_tx_queues(adapter, txo, j) {		for_all_tx_queues(adapter, txo, j) {
	for (i = 0; i < ETHTOOL_TXSTATS_NUM; i++) {		for (i = 0; i < ETHTOOL_TXSTATS_NUM; i++) {
	p = (u8 *)&txo->stats + et_tx_stats[i].offset;		p = (u8 *)tx_stats(txo) + et_tx_stats[i].offset;
	data[base + j * ETHTOOL_TXSTATS_NUM + i] =		data[base + j * ETHTOOL_TXSTATS_NUM + i] =
	(et_tx_stats[i].size == sizeof(u64)) ?		(et_tx_stats[i].size == sizeof(u64)) ?
	(u64 )p: (u32 )p;		(u64 )p: (u32 )p;

drivers/net/benet/be_main.c

+84 −179

Original line number	Original line	Diff line number	Diff line
	@@ -245,14 +245,14 @@ static int be_mac_addr_set(struct net_device netdev, void p)

	static void populate_be2_stats(struct be_adapter *adapter)		static void populate_be2_stats(struct be_adapter *adapter)
	{		{
			struct be_hw_stats_v0 *hw_stats = hw_stats_from_cmd(adapter);
	struct be_drv_stats *drvs = &adapter->drv_stats;		struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
	struct be_pmem_stats *pmem_sts = be_pmem_stats_from_cmd(adapter);		struct be_rxf_stats_v0 *rxf_stats = &hw_stats->rxf;
	struct be_port_rxf_stats_v0 *port_stats =		struct be_port_rxf_stats_v0 *port_stats =
	be_port_rxf_stats_from_cmd(adapter);		&rxf_stats->port[adapter->port_num];
	struct be_rxf_stats_v0 *rxf_stats =		struct be_drv_stats *drvs = &adapter->drv_stats;
	be_rxf_stats_from_cmd(adapter);

			be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
	drvs->rx_pause_frames = port_stats->rx_pause_frames;		drvs->rx_pause_frames = port_stats->rx_pause_frames;
	drvs->rx_crc_errors = port_stats->rx_crc_errors;		drvs->rx_crc_errors = port_stats->rx_crc_errors;
	drvs->rx_control_frames = port_stats->rx_control_frames;		drvs->rx_control_frames = port_stats->rx_control_frames;
	@@ -267,12 +267,10 @@ static void populate_be2_stats(struct be_adapter *adapter)
	drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;		drvs->rx_dropped_too_small = port_stats->rx_dropped_too_small;
	drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;		drvs->rx_dropped_too_short = port_stats->rx_dropped_too_short;
	drvs->rx_out_range_errors = port_stats->rx_out_range_errors;		drvs->rx_out_range_errors = port_stats->rx_out_range_errors;
	drvs->rx_input_fifo_overflow_drop =		drvs->rx_input_fifo_overflow_drop = port_stats->rx_input_fifo_overflow;
	port_stats->rx_input_fifo_overflow;
	drvs->rx_dropped_header_too_small =		drvs->rx_dropped_header_too_small =
	port_stats->rx_dropped_header_too_small;		port_stats->rx_dropped_header_too_small;
	drvs->rx_address_match_errors =		drvs->rx_address_match_errors = port_stats->rx_address_match_errors;
	port_stats->rx_address_match_errors;
	drvs->rx_alignment_symbol_errors =		drvs->rx_alignment_symbol_errors =
	port_stats->rx_alignment_symbol_errors;		port_stats->rx_alignment_symbol_errors;

	@@ -280,36 +278,30 @@ static void populate_be2_stats(struct be_adapter *adapter)
	drvs->tx_controlframes = port_stats->tx_controlframes;		drvs->tx_controlframes = port_stats->tx_controlframes;

	if (adapter->port_num)		if (adapter->port_num)
	drvs->jabber_events =		drvs->jabber_events = rxf_stats->port1_jabber_events;
	rxf_stats->port1_jabber_events;
	else		else
	drvs->jabber_events =		drvs->jabber_events = rxf_stats->port0_jabber_events;
	rxf_stats->port0_jabber_events;
	drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;		drvs->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf;
	drvs->rx_drops_no_txpb = rxf_stats->rx_drops_no_txpb;		drvs->rx_drops_no_txpb = rxf_stats->rx_drops_no_txpb;
	drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;		drvs->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr;
	drvs->rx_drops_invalid_ring = rxf_stats->rx_drops_invalid_ring;		drvs->rx_drops_invalid_ring = rxf_stats->rx_drops_invalid_ring;
	drvs->forwarded_packets = rxf_stats->forwarded_packets;		drvs->forwarded_packets = rxf_stats->forwarded_packets;
	drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;		drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
	drvs->rx_drops_no_tpre_descr =		drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
	rxf_stats->rx_drops_no_tpre_descr;		drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
	drvs->rx_drops_too_many_frags =
	rxf_stats->rx_drops_too_many_frags;
	adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;		adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
	}		}

	static void populate_be3_stats(struct be_adapter *adapter)		static void populate_be3_stats(struct be_adapter *adapter)
	{		{
	struct be_drv_stats *drvs = &adapter->drv_stats;		struct be_hw_stats_v1 *hw_stats = hw_stats_from_cmd(adapter);
	struct be_pmem_stats *pmem_sts = be_pmem_stats_from_cmd(adapter);		struct be_pmem_stats *pmem_sts = &hw_stats->pmem;
			struct be_rxf_stats_v1 *rxf_stats = &hw_stats->rxf;
	struct be_rxf_stats_v1 *rxf_stats =
	be_rxf_stats_from_cmd(adapter);
	struct be_port_rxf_stats_v1 *port_stats =		struct be_port_rxf_stats_v1 *port_stats =
	be_port_rxf_stats_from_cmd(adapter);		&rxf_stats->port[adapter->port_num];
			struct be_drv_stats *drvs = &adapter->drv_stats;

	drvs->rx_priority_pause_frames = 0;		be_dws_le_to_cpu(hw_stats, sizeof(*hw_stats));
	drvs->pmem_fifo_overflow_drop = 0;
	drvs->rx_pause_frames = port_stats->rx_pause_frames;		drvs->rx_pause_frames = port_stats->rx_pause_frames;
	drvs->rx_crc_errors = port_stats->rx_crc_errors;		drvs->rx_crc_errors = port_stats->rx_crc_errors;
	drvs->rx_control_frames = port_stats->rx_control_frames;		drvs->rx_control_frames = port_stats->rx_control_frames;
	@@ -327,12 +319,10 @@ static void populate_be3_stats(struct be_adapter *adapter)
	port_stats->rx_dropped_header_too_small;		port_stats->rx_dropped_header_too_small;
	drvs->rx_input_fifo_overflow_drop =		drvs->rx_input_fifo_overflow_drop =
	port_stats->rx_input_fifo_overflow_drop;		port_stats->rx_input_fifo_overflow_drop;
	drvs->rx_address_match_errors =		drvs->rx_address_match_errors = port_stats->rx_address_match_errors;
	port_stats->rx_address_match_errors;
	drvs->rx_alignment_symbol_errors =		drvs->rx_alignment_symbol_errors =
	port_stats->rx_alignment_symbol_errors;		port_stats->rx_alignment_symbol_errors;
	drvs->rxpp_fifo_overflow_drop =		drvs->rxpp_fifo_overflow_drop = port_stats->rxpp_fifo_overflow_drop;
	port_stats->rxpp_fifo_overflow_drop;
	drvs->tx_pauseframes = port_stats->tx_pauseframes;		drvs->tx_pauseframes = port_stats->tx_pauseframes;
	drvs->tx_controlframes = port_stats->tx_controlframes;		drvs->tx_controlframes = port_stats->tx_controlframes;
	drvs->jabber_events = port_stats->jabber_events;		drvs->jabber_events = port_stats->jabber_events;
	@@ -342,10 +332,8 @@ static void populate_be3_stats(struct be_adapter *adapter)
	drvs->rx_drops_invalid_ring = rxf_stats->rx_drops_invalid_ring;		drvs->rx_drops_invalid_ring = rxf_stats->rx_drops_invalid_ring;
	drvs->forwarded_packets = rxf_stats->forwarded_packets;		drvs->forwarded_packets = rxf_stats->forwarded_packets;
	drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;		drvs->rx_drops_mtu = rxf_stats->rx_drops_mtu;
	drvs->rx_drops_no_tpre_descr =		drvs->rx_drops_no_tpre_descr = rxf_stats->rx_drops_no_tpre_descr;
	rxf_stats->rx_drops_no_tpre_descr;		drvs->rx_drops_too_many_frags = rxf_stats->rx_drops_too_many_frags;
	drvs->rx_drops_too_many_frags =
	rxf_stats->rx_drops_too_many_frags;
	adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;		adapter->drv_stats.eth_red_drops = pmem_sts->eth_red_drops;
	}		}

	@@ -353,22 +341,15 @@ static void populate_lancer_stats(struct be_adapter *adapter)
	{		{

	struct be_drv_stats *drvs = &adapter->drv_stats;		struct be_drv_stats *drvs = &adapter->drv_stats;
	struct lancer_cmd_pport_stats *pport_stats = pport_stats_from_cmd		struct lancer_pport_stats *pport_stats =
	(adapter);		pport_stats_from_cmd(adapter);
	drvs->rx_priority_pause_frames = 0;
	drvs->pmem_fifo_overflow_drop = 0;		be_dws_le_to_cpu(pport_stats, sizeof(*pport_stats));
	drvs->rx_pause_frames =		drvs->rx_pause_frames = pport_stats->rx_pause_frames_lo;
	make_64bit_val(pport_stats->rx_pause_frames_hi,		drvs->rx_crc_errors = pport_stats->rx_crc_errors_lo;
	pport_stats->rx_pause_frames_lo);		drvs->rx_control_frames = pport_stats->rx_control_frames_lo;
	drvs->rx_crc_errors = make_64bit_val(pport_stats->rx_crc_errors_hi,
	pport_stats->rx_crc_errors_lo);
	drvs->rx_control_frames =
	make_64bit_val(pport_stats->rx_control_frames_hi,
	pport_stats->rx_control_frames_lo);
	drvs->rx_in_range_errors = pport_stats->rx_in_range_errors;		drvs->rx_in_range_errors = pport_stats->rx_in_range_errors;
	drvs->rx_frame_too_long =		drvs->rx_frame_too_long = pport_stats->rx_frames_too_long_lo;
	make_64bit_val(pport_stats->rx_internal_mac_errors_hi,
	pport_stats->rx_frames_too_long_lo);
	drvs->rx_dropped_runt = pport_stats->rx_dropped_runt;		drvs->rx_dropped_runt = pport_stats->rx_dropped_runt;
	drvs->rx_ip_checksum_errs = pport_stats->rx_ip_checksum_errors;		drvs->rx_ip_checksum_errs = pport_stats->rx_ip_checksum_errors;
	drvs->rx_tcp_checksum_errs = pport_stats->rx_tcp_checksum_errors;		drvs->rx_tcp_checksum_errs = pport_stats->rx_tcp_checksum_errors;
	@@ -382,32 +363,24 @@ static void populate_lancer_stats(struct be_adapter *adapter)
	pport_stats->rx_dropped_header_too_small;		pport_stats->rx_dropped_header_too_small;
	drvs->rx_input_fifo_overflow_drop = pport_stats->rx_fifo_overflow;		drvs->rx_input_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
	drvs->rx_address_match_errors = pport_stats->rx_address_match_errors;		drvs->rx_address_match_errors = pport_stats->rx_address_match_errors;
	drvs->rx_alignment_symbol_errors =		drvs->rx_alignment_symbol_errors = pport_stats->rx_symbol_errors_lo;
	make_64bit_val(pport_stats->rx_symbol_errors_hi,
	pport_stats->rx_symbol_errors_lo);
	drvs->rxpp_fifo_overflow_drop = pport_stats->rx_fifo_overflow;		drvs->rxpp_fifo_overflow_drop = pport_stats->rx_fifo_overflow;
	drvs->tx_pauseframes = make_64bit_val(pport_stats->tx_pause_frames_hi,		drvs->tx_pauseframes = pport_stats->tx_pause_frames_lo;
	pport_stats->tx_pause_frames_lo);		drvs->tx_controlframes = pport_stats->tx_control_frames_lo;
	drvs->tx_controlframes =
	make_64bit_val(pport_stats->tx_control_frames_hi,
	pport_stats->tx_control_frames_lo);
	drvs->jabber_events = pport_stats->rx_jabbers;		drvs->jabber_events = pport_stats->rx_jabbers;
	drvs->rx_drops_no_pbuf = 0;
	drvs->rx_drops_no_txpb = 0;
	drvs->rx_drops_no_erx_descr = 0;
	drvs->rx_drops_invalid_ring = pport_stats->rx_drops_invalid_queue;		drvs->rx_drops_invalid_ring = pport_stats->rx_drops_invalid_queue;
	drvs->forwarded_packets = make_64bit_val(pport_stats->num_forwards_hi,		drvs->forwarded_packets = pport_stats->num_forwards_lo;
	pport_stats->num_forwards_lo);		drvs->rx_drops_mtu = pport_stats->rx_drops_mtu_lo;
	drvs->rx_drops_mtu = make_64bit_val(pport_stats->rx_drops_mtu_hi,
	pport_stats->rx_drops_mtu_lo);
	drvs->rx_drops_no_tpre_descr = 0;
	drvs->rx_drops_too_many_frags =		drvs->rx_drops_too_many_frags =
	make_64bit_val(pport_stats->rx_drops_too_many_frags_hi,		pport_stats->rx_drops_too_many_frags_lo;
	pport_stats->rx_drops_too_many_frags_lo);
	}		}

	void be_parse_stats(struct be_adapter *adapter)		void be_parse_stats(struct be_adapter *adapter)
	{		{
			struct be_erx_stats_v1 *erx = be_erx_stats_from_cmd(adapter);
			struct be_rx_obj *rxo;
			int i;

	if (adapter->generation == BE_GEN3) {		if (adapter->generation == BE_GEN3) {
	if (lancer_chip(adapter))		if (lancer_chip(adapter))
	populate_lancer_stats(adapter);		populate_lancer_stats(adapter);
	@@ -416,6 +389,11 @@ void be_parse_stats(struct be_adapter *adapter)
	} else {		} else {
	populate_be2_stats(adapter);		populate_be2_stats(adapter);
	}		}

			/* as erx_v1 is longer than v0, ok to use v1 defn for v0 access */
			for_all_rx_queues(adapter, rxo, i)
			rx_stats(rxo)->rx_drops_no_frags =
			erx->rx_drops_no_fragments[rxo->q.id];
	}		}

	void netdev_stats_update(struct be_adapter *adapter)		void netdev_stats_update(struct be_adapter *adapter)
	@@ -431,19 +409,7 @@ void netdev_stats_update(struct be_adapter *adapter)
	pkts += rx_stats(rxo)->rx_pkts;		pkts += rx_stats(rxo)->rx_pkts;
	bytes += rx_stats(rxo)->rx_bytes;		bytes += rx_stats(rxo)->rx_bytes;
	mcast += rx_stats(rxo)->rx_mcast_pkts;		mcast += rx_stats(rxo)->rx_mcast_pkts;
	drops += rx_stats(rxo)->rx_dropped;		drops += rx_stats(rxo)->rx_drops_no_skbs;
	/* no space in linux buffers: best possible approximation */
	if (adapter->generation == BE_GEN3) {
	if (!(lancer_chip(adapter))) {
	struct be_erx_stats_v1 *erx =
	be_erx_stats_from_cmd(adapter);
	drops += erx->rx_drops_no_fragments[rxo->q.id];
	}
	} else {
	struct be_erx_stats_v0 *erx =
	be_erx_stats_from_cmd(adapter);
	drops += erx->rx_drops_no_fragments[rxo->q.id];
	}
	}		}
	dev_stats->rx_packets = pkts;		dev_stats->rx_packets = pkts;
	dev_stats->rx_bytes = bytes;		dev_stats->rx_bytes = bytes;
	@@ -452,8 +418,8 @@ void netdev_stats_update(struct be_adapter *adapter)

	pkts = bytes = 0;		pkts = bytes = 0;
	for_all_tx_queues(adapter, txo, i) {		for_all_tx_queues(adapter, txo, i) {
	pkts += tx_stats(txo)->be_tx_pkts;		pkts += tx_stats(txo)->tx_pkts;
	bytes += tx_stats(txo)->be_tx_bytes;		bytes += tx_stats(txo)->tx_bytes;
	}		}
	dev_stats->tx_packets = pkts;		dev_stats->tx_packets = pkts;
	dev_stats->tx_bytes = bytes;		dev_stats->tx_bytes = bytes;
	@@ -508,89 +474,17 @@ void be_link_status_update(struct be_adapter *adapter, bool link_up)
	}		}
	}		}

	/* Update the EQ delay n BE based on the RX frags consumed / sec */
	static void be_rx_eqd_update(struct be_adapter adapter, struct be_rx_obj rxo)
	{
	struct be_eq_obj *rx_eq = &rxo->rx_eq;
	struct be_rx_stats *stats = &rxo->stats;
	ulong now = jiffies;
	u32 eqd;

	if (!rx_eq->enable_aic)
	return;

	/* Wrapped around */
	if (time_before(now, stats->rx_fps_jiffies)) {
	stats->rx_fps_jiffies = now;
	return;
	}

	/* Update once a second */
	if ((now - stats->rx_fps_jiffies) < HZ)
	return;

	stats->rx_fps = (stats->rx_frags - stats->prev_rx_frags) /
	((now - stats->rx_fps_jiffies) / HZ);

	stats->rx_fps_jiffies = now;
	stats->prev_rx_frags = stats->rx_frags;
	eqd = stats->rx_fps / 110000;
	eqd = eqd << 3;
	if (eqd > rx_eq->max_eqd)
	eqd = rx_eq->max_eqd;
	if (eqd < rx_eq->min_eqd)
	eqd = rx_eq->min_eqd;
	if (eqd < 10)
	eqd = 0;
	if (eqd != rx_eq->cur_eqd)
	be_cmd_modify_eqd(adapter, rx_eq->q.id, eqd);

	rx_eq->cur_eqd = eqd;
	}

	static u32 be_calc_rate(u64 bytes, unsigned long ticks)
	{
	u64 rate = bytes;

	do_div(rate, ticks / HZ);
	rate <<= 3; /* bytes/sec -> bits/sec */
	do_div(rate, 1000000ul); /* MB/Sec */

	return rate;
	}

	static void be_tx_rate_update(struct be_tx_obj *txo)
	{
	struct be_tx_stats *stats = tx_stats(txo);
	ulong now = jiffies;

	/* Wrapped around? */
	if (time_before(now, stats->be_tx_jiffies)) {
	stats->be_tx_jiffies = now;
	return;
	}

	/* Update tx rate once in two seconds */
	if ((now - stats->be_tx_jiffies) > 2 * HZ) {
	stats->be_tx_rate = be_calc_rate(stats->be_tx_bytes
	- stats->be_tx_bytes_prev,
	now - stats->be_tx_jiffies);
	stats->be_tx_jiffies = now;
	stats->be_tx_bytes_prev = stats->be_tx_bytes;
	}
	}

	static void be_tx_stats_update(struct be_tx_obj *txo,		static void be_tx_stats_update(struct be_tx_obj *txo,
	u32 wrb_cnt, u32 copied, u32 gso_segs, bool stopped)		u32 wrb_cnt, u32 copied, u32 gso_segs, bool stopped)
	{		{
	struct be_tx_stats *stats = tx_stats(txo);		struct be_tx_stats *stats = tx_stats(txo);

	stats->be_tx_reqs++;		stats->tx_reqs++;
	stats->be_tx_wrbs += wrb_cnt;		stats->tx_wrbs += wrb_cnt;
	stats->be_tx_bytes += copied;		stats->tx_bytes += copied;
	stats->be_tx_pkts += (gso_segs ? gso_segs : 1);		stats->tx_pkts += (gso_segs ? gso_segs : 1);
	if (stopped)		if (stopped)
	stats->be_tx_stops++;		stats->tx_stops++;
	}		}

	/* Determine number of WRB entries needed to xmit data in an skb */		/* Determine number of WRB entries needed to xmit data in an skb */
	@@ -1005,10 +899,16 @@ static int be_set_vf_tx_rate(struct net_device *netdev,
	return status;		return status;
	}		}

	static void be_rx_rate_update(struct be_rx_obj *rxo)		static void be_rx_eqd_update(struct be_adapter adapter, struct be_rx_obj rxo)
	{		{
	struct be_rx_stats *stats = &rxo->stats;		struct be_eq_obj *rx_eq = &rxo->rx_eq;
			struct be_rx_stats *stats = rx_stats(rxo);
	ulong now = jiffies;		ulong now = jiffies;
			ulong delta = now - stats->rx_jiffies;
			u32 eqd;

			if (!rx_eq->enable_aic)
			return;

	/* Wrapped around */		/* Wrapped around */
	if (time_before(now, stats->rx_jiffies)) {		if (time_before(now, stats->rx_jiffies)) {
	@@ -1016,29 +916,39 @@ static void be_rx_rate_update(struct be_rx_obj *rxo)
	return;		return;
	}		}

	/* Update the rate once in two seconds */		/* Update once a second */
	if ((now - stats->rx_jiffies) < 2 * HZ)		if (delta < HZ)
	return;		return;

	stats->rx_rate = be_calc_rate(stats->rx_bytes - stats->rx_bytes_prev,		stats->rx_pps = (stats->rx_pkts - stats->rx_pkts_prev) / (delta / HZ);
	now - stats->rx_jiffies);		stats->rx_pkts_prev = stats->rx_pkts;
	stats->rx_jiffies = now;		stats->rx_jiffies = now;
	stats->rx_bytes_prev = stats->rx_bytes;		eqd = stats->rx_pps / 110000;
			eqd = eqd << 3;
			if (eqd > rx_eq->max_eqd)
			eqd = rx_eq->max_eqd;
			if (eqd < rx_eq->min_eqd)
			eqd = rx_eq->min_eqd;
			if (eqd < 10)
			eqd = 0;
			if (eqd != rx_eq->cur_eqd) {
			be_cmd_modify_eqd(adapter, rx_eq->q.id, eqd);
			rx_eq->cur_eqd = eqd;
			}
	}		}

	static void be_rx_stats_update(struct be_rx_obj *rxo,		static void be_rx_stats_update(struct be_rx_obj *rxo,
	struct be_rx_compl_info *rxcp)		struct be_rx_compl_info *rxcp)
	{		{
	struct be_rx_stats *stats = &rxo->stats;		struct be_rx_stats *stats = rx_stats(rxo);

	stats->rx_compl++;		stats->rx_compl++;
	stats->rx_frags += rxcp->num_rcvd;
	stats->rx_bytes += rxcp->pkt_size;		stats->rx_bytes += rxcp->pkt_size;
	stats->rx_pkts++;		stats->rx_pkts++;
	if (rxcp->pkt_type == BE_MULTICAST_PACKET)		if (rxcp->pkt_type == BE_MULTICAST_PACKET)
	stats->rx_mcast_pkts++;		stats->rx_mcast_pkts++;
	if (rxcp->err)		if (rxcp->err)
	stats->rxcp_err++;		stats->rx_compl_err++;
	}		}

	static inline bool csum_passed(struct be_rx_compl_info *rxcp)		static inline bool csum_passed(struct be_rx_compl_info *rxcp)
	@@ -1174,7 +1084,7 @@ static void be_rx_compl_process(struct be_adapter *adapter,

	skb = netdev_alloc_skb_ip_align(netdev, BE_HDR_LEN);		skb = netdev_alloc_skb_ip_align(netdev, BE_HDR_LEN);
	if (unlikely(!skb)) {		if (unlikely(!skb)) {
	rxo->stats.rx_dropped++;		rx_stats(rxo)->rx_drops_no_skbs++;
	be_rx_compl_discard(adapter, rxo, rxcp);		be_rx_compl_discard(adapter, rxo, rxcp);
	return;		return;
	}		}
	@@ -1389,7 +1299,7 @@ static void be_post_rx_frags(struct be_rx_obj *rxo, gfp_t gfp)
	if (!pagep) {		if (!pagep) {
	pagep = be_alloc_pages(adapter->big_page_size, gfp);		pagep = be_alloc_pages(adapter->big_page_size, gfp);
	if (unlikely(!pagep)) {		if (unlikely(!pagep)) {
	rxo->stats.rx_post_fail++;		rx_stats(rxo)->rx_post_fail++;
	break;		break;
	}		}
	page_dmaaddr = dma_map_page(&adapter->pdev->dev, pagep,		page_dmaaddr = dma_map_page(&adapter->pdev->dev, pagep,
	@@ -1899,7 +1809,7 @@ static int be_poll_rx(struct napi_struct *napi, int budget)
	struct be_rx_compl_info *rxcp;		struct be_rx_compl_info *rxcp;
	u32 work_done;		u32 work_done;

	rxo->stats.rx_polls++;		rx_stats(rxo)->rx_polls++;
	for (work_done = 0; work_done < budget; work_done++) {		for (work_done = 0; work_done < budget; work_done++) {
	rxcp = be_rx_compl_get(rxo);		rxcp = be_rx_compl_get(rxo);
	if (!rxcp)		if (!rxcp)
	@@ -1968,8 +1878,8 @@ static int be_poll_tx_mcc(struct napi_struct *napi, int budget)
	netif_wake_subqueue(adapter->netdev, i);		netif_wake_subqueue(adapter->netdev, i);
	}		}

	adapter->drv_stats.be_tx_events++;		adapter->drv_stats.tx_events++;
	txo->stats.be_tx_compl += tx_compl;		tx_stats(txo)->tx_compl += tx_compl;
	}		}
	}		}

	@@ -2031,7 +1941,6 @@ static void be_worker(struct work_struct *work)
	struct be_adapter *adapter =		struct be_adapter *adapter =
	container_of(work, struct be_adapter, work.work);		container_of(work, struct be_adapter, work.work);
	struct be_rx_obj *rxo;		struct be_rx_obj *rxo;
	struct be_tx_obj *txo;
	int i;		int i;

	if (!adapter->ue_detected && !lancer_chip(adapter))		if (!adapter->ue_detected && !lancer_chip(adapter))
	@@ -2060,11 +1969,7 @@ static void be_worker(struct work_struct *work)
	be_cmd_get_stats(adapter, &adapter->stats_cmd);		be_cmd_get_stats(adapter, &adapter->stats_cmd);
	}		}

	for_all_tx_queues(adapter, txo, i)
	be_tx_rate_update(txo);

	for_all_rx_queues(adapter, rxo, i) {		for_all_rx_queues(adapter, rxo, i) {
	be_rx_rate_update(rxo);
	be_rx_eqd_update(adapter, rxo);		be_rx_eqd_update(adapter, rxo);

	if (rxo->rx_post_starved) {		if (rxo->rx_post_starved) {