[net-next-2.6.git] / drivers / net / sfc / falcon_gmac.c

/****************************************************************************
 * Driver for Solarflare Solarstorm network controllers and boards
 * Copyright 2005-2006 Fen Systems Ltd.
 * Copyright 2006-2008 Solarflare Communications Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
 * by the Free Software Foundation, incorporated herein by reference.
 */

#include <linux/delay.h>
#include "net_driver.h"
#include "efx.h"
#include "nic.h"
#include "mac.h"
#include "regs.h"
#include "io.h"

/**************************************************************************
 *
 * MAC operations
 *
 *************************************************************************/

static int falcon_reconfigure_gmac(struct efx_nic *efx)
{
	struct efx_link_state *link_state = &efx->link_state;
	bool loopback, tx_fc, rx_fc, bytemode;
	int if_mode;
	unsigned int max_frame_len;
	efx_oword_t reg;

	/* Configuration register 1 */
	tx_fc = (link_state->fc & EFX_FC_TX) || !link_state->fd;
	rx_fc = !!(link_state->fc & EFX_FC_RX);
	loopback = (efx->loopback_mode == LOOPBACK_GMAC);
	bytemode = (link_state->speed == 1000);

	EFX_POPULATE_OWORD_5(reg,
			     FRF_AB_GM_LOOP, loopback,
			     FRF_AB_GM_TX_EN, 1,
			     FRF_AB_GM_TX_FC_EN, tx_fc,
			     FRF_AB_GM_RX_EN, 1,
			     FRF_AB_GM_RX_FC_EN, rx_fc);
	efx_writeo(efx, &reg, FR_AB_GM_CFG1);
	udelay(10);

	/* Configuration register 2 */
	if_mode = (bytemode) ? 2 : 1;
	EFX_POPULATE_OWORD_5(reg,
			     FRF_AB_GM_IF_MODE, if_mode,
			     FRF_AB_GM_PAD_CRC_EN, 1,
			     FRF_AB_GM_LEN_CHK, 1,
			     FRF_AB_GM_FD, link_state->fd,
			     FRF_AB_GM_PAMBL_LEN, 0x7/*datasheet recommended */);

	efx_writeo(efx, &reg, FR_AB_GM_CFG2);
	udelay(10);

	/* Max frame len register */
	max_frame_len = EFX_MAX_FRAME_LEN(efx->net_dev->mtu);
	EFX_POPULATE_OWORD_1(reg, FRF_AB_GM_MAX_FLEN, max_frame_len);
	efx_writeo(efx, &reg, FR_AB_GM_MAX_FLEN);
	udelay(10);

	/* FIFO configuration register 0 */
	EFX_POPULATE_OWORD_5(reg,
			     FRF_AB_GMF_FTFENREQ, 1,
			     FRF_AB_GMF_STFENREQ, 1,
			     FRF_AB_GMF_FRFENREQ, 1,
			     FRF_AB_GMF_SRFENREQ, 1,
			     FRF_AB_GMF_WTMENREQ, 1);
	efx_writeo(efx, &reg, FR_AB_GMF_CFG0);
	udelay(10);

	/* FIFO configuration register 1 */
	EFX_POPULATE_OWORD_2(reg,
			     FRF_AB_GMF_CFGFRTH, 0x12,
			     FRF_AB_GMF_CFGXOFFRTX, 0xffff);
	efx_writeo(efx, &reg, FR_AB_GMF_CFG1);
	udelay(10);

	/* FIFO configuration register 2 */
	EFX_POPULATE_OWORD_2(reg,
			     FRF_AB_GMF_CFGHWM, 0x3f,
			     FRF_AB_GMF_CFGLWM, 0xa);
	efx_writeo(efx, &reg, FR_AB_GMF_CFG2);
	udelay(10);

	/* FIFO configuration register 3 */
	EFX_POPULATE_OWORD_2(reg,
			     FRF_AB_GMF_CFGHWMFT, 0x1c,
			     FRF_AB_GMF_CFGFTTH, 0x08);
	efx_writeo(efx, &reg, FR_AB_GMF_CFG3);
	udelay(10);

	/* FIFO configuration register 4 */
	EFX_POPULATE_OWORD_1(reg, FRF_AB_GMF_HSTFLTRFRM_PAUSE, 1);
	efx_writeo(efx, &reg, FR_AB_GMF_CFG4);
	udelay(10);

	/* FIFO configuration register 5 */
	efx_reado(efx, &reg, FR_AB_GMF_CFG5);
	EFX_SET_OWORD_FIELD(reg, FRF_AB_GMF_CFGBYTMODE, bytemode);
	EFX_SET_OWORD_FIELD(reg, FRF_AB_GMF_CFGHDPLX, !link_state->fd);
	EFX_SET_OWORD_FIELD(reg, FRF_AB_GMF_HSTDRPLT64, !link_state->fd);
	EFX_SET_OWORD_FIELD(reg, FRF_AB_GMF_HSTFLTRFRMDC_PAUSE, 0);
	efx_writeo(efx, &reg, FR_AB_GMF_CFG5);
	udelay(10);

	/* MAC address */
	EFX_POPULATE_OWORD_4(reg,
			     FRF_AB_GM_ADR_B0, efx->net_dev->dev_addr[5],
			     FRF_AB_GM_ADR_B1, efx->net_dev->dev_addr[4],
			     FRF_AB_GM_ADR_B2, efx->net_dev->dev_addr[3],
			     FRF_AB_GM_ADR_B3, efx->net_dev->dev_addr[2]);
	efx_writeo(efx, &reg, FR_AB_GM_ADR1);
	udelay(10);
	EFX_POPULATE_OWORD_2(reg,
			     FRF_AB_GM_ADR_B4, efx->net_dev->dev_addr[1],
			     FRF_AB_GM_ADR_B5, efx->net_dev->dev_addr[0]);
	efx_writeo(efx, &reg, FR_AB_GM_ADR2);
	udelay(10);

	falcon_reconfigure_mac_wrapper(efx);

	return 0;
}

