Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit fda19e83 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'netcp-next' 



WingMan Kwok says:

====================
net: netcp: Bug fixes of CPSW statistics collection

This patch set contains bug fixes and enhencements of hw ethernet
statistics processing on TI's Keystone2 CPSW ethernet switches.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents ea6f82fe 5be4001e

drivers/net/ethernet/ti/netcp_ethss.c

+324 −79
Original line number Diff line number Diff line
@@ -295,8 +295,6 @@ struct xgbe_hw_stats { 
	u32	rx_dma_overruns;

};



#define XGBE10_NUM_STAT_ENTRIES (sizeof(struct xgbe_hw_stats)/sizeof(u32))



struct gbenu_ss_regs {

	u32	id_ver;

	u32	synce_count;		/* NU */
@@ -480,7 +478,6 @@ struct gbenu_hw_stats { 
	u32	tx_pri7_drop_bcnt;

};



#define GBENU_NUM_HW_STAT_ENTRIES (sizeof(struct gbenu_hw_stats) / sizeof(u32))

#define GBENU_HW_STATS_REG_MAP_SZ	0x200



struct gbe_ss_regs {
@@ -615,7 +612,6 @@ struct gbe_hw_stats { 
	u32	rx_dma_overruns;

};



#define GBE13_NUM_HW_STAT_ENTRIES (sizeof(struct gbe_hw_stats)/sizeof(u32))

#define GBE_MAX_HW_STAT_MODS			9

#define GBE_HW_STATS_REG_MAP_SZ			0x100
@@ -646,6 +642,7 @@ struct gbe_priv { 
	bool				enable_ale;

	u8				max_num_slaves;

	u8				max_num_ports; /* max_num_slaves + 1 */

	u8				num_stats_mods;

	struct netcp_tx_pipe		tx_pipe;



	int				host_port;
@@ -675,6 +672,7 @@ struct gbe_priv { 
	struct net_device		*dummy_ndev;



	u64				*hw_stats;

	u32				*hw_stats_prev;

	const struct netcp_ethtool_stat *et_stats;

	int				num_et_stats;

	/*  Lock for updating the hwstats */
@@ -874,7 +872,7 @@ static const struct netcp_ethtool_stat gbe13_et_stats[] = { 
};



/* This is the size of entries in GBENU_STATS_HOST */

#define GBENU_ET_STATS_HOST_SIZE	33

#define GBENU_ET_STATS_HOST_SIZE	52



#define GBENU_STATS_HOST(field)					\

{								\
@@ -883,8 +881,8 @@ static const struct netcp_ethtool_stat gbe13_et_stats[] = { 
	offsetof(struct gbenu_hw_stats, field)			\

}



/* This is the size of entries in GBENU_STATS_HOST */

#define GBENU_ET_STATS_PORT_SIZE	46

/* This is the size of entries in GBENU_STATS_PORT */

#define GBENU_ET_STATS_PORT_SIZE	65



#define GBENU_STATS_P1(field)					\

{								\
@@ -976,7 +974,26 @@ static const struct netcp_ethtool_stat gbenu_et_stats[] = { 
	GBENU_STATS_HOST(ale_unknown_mcast_bytes),

	GBENU_STATS_HOST(ale_unknown_bcast),

	GBENU_STATS_HOST(ale_unknown_bcast_bytes),

	GBENU_STATS_HOST(ale_pol_match),

	GBENU_STATS_HOST(ale_pol_match_red),

	GBENU_STATS_HOST(ale_pol_match_yellow),

	GBENU_STATS_HOST(tx_mem_protect_err),

	GBENU_STATS_HOST(tx_pri0_drop),

	GBENU_STATS_HOST(tx_pri1_drop),

	GBENU_STATS_HOST(tx_pri2_drop),

	GBENU_STATS_HOST(tx_pri3_drop),

	GBENU_STATS_HOST(tx_pri4_drop),

	GBENU_STATS_HOST(tx_pri5_drop),

	GBENU_STATS_HOST(tx_pri6_drop),

	GBENU_STATS_HOST(tx_pri7_drop),

	GBENU_STATS_HOST(tx_pri0_drop_bcnt),

	GBENU_STATS_HOST(tx_pri1_drop_bcnt),

	GBENU_STATS_HOST(tx_pri2_drop_bcnt),

	GBENU_STATS_HOST(tx_pri3_drop_bcnt),

	GBENU_STATS_HOST(tx_pri4_drop_bcnt),

	GBENU_STATS_HOST(tx_pri5_drop_bcnt),

	GBENU_STATS_HOST(tx_pri6_drop_bcnt),

	GBENU_STATS_HOST(tx_pri7_drop_bcnt),

	/* GBENU Module 1 */

	GBENU_STATS_P1(rx_good_frames),

	GBENU_STATS_P1(rx_broadcast_frames),
@@ -1023,7 +1040,26 @@ static const struct netcp_ethtool_stat gbenu_et_stats[] = { 
	GBENU_STATS_P1(ale_unknown_mcast_bytes),

	GBENU_STATS_P1(ale_unknown_bcast),

	GBENU_STATS_P1(ale_unknown_bcast_bytes),

	GBENU_STATS_P1(ale_pol_match),

	GBENU_STATS_P1(ale_pol_match_red),

	GBENU_STATS_P1(ale_pol_match_yellow),

	GBENU_STATS_P1(tx_mem_protect_err),

	GBENU_STATS_P1(tx_pri0_drop),

	GBENU_STATS_P1(tx_pri1_drop),

	GBENU_STATS_P1(tx_pri2_drop),

	GBENU_STATS_P1(tx_pri3_drop),

	GBENU_STATS_P1(tx_pri4_drop),

	GBENU_STATS_P1(tx_pri5_drop),

	GBENU_STATS_P1(tx_pri6_drop),

	GBENU_STATS_P1(tx_pri7_drop),

	GBENU_STATS_P1(tx_pri0_drop_bcnt),

	GBENU_STATS_P1(tx_pri1_drop_bcnt),

	GBENU_STATS_P1(tx_pri2_drop_bcnt),

	GBENU_STATS_P1(tx_pri3_drop_bcnt),

	GBENU_STATS_P1(tx_pri4_drop_bcnt),

	GBENU_STATS_P1(tx_pri5_drop_bcnt),

	GBENU_STATS_P1(tx_pri6_drop_bcnt),

	GBENU_STATS_P1(tx_pri7_drop_bcnt),

	/* GBENU Module 2 */

	GBENU_STATS_P2(rx_good_frames),

	GBENU_STATS_P2(rx_broadcast_frames),
@@ -1070,7 +1106,26 @@ static const struct netcp_ethtool_stat gbenu_et_stats[] = { 
	GBENU_STATS_P2(ale_unknown_mcast_bytes),

	GBENU_STATS_P2(ale_unknown_bcast),

	GBENU_STATS_P2(ale_unknown_bcast_bytes),

	GBENU_STATS_P2(ale_pol_match),

	GBENU_STATS_P2(ale_pol_match_red),

	GBENU_STATS_P2(ale_pol_match_yellow),

	GBENU_STATS_P2(tx_mem_protect_err),

	GBENU_STATS_P2(tx_pri0_drop),

	GBENU_STATS_P2(tx_pri1_drop),

	GBENU_STATS_P2(tx_pri2_drop),

	GBENU_STATS_P2(tx_pri3_drop),

	GBENU_STATS_P2(tx_pri4_drop),

	GBENU_STATS_P2(tx_pri5_drop),

	GBENU_STATS_P2(tx_pri6_drop),

	GBENU_STATS_P2(tx_pri7_drop),

	GBENU_STATS_P2(tx_pri0_drop_bcnt),

	GBENU_STATS_P2(tx_pri1_drop_bcnt),

	GBENU_STATS_P2(tx_pri2_drop_bcnt),

	GBENU_STATS_P2(tx_pri3_drop_bcnt),

	GBENU_STATS_P2(tx_pri4_drop_bcnt),

	GBENU_STATS_P2(tx_pri5_drop_bcnt),

	GBENU_STATS_P2(tx_pri6_drop_bcnt),

	GBENU_STATS_P2(tx_pri7_drop_bcnt),

	/* GBENU Module 3 */

	GBENU_STATS_P3(rx_good_frames),

	GBENU_STATS_P3(rx_broadcast_frames),
@@ -1117,7 +1172,26 @@ static const struct netcp_ethtool_stat gbenu_et_stats[] = { 
	GBENU_STATS_P3(ale_unknown_mcast_bytes),

	GBENU_STATS_P3(ale_unknown_bcast),

	GBENU_STATS_P3(ale_unknown_bcast_bytes),

	GBENU_STATS_P3(ale_pol_match),

	GBENU_STATS_P3(ale_pol_match_red),

	GBENU_STATS_P3(ale_pol_match_yellow),

	GBENU_STATS_P3(tx_mem_protect_err),

	GBENU_STATS_P3(tx_pri0_drop),

	GBENU_STATS_P3(tx_pri1_drop),

	GBENU_STATS_P3(tx_pri2_drop),

	GBENU_STATS_P3(tx_pri3_drop),

	GBENU_STATS_P3(tx_pri4_drop),

	GBENU_STATS_P3(tx_pri5_drop),

	GBENU_STATS_P3(tx_pri6_drop),

	GBENU_STATS_P3(tx_pri7_drop),

	GBENU_STATS_P3(tx_pri0_drop_bcnt),

	GBENU_STATS_P3(tx_pri1_drop_bcnt),

	GBENU_STATS_P3(tx_pri2_drop_bcnt),

	GBENU_STATS_P3(tx_pri3_drop_bcnt),

	GBENU_STATS_P3(tx_pri4_drop_bcnt),

	GBENU_STATS_P3(tx_pri5_drop_bcnt),

	GBENU_STATS_P3(tx_pri6_drop_bcnt),

	GBENU_STATS_P3(tx_pri7_drop_bcnt),

	/* GBENU Module 4 */

	GBENU_STATS_P4(rx_good_frames),

	GBENU_STATS_P4(rx_broadcast_frames),
@@ -1164,7 +1238,26 @@ static const struct netcp_ethtool_stat gbenu_et_stats[] = { 
	GBENU_STATS_P4(ale_unknown_mcast_bytes),

	GBENU_STATS_P4(ale_unknown_bcast),

	GBENU_STATS_P4(ale_unknown_bcast_bytes),

	GBENU_STATS_P4(ale_pol_match),

	GBENU_STATS_P4(ale_pol_match_red),

	GBENU_STATS_P4(ale_pol_match_yellow),

	GBENU_STATS_P4(tx_mem_protect_err),

	GBENU_STATS_P4(tx_pri0_drop),

	GBENU_STATS_P4(tx_pri1_drop),

	GBENU_STATS_P4(tx_pri2_drop),

	GBENU_STATS_P4(tx_pri3_drop),

	GBENU_STATS_P4(tx_pri4_drop),

	GBENU_STATS_P4(tx_pri5_drop),

	GBENU_STATS_P4(tx_pri6_drop),

	GBENU_STATS_P4(tx_pri7_drop),

	GBENU_STATS_P4(tx_pri0_drop_bcnt),

	GBENU_STATS_P4(tx_pri1_drop_bcnt),

	GBENU_STATS_P4(tx_pri2_drop_bcnt),

	GBENU_STATS_P4(tx_pri3_drop_bcnt),

	GBENU_STATS_P4(tx_pri4_drop_bcnt),

	GBENU_STATS_P4(tx_pri5_drop_bcnt),

	GBENU_STATS_P4(tx_pri6_drop_bcnt),

	GBENU_STATS_P4(tx_pri7_drop_bcnt),

	/* GBENU Module 5 */

	GBENU_STATS_P5(rx_good_frames),

	GBENU_STATS_P5(rx_broadcast_frames),
@@ -1211,7 +1304,26 @@ static const struct netcp_ethtool_stat gbenu_et_stats[] = { 
	GBENU_STATS_P5(ale_unknown_mcast_bytes),

	GBENU_STATS_P5(ale_unknown_bcast),

	GBENU_STATS_P5(ale_unknown_bcast_bytes),

	GBENU_STATS_P5(ale_pol_match),

	GBENU_STATS_P5(ale_pol_match_red),

	GBENU_STATS_P5(ale_pol_match_yellow),

	GBENU_STATS_P5(tx_mem_protect_err),

	GBENU_STATS_P5(tx_pri0_drop),

	GBENU_STATS_P5(tx_pri1_drop),

	GBENU_STATS_P5(tx_pri2_drop),

	GBENU_STATS_P5(tx_pri3_drop),

	GBENU_STATS_P5(tx_pri4_drop),

	GBENU_STATS_P5(tx_pri5_drop),

	GBENU_STATS_P5(tx_pri6_drop),

	GBENU_STATS_P5(tx_pri7_drop),

	GBENU_STATS_P5(tx_pri0_drop_bcnt),

	GBENU_STATS_P5(tx_pri1_drop_bcnt),

	GBENU_STATS_P5(tx_pri2_drop_bcnt),

	GBENU_STATS_P5(tx_pri3_drop_bcnt),

	GBENU_STATS_P5(tx_pri4_drop_bcnt),

	GBENU_STATS_P5(tx_pri5_drop_bcnt),

	GBENU_STATS_P5(tx_pri6_drop_bcnt),

	GBENU_STATS_P5(tx_pri7_drop_bcnt),

	/* GBENU Module 6 */

	GBENU_STATS_P6(rx_good_frames),

	GBENU_STATS_P6(rx_broadcast_frames),
@@ -1258,7 +1370,26 @@ static const struct netcp_ethtool_stat gbenu_et_stats[] = { 
	GBENU_STATS_P6(ale_unknown_mcast_bytes),

	GBENU_STATS_P6(ale_unknown_bcast),

	GBENU_STATS_P6(ale_unknown_bcast_bytes),

	GBENU_STATS_P6(ale_pol_match),

	GBENU_STATS_P6(ale_pol_match_red),

	GBENU_STATS_P6(ale_pol_match_yellow),

	GBENU_STATS_P6(tx_mem_protect_err),

	GBENU_STATS_P6(tx_pri0_drop),

	GBENU_STATS_P6(tx_pri1_drop),

	GBENU_STATS_P6(tx_pri2_drop),

	GBENU_STATS_P6(tx_pri3_drop),

	GBENU_STATS_P6(tx_pri4_drop),

	GBENU_STATS_P6(tx_pri5_drop),

	GBENU_STATS_P6(tx_pri6_drop),

	GBENU_STATS_P6(tx_pri7_drop),

	GBENU_STATS_P6(tx_pri0_drop_bcnt),

	GBENU_STATS_P6(tx_pri1_drop_bcnt),

	GBENU_STATS_P6(tx_pri2_drop_bcnt),

	GBENU_STATS_P6(tx_pri3_drop_bcnt),

	GBENU_STATS_P6(tx_pri4_drop_bcnt),

	GBENU_STATS_P6(tx_pri5_drop_bcnt),

	GBENU_STATS_P6(tx_pri6_drop_bcnt),

	GBENU_STATS_P6(tx_pri7_drop_bcnt),

	/* GBENU Module 7 */

	GBENU_STATS_P7(rx_good_frames),

	GBENU_STATS_P7(rx_broadcast_frames),
@@ -1305,7 +1436,26 @@ static const struct netcp_ethtool_stat gbenu_et_stats[] = { 
	GBENU_STATS_P7(ale_unknown_mcast_bytes),

	GBENU_STATS_P7(ale_unknown_bcast),

	GBENU_STATS_P7(ale_unknown_bcast_bytes),

	GBENU_STATS_P7(ale_pol_match),

	GBENU_STATS_P7(ale_pol_match_red),

	GBENU_STATS_P7(ale_pol_match_yellow),

	GBENU_STATS_P7(tx_mem_protect_err),

	GBENU_STATS_P7(tx_pri0_drop),

	GBENU_STATS_P7(tx_pri1_drop),

	GBENU_STATS_P7(tx_pri2_drop),

	GBENU_STATS_P7(tx_pri3_drop),

	GBENU_STATS_P7(tx_pri4_drop),

	GBENU_STATS_P7(tx_pri5_drop),

	GBENU_STATS_P7(tx_pri6_drop),

	GBENU_STATS_P7(tx_pri7_drop),

	GBENU_STATS_P7(tx_pri0_drop_bcnt),

	GBENU_STATS_P7(tx_pri1_drop_bcnt),

	GBENU_STATS_P7(tx_pri2_drop_bcnt),

	GBENU_STATS_P7(tx_pri3_drop_bcnt),

	GBENU_STATS_P7(tx_pri4_drop_bcnt),

	GBENU_STATS_P7(tx_pri5_drop_bcnt),

	GBENU_STATS_P7(tx_pri6_drop_bcnt),

	GBENU_STATS_P7(tx_pri7_drop_bcnt),

	/* GBENU Module 8 */

	GBENU_STATS_P8(rx_good_frames),

	GBENU_STATS_P8(rx_broadcast_frames),
@@ -1352,7 +1502,26 @@ static const struct netcp_ethtool_stat gbenu_et_stats[] = { 
	GBENU_STATS_P8(ale_unknown_mcast_bytes),

	GBENU_STATS_P8(ale_unknown_bcast),

	GBENU_STATS_P8(ale_unknown_bcast_bytes),

	GBENU_STATS_P8(ale_pol_match),

	GBENU_STATS_P8(ale_pol_match_red),

	GBENU_STATS_P8(ale_pol_match_yellow),

	GBENU_STATS_P8(tx_mem_protect_err),

	GBENU_STATS_P8(tx_pri0_drop),

	GBENU_STATS_P8(tx_pri1_drop),

	GBENU_STATS_P8(tx_pri2_drop),

	GBENU_STATS_P8(tx_pri3_drop),

	GBENU_STATS_P8(tx_pri4_drop),

	GBENU_STATS_P8(tx_pri5_drop),

	GBENU_STATS_P8(tx_pri6_drop),

	GBENU_STATS_P8(tx_pri7_drop),

	GBENU_STATS_P8(tx_pri0_drop_bcnt),

	GBENU_STATS_P8(tx_pri1_drop_bcnt),

	GBENU_STATS_P8(tx_pri2_drop_bcnt),

	GBENU_STATS_P8(tx_pri3_drop_bcnt),

	GBENU_STATS_P8(tx_pri4_drop_bcnt),

	GBENU_STATS_P8(tx_pri5_drop_bcnt),

	GBENU_STATS_P8(tx_pri6_drop_bcnt),

	GBENU_STATS_P8(tx_pri7_drop_bcnt),

};



#define XGBE_STATS0_INFO(field)				\
@@ -1554,70 +1723,97 @@ static int keystone_get_sset_count(struct net_device *ndev, int stringset) 
	}

}



static void gbe_update_stats(struct gbe_priv *gbe_dev, uint64_t *data)

static void gbe_reset_mod_stats(struct gbe_priv *gbe_dev, int stats_mod)

{

	void __iomem *base = gbe_dev->hw_stats_regs[stats_mod];

	u32  __iomem *p_stats_entry;

	int i;



	for (i = 0; i < gbe_dev->num_et_stats; i++) {

		if (gbe_dev->et_stats[i].type == stats_mod) {

			p_stats_entry = base + gbe_dev->et_stats[i].offset;

			gbe_dev->hw_stats[i] = 0;

			gbe_dev->hw_stats_prev[i] = readl(p_stats_entry);

		}

	}

}



static inline void gbe_update_hw_stats_entry(struct gbe_priv *gbe_dev,

					     int et_stats_entry)

{

	void __iomem *base = NULL;

	u32  __iomem *p;

	u32 tmp = 0;

	u32  __iomem *p_stats_entry;

	u32 curr, delta;



	/* The hw_stats_regs pointers are already

	 * properly set to point to the right base:

	 */

	base = gbe_dev->hw_stats_regs[gbe_dev->et_stats[et_stats_entry].type];

	p_stats_entry = base + gbe_dev->et_stats[et_stats_entry].offset;

	curr = readl(p_stats_entry);

	delta = curr - gbe_dev->hw_stats_prev[et_stats_entry];

	gbe_dev->hw_stats_prev[et_stats_entry] = curr;

	gbe_dev->hw_stats[et_stats_entry] += delta;

}



static void gbe_update_stats(struct gbe_priv *gbe_dev, uint64_t *data)

{

	int i;



	for (i = 0; i < gbe_dev->num_et_stats; i++) {

		base = gbe_dev->hw_stats_regs[gbe_dev->et_stats[i].type];

		p = base + gbe_dev->et_stats[i].offset;

		tmp = readl(p);

		gbe_dev->hw_stats[i] = gbe_dev->hw_stats[i] + tmp;

		gbe_update_hw_stats_entry(gbe_dev, i);



		if (data)

			data[i] = gbe_dev->hw_stats[i];

		/* write-to-decrement:

		 * new register value = old register value - write value

		 */

		writel(tmp, p);

	}

}



static void gbe_update_stats_ver14(struct gbe_priv *gbe_dev, uint64_t *data)

static inline void gbe_stats_mod_visible_ver14(struct gbe_priv *gbe_dev,

					       int stats_mod)

{

	void __iomem *gbe_statsa = gbe_dev->hw_stats_regs[0];

	void __iomem *gbe_statsb = gbe_dev->hw_stats_regs[1];

	u64 *hw_stats = &gbe_dev->hw_stats[0];

	void __iomem *base = NULL;

	u32  __iomem *p;

	u32 tmp = 0, val, pair_size = (gbe_dev->num_et_stats / 2);

	int i, j, pair;

	u32 val;



	for (pair = 0; pair < 2; pair++) {

	val = readl(GBE_REG_ADDR(gbe_dev, switch_regs, stat_port_en));



		if (pair == 0)

	switch (stats_mod) {

	case GBE_STATSA_MODULE:

	case GBE_STATSB_MODULE:

		val &= ~GBE_STATS_CD_SEL;

		else

		break;

	case GBE_STATSC_MODULE:

	case GBE_STATSD_MODULE:

		val |= GBE_STATS_CD_SEL;

		break;

	default:

		return;

	}



		/* make the stat modules visible */

	/* make the stat module visible */

	writel(val, GBE_REG_ADDR(gbe_dev, switch_regs, stat_port_en));

}



		for (i = 0; i < pair_size; i++) {

			j = pair * pair_size + i;

			switch (gbe_dev->et_stats[j].type) {

			case GBE_STATSA_MODULE:

			case GBE_STATSC_MODULE:

				base = gbe_statsa;

			break;

			case GBE_STATSB_MODULE:

			case GBE_STATSD_MODULE:

				base  = gbe_statsb;

			break;

static void gbe_reset_mod_stats_ver14(struct gbe_priv *gbe_dev, int stats_mod)

{

	gbe_stats_mod_visible_ver14(gbe_dev, stats_mod);

	gbe_reset_mod_stats(gbe_dev, stats_mod);

}



			p = base + gbe_dev->et_stats[j].offset;

			tmp = readl(p);

			hw_stats[j] += tmp;

static void gbe_update_stats_ver14(struct gbe_priv *gbe_dev, uint64_t *data)

{

	u32 half_num_et_stats = (gbe_dev->num_et_stats / 2);

	int et_entry, j, pair;



	for (pair = 0; pair < 2; pair++) {

		gbe_stats_mod_visible_ver14(gbe_dev, (pair ?

						      GBE_STATSC_MODULE :

						      GBE_STATSA_MODULE));



		for (j = 0; j < half_num_et_stats; j++) {

			et_entry = pair * half_num_et_stats + j;

			gbe_update_hw_stats_entry(gbe_dev, et_entry);



			if (data)

				data[j] = hw_stats[j];

			/* write-to-decrement:

			 * new register value = old register value - write value

			 */

			writel(tmp, p);

				data[et_entry] = gbe_dev->hw_stats[et_entry];

		}

	}

}
@@ -2189,14 +2385,15 @@ static void netcp_ethss_timer(unsigned long arg) 
		netcp_ethss_update_link_state(gbe_dev, slave, NULL);

	}



	spin_lock_bh(&gbe_dev->hw_stats_lock);

	/* A timer runs as a BH, no need to block them */

	spin_lock(&gbe_dev->hw_stats_lock);



	if (gbe_dev->ss_version == GBE_SS_VERSION_14)

		gbe_update_stats_ver14(gbe_dev, NULL);

	else

		gbe_update_stats(gbe_dev, NULL);



	spin_unlock_bh(&gbe_dev->hw_stats_lock);

	spin_unlock(&gbe_dev->hw_stats_lock);



	gbe_dev->timer.expires	= jiffies + GBE_TIMER_INTERVAL;

	add_timer(&gbe_dev->timer);
@@ -2554,15 +2751,28 @@ static int set_xgbe_ethss10_priv(struct gbe_priv *gbe_dev, 
	}

	gbe_dev->xgbe_serdes_regs = regs;



	gbe_dev->num_stats_mods = gbe_dev->max_num_ports;

	gbe_dev->et_stats = xgbe10_et_stats;

	gbe_dev->num_et_stats = ARRAY_SIZE(xgbe10_et_stats);



	gbe_dev->hw_stats = devm_kzalloc(gbe_dev->dev,

				  XGBE10_NUM_STAT_ENTRIES *

				  (gbe_dev->max_num_ports) * sizeof(u64),

					 gbe_dev->num_et_stats * sizeof(u64),

					 GFP_KERNEL);

	if (!gbe_dev->hw_stats) {

		dev_err(gbe_dev->dev, "hw_stats memory allocation failed\n");

		return -ENOMEM;

	}



	gbe_dev->hw_stats_prev =

		devm_kzalloc(gbe_dev->dev,

			     gbe_dev->num_et_stats * sizeof(u32),

			     GFP_KERNEL);

	if (!gbe_dev->hw_stats_prev) {

		dev_err(gbe_dev->dev,

			"hw_stats_prev memory allocation failed\n");

		return -ENOMEM;

	}



	gbe_dev->ss_version = XGBE_SS_VERSION_10;

	gbe_dev->sgmii_port_regs = gbe_dev->ss_regs +

					XGBE10_SGMII_MODULE_OFFSET;
@@ -2576,8 +2786,6 @@ static int set_xgbe_ethss10_priv(struct gbe_priv *gbe_dev, 
	gbe_dev->ale_ports = gbe_dev->max_num_ports;

	gbe_dev->host_port = XGBE10_HOST_PORT_NUM;

	gbe_dev->ale_entries = XGBE10_NUM_ALE_ENTRIES;

	gbe_dev->et_stats = xgbe10_et_stats;

	gbe_dev->num_et_stats = ARRAY_SIZE(xgbe10_et_stats);

	gbe_dev->stats_en_mask = (1 << (gbe_dev->max_num_ports)) - 1;



	/* Subsystem registers */
@@ -2662,30 +2870,45 @@ static int set_gbe_ethss14_priv(struct gbe_priv *gbe_dev, 
	}

	gbe_dev->switch_regs = regs;



	gbe_dev->num_stats_mods = gbe_dev->max_num_slaves;

	gbe_dev->et_stats = gbe13_et_stats;

	gbe_dev->num_et_stats = ARRAY_SIZE(gbe13_et_stats);



	gbe_dev->hw_stats = devm_kzalloc(gbe_dev->dev,

					  GBE13_NUM_HW_STAT_ENTRIES *

					  gbe_dev->max_num_slaves * sizeof(u64),

					 gbe_dev->num_et_stats * sizeof(u64),

					 GFP_KERNEL);

	if (!gbe_dev->hw_stats) {

		dev_err(gbe_dev->dev, "hw_stats memory allocation failed\n");

		return -ENOMEM;

	}



	gbe_dev->hw_stats_prev =

		devm_kzalloc(gbe_dev->dev,

			     gbe_dev->num_et_stats * sizeof(u32),

			     GFP_KERNEL);

	if (!gbe_dev->hw_stats_prev) {

		dev_err(gbe_dev->dev,

			"hw_stats_prev memory allocation failed\n");

		return -ENOMEM;

	}



	gbe_dev->sgmii_port_regs = gbe_dev->ss_regs + GBE13_SGMII_MODULE_OFFSET;

	gbe_dev->host_port_regs = gbe_dev->switch_regs + GBE13_HOST_PORT_OFFSET;



	/* K2HK has only 2 hw stats modules visible at a time, so

	 * module 0 & 2 points to one base and

	 * module 1 & 3 points to the other base

	 */

	for (i = 0; i < gbe_dev->max_num_slaves; i++) {

		gbe_dev->hw_stats_regs[i] =

			gbe_dev->switch_regs + GBE13_HW_STATS_OFFSET +

			(GBE_HW_STATS_REG_MAP_SZ * i);

			(GBE_HW_STATS_REG_MAP_SZ * (i & 0x1));

	}



	gbe_dev->ale_reg = gbe_dev->switch_regs + GBE13_ALE_OFFSET;

	gbe_dev->ale_ports = gbe_dev->max_num_ports;

	gbe_dev->host_port = GBE13_HOST_PORT_NUM;

	gbe_dev->ale_entries = GBE13_NUM_ALE_ENTRIES;

	gbe_dev->et_stats = gbe13_et_stats;

	gbe_dev->num_et_stats = ARRAY_SIZE(gbe13_et_stats);

	gbe_dev->stats_en_mask = GBE13_REG_VAL_STAT_ENABLE_ALL;



	/* Subsystem registers */
@@ -2712,15 +2935,34 @@ static int set_gbenu_ethss_priv(struct gbe_priv *gbe_dev, 
	void __iomem *regs;

	int i, ret;



	gbe_dev->num_stats_mods = gbe_dev->max_num_ports;

	gbe_dev->et_stats = gbenu_et_stats;



	if (IS_SS_ID_NU(gbe_dev))

		gbe_dev->num_et_stats = GBENU_ET_STATS_HOST_SIZE +

			(gbe_dev->max_num_slaves * GBENU_ET_STATS_PORT_SIZE);

	else

		gbe_dev->num_et_stats = GBENU_ET_STATS_HOST_SIZE +

					GBENU_ET_STATS_PORT_SIZE;



	gbe_dev->hw_stats = devm_kzalloc(gbe_dev->dev,

				  GBENU_NUM_HW_STAT_ENTRIES *

				  (gbe_dev->max_num_ports) * sizeof(u64),

					 gbe_dev->num_et_stats * sizeof(u64),

					 GFP_KERNEL);

	if (!gbe_dev->hw_stats) {

		dev_err(gbe_dev->dev, "hw_stats memory allocation failed\n");

		return -ENOMEM;

	}



	gbe_dev->hw_stats_prev =

		devm_kzalloc(gbe_dev->dev,

			     gbe_dev->num_et_stats * sizeof(u32),

			     GFP_KERNEL);

	if (!gbe_dev->hw_stats_prev) {

		dev_err(gbe_dev->dev,

			"hw_stats_prev memory allocation failed\n");

		return -ENOMEM;

	}



	ret = of_address_to_resource(node, GBENU_SM_REG_INDEX, &res);

	if (ret) {

		dev_err(gbe_dev->dev,
@@ -2748,16 +2990,8 @@ static int set_gbenu_ethss_priv(struct gbe_priv *gbe_dev, 
	gbe_dev->ale_ports = gbe_dev->max_num_ports;

	gbe_dev->host_port = GBENU_HOST_PORT_NUM;

	gbe_dev->ale_entries = GBE13_NUM_ALE_ENTRIES;

	gbe_dev->et_stats = gbenu_et_stats;

	gbe_dev->stats_en_mask = (1 << (gbe_dev->max_num_ports)) - 1;



	if (IS_SS_ID_NU(gbe_dev))

		gbe_dev->num_et_stats = GBENU_ET_STATS_HOST_SIZE +

			(gbe_dev->max_num_slaves * GBENU_ET_STATS_PORT_SIZE);

	else

		gbe_dev->num_et_stats = GBENU_ET_STATS_HOST_SIZE +

					GBENU_ET_STATS_PORT_SIZE;



	/* Subsystem registers */

	GBENU_SET_REG_OFS(gbe_dev, ss_regs, id_ver);
@@ -2787,7 +3021,7 @@ static int gbe_probe(struct netcp_device *netcp_device, struct device *dev, 
	struct cpsw_ale_params ale_params;

	struct gbe_priv *gbe_dev;

	u32 slave_num;

	int ret = 0;

	int i, ret = 0;



	if (!node) {

		dev_err(dev, "device tree info unavailable\n");
@@ -2935,6 +3169,15 @@ static int gbe_probe(struct netcp_device *netcp_device, struct device *dev, 
	/* initialize host port */

	gbe_init_host_port(gbe_dev);



	spin_lock_bh(&gbe_dev->hw_stats_lock);

	for (i = 0; i < gbe_dev->num_stats_mods; i++) {

		if (gbe_dev->ss_version == GBE_SS_VERSION_14)

			gbe_reset_mod_stats_ver14(gbe_dev, i);

		else

			gbe_reset_mod_stats(gbe_dev, i);

	}

	spin_unlock_bh(&gbe_dev->hw_stats_lock);



	init_timer(&gbe_dev->timer);

	gbe_dev->timer.data	 = (unsigned long)gbe_dev;

	gbe_dev->timer.function = netcp_ethss_timer;
@@ -2946,6 +3189,8 @@ static int gbe_probe(struct netcp_device *netcp_device, struct device *dev, 
quit:

	if (gbe_dev->hw_stats)

		devm_kfree(dev, gbe_dev->hw_stats);

	if (gbe_dev->hw_stats_prev)

		devm_kfree(dev, gbe_dev->hw_stats_prev);

	cpsw_ale_destroy(gbe_dev->ale);

	if (gbe_dev->ss_regs)

		devm_iounmap(dev, gbe_dev->ss_regs);