[FIX] remove cute code

1 files changed, 127 insertions, 129 deletions

diff --git a/drivers/net/xilinx_emaclite.c b/drivers/net/xilinx_emaclite.c
index 99e70354b..5d8eaa518 100644
--- a/drivers/net/xilinx_emaclite.c
+++ b/drivers/net/xilinx_emaclite.c
@@ -64,76 +64,73 @@
 #define XEL_RSR_RECV_IE_MASK		0x00000008UL
 
 typedef struct {
-	unsigned int BaseAddress;	/* Base address for device (IPIF) */
-	unsigned int NextTxBufferToUse;	/* Next TX buffer to write to */
-	unsigned int NextRxBufferToUse;	/* Next RX buffer to read from */
-	unsigned char DeviceId;		/* Unique ID of device - for future */
-} XEmacLite;
+	unsigned int baseaddress;	/* Base address for device (IPIF) */
+	unsigned int nexttxbuffertouse;	/* Next TX buffer to write to */
+	unsigned int nextrxbuffertouse;	/* Next RX buffer to read from */
+	unsigned char deviceid;		/* Unique ID of device - for future */
+} xemaclite;
 
-static XEmacLite EmacLite;
+static xemaclite emaclite;
 
-static char etherrxbuff[PKTSIZE_ALIGN]; /* Receive buffer */
+static char etherrxbuff[PKTSIZE_ALIGN/4]; /* Receive buffer */
 
 /* hardcoded MAC address for the Xilinx EMAC Core when env is nowhere*/
 #ifdef CFG_ENV_IS_NOWHERE
-static u8 EMACAddr[ENET_ADDR_LENGTH] = { 0x00, 0x0a, 0x35, 0x00, 0x22, 0x01 };
+static u8 emacaddr[ENET_ADDR_LENGTH] = { 0x00, 0x0a, 0x35, 0x00, 0x22, 0x01 };
 #endif
 
