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

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

Merge branch 'altera_tse' 



Vince Bridgers says:

====================
This series of patches addresses a handful of issues found in testing
and reported by users of the Altera Triple Speed Ethernet soft IP.

The patches address the following issues (in summary)

1) The SGDMA soft IP was found to incorrectly process receive packets
   when the target physical address of the receive buffer was on
   a boundary that's not 32-bit aligned. One of the patches addresses
   this issue.
2) The pause quanta was not being set by the driver, one patch of this
   series sets the pause quanta to the IEEE defined default value
   since the hardware reset value is 0.
3) An issue in a error recovery path of the probe routine caused a
   kernel panic in the event a phy was probed and could not be found.
   A patch addresses this issue.
4) A change was made to the driver name for Ethtool support, and
   comments added to support an addition to Ethtool to support
   the Altera Triple Speed Ethernet controller.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents c2163260 99514e11

drivers/net/ethernet/altera/altera_msgdma.c

+5 −2
Original line number Diff line number Diff line
@@ -29,6 +29,10 @@ void msgdma_uninitialize(struct altera_tse_private *priv) 
{

}



void msgdma_start_rxdma(struct altera_tse_private *priv)

{

}



void msgdma_reset(struct altera_tse_private *priv)

{

	int counter;
@@ -154,7 +158,7 @@ u32 msgdma_tx_completions(struct altera_tse_private *priv) 


/* Put buffer to the mSGDMA RX FIFO

 */

int msgdma_add_rx_desc(struct altera_tse_private *priv,

void msgdma_add_rx_desc(struct altera_tse_private *priv,

			struct tse_buffer *rxbuffer)

{

	struct msgdma_extended_desc *desc = priv->rx_dma_desc;
@@ -175,7 +179,6 @@ int msgdma_add_rx_desc(struct altera_tse_private *priv, 
	iowrite32(0, &desc->burst_seq_num);

	iowrite32(0x00010001, &desc->stride);

	iowrite32(control, &desc->control);

	return 1;

}



/* status is returned on upper 16 bits,

drivers/net/ethernet/altera/altera_msgdma.h

+2 −1
Original line number Diff line number Diff line
@@ -25,10 +25,11 @@ void msgdma_disable_txirq(struct altera_tse_private *); 
void msgdma_clear_rxirq(struct altera_tse_private *);

void msgdma_clear_txirq(struct altera_tse_private *);

u32 msgdma_tx_completions(struct altera_tse_private *);

int msgdma_add_rx_desc(struct altera_tse_private *, struct tse_buffer *);

void msgdma_add_rx_desc(struct altera_tse_private *, struct tse_buffer *);

int msgdma_tx_buffer(struct altera_tse_private *, struct tse_buffer *);

u32 msgdma_rx_status(struct altera_tse_private *);

int msgdma_initialize(struct altera_tse_private *);

void msgdma_uninitialize(struct altera_tse_private *);

void msgdma_start_rxdma(struct altera_tse_private *);



#endif /*  __ALTERA_MSGDMA_H__ */

drivers/net/ethernet/altera/altera_sgdma.c

+69 −36
Original line number Diff line number Diff line
@@ -64,11 +64,15 @@ queue_rx_peekhead(struct altera_tse_private *priv); 


int sgdma_initialize(struct altera_tse_private *priv)

{

	priv->txctrlreg = SGDMA_CTRLREG_ILASTD;

	priv->txctrlreg = SGDMA_CTRLREG_ILASTD |

		      SGDMA_CTRLREG_INTEN;



	priv->rxctrlreg = SGDMA_CTRLREG_IDESCRIP |

		      SGDMA_CTRLREG_INTEN |

		      SGDMA_CTRLREG_ILASTD;



	priv->sgdmadesclen = sizeof(sgdma_descrip);



	INIT_LIST_HEAD(&priv->txlisthd);

	INIT_LIST_HEAD(&priv->rxlisthd);
@@ -93,6 +97,16 @@ int sgdma_initialize(struct altera_tse_private *priv) 
		return -EINVAL;

	}



	/* Initialize descriptor memory to all 0's, sync memory to cache */

	memset(priv->tx_dma_desc, 0, priv->txdescmem);

	memset(priv->rx_dma_desc, 0, priv->rxdescmem);



	dma_sync_single_for_device(priv->device, priv->txdescphys,

				   priv->txdescmem, DMA_TO_DEVICE);



	dma_sync_single_for_device(priv->device, priv->rxdescphys,

				   priv->rxdescmem, DMA_TO_DEVICE);



	return 0;

}
@@ -130,26 +144,23 @@ void sgdma_reset(struct altera_tse_private *priv) 
	iowrite32(0, &prxsgdma->control);

}



/* For SGDMA, interrupts remain enabled after initially enabling,

 * so no need to provide implementations for abstract enable

 * and disable

 */



void sgdma_enable_rxirq(struct altera_tse_private *priv)

{

	struct sgdma_csr *csr = (struct sgdma_csr *)priv->rx_dma_csr;

	priv->rxctrlreg |= SGDMA_CTRLREG_INTEN;

	tse_set_bit(&csr->control, SGDMA_CTRLREG_INTEN);

}



void sgdma_enable_txirq(struct altera_tse_private *priv)

{

	struct sgdma_csr *csr = (struct sgdma_csr *)priv->tx_dma_csr;

	priv->txctrlreg |= SGDMA_CTRLREG_INTEN;

	tse_set_bit(&csr->control, SGDMA_CTRLREG_INTEN);

}



/* for SGDMA, RX interrupts remain enabled after enabling */

void sgdma_disable_rxirq(struct altera_tse_private *priv)

{

}



/* for SGDMA, TX interrupts remain enabled after enabling */

void sgdma_disable_txirq(struct altera_tse_private *priv)

{

}
@@ -219,11 +230,15 @@ u32 sgdma_tx_completions(struct altera_tse_private *priv) 
	return ready;

}