static void falcon_update_stats_gmac(struct efx_nic *efx)
{
	struct efx_mac_stats *mac_stats = &efx->mac_stats;
	unsigned long old_rx_pause, old_tx_pause;
	unsigned long new_rx_pause, new_tx_pause;

	/* Pause frames are erroneously counted as errors (SFC bug 3269) */
	old_rx_pause = mac_stats->rx_pause;
	old_tx_pause = mac_stats->tx_pause;

	/* Update MAC stats from DMAed values */
	FALCON_STAT(efx, GRxGoodOct, rx_good_bytes);
	FALCON_STAT(efx, GRxBadOct, rx_bad_bytes);
	FALCON_STAT(efx, GRxMissPkt, rx_missed);
	FALCON_STAT(efx, GRxFalseCRS, rx_false_carrier);
	FALCON_STAT(efx, GRxPausePkt, rx_pause);
	FALCON_STAT(efx, GRxBadPkt, rx_bad);
	FALCON_STAT(efx, GRxUcastPkt, rx_unicast);
	FALCON_STAT(efx, GRxMcastPkt, rx_multicast);
	FALCON_STAT(efx, GRxBcastPkt, rx_broadcast);
	FALCON_STAT(efx, GRxGoodLt64Pkt, rx_good_lt64);
	FALCON_STAT(efx, GRxBadLt64Pkt, rx_bad_lt64);
	FALCON_STAT(efx, GRx64Pkt, rx_64);
	FALCON_STAT(efx, GRx65to127Pkt, rx_65_to_127);
	FALCON_STAT(efx, GRx128to255Pkt, rx_128_to_255);
	FALCON_STAT(efx, GRx256to511Pkt, rx_256_to_511);
	FALCON_STAT(efx, GRx512to1023Pkt, rx_512_to_1023);
	FALCON_STAT(efx, GRx1024to15xxPkt, rx_1024_to_15xx);
	FALCON_STAT(efx, GRx15xxtoJumboPkt, rx_15xx_to_jumbo);
	FALCON_STAT(efx, GRxGtJumboPkt, rx_gtjumbo);
	FALCON_STAT(efx, GRxFcsErr64to15xxPkt, rx_bad_64_to_15xx);
	FALCON_STAT(efx, GRxFcsErr15xxtoJumboPkt, rx_bad_15xx_to_jumbo);
	FALCON_STAT(efx, GRxFcsErrGtJumboPkt, rx_bad_gtjumbo);
	FALCON_STAT(efx, GTxGoodBadOct, tx_bytes);
	FALCON_STAT(efx, GTxGoodOct, tx_good_bytes);
	FALCON_STAT(efx, GTxSglColPkt, tx_single_collision);
	FALCON_STAT(efx, GTxMultColPkt, tx_multiple_collision);
	FALCON_STAT(efx, GTxExColPkt, tx_excessive_collision);
	FALCON_STAT(efx, GTxDefPkt, tx_deferred);
	FALCON_STAT(efx, GTxLateCol, tx_late_collision);
	FALCON_STAT(efx, GTxExDefPkt, tx_excessive_deferred);
	FALCON_STAT(efx, GTxPausePkt, tx_pause);
	FALCON_STAT(efx, GTxBadPkt, tx_bad);
	FALCON_STAT(efx, GTxUcastPkt, tx_unicast);
	FALCON_STAT(efx, GTxMcastPkt, tx_multicast);
	FALCON_STAT(efx, GTxBcastPkt, tx_broadcast);
	FALCON_STAT(efx, GTxLt64Pkt, tx_lt64);
	FALCON_STAT(efx, GTx64Pkt, tx_64);
	FALCON_STAT(efx, GTx65to127Pkt, tx_65_to_127);
	FALCON_STAT(efx, GTx128to255Pkt, tx_128_to_255);
	FALCON_STAT(efx, GTx256to511Pkt, tx_256_to_511);
	FALCON_STAT(efx, GTx512to1023Pkt, tx_512_to_1023);
	FALCON_STAT(efx, GTx1024to15xxPkt, tx_1024_to_15xx);
	FALCON_STAT(efx, GTx15xxtoJumboPkt, tx_15xx_to_jumbo);
	FALCON_STAT(efx, GTxGtJumboPkt, tx_gtjumbo);
	FALCON_STAT(efx, GTxNonTcpUdpPkt, tx_non_tcpudp);
	FALCON_STAT(efx, GTxMacSrcErrPkt, tx_mac_src_error);
	FALCON_STAT(efx, GTxIpSrcErrPkt, tx_ip_src_error);

	/* Pause frames are erroneously counted as errors (SFC bug 3269) */
	new_rx_pause = mac_stats->rx_pause;
	new_tx_pause = mac_stats->tx_pause;
	mac_stats->rx_bad -= (new_rx_pause - old_rx_pause);
	mac_stats->tx_bad -= (new_tx_pause - old_tx_pause);

	/* Derive stats that the MAC doesn't provide directly */
	mac_stats->tx_bad_bytes =
		mac_stats->tx_bytes - mac_stats->tx_good_bytes;
	mac_stats->tx_packets =
		mac_stats->tx_lt64 + mac_stats->tx_64 +
		mac_stats->tx_65_to_127 + mac_stats->tx_128_to_255 +
		mac_stats->tx_256_to_511 + mac_stats->tx_512_to_1023 +
		mac_stats->tx_1024_to_15xx + mac_stats->tx_15xx_to_jumbo +
		mac_stats->tx_gtjumbo;
	mac_stats->tx_collision =
		mac_stats->tx_single_collision +
		mac_stats->tx_multiple_collision +
		mac_stats->tx_excessive_collision +
		mac_stats->tx_late_collision;
	mac_stats->rx_bytes =
		mac_stats->rx_good_bytes + mac_stats->rx_bad_bytes;
	mac_stats->rx_packets =
		mac_stats->rx_good_lt64 + mac_stats->rx_bad_lt64 +
		mac_stats->rx_64 + mac_stats->rx_65_to_127 +
		mac_stats->rx_128_to_255 + mac_stats->rx_256_to_511 +
		mac_stats->rx_512_to_1023 + mac_stats->rx_1024_to_15xx +
		mac_stats->rx_15xx_to_jumbo + mac_stats->rx_gtjumbo;
	mac_stats->rx_good = mac_stats->rx_packets - mac_stats->rx_bad;
	mac_stats->rx_lt64 = mac_stats->rx_good_lt64 + mac_stats->rx_bad_lt64;
}