-void XEmacLite_AlignedRead (u32 * SrcPtr, void *DestPtr, unsigned ByteCount)
+void xemaclite_alignedread (u32 * srcptr, void *destptr, unsigned bytecount)
 {
-	unsigned i;
-	unsigned Length = ByteCount;
-	u32 AlignBuffer;
-	u32 *To32Ptr;
-	u32 *From32Ptr;
-	u8 *To8Ptr;
-	u8 *From8Ptr;
+	unsigned int i;
+	u32 alignbuffer;
+	u32 *to32ptr;
+	u32 *from32ptr;
+	u8 *to8ptr;
+	u8 *from8ptr;
 
-	From32Ptr = (u32 *) SrcPtr;
+	from32ptr = (u32 *) srcptr;
 
 	/* Word aligned buffer, no correction needed. */
-	To32Ptr = (u32 *) DestPtr;
-	while (Length > 3) {
-		*To32Ptr++ = *From32Ptr++;
-		Length -= 4;
+	to32ptr = (u32 *) destptr;
+	while (bytecount > 3) {
+		*to32ptr++ = *from32ptr++;
+		bytecount -= 4;
 	}
-	To8Ptr = (u8 *) To32Ptr;
+	to8ptr = (u8 *) to32ptr;
 
-	AlignBuffer = *From32Ptr++;
-	From8Ptr = (u8 *) & AlignBuffer;
+	alignbuffer = *from32ptr++;
+	from8ptr = (u8 *) & alignbuffer;
 
-	for (i = 0; i < Length; i++) {
-		*To8Ptr++ = *From8Ptr++;
+	for (i = 0; i < bytecount; i++) {
+		*to8ptr++ = *from8ptr++;
 	}
 }
 
-void XEmacLite_AlignedWrite (void *SrcPtr, u32 * DestPtr, unsigned ByteCount)
+void xemaclite_alignedwrite (void *srcptr, u32 destptr, unsigned bytecount)
 {
 	unsigned i;
-	unsigned Length = ByteCount;
-	u32 AlignBuffer;
-	u32 *To32Ptr;
-	u32 *From32Ptr;
-	u8 *To8Ptr;
-	u8 *From8Ptr;
-	To32Ptr = DestPtr;
+	u32 alignbuffer;
+	u32 *to32ptr = (u32 *) destptr;
+	u32 *from32ptr;
+	u8 *to8ptr;
+	u8 *from8ptr;
 
-	From32Ptr = (u32 *) SrcPtr;
-	while (Length > 3) {
+	from32ptr = (u32 *) srcptr;
+	while (bytecount > 3) {
 
-		*To32Ptr++ = *From32Ptr++;
-		Length -= 4;
+		*to32ptr++ = *from32ptr++;
+		bytecount -= 4;
 	}
 
-	AlignBuffer = 0;
-	To8Ptr = (u8 *) & AlignBuffer;
-	From8Ptr = (u8 *) From32Ptr;
+	alignbuffer = 0;
+	to8ptr = (u8 *) & alignbuffer;
+	from8ptr = (u8 *) from32ptr;
 
-	for (i = 0; i < Length; i++) {
-		*To8Ptr++ = *From8Ptr++;
+	for (i = 0; i < bytecount; i++) {
+		*to8ptr++ = *from8ptr++;
 	}
 
-	*To32Ptr++ = AlignBuffer;
+	*to32ptr++ = alignbuffer;
 }
 
 void eth_halt (void)
@@ -148,37 +145,38 @@ int eth_init (bd_t * bis)
 #ifdef DEBUG
 	puts ("EmacLite Initialization Started\n");
 #endif
-	memset (&EmacLite, 0, sizeof (XEmacLite));
-	EmacLite.BaseAddress = XILINX_EMACLITE_BASEADDR;
+	memset (&emaclite, 0, sizeof (xemaclite));
+	emaclite.baseaddress = XILINX_EMACLITE_BASEADDR;
+
+	if (!getenv("ethaddr")) {
+		memcpy(bis->bi_enetaddr, emacaddr, ENET_ADDR_LENGTH);
+	}
 
-#ifdef CFG_ENV_IS_NOWHERE
-	memcpy (bis->bi_enetaddr, EMACAddr, ENET_ADDR_LENGTH);
-#endif
 /*
  * TX - TX_PING & TX_PONG initialization
  */
 	/* Restart PING TX */
-	out_be32 (EmacLite.BaseAddress + XEL_TSR_OFFSET, 0);
+	out_be32 (emaclite.baseaddress + XEL_TSR_OFFSET, 0);
 	/* Copy MAC address */
-	XEmacLite_AlignedWrite (bis->bi_enetaddr,
-		EmacLite.BaseAddress, ENET_ADDR_LENGTH);
+	xemaclite_alignedwrite (bis->bi_enetaddr,
+		emaclite.baseaddress, ENET_ADDR_LENGTH);
 	/* Set the length */
-	out_be32 (EmacLite.BaseAddress + XEL_TPLR_OFFSET, ENET_ADDR_LENGTH);
+	out_be32 (emaclite.baseaddress + XEL_TPLR_OFFSET, ENET_ADDR_LENGTH);
 	/* Update the MAC address in the EMAC Lite */
-	out_be32 (EmacLite.BaseAddress + XEL_TSR_OFFSET, XEL_TSR_PROG_MAC_ADDR);
+	out_be32 (emaclite.baseaddress + XEL_TSR_OFFSET, XEL_TSR_PROG_MAC_ADDR);
 	/* Wait for EMAC Lite to finish with the MAC address update */
-	while ((in_be32 (EmacLite.BaseAddress + XEL_TSR_OFFSET) &
+	while ((in_be32 (emaclite.baseaddress + XEL_TSR_OFFSET) &
 		XEL_TSR_PROG_MAC_ADDR) != 0) ;
 
 #ifdef XILINX_EMACLITE_TX_PING_PONG
 	/* The same operation with PONG TX */
-	out_be32 (EmacLite.BaseAddress + XEL_TSR_OFFSET + XEL_BUFFER_OFFSET, 0);	
-	XEmacLite_AlignedWrite (bis->bi_enetaddr,
-		EmacLite.BaseAddress + XEL_BUFFER_OFFSET, ENET_ADDR_LENGTH);
-	out_be32 (EmacLite.BaseAddress + XEL_TPLR_OFFSET, ENET_ADDR_LENGTH);
-	out_be32 (EmacLite.BaseAddress + XEL_TSR_OFFSET + XEL_BUFFER_OFFSET,
+	out_be32 (emaclite.baseaddress + XEL_TSR_OFFSET + XEL_BUFFER_OFFSET, 0);
+	xemaclite_alignedwrite (bis->bi_enetaddr, emaclite.baseaddress +
+		XEL_BUFFER_OFFSET, ENET_ADDR_LENGTH);
+	out_be32 (emaclite.baseaddress + XEL_TPLR_OFFSET, ENET_ADDR_LENGTH);
+	out_be32 (emaclite.baseaddress + XEL_TSR_OFFSET + XEL_BUFFER_OFFSET,
 		XEL_TSR_PROG_MAC_ADDR);
-	while ((in_be32	(EmacLite.BaseAddress + XEL_TSR_OFFSET +
+	while ((in_be32 (emaclite.baseaddress + XEL_TSR_OFFSET +
 		 XEL_BUFFER_OFFSET) & XEL_TSR_PROG_MAC_ADDR) != 0) ;
 #endif
 
@@ -186,9 +184,9 @@ int eth_init (bd_t * bis)
  * RX - RX_PING & RX_PONG initialization
  */
 	/* Write out the value to flush the RX buffer */
-	out_be32 (EmacLite.BaseAddress + XEL_RSR_OFFSET, XEL_RSR_RECV_IE_MASK);
+	out_be32 (emaclite.baseaddress + XEL_RSR_OFFSET, XEL_RSR_RECV_IE_MASK);
 #ifdef XILINX_EMACLITE_RX_PING_PONG
-	out_be32 (EmacLite.BaseAddress + XEL_RSR_OFFSET + XEL_BUFFER_OFFSET,
+	out_be32 (emaclite.baseaddress + XEL_RSR_OFFSET + XEL_BUFFER_OFFSET,
 		XEL_RSR_RECV_IE_MASK);
 #endif
 
@@ -198,39 +196,39 @@ int eth_init (bd_t * bis)
 	return 0;
 }
 
-int XEmacLite_TxBufferAvailable (XEmacLite * InstancePtr)
+int xemaclite_txbufferavailable (xemaclite * instanceptr)
 {
-	u32 Register;
-	u32 TxPingBusy;
-	u32 TxPongBusy;
+	u32 reg;
+	u32 txpingbusy;
+	u32 txpongbusy;
 	/*
 	 * Read the other buffer register
 	 * and determine if the other buffer is available
 	 */
-	Register = in_be32 (InstancePtr->BaseAddress +
-			InstancePtr->NextTxBufferToUse + 0);
-	TxPingBusy = ((Register & XEL_TSR_XMIT_BUSY_MASK) ==
+	reg = in_be32 (instanceptr->baseaddress +
+			instanceptr->nexttxbuffertouse + 0);
+	txpingbusy = ((reg & XEL_TSR_XMIT_BUSY_MASK) ==
 			XEL_TSR_XMIT_BUSY_MASK);
 
-	Register = in_be32 (InstancePtr->BaseAddress +
-			(InstancePtr->NextTxBufferToUse ^ XEL_TSR_OFFSET) + 0);
-	TxPongBusy = ((Register & XEL_TSR_XMIT_BUSY_MASK) ==
+	reg = in_be32 (instanceptr->baseaddress +
+			(instanceptr->nexttxbuffertouse ^ XEL_TSR_OFFSET) + 0);
+	txpongbusy = ((reg & XEL_TSR_XMIT_BUSY_MASK) ==
 			XEL_TSR_XMIT_BUSY_MASK);
 
-	return (!(TxPingBusy && TxPongBusy));
+	return (!(txpingbusy && txpongbusy));
 }
 
 int eth_send (volatile void *ptr, int len) {
 
-	unsigned int Register;
-	unsigned int BaseAddress;
+	unsigned int reg;
+	unsigned int baseaddress;
 
 	unsigned maxtry = 1000;
 
 	if (len > ENET_MAX_MTU)
 		len = ENET_MAX_MTU;
 
-	while (!XEmacLite_TxBufferAvailable (&EmacLite) && maxtry) {
+	while (!xemaclite_txbufferavailable (&emaclite) && maxtry) {
 		udelay (10);
 		maxtry--;
 	}
@@ -238,62 +236,62 @@ int eth_send (volatile void *ptr, int len) {
 	if (!maxtry) {
 		printf ("Error: Timeout waiting for ethernet TX buffer\n");
 		/* Restart PING TX */
-		out_be32 (EmacLite.BaseAddress + XEL_TSR_OFFSET, 0);
+		out_be32 (emaclite.baseaddress + XEL_TSR_OFFSET, 0);
 #ifdef XILINX_EMACLITE_TX_PING_PONG
-		out_be32 (EmacLite.BaseAddress + XEL_TSR_OFFSET +
+		out_be32 (emaclite.baseaddress + XEL_TSR_OFFSET +
 		XEL_BUFFER_OFFSET, 0);
 #endif
 		return 0;
 	}
 
 	/* Determine the expected TX buffer address */
-	BaseAddress = (EmacLite.BaseAddress + EmacLite.NextTxBufferToUse);
+	baseaddress = (emaclite.baseaddress + emaclite.nexttxbuffertouse);
 
 	/* Determine if the expected buffer address is empty */
-	Register = in_be32 (BaseAddress + XEL_TSR_OFFSET);
-	if (((Register & XEL_TSR_XMIT_BUSY_MASK) == 0)
-		&& ((in_be32 ((BaseAddress) + XEL_TSR_OFFSET)
+	reg = in_be32 (baseaddress + XEL_TSR_OFFSET);
+	if (((reg & XEL_TSR_XMIT_BUSY_MASK) == 0)
+		&& ((in_be32 ((baseaddress) + XEL_TSR_OFFSET)
 			& XEL_TSR_XMIT_ACTIVE_MASK) == 0)) {
 
 #ifdef XILINX_EMACLITE_TX_PING_PONG
-		EmacLite.NextTxBufferToUse ^= XEL_BUFFER_OFFSET;
+		emaclite.nexttxbuffertouse ^= XEL_BUFFER_OFFSET;
 #endif
 #ifdef DEBUG
-		printf ("Send packet from 0x%x\n", BaseAddress);
+		printf ("Send packet from 0x%x\n", baseaddress);
 #endif
 		/* Write the frame to the buffer */
-		XEmacLite_AlignedWrite (ptr, (u32 *) BaseAddress, len);
-		out_be32 (BaseAddress + XEL_TPLR_OFFSET,(len &
+		xemaclite_alignedwrite ((void *) ptr, baseaddress, len);
+		out_be32 (baseaddress + XEL_TPLR_OFFSET,(len &
 			(XEL_TPLR_LENGTH_MASK_HI | XEL_TPLR_LENGTH_MASK_LO)));
-		Register = in_be32 (BaseAddress + XEL_TSR_OFFSET);
-		Register |= XEL_TSR_XMIT_BUSY_MASK;
-		if ((Register & XEL_TSR_XMIT_IE_MASK) != 0) {
-			Register |= XEL_TSR_XMIT_ACTIVE_MASK;
+		reg = in_be32 (baseaddress + XEL_TSR_OFFSET);
+		reg |= XEL_TSR_XMIT_BUSY_MASK;
+		if ((reg & XEL_TSR_XMIT_IE_MASK) != 0) {
+			reg |= XEL_TSR_XMIT_ACTIVE_MASK;
 		}
-		out_be32 (BaseAddress + XEL_TSR_OFFSET, Register);
+		out_be32 (baseaddress + XEL_TSR_OFFSET, reg);
 		return 1;
 	}
 #ifdef XILINX_EMACLITE_TX_PING_PONG
 	/* Switch to second buffer */
-	BaseAddress ^= XEL_BUFFER_OFFSET;
+	baseaddress ^= XEL_BUFFER_OFFSET;
 	/* Determine if the expected buffer address is empty */
-	Register = in_be32 (BaseAddress + XEL_TSR_OFFSET);
-	if (((Register & XEL_TSR_XMIT_BUSY_MASK) == 0)
-		&& ((in_be32 ((BaseAddress) + XEL_TSR_OFFSET)
+	reg = in_be32 (baseaddress + XEL_TSR_OFFSET);
+	if (((reg & XEL_TSR_XMIT_BUSY_MASK) == 0)
+		&& ((in_be32 ((baseaddress) + XEL_TSR_OFFSET)
 			& XEL_TSR_XMIT_ACTIVE_MASK) == 0)) {
 #ifdef DEBUG
-		printf ("Send packet from 0x%x\n", BaseAddress);
+		printf ("Send packet from 0x%x\n", baseaddress);
 #endif
 		/* Write the frame to the buffer */
-		XEmacLite_AlignedWrite (ptr, (u32 *) BaseAddress, len);
-		out_be32 (BaseAddress + XEL_TPLR_OFFSET,(len &
+		xemaclite_alignedwrite ((void *) ptr, baseaddress, len);
+		out_be32 (baseaddress + XEL_TPLR_OFFSET,(len &
 			(XEL_TPLR_LENGTH_MASK_HI | XEL_TPLR_LENGTH_MASK_LO)));
-		Register = in_be32 (BaseAddress + XEL_TSR_OFFSET);
-		Register |= XEL_TSR_XMIT_BUSY_MASK;
-		if ((Register & XEL_TSR_XMIT_IE_MASK) != 0) {
-			Register |= XEL_TSR_XMIT_ACTIVE_MASK;
+		reg = in_be32 (baseaddress + XEL_TSR_OFFSET);
+		reg |= XEL_TSR_XMIT_BUSY_MASK;
+		if ((reg & XEL_TSR_XMIT_IE_MASK) != 0) {
+			reg |= XEL_TSR_XMIT_ACTIVE_MASK;
 		}
-		out_be32 (BaseAddress + XEL_TSR_OFFSET, Register);
+		out_be32 (baseaddress + XEL_TSR_OFFSET, reg);
 		return 1;
 	}
 #endif
@@ -303,50 +301,50 @@ int eth_send (volatile void *ptr, int len) {
 
 int eth_rx (void)
 {
-	unsigned int Length;
-	unsigned int Register;
-	unsigned int BaseAddress;
+	unsigned int length;
+	unsigned int reg;
+	unsigned int baseaddress;
 
-	BaseAddress = EmacLite.BaseAddress + EmacLite.NextRxBufferToUse;
-	Register = in_be32 (BaseAddress + XEL_RSR_OFFSET);
+	baseaddress = emaclite.baseaddress + emaclite.nextrxbuffertouse;
+	reg = in_be32 (baseaddress + XEL_RSR_OFFSET);
 #ifdef DEBUG
-	printf ("Testing data at address 0x%x\n", BaseAddress);
+	printf ("Testing data at address 0x%x\n", baseaddress);
 #endif
-	if ((Register & XEL_RSR_RECV_DONE_MASK) == XEL_RSR_RECV_DONE_MASK) {
+	if ((reg & XEL_RSR_RECV_DONE_MASK) == XEL_RSR_RECV_DONE_MASK) {
 #ifdef XILINX_EMACLITE_RX_PING_PONG
-		EmacLite.NextRxBufferToUse ^= XEL_BUFFER_OFFSET;
+		emaclite.nextrxbuffertouse ^= XEL_BUFFER_OFFSET;
 #endif
 	} else {
 #ifndef XILINX_EMACLITE_RX_PING_PONG
 #ifdef DEBUG
-		printf ("No data was available - address 0x%x\n", BaseAddress);
+		printf ("No data was available - address 0x%x\n", baseaddress);
 #endif
 		return 0;
 #else
-		BaseAddress ^= XEL_BUFFER_OFFSET;
-		Register = in_be32 (BaseAddress + XEL_RSR_OFFSET);
-		if ((Register & XEL_RSR_RECV_DONE_MASK) !=
+		baseaddress ^= XEL_BUFFER_OFFSET;
+		reg = in_be32 (baseaddress + XEL_RSR_OFFSET);
+		if ((reg & XEL_RSR_RECV_DONE_MASK) !=
 					XEL_RSR_RECV_DONE_MASK) {
 #ifdef DEBUG
 			printf ("No data was available - address 0x%x\n",
-					BaseAddress);
+					baseaddress);
 #endif
 			return 0;
 		}
 #endif
 	}
 	/* Get the length of the frame that arrived */
-	switch(((in_be32(BaseAddress + XEL_RXBUFF_OFFSET + 0xC)) &
+	switch(((in_be32 (baseaddress + XEL_RXBUFF_OFFSET + 0xC)) &
 			0xFFFF0000 ) >> 16) {
 		case 0x806:
-			Length = 42 + 20; /* FIXME size of ARP */
+			length = 42 + 20; /* FIXME size of ARP */
 #ifdef DEBUG
 			puts ("ARP Packet\n");
 #endif
 			break;
 		case 0x800:
-			Length = 14 + 14 +
-			(((in_be32(BaseAddress + XEL_RXBUFF_OFFSET + 0x10)) &
+			length = 14 + 14 +
+			(((in_be32 (baseaddress + XEL_RXBUFF_OFFSET + 0x10)) &
 			0xFFFF0000) >> 16); /* FIXME size of IP packet */
 #ifdef DEBUG
 			puts("IP Packet\n");
@@ -356,22 +354,22 @@ int eth_rx (void)
 #ifdef DEBUG
 			puts("Other Packet\n");
 #endif
-			Length = ENET_MAX_MTU;
+			length = ENET_MAX_MTU;
 			break;
 	}
 
-	XEmacLite_AlignedRead ((BaseAddress + XEL_RXBUFF_OFFSET),
-			etherrxbuff, Length);
+	xemaclite_alignedread ((u32 *) (baseaddress + XEL_RXBUFF_OFFSET),
+			etherrxbuff, length);
 
 	/* Acknowledge the frame */
-	Register = in_be32 (BaseAddress + XEL_RSR_OFFSET);
-	Register &= ~XEL_RSR_RECV_DONE_MASK;
-	out_be32 (BaseAddress + XEL_RSR_OFFSET, Register);
+	reg = in_be32 (baseaddress + XEL_RSR_OFFSET);
+	reg &= ~XEL_RSR_RECV_DONE_MASK;
+	out_be32 (baseaddress + XEL_RSR_OFFSET, reg);
 
 #ifdef DEBUG
-	printf ("Packet receive from 0x%x, length %dB\n", BaseAddress, Length);
+	printf ("Packet receive from 0x%x, length %dB\n", baseaddress, length);
 #endif
-	NetReceive ((uchar *) etherrxbuff, Length);
+	NetReceive ((uchar *) etherrxbuff, length);
 	return 1;
 
 }