int sgdma_add_rx_desc(struct altera_tse_private *priv,

void sgdma_start_rxdma(struct altera_tse_private *priv)

{

	sgdma_async_read(priv);

}



void sgdma_add_rx_desc(struct altera_tse_private *priv,

		       struct tse_buffer *rxbuffer)

{

	queue_rx(priv, rxbuffer);

	return sgdma_async_read(priv);

}



/* status is returned on upper 16 bits,
@@ -240,29 +255,53 @@ u32 sgdma_rx_status(struct altera_tse_private *priv) 
	unsigned int pktstatus = 0;

	struct tse_buffer *rxbuffer = NULL;



	u32 sts = ioread32(&csr->status);



	desc = &base[0];

	if (sts & SGDMA_STSREG_EOP) {

		dma_sync_single_for_cpu(priv->device,

					priv->rxdescphys,

				priv->rxdescmem,

				DMA_BIDIRECTIONAL);

					priv->sgdmadesclen,

					DMA_FROM_DEVICE);



	desc = &base[0];

	if ((ioread32(&csr->status) & SGDMA_STSREG_EOP) ||

	    (desc->status & SGDMA_STATUS_EOP)) {

		pktlength = desc->bytes_xferred;

		pktstatus = desc->status & 0x3f;

		rxstatus = pktstatus;

		rxstatus = rxstatus << 16;

		rxstatus |= (pktlength & 0xffff);



		if (rxstatus) {

			desc->status = 0;



			rxbuffer = dequeue_rx(priv);

			if (rxbuffer == NULL)

			netdev_err(priv->dev,

				netdev_info(priv->dev,

					    "sgdma rx and rx queue empty!\n");



			/* Clear control */

			iowrite32(0, &csr->control);

			/* clear status */

			iowrite32(0xf, &csr->status);



			/* kick the rx sgdma after reaping this descriptor */

			pktsrx = sgdma_async_read(priv);



		} else {

			/* If the SGDMA indicated an end of packet on recv,

			 * then it's expected that the rxstatus from the

			 * descriptor is non-zero - meaning a valid packet

			 * with a nonzero length, or an error has been

			 * indicated. if not, then all we can do is signal

			 * an error and return no packet received. Most likely

			 * there is a system design error, or an error in the

			 * underlying kernel (cache or cache management problem)

			 */

			netdev_err(priv->dev,

				   "SGDMA RX Error Info: %x, %x, %x\n",

				   sts, desc->status, rxstatus);

		}

	} else if (sts == 0) {

		pktsrx = sgdma_async_read(priv);

	}



	return rxstatus;
