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

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

Merge branch 'amd-xgbe-next' 



Tom Lendacky says:

====================
amd-xgbe: AMD XGBE driver updates 2015-05-22

The following patches are included in this driver update series:

- Retrieve and set an additional hardware feature setting
- Fix the initial mode/speed determination when auto-negotiation is
  disabled
- Add additional netif_dbg support to the driver

This patch series is based on net-next.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents cf826244 d5c78399

drivers/net/ethernet/amd/xgbe/xgbe-drv.c

+1 −0
Original line number Original line Diff line number Diff line
@@ -531,6 +531,7 @@ void xgbe_get_all_hw_features(struct xgbe_prv_data *pdata) 
						RXFIFOSIZE);

						RXFIFOSIZE);

	hw_feat->tx_fifo_size  = XGMAC_GET_BITS(mac_hfr1, MAC_HWF1R,

	hw_feat->tx_fifo_size  = XGMAC_GET_BITS(mac_hfr1, MAC_HWF1R,

						TXFIFOSIZE);

						TXFIFOSIZE);

	hw_feat->adv_ts_hi     = XGMAC_GET_BITS(mac_hfr1, MAC_HWF1R, ADVTHWORD);

	hw_feat->dma_width     = XGMAC_GET_BITS(mac_hfr1, MAC_HWF1R, ADDR64);

	hw_feat->dma_width     = XGMAC_GET_BITS(mac_hfr1, MAC_HWF1R, ADDR64);

	hw_feat->dcb           = XGMAC_GET_BITS(mac_hfr1, MAC_HWF1R, DCBEN);

	hw_feat->dcb           = XGMAC_GET_BITS(mac_hfr1, MAC_HWF1R, DCBEN);

	hw_feat->sph           = XGMAC_GET_BITS(mac_hfr1, MAC_HWF1R, SPHEN);

	hw_feat->sph           = XGMAC_GET_BITS(mac_hfr1, MAC_HWF1R, SPHEN);

drivers/net/ethernet/amd/xgbe/xgbe-mdio.c

+104 −9
Original line number Original line Diff line number Diff line
@@ -185,7 +185,7 @@ static void xgbe_serdes_complete_ratechange(struct xgbe_prv_data *pdata) 
			goto rx_reset;

			goto rx_reset;

	}

	}





	netdev_dbg(pdata->netdev, "SerDes rx/tx not ready (%#hx)\n",

	netif_dbg(pdata, link, pdata->netdev, "SerDes rx/tx not ready (%#hx)\n",

		  status);

		  status);





rx_reset:

rx_reset:
@@ -238,6 +238,8 @@ static void xgbe_xgmii_mode(struct xgbe_prv_data *pdata) 
		      pdata->serdes_dfe_tap_ena[XGBE_SPEED_10000]);

		      pdata->serdes_dfe_tap_ena[XGBE_SPEED_10000]);





	xgbe_serdes_complete_ratechange(pdata);

	xgbe_serdes_complete_ratechange(pdata);



	netif_dbg(pdata, link, pdata->netdev, "10GbE KR mode set\n");

}

}





static void xgbe_gmii_2500_mode(struct xgbe_prv_data *pdata)

static void xgbe_gmii_2500_mode(struct xgbe_prv_data *pdata)
@@ -284,6 +286,8 @@ static void xgbe_gmii_2500_mode(struct xgbe_prv_data *pdata) 
		      pdata->serdes_dfe_tap_ena[XGBE_SPEED_2500]);

		      pdata->serdes_dfe_tap_ena[XGBE_SPEED_2500]);





	xgbe_serdes_complete_ratechange(pdata);

	xgbe_serdes_complete_ratechange(pdata);



	netif_dbg(pdata, link, pdata->netdev, "2.5GbE KX mode set\n");

}

}





static void xgbe_gmii_mode(struct xgbe_prv_data *pdata)

