/*------------------------------------------------------------------------ * lan91c96.c * This is a driver for SMSC's LAN91C96 single-chip Ethernet device, based * on the SMC91111 driver from U-boot. * * (C) Copyright 2002 * Sysgo Real-Time Solutions, GmbH <www.elinos.com> * Rolf Offermanns <rof@sysgo.de> * * Copyright (C) 2001 Standard Microsystems Corporation (SMSC) *       Developed by Simple Network Magic Corporation (SNMC) * Copyright (C) 1996 by Erik Stahlman (ES) * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA * * Information contained in this file was obtained from the LAN91C96 * manual from SMC.  To get a copy, if you really want one, you can find * information under www.smsc.com. * * * "Features" of the SMC chip: *   6144 byte packet memory. ( for the 91C96 ) *   EEPROM for configuration *   AUI/TP selection  ( mine has 10Base2/10BaseT select ) * * Arguments: * 	io	= for the base address *	irq	= for the IRQ * * author: * 	Erik Stahlman				( erik@vt.edu ) * 	Daris A Nevil				( dnevil@snmc.com ) * * * Hardware multicast code from Peter Cammaert ( pc@denkart.be ) * * Sources: *    o   SMSC LAN91C96 databook (www.smsc.com) *    o   smc91111.c (u-boot driver) *    o   smc9194.c (linux kernel driver) *    o   lan91c96.c (Intel Diagnostic Manager driver) * * History: * 	04/30/03  Mathijs Haarman	Modified smc91111.c (u-boot version) *					for lan91c96 *--------------------------------------------------------------------------- */#include <common.h>#include <command.h>#include "lan91c96.h"#include <net.h>#ifdef CONFIG_DRIVER_LAN91C96#if defined(CONFIG_CMD_NET)/*------------------------------------------------------------------------ * * Configuration options, for the experienced user to change. * -------------------------------------------------------------------------*//* Use power-down feature of the chip */#define POWER_DOWN	0/* * Wait time for memory to be free.  This probably shouldn't be * tuned that much, as waiting for this means nothing else happens * in the system*/#define MEMORY_WAIT_TIME 16#define SMC_DEBUG 0#if (SMC_DEBUG > 2 )#define PRINTK3(args...) printf(args)#else#define PRINTK3(args...)#endif#if SMC_DEBUG > 1#define PRINTK2(args...) printf(args)#else#define PRINTK2(args...)#endif#ifdef SMC_DEBUG#define PRINTK(args...) printf(args)#else#define PRINTK(args...)#endif/*------------------------------------------------------------------------ * * The internal workings of the driver.  If you are changing anything * here with the SMC stuff, you should have the datasheet and know * what you are doing. * *------------------------------------------------------------------------ */#define CARDNAME "LAN91C96"#define SMC_BASE_ADDRESS CONFIG_LAN91C96_BASE#define SMC_DEV_NAME "LAN91C96"#define SMC_ALLOC_MAX_TRY 5#define SMC_TX_TIMEOUT 30#define ETH_ZLEN 60#ifdef  CONFIG_LAN91C96_USE_32_BIT#define USE_32_BIT  1#else#undef USE_32_BIT#endif/*----------------------------------------------------------------- * *  The driver can be entered at any of the following entry points. * *----------------------------------------------------------------- */extern int eth_init (bd_t * bd);extern void eth_halt (void);extern int eth_rx (void);extern int eth_send (volatile void *packet, int length);#if 0static int smc_hw_init (void);#endif/* * This is called by  register_netdev().  It is responsible for * checking the portlist for the SMC9000 series chipset.  If it finds * one, then it will initialize the device, find the hardware information, * and sets up the appropriate device parameters. * NOTE: Interrupts are *OFF* when this procedure is called. * * NB:This shouldn't be static since it is referred to externally. */int smc_init (void);/* * This is called by  unregister_netdev().  It is responsible for * cleaning up before the driver is finally unregistered and discarded. */void smc_destructor (void);/* * The kernel calls this function when someone wants to use the device, * typically 'ifconfig ethX up'. */static int smc_open (bd_t *bd);/* * This is called by the kernel in response to 'ifconfig ethX down'.  It * is responsible for cleaning up everything that the open routine * does, and maybe putting the card into a powerdown state. */static int smc_close (void);/* * This is a separate procedure to handle the receipt of a packet, to * leave the interrupt code looking slightly cleaner */static int smc_rcv (void);/* See if a MAC address is defined in the current environment. If so use it. If not . print a warning and set the environment and other globals with the default. . If an EEPROM is present it really should be consulted.*/int smc_get_ethaddr(bd_t *bd);int get_rom_mac(unsigned char *v_rom_mac);/* ------------------------------------------------------------ * Internal routines * ------------------------------------------------------------ */static unsigned char smc_mac_addr[] = { 0xc0, 0x00, 0x00, 0x1b, 0x62, 0x9c };/* * This function must be called before smc_open() if you want to override * the default mac address. */void smc_set_mac_addr (const unsigned char *addr){	int i;	for (i = 0; i < sizeof (smc_mac_addr); i++) {		smc_mac_addr[i] = addr[i];	}}/* * smc_get_macaddr is no longer used. If you want to override the default * mac address, call smc_get_mac_addr as a part of the board initialisation. */#if 0void smc_get_macaddr (byte * addr){	/* MAC ADDRESS AT FLASHBLOCK 1 / OFFSET 0x10 */	unsigned char *dnp1110_mac = (unsigned char *) (0xE8000000 + 0x20010);	int i;	for (i = 0; i < 6; i++) {		addr[0] = *(dnp1110_mac + 0);		addr[1] = *(dnp1110_mac + 1);		addr[2] = *(dnp1110_mac + 2);		addr[3] = *(dnp1110_mac + 3);		addr[4] = *(dnp1110_mac + 4);		addr[5] = *(dnp1110_mac + 5);	}}#endif /* 0 *//*********************************************** * Show available memory                       * ***********************************************/void dump_memory_info (void){	word mem_info;	word old_bank;	old_bank = SMC_inw (LAN91C96_BANK_SELECT) & 0xF;	SMC_SELECT_BANK (0);	mem_info = SMC_inw (LAN91C96_MIR);	PRINTK2 ("Memory: %4d available\n", (mem_info >> 8) * 2048);	SMC_SELECT_BANK (old_bank);}/* * A rather simple routine to print out a packet for debugging purposes. */#if SMC_DEBUG > 2static void print_packet (byte *, int);#endif/* #define tx_done(dev) 1 *//* this does a soft reset on the device */static void smc_reset (void);/* Enable Interrupts, Receive, and Transmit */static void smc_enable (void);/* this puts the device in an inactive state */static void smc_shutdown (void);static int poll4int (byte mask, int timeout){	int tmo = get_timer (0) + timeout * CFG_HZ;	int is_timeout = 0;	word old_bank = SMC_inw (LAN91C96_BANK_SELECT);	PRINTK2 ("Polling...\n");	SMC_SELECT_BANK (2);	while ((SMC_inw (LAN91C96_INT_STATS) & mask) == 0) {		if (get_timer (0) >= tmo) {			is_timeout = 1;			break;		}	}	/* restore old bank selection */	SMC_SELECT_BANK (old_bank);	if (is_timeout)		return 1;	else		return 0;}/* * Function: smc_reset( void ) * Purpose: *  	This sets the SMC91111 chip to its normal state, hopefully from whatever * 	mess that any other DOS driver has put it in. * * Maybe I should reset more registers to defaults in here?  SOFTRST  should * do that for me. * * Method: *	1.  send a SOFT RESET *	2.  wait for it to finish *	3.  enable autorelease mode *	4.  reset the memory management unit *	5.  clear all interrupts **/static void smc_reset (void){	PRINTK2 ("%s:smc_reset\n", SMC_DEV_NAME);	/* This resets the registers mostly to defaults, but doesn't	   affect EEPROM.  That seems unnecessary */	SMC_SELECT_BANK (0);	SMC_outw (LAN91C96_RCR_SOFT_RST, LAN91C96_RCR);	udelay (10);	/* Disable transmit and receive functionality */	SMC_outw (0, LAN91C96_RCR);	SMC_outw (0, LAN91C96_TCR);	/* set the control register */	SMC_SELECT_BANK (1);	SMC_outw (SMC_inw (LAN91C96_CONTROL) | LAN91C96_CTR_BIT_8,			  LAN91C96_CONTROL);	/* Disable all interrupts */	SMC_outb (0, LAN91C96_INT_MASK);}/* * Function: smc_enable * Purpose: let the chip talk to the outside work * Method: *	1.  Initialize the Memory Configuration Register *	2.  Enable the transmitter *	3.  Enable the receiver*/static void smc_enable (){	PRINTK2 ("%s:smc_enable\n", SMC_DEV_NAME);	SMC_SELECT_BANK (0);	/* Initialize the Memory Configuration Register. See page	   49 of the LAN91C96 data sheet for details. */	SMC_outw (LAN91C96_MCR_TRANSMIT_PAGES, LAN91C96_MCR);	/* Initialize the Transmit Control Register */	SMC_outw (LAN91C96_TCR_TXENA, LAN91C96_TCR);	/* Initialize the Receive Control Register	 * FIXME:	 * The promiscuous bit set because I could not receive ARP reply	 * packets from the server when I send a ARP request. It only works	 * when I set the promiscuous bit	 */	SMC_outw (LAN91C96_RCR_RXEN | LAN91C96_RCR_PRMS, LAN91C96_RCR);}/* * Function: smc_shutdown * Purpose:  closes down the SMC91xxx chip. * Method: *	1. zero the interrupt mask *	2. clear the enable receive flag *	3. clear the enable xmit flags * * TODO: *   (1) maybe utilize power down mode. *	Why not yet?  Because while the chip will go into power down mode, *	the manual says that it will wake up in response to any I/O requests *	in the register space.   Empirical results do not show this working. */static void smc_shutdown (){	PRINTK2 (CARDNAME ":smc_shutdown\n");	/* no more interrupts for me */	SMC_SELECT_BANK (2);	SMC_outb (0, LAN91C96_INT_MASK);	/* and tell the card to stay away from that nasty outside world */	SMC_SELECT_BANK (0);	SMC_outb (0, LAN91C96_RCR);	SMC_outb (0, LAN91C96_TCR);}/* * Function:  smc_hardware_send_packet(struct net_device * ) * Purpose: *	This sends the actual packet to the SMC9xxx chip. * * Algorithm: * 	First, see if a saved_skb is available. *		( this should NOT be called if there is no 'saved_skb' *	Now, find the packet number that the chip allocated *	Point the data pointers at it in memory *	Set the length word in the chip's memory *	Dump the packet to chip memory *	Check if a last byte is needed ( odd length packet ) *		if so, set the control flag right * 	Tell the card to send it *	Enable the transmit interrupt, so I know if it failed * 	Free the kernel data if I actually sent it. */static int smc_send_packet (volatile void *packet, int packet_length){	byte packet_no;	unsigned long ioaddr;	byte *buf;	int length;	int numPages;	int try = 0;	int time_out;	byte status;	PRINTK3 ("%s:smc_hardware_send_packet\n", SMC_DEV_NAME);	length = ETH_ZLEN < packet_length ? packet_length : ETH_ZLEN;	/* allocate memory	 ** The MMU wants the number of pages to be the number of 256 bytes	 ** 'pages', minus 1 ( since a packet can't ever have 0 pages :) )	 **	 ** The 91C111 ignores the size bits, but the code is left intact	 ** for backwards and future compatibility.	 **	 ** Pkt size for allocating is data length +6 (for additional status	 ** words, length and ctl!)	 **	 ** If odd size then last byte is included in this header.	 */	numPages = ((length & 0xfffe) + 6);	numPages >>= 8;				/* Divide by 256 */	if (numPages > 7) {		printf ("%s: Far too big packet error. \n", SMC_DEV_NAME);		return 0;	}	/* now, try to allocate the memory */	SMC_SELECT_BANK (2);	SMC_outw (LAN91C96_MMUCR_ALLOC_TX | numPages, LAN91C96_MMU);  again:	try++;	time_out = MEMORY_WAIT_TIME;	do {		status = SMC_inb (LAN91C96_INT_STATS);		if (status & LAN91C96_IST_ALLOC_INT) {			SMC_outb (LAN91C96_IST_ALLOC_INT, LAN91C96_INT_STATS);			break;		}	} while (--time_out);	if (!time_out) {		PRINTK2 ("%s: memory allocation, try %d failed ...\n",				 SMC_DEV_NAME, try);		if (try < SMC_ALLOC_MAX_TRY)			goto again;		else			return 0;	}	PRINTK2 ("%s: memory allocation, try %d succeeded ...\n",			 SMC_DEV_NAME, try);	/* I can send the packet now.. */	ioaddr = SMC_BASE_ADDRESS;	buf = (byte *) packet;	/* If I get here, I _know_ there is a packet slot waiting for me */	packet_no = SMC_inb (LAN91C96_ARR);