@@ -319,13 +358,14 @@ static int sgdma_async_read(struct altera_tse_private *priv) 
	struct sgdma_descrip *cdesc = &descbase[0];

	struct sgdma_descrip *ndesc = &descbase[1];



	unsigned int sts = ioread32(&csr->status);

	struct tse_buffer *rxbuffer = NULL;



	if (!sgdma_rxbusy(priv)) {

		rxbuffer = queue_rx_peekhead(priv);

		if (rxbuffer == NULL)

		if (rxbuffer == NULL) {

			netdev_err(priv->dev, "no rx buffers available\n");

			return 0;

		}



		sgdma_descrip(cdesc,		/* current descriptor */

			      ndesc,		/* next descriptor */
@@ -337,17 +377,10 @@ static int sgdma_async_read(struct altera_tse_private *priv) 
			      0,		/* read fixed: NA for rx dma */

			      0);		/* SOP: NA for rx DMA */



		/* clear control and status */

		iowrite32(0, &csr->control);



		/* If status available, clear those bits */

		if (sts & 0xf)

			iowrite32(0xf, &csr->status);



		dma_sync_single_for_device(priv->device,

					   priv->rxdescphys,

					   priv->rxdescmem,

					   DMA_BIDIRECTIONAL);

					   priv->sgdmadesclen,

					   DMA_TO_DEVICE);



		iowrite32(lower_32_bits(sgdma_rxphysaddr(priv, cdesc)),

			  &csr->next_descrip);
@@ -374,7 +407,7 @@ static int sgdma_async_write(struct altera_tse_private *priv, 
	iowrite32(0x1f, &csr->status);



	dma_sync_single_for_device(priv->device, priv->txdescphys,

				   priv->txdescmem, DMA_TO_DEVICE);

				   priv->sgdmadesclen, DMA_TO_DEVICE);



	iowrite32(lower_32_bits(sgdma_txphysaddr(priv, desc)),

		  &csr->next_descrip);

drivers/net/ethernet/altera/altera_sgdma.h

+2 −1
Original line number Diff line number Diff line
@@ -26,10 +26,11 @@ void sgdma_clear_rxirq(struct altera_tse_private *); 
void sgdma_clear_txirq(struct altera_tse_private *);

int sgdma_tx_buffer(struct altera_tse_private *priv, struct tse_buffer *);

u32 sgdma_tx_completions(struct altera_tse_private *);

int sgdma_add_rx_desc(struct altera_tse_private *priv, struct tse_buffer *);

void sgdma_add_rx_desc(struct altera_tse_private *priv, struct tse_buffer *);

void sgdma_status(struct altera_tse_private *);

u32 sgdma_rx_status(struct altera_tse_private *);

int sgdma_initialize(struct altera_tse_private *);

void sgdma_uninitialize(struct altera_tse_private *);

void sgdma_start_rxdma(struct altera_tse_private *);



#endif /*  __ALTERA_SGDMA_H__ */

drivers/net/ethernet/altera/altera_tse.h

+5 −1
Original line number Diff line number Diff line
@@ -58,6 +58,8 @@ 
/* MAC function configuration default settings */

#define ALTERA_TSE_TX_IPG_LENGTH	12



#define ALTERA_TSE_PAUSE_QUANTA		0xffff



#define GET_BIT_VALUE(v, bit)		(((v) >> (bit)) & 0x1)



/* MAC Command_Config Register Bit Definitions
@@ -390,10 +392,11 @@ struct altera_dmaops { 
	void (*clear_rxirq)(struct altera_tse_private *);

	int (*tx_buffer)(struct altera_tse_private *, struct tse_buffer *);

	u32 (*tx_completions)(struct altera_tse_private *);

	int (*add_rx_desc)(struct altera_tse_private *, struct tse_buffer *);

	void (*add_rx_desc)(struct altera_tse_private *, struct tse_buffer *);

	u32 (*get_rx_status)(struct altera_tse_private *);

	int (*init_dma)(struct altera_tse_private *);

	void (*uninit_dma)(struct altera_tse_private *);

	void (*start_rxdma)(struct altera_tse_private *);

};



/* This structure is private to each device.
@@ -453,6 +456,7 @@ struct altera_tse_private { 
	u32 rxctrlreg;

	dma_addr_t rxdescphys;

	dma_addr_t txdescphys;

	size_t sgdmadesclen;



	struct list_head txlisthd;

	struct list_head rxlisthd;