static void xgbe_gmii_mode(struct xgbe_prv_data *pdata)
@@ -330,6 +334,8 @@ static void xgbe_gmii_mode(struct xgbe_prv_data *pdata) 
		      pdata->serdes_dfe_tap_ena[XGBE_SPEED_1000]);

		      pdata->serdes_dfe_tap_ena[XGBE_SPEED_1000]);





	xgbe_serdes_complete_ratechange(pdata);

	xgbe_serdes_complete_ratechange(pdata);



	netif_dbg(pdata, link, pdata->netdev, "1GbE KX mode set\n");

}

}





static void xgbe_cur_mode(struct xgbe_prv_data *pdata,

static void xgbe_cur_mode(struct xgbe_prv_data *pdata,
@@ -376,6 +382,45 @@ static void xgbe_set_mode(struct xgbe_prv_data *pdata, 
		xgbe_switch_mode(pdata);

		xgbe_switch_mode(pdata);

}

}





static bool xgbe_use_xgmii_mode(struct xgbe_prv_data *pdata)

{

	if (pdata->phy.autoneg == AUTONEG_ENABLE) {

		if (pdata->phy.advertising & ADVERTISED_10000baseKR_Full)

			return true;

	} else {

		if (pdata->phy.speed == SPEED_10000)

			return true;

	}



	return false;

}



static bool xgbe_use_gmii_2500_mode(struct xgbe_prv_data *pdata)

{

	if (pdata->phy.autoneg == AUTONEG_ENABLE) {

		if (pdata->phy.advertising & ADVERTISED_2500baseX_Full)

			return true;

	} else {

		if (pdata->phy.speed == SPEED_2500)

			return true;

	}



	return false;

}



static bool xgbe_use_gmii_mode(struct xgbe_prv_data *pdata)

{

	if (pdata->phy.autoneg == AUTONEG_ENABLE) {

		if (pdata->phy.advertising & ADVERTISED_1000baseKX_Full)

			return true;

	} else {

		if (pdata->phy.speed == SPEED_1000)

			return true;

	}



	return false;

}



static void xgbe_set_an(struct xgbe_prv_data *pdata, bool enable, bool restart)

static void xgbe_set_an(struct xgbe_prv_data *pdata, bool enable, bool restart)

{

{

	unsigned int reg;

	unsigned int reg;
@@ -395,11 +440,15 @@ static void xgbe_set_an(struct xgbe_prv_data *pdata, bool enable, bool restart) 
static void xgbe_restart_an(struct xgbe_prv_data *pdata)

static void xgbe_restart_an(struct xgbe_prv_data *pdata)

{

{

	xgbe_set_an(pdata, true, true);

	xgbe_set_an(pdata, true, true);



	netif_dbg(pdata, link, pdata->netdev, "AN enabled/restarted\n");

}

}





static void xgbe_disable_an(struct xgbe_prv_data *pdata)

static void xgbe_disable_an(struct xgbe_prv_data *pdata)

{

{

	xgbe_set_an(pdata, false, false);

	xgbe_set_an(pdata, false, false);



	netif_dbg(pdata, link, pdata->netdev, "AN disabled\n");

}

}





static enum xgbe_an xgbe_an_tx_training(struct xgbe_prv_data *pdata,

static enum xgbe_an xgbe_an_tx_training(struct xgbe_prv_data *pdata,
@@ -434,6 +483,9 @@ static enum xgbe_an xgbe_an_tx_training(struct xgbe_prv_data *pdata, 
			    reg);

			    reg);





		XSIR0_IOWRITE_BITS(pdata, SIR0_KR_RT_1, RESET, 0);

		XSIR0_IOWRITE_BITS(pdata, SIR0_KR_RT_1, RESET, 0);



		netif_dbg(pdata, link, pdata->netdev,

			  "KR training initiated\n");

	}

	}





	return XGBE_AN_PAGE_RECEIVED;

	return XGBE_AN_PAGE_RECEIVED;
@@ -512,6 +564,9 @@ static enum xgbe_an xgbe_an_page_received(struct xgbe_prv_data *pdata) 
			pdata->kx_state = XGBE_RX_BPA;

			pdata->kx_state = XGBE_RX_BPA;





			pdata->an_start = jiffies;

			pdata->an_start = jiffies;



			netif_dbg(pdata, link, pdata->netdev,

				  "AN timed out, resetting state\n");

		}

		}

	}

	}