static bool falcon_gmac_check_fault(struct efx_nic *efx)
{
	return false;
}

struct efx_mac_operations falcon_gmac_operations = {
	.reconfigure	= falcon_reconfigure_gmac,
	.update_stats	= falcon_update_stats_gmac,
	.check_fault 	= falcon_gmac_check_fault,
};
Commit	Line	Data
177dfcd8 BH	1	/****************************************************************************
	2	* Driver for Solarflare Solarstorm network controllers and boards
	3	* Copyright 2005-2006 Fen Systems Ltd.
	4	* Copyright 2006-2008 Solarflare Communications Inc.
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License version 2 as published
	8	* by the Free Software Foundation, incorporated herein by reference.
	9	*/
	10
	11	#include <linux/delay.h>
	12	#include "net_driver.h"
	13	#include "efx.h"
744093c9	14	#include "nic.h"
177dfcd8	15	#include "mac.h"
3e6c4538	16	#include "regs.h"
12d00cad	17	#include "io.h"
177dfcd8 BH	18
	19	/**************************************************************************
	20	*
	21	* MAC operations
	22	*
	23	*************************************************************************/
	24
d3245b28	25	static int falcon_reconfigure_gmac(struct efx_nic *efx)
177dfcd8	26	{
eb50c0d6	27	struct efx_link_state *link_state = &efx->link_state;
177dfcd8 BH	28	bool loopback, tx_fc, rx_fc, bytemode;
	29	int if_mode;
	30	unsigned int max_frame_len;
	31	efx_oword_t reg;
	32
	33	/* Configuration register 1 */
eb50c0d6 BH	34	tx_fc = (link_state->fc & EFX_FC_TX) \|\| !link_state->fd;
eb50c0d6 BH	35	rx_fc = !!(link_state->fc & EFX_FC_RX);
177dfcd8	36	loopback = (efx->loopback_mode == LOOPBACK_GMAC);
eb50c0d6	37	bytemode = (link_state->speed == 1000);
177dfcd8 BH	38
177dfcd8 BH	39	EFX_POPULATE_OWORD_5(reg,
3e6c4538 BH	40	FRF_AB_GM_LOOP, loopback,
	41	FRF_AB_GM_TX_EN, 1,
	42	FRF_AB_GM_TX_FC_EN, tx_fc,
	43	FRF_AB_GM_RX_EN, 1,
	44	FRF_AB_GM_RX_FC_EN, rx_fc);
12d00cad	45	efx_writeo(efx, &reg, FR_AB_GM_CFG1);
177dfcd8 BH	46	udelay(10);
	47
	48	/* Configuration register 2 */
	49	if_mode = (bytemode) ? 2 : 1;
	50	EFX_POPULATE_OWORD_5(reg,
3e6c4538 BH	51	FRF_AB_GM_IF_MODE, if_mode,
	52	FRF_AB_GM_PAD_CRC_EN, 1,
	53	FRF_AB_GM_LEN_CHK, 1,
eb50c0d6	54	FRF_AB_GM_FD, link_state->fd,
3e6c4538	55	FRF_AB_GM_PAMBL_LEN, 0x7/datasheet recommended /);
177dfcd8	56
12d00cad	57	efx_writeo(efx, &reg, FR_AB_GM_CFG2);
177dfcd8 BH	58	udelay(10);
	59
	60	/* Max frame len register */
	61	max_frame_len = EFX_MAX_FRAME_LEN(efx->net_dev->mtu);
3e6c4538	62	EFX_POPULATE_OWORD_1(reg, FRF_AB_GM_MAX_FLEN, max_frame_len);
12d00cad	63	efx_writeo(efx, &reg, FR_AB_GM_MAX_FLEN);
177dfcd8 BH	64	udelay(10);
	65
	66	/* FIFO configuration register 0 */
	67	EFX_POPULATE_OWORD_5(reg,
3e6c4538 BH	68	FRF_AB_GMF_FTFENREQ, 1,
	69	FRF_AB_GMF_STFENREQ, 1,
	70	FRF_AB_GMF_FRFENREQ, 1,
	71	FRF_AB_GMF_SRFENREQ, 1,
	72	FRF_AB_GMF_WTMENREQ, 1);
12d00cad	73	efx_writeo(efx, &reg, FR_AB_GMF_CFG0);
177dfcd8 BH	74	udelay(10);
	75
	76	/* FIFO configuration register 1 */
	77	EFX_POPULATE_OWORD_2(reg,
3e6c4538 BH	78	FRF_AB_GMF_CFGFRTH, 0x12,
3e6c4538 BH	79	FRF_AB_GMF_CFGXOFFRTX, 0xffff);
12d00cad	80	efx_writeo(efx, &reg, FR_AB_GMF_CFG1);
177dfcd8 BH	81	udelay(10);
	82
	83	/* FIFO configuration register 2 */
	84	EFX_POPULATE_OWORD_2(reg,
3e6c4538 BH	85	FRF_AB_GMF_CFGHWM, 0x3f,
3e6c4538 BH	86	FRF_AB_GMF_CFGLWM, 0xa);
12d00cad	87	efx_writeo(efx, &reg, FR_AB_GMF_CFG2);
177dfcd8 BH	88	udelay(10);
	89
	90	/* FIFO configuration register 3 */
	91	EFX_POPULATE_OWORD_2(reg,
3e6c4538 BH	92	FRF_AB_GMF_CFGHWMFT, 0x1c,
3e6c4538 BH	93	FRF_AB_GMF_CFGFTTH, 0x08);
12d00cad	94	efx_writeo(efx, &reg, FR_AB_GMF_CFG3);
177dfcd8 BH	95	udelay(10);
	96
	97	/* FIFO configuration register 4 */
3e6c4538	98	EFX_POPULATE_OWORD_1(reg, FRF_AB_GMF_HSTFLTRFRM_PAUSE, 1);
12d00cad	99	efx_writeo(efx, &reg, FR_AB_GMF_CFG4);
177dfcd8 BH	100	udelay(10);
	101
	102	/* FIFO configuration register 5 */
12d00cad	103	efx_reado(efx, &reg, FR_AB_GMF_CFG5);
3e6c4538	104	EFX_SET_OWORD_FIELD(reg, FRF_AB_GMF_CFGBYTMODE, bytemode);
eb50c0d6 BH	105	EFX_SET_OWORD_FIELD(reg, FRF_AB_GMF_CFGHDPLX, !link_state->fd);
eb50c0d6 BH	106	EFX_SET_OWORD_FIELD(reg, FRF_AB_GMF_HSTDRPLT64, !link_state->fd);
3e6c4538	107	EFX_SET_OWORD_FIELD(reg, FRF_AB_GMF_HSTFLTRFRMDC_PAUSE, 0);
12d00cad	108	efx_writeo(efx, &reg, FR_AB_GMF_CFG5);
177dfcd8 BH	109	udelay(10);
	110
	111	/* MAC address */
	112	EFX_POPULATE_OWORD_4(reg,
3e6c4538 BH	113	FRF_AB_GM_ADR_B0, efx->net_dev->dev_addr[5],
	114	FRF_AB_GM_ADR_B1, efx->net_dev->dev_addr[4],
	115	FRF_AB_GM_ADR_B2, efx->net_dev->dev_addr[3],
	116	FRF_AB_GM_ADR_B3, efx->net_dev->dev_addr[2]);
12d00cad	117	efx_writeo(efx, &reg, FR_AB_GM_ADR1);
177dfcd8 BH	118	udelay(10);
177dfcd8 BH	119	EFX_POPULATE_OWORD_2(reg,
3e6c4538 BH	120	FRF_AB_GM_ADR_B4, efx->net_dev->dev_addr[1],
3e6c4538 BH	121	FRF_AB_GM_ADR_B5, efx->net_dev->dev_addr[0]);
12d00cad	122	efx_writeo(efx, &reg, FR_AB_GM_ADR2);
177dfcd8 BH	123	udelay(10);
	124
	125	falcon_reconfigure_mac_wrapper(efx);
d3245b28 BH	126
d3245b28 BH	127	return 0;
177dfcd8 BH	128	}
	129
	130	static void falcon_update_stats_gmac(struct efx_nic *efx)
	131	{
	132	struct efx_mac_stats *mac_stats = &efx->mac_stats;
	133	unsigned long old_rx_pause, old_tx_pause;
	134	unsigned long new_rx_pause, new_tx_pause;
177dfcd8 BH	135
	136	/* Pause frames are erroneously counted as errors (SFC bug 3269) */
	137	old_rx_pause = mac_stats->rx_pause;
	138	old_tx_pause = mac_stats->tx_pause;
	139
	140	/* Update MAC stats from DMAed values */
	141	FALCON_STAT(efx, GRxGoodOct, rx_good_bytes);
	142	FALCON_STAT(efx, GRxBadOct, rx_bad_bytes);
	143	FALCON_STAT(efx, GRxMissPkt, rx_missed);
	144	FALCON_STAT(efx, GRxFalseCRS, rx_false_carrier);
	145	FALCON_STAT(efx, GRxPausePkt, rx_pause);
	146	FALCON_STAT(efx, GRxBadPkt, rx_bad);
	147	FALCON_STAT(efx, GRxUcastPkt, rx_unicast);
	148	FALCON_STAT(efx, GRxMcastPkt, rx_multicast);
	149	FALCON_STAT(efx, GRxBcastPkt, rx_broadcast);
	150	FALCON_STAT(efx, GRxGoodLt64Pkt, rx_good_lt64);
	151	FALCON_STAT(efx, GRxBadLt64Pkt, rx_bad_lt64);
	152	FALCON_STAT(efx, GRx64Pkt, rx_64);
	153	FALCON_STAT(efx, GRx65to127Pkt, rx_65_to_127);
	154	FALCON_STAT(efx, GRx128to255Pkt, rx_128_to_255);
	155	FALCON_STAT(efx, GRx256to511Pkt, rx_256_to_511);
	156	FALCON_STAT(efx, GRx512to1023Pkt, rx_512_to_1023);
	157	FALCON_STAT(efx, GRx1024to15xxPkt, rx_1024_to_15xx);
	158	FALCON_STAT(efx, GRx15xxtoJumboPkt, rx_15xx_to_jumbo);
	159	FALCON_STAT(efx, GRxGtJumboPkt, rx_gtjumbo);
	160	FALCON_STAT(efx, GRxFcsErr64to15xxPkt, rx_bad_64_to_15xx);
	161	FALCON_STAT(efx, GRxFcsErr15xxtoJumboPkt, rx_bad_15xx_to_jumbo);
	162	FALCON_STAT(efx, GRxFcsErrGtJumboPkt, rx_bad_gtjumbo);
	163	FALCON_STAT(efx, GTxGoodBadOct, tx_bytes);
	164	FALCON_STAT(efx, GTxGoodOct, tx_good_bytes);
	165	FALCON_STAT(efx, GTxSglColPkt, tx_single_collision);
	166	FALCON_STAT(efx, GTxMultColPkt, tx_multiple_collision);
	167	FALCON_STAT(efx, GTxExColPkt, tx_excessive_collision);
	168	FALCON_STAT(efx, GTxDefPkt, tx_deferred);
	169	FALCON_STAT(efx, GTxLateCol, tx_late_collision);
	170	FALCON_STAT(efx, GTxExDefPkt, tx_excessive_deferred);
	171	FALCON_STAT(efx, GTxPausePkt, tx_pause);
	172	FALCON_STAT(efx, GTxBadPkt, tx_bad);
	173	FALCON_STAT(efx, GTxUcastPkt, tx_unicast);
	174	FALCON_STAT(efx, GTxMcastPkt, tx_multicast);
	175	FALCON_STAT(efx, GTxBcastPkt, tx_broadcast);
	176	FALCON_STAT(efx, GTxLt64Pkt, tx_lt64);
	177	FALCON_STAT(efx, GTx64Pkt, tx_64);
	178	FALCON_STAT(efx, GTx65to127Pkt, tx_65_to_127);
	179	FALCON_STAT(efx, GTx128to255Pkt, tx_128_to_255);
	180	FALCON_STAT(efx, GTx256to511Pkt, tx_256_to_511);
	181	FALCON_STAT(efx, GTx512to1023Pkt, tx_512_to_1023);
	182	FALCON_STAT(efx, GTx1024to15xxPkt, tx_1024_to_15xx);
	183	FALCON_STAT(efx, GTx15xxtoJumboPkt, tx_15xx_to_jumbo);
	184	FALCON_STAT(efx, GTxGtJumboPkt, tx_gtjumbo);
	185	FALCON_STAT(efx, GTxNonTcpUdpPkt, tx_non_tcpudp);
	186	FALCON_STAT(efx, GTxMacSrcErrPkt, tx_mac_src_error);
	187	FALCON_STAT(efx, GTxIpSrcErrPkt, tx_ip_src_error);
	188
	189	/* Pause frames are erroneously counted as errors (SFC bug 3269) */
	190	new_rx_pause = mac_stats->rx_pause;
	191	new_tx_pause = mac_stats->tx_pause;
	192	mac_stats->rx_bad -= (new_rx_pause - old_rx_pause);
	193	mac_stats->tx_bad -= (new_tx_pause - old_tx_pause);
	194
	195	/* Derive stats that the MAC doesn't provide directly */
	196	mac_stats->tx_bad_bytes =
	197	mac_stats->tx_bytes - mac_stats->tx_good_bytes;
	198	mac_stats->tx_packets =
199	mac_stats->tx_lt64 + mac_stats->tx_64 +
200	mac_stats->tx_65_to_127 + mac_stats->tx_128_to_255 +
201	mac_stats->tx_256_to_511 + mac_stats->tx_512_to_1023 +
202	mac_stats->tx_1024_to_15xx + mac_stats->tx_15xx_to_jumbo +
203	mac_stats->tx_gtjumbo;
204	mac_stats->tx_collision =
205	mac_stats->tx_single_collision +
206	mac_stats->tx_multiple_collision +
207	mac_stats->tx_excessive_collision +
208	mac_stats->tx_late_collision;
209	mac_stats->rx_bytes =
210	mac_stats->rx_good_bytes + mac_stats->rx_bad_bytes;
211	mac_stats->rx_packets =
212	mac_stats->rx_good_lt64 + mac_stats->rx_bad_lt64 +
213	mac_stats->rx_64 + mac_stats->rx_65_to_127 +
214	mac_stats->rx_128_to_255 + mac_stats->rx_256_to_511 +
215	mac_stats->rx_512_to_1023 + mac_stats->rx_1024_to_15xx +
216	mac_stats->rx_15xx_to_jumbo + mac_stats->rx_gtjumbo;
217	mac_stats->rx_good = mac_stats->rx_packets - mac_stats->rx_bad;
218	mac_stats->rx_lt64 = mac_stats->rx_good_lt64 + mac_stats->rx_bad_lt64;
219	}
220
9007b9fa BH	221	static bool falcon_gmac_check_fault(struct efx_nic *efx)
	222	{
	223	return false;
	224	}
	225
177dfcd8 BH	226	struct efx_mac_operations falcon_gmac_operations = {
	227	.reconfigure = falcon_reconfigure_gmac,
	228	.update_stats = falcon_update_stats_gmac,
9007b9fa	229	.check_fault = falcon_gmac_check_fault,
177dfcd8	230	};