@@ -569,6 +624,8 @@ static irqreturn_t xgbe_an_isr(int irq, void *data) 
{

{

	struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)data;

	struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)data;





	netif_dbg(pdata, intr, pdata->netdev, "AN interrupt received\n");



	/* Interrupt reason must be read and cleared outside of IRQ context */

	/* Interrupt reason must be read and cleared outside of IRQ context */

	disable_irq_nosync(pdata->an_irq);

	disable_irq_nosync(pdata->an_irq);
@@ -590,6 +647,26 @@ static void xgbe_an_irq_work(struct work_struct *work) 
	queue_work(pdata->an_workqueue, &pdata->an_work);

	queue_work(pdata->an_workqueue, &pdata->an_work);

}

}





static const char *xgbe_state_as_string(enum xgbe_an state)

{

	switch (state) {

	case XGBE_AN_READY:

		return "Ready";

	case XGBE_AN_PAGE_RECEIVED:

		return "Page-Received";

	case XGBE_AN_INCOMPAT_LINK:

		return "Incompatible-Link";

	case XGBE_AN_COMPLETE:

		return "Complete";

	case XGBE_AN_NO_LINK:

		return "No-Link";

	case XGBE_AN_ERROR:

		return "Error";

	default:

		return "Undefined";

	}

}



static void xgbe_an_state_machine(struct work_struct *work)

static void xgbe_an_state_machine(struct work_struct *work)

{

{

	struct xgbe_prv_data *pdata = container_of(work,

	struct xgbe_prv_data *pdata = container_of(work,
@@ -627,6 +704,9 @@ static void xgbe_an_state_machine(struct work_struct *work) 
	pdata->an_result = pdata->an_state;

	pdata->an_result = pdata->an_state;





again:

again:

	netif_dbg(pdata, link, pdata->netdev, "AN %s\n",

		  xgbe_state_as_string(pdata->an_state));



	cur_state = pdata->an_state;

	cur_state = pdata->an_state;





	switch (pdata->an_state) {

	switch (pdata->an_state) {
@@ -647,7 +727,7 @@ static void xgbe_an_state_machine(struct work_struct *work) 




	case XGBE_AN_COMPLETE:

	case XGBE_AN_COMPLETE:

		pdata->parallel_detect = pdata->an_supported ? 0 : 1;

		pdata->parallel_detect = pdata->an_supported ? 0 : 1;

		netdev_dbg(pdata->netdev, "%s successful\n",

		netif_dbg(pdata, link, pdata->netdev, "%s successful\n",

			  pdata->an_supported ? "Auto negotiation"

			  pdata->an_supported ? "Auto negotiation"

					      : "Parallel detection");

					      : "Parallel detection");

		break;

		break;
@@ -677,6 +757,9 @@ static void xgbe_an_state_machine(struct work_struct *work) 
		pdata->kr_state = XGBE_RX_BPA;

		pdata->kr_state = XGBE_RX_BPA;

		pdata->kx_state = XGBE_RX_BPA;

		pdata->kx_state = XGBE_RX_BPA;

		pdata->an_start = 0;

		pdata->an_start = 0;



		netif_dbg(pdata, link, pdata->netdev, "AN result: %s\n",

			  xgbe_state_as_string(pdata->an_result));

	}

	}





	if (cur_state != pdata->an_state)

	if (cur_state != pdata->an_state)
@@ -735,6 +818,8 @@ static void xgbe_an_init(struct xgbe_prv_data *pdata) 
	reg &= ~XGBE_XNP_NP_EXCHANGE;

	reg &= ~XGBE_XNP_NP_EXCHANGE;





	XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE, reg);

	XMDIO_WRITE(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE, reg);



	netif_dbg(pdata, link, pdata->netdev, "AN initialized\n");

}

}





static const char *xgbe_phy_fc_string(struct xgbe_prv_data *pdata)

static const char *xgbe_phy_fc_string(struct xgbe_prv_data *pdata)
@@ -819,6 +904,8 @@ static void xgbe_phy_adjust_link(struct xgbe_prv_data *pdata) 




static int xgbe_phy_config_fixed(struct xgbe_prv_data *pdata)

static int xgbe_phy_config_fixed(struct xgbe_prv_data *pdata)

{

{

	netif_dbg(pdata, link, pdata->netdev, "fixed PHY configuration\n");



	/* Disable auto-negotiation */

	/* Disable auto-negotiation */

	xgbe_disable_an(pdata);

	xgbe_disable_an(pdata);
@@ -852,6 +939,8 @@ static int __xgbe_phy_config_aneg(struct xgbe_prv_data *pdata) 
	if (pdata->phy.autoneg != AUTONEG_ENABLE)

	if (pdata->phy.autoneg != AUTONEG_ENABLE)

		return xgbe_phy_config_fixed(pdata);

		return xgbe_phy_config_fixed(pdata);





	netif_dbg(pdata, link, pdata->netdev, "AN PHY configuration\n");



	/* Disable auto-negotiation interrupt */

	/* Disable auto-negotiation interrupt */

	disable_irq(pdata->an_irq);

	disable_irq(pdata->an_irq);
@@ -916,9 +1005,11 @@ static void xgbe_check_link_timeout(struct xgbe_prv_data *pdata) 
	unsigned long link_timeout;

	unsigned long link_timeout;





	link_timeout = pdata->link_check + (XGBE_LINK_TIMEOUT * HZ);

	link_timeout = pdata->link_check + (XGBE_LINK_TIMEOUT * HZ);

	if (time_after(jiffies, link_timeout))

	if (time_after(jiffies, link_timeout)) {

		netif_dbg(pdata, link, pdata->netdev, "AN link timeout\n");

		xgbe_phy_config_aneg(pdata);

		xgbe_phy_config_aneg(pdata);

	}

	}

}





static void xgbe_phy_status_force(struct xgbe_prv_data *pdata)

static void xgbe_phy_status_force(struct xgbe_prv_data *pdata)

{

{
@@ -1077,6 +1168,8 @@ static void xgbe_phy_status(struct xgbe_prv_data *pdata) 




static void xgbe_phy_stop(struct xgbe_prv_data *pdata)

static void xgbe_phy_stop(struct xgbe_prv_data *pdata)

{

{

	netif_dbg(pdata, link, pdata->netdev, "stopping PHY\n");



	/* Disable auto-negotiation */

	/* Disable auto-negotiation */

	xgbe_disable_an(pdata);

	xgbe_disable_an(pdata);
@@ -1097,6 +1190,8 @@ static int xgbe_phy_start(struct xgbe_prv_data *pdata) 
	struct net_device *netdev = pdata->netdev;

	struct net_device *netdev = pdata->netdev;

	int ret;

	int ret;





	netif_dbg(pdata, link, pdata->netdev, "starting PHY\n");



	ret = devm_request_irq(pdata->dev, pdata->an_irq,

	ret = devm_request_irq(pdata->dev, pdata->an_irq,

			       xgbe_an_isr, 0, pdata->an_name,

			       xgbe_an_isr, 0, pdata->an_name,

			       pdata);

			       pdata);
@@ -1108,11 +1203,11 @@ static int xgbe_phy_start(struct xgbe_prv_data *pdata) 
	/* Set initial mode - call the mode setting routines

	/* Set initial mode - call the mode setting routines

	 * directly to insure we are properly configured

	 * directly to insure we are properly configured

	 */

	 */

	if (pdata->phy.advertising & ADVERTISED_10000baseKR_Full) {

	if (xgbe_use_xgmii_mode(pdata)) {

		xgbe_xgmii_mode(pdata);

		xgbe_xgmii_mode(pdata);

	} else if (pdata->phy.advertising & ADVERTISED_1000baseKX_Full) {

	} else if (xgbe_use_gmii_mode(pdata)) {

		xgbe_gmii_mode(pdata);

		xgbe_gmii_mode(pdata);

	} else if (pdata->phy.advertising & ADVERTISED_2500baseX_Full) {

	} else if (xgbe_use_gmii_2500_mode(pdata)) {

		xgbe_gmii_2500_mode(pdata);

		xgbe_gmii_2500_mode(pdata);

	} else {

	} else {

		ret = -EINVAL;

		ret = -EINVAL;