/* cs89x0.c: A Crystal Semiconductor CS89[02]0 driver for grub4dos. * *  Copyright (C) 2007 Tinybit <tinybit@tom.com> *  Copyright (C) 1997-2007 Ken Yap <ken.yap@acm.org> *  Copyright (C) 1996-2007 Markus Gutschke <gutschk@math.uni-muenster.de> *  Copyright (C) 1988-2007 Russell Nelson, Crynwr Software * *  This program is free software; you can redistribute it and/or modify *  it under the terms of the GNU General Public License version 1 or *  version 2 as published by the Free Software Foundation. * *  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., 675 Mass Ave, Cambridge, MA 02139, USA. *//*In August 2, 2007, Sascha Sommer <ssommer@suse.de> posted a message tothe grub4dos-devel@gna.org mailing list as follows:-------------------------------------------------------------------------------	Subject： 	[Grub4dos-devel] cs89x0.c driver	Hi,	the file netboot/cs98x0.txt contains the following statement:	"Permission is granted to distribute the enclosed cs89x0.[ch] driver	only in conjunction with the Etherboot package.  The code is	ordinarily distributed under the GPL.			Russ Nelson, January 2000"	So it looks like these files cannot be distributed with grub4dos. 	As the Makefile in the netboot dir contains following statements		"# Don't build the netboot support by default."	I wonder if the cs89x0 driver cannot be removed from the grub4dos	distribution.		Regards		Sascha-------------------------------------------------------------------------------In reply to the doubts above, I make the following note on the license issue,and claim we are distributing the code under GPL at the very beginning of thefile.In etherboot-4.2 which was released in June 5, 1999, the files cs89x0.[ch]have this copyright notice by Markus Gutschke(gutschk@math.uni-muenster.de):===============================================================================  This code is heavily based on the linux driver as written by  Russell Nelson <nelson@crynwr.com> and Donald Becker  <becker@cesdis.gsfc.nasa.gov> and modified by Mike Cruse  <mcruse@cti-ltd.com>. That driver has been released under the  conditions of the GNU Public License, thus this one is probably to  be considered "derived work". Therefore, there are some legal  obstacles in combining this file with etherboot's code, which is  released under a BSD style license.  So, if you want to actually use this code, you should make sure that  you are aware of the legal implications. I release *my* work into  the PUBLIC DOMAIN which implies that you can use it either under a  BSD style license, or under the conditions of the GPL, or under any  other conditions that you like. N.B. this does not apply to the  parts that originate from other authors. So, you should probably  contact them first and verify if they agree with your intended use.  If you contacted all of the above authors and they agreed to give  special permission for using this code under the conditions of a BSD  style license, then please do let me know.===============================================================================In a later etherboot release, the copyright notice changed to this:**********************************************************************  Permission is granted to distribute the enclosed cs89x0.[ch] driver  only in conjunction with the Etherboot package.  The code is  ordinarily distributed under the GPL.  Russ Nelson, January 2000**********************************************************************Don't be confused by the statements. Look at the first statement:  Permission is granted to distribute the enclosed cs89x0.[ch] driver  only in conjunction with the Etherboot package.It should be understood as:  ----------------------------------------------------------------------------                                (1)  Permission is granted **(to distribute the enclosed cs89x0.[ch] driver  only in conjunction with the Etherboot package)**.  ----------------------------------------------------------------------------which means if the driver is distributed only in conjunction with theEtherboot package, then Permission is granted for it.It should not be understood as this:  ----------------------------------------------------------------------------                                (2)  **(Permission is granted to distribute the enclosed cs89x0.[ch] driver)**  only in conjunction with the Etherboot package.  ----------------------------------------------------------------------------which means Permission is **only** granted to distribute the driverin conjunction with the Etherboot package, and if it is not distributed inconjunction with Etherboot, then Permission is not granted.The latter understanding of (2) is obviously wrong because it directlyconflicts with GPL claimed above in the second statement by Russ Nelson.But if you consider Russ Nelson's announcements as dual license: one licenseis for how to use this driver in Etherboot:  ----------------------------------------------------------------------------  Permission is granted to distribute the enclosed cs89x0.[ch] driver  only in conjunction with the Etherboot package.  ----------------------------------------------------------------------------and the other license is for how to use this driver in other packages:  --------------------------------------------------------  The code is ordinarily distributed under the GPL.  --------------------------------------------------------then the different understandings between (1) and (2) are not important.This is because, for the dual license, either of the included licensescan be chosen by the recipient. You don't have to accept both licensessimultaneously.We are introducing the driver from Etherboot, so we can legally inheritthe GPL from Etherboot. In any case, we can distribute the cs89x0.[ch]driver under GPL. There are no problems. Don't worry.             ---- Tinybit <tinybit@tom.com> August 20, 2007*//***************************************************************************//***************************************************************************//* cs89x0.c: A Crystal Semiconductor CS89[02]0 driver for etherboot. *//*  Permission is granted to distribute the enclosed cs89x0.[ch] driver  only in conjunction with the Etherboot package.  The code is  ordinarily distributed under the GPL.    Russ Nelson, January 2000  ChangeLog:  Thu Dec 6 22:40:00 1996  Markus Gutschke  <gutschk@math.uni-muenster.de>  * disabled all "advanced" features; this should make the code more reliable  * reorganized the reset function  * always reset the address port, so that autoprobing will continue working  * some cosmetic changes  * 2.5  Thu Dec 5 21:00:00 1996  Markus Gutschke  <gutschk@math.uni-muenster.de>  * tested the code against a CS8900 card  * lots of minor bug fixes and adjustments  * this is the first release, that actually works! it still requires some    changes in order to be more tolerant to different environments  * 4  Fri Nov 22 23:00:00 1996  Markus Gutschke  <gutschk@math.uni-muenster.de>  * read the manuals for the CS89x0 chipsets and took note of all the    changes that will be neccessary in order to adapt Russel Nelson's code    to the requirements of a BOOT-Prom  * 6  Thu Nov 19 22:00:00 1996  Markus Gutschke  <gutschk@math.uni-muenster.de>  * Synched with Russel Nelson's current code (v1.00)  * 2  Thu Nov 12 18:00:00 1996  Markus Gutschke  <gutschk@math.uni-muenster.de>  * Cleaned up some of the code and tried to optimize the code size.  * 1.5  Sun Nov 10 16:30:00 1996  Markus Gutschke  <gutschk@math.uni-muenster.de>  * First experimental release. This code compiles fine, but I  have no way of testing whether it actually works.  * I did not (yet) bother to make the code 16bit aware, so for  the time being, it will only work for Etherboot/32.  * 12  */#include "etherboot.h"#include "nic.h"#include "cards.h"#include "cs89x0.h"static unsigned short	eth_nic_base;static unsigned long    eth_mem_start;static unsigned short   eth_irq;static unsigned short   eth_cs_type;	/* one of: CS8900, CS8920, CS8920M  */static unsigned short   eth_auto_neg_cnf;static unsigned short   eth_adapter_cnf;static unsigned short	eth_linectl;/*************************************************************************	CS89x0 - specific routines**************************************************************************/static inline int readreg(int portno){	outw(portno, eth_nic_base + ADD_PORT);	return inw(eth_nic_base + DATA_PORT);}static inline void writereg(int portno, int value){	outw(portno, eth_nic_base + ADD_PORT);	outw(value, eth_nic_base + DATA_PORT);	return;}/*************************************************************************EEPROM access**************************************************************************/static int wait_eeprom_ready(void){	unsigned long tmo = currticks() + 4*TICKS_PER_SEC;	/* check to see if the EEPROM is ready, a timeout is used -	   just in case EEPROM is ready when SI_BUSY in the	   PP_SelfST is clear */	while(readreg(PP_SelfST) & SI_BUSY) {		if (currticks() >= tmo)			return -1; }	return 0;}static int get_eeprom_data(int off, int len, unsigned short *buffer){	int i;#ifdef	EDEBUG	printf("\ncs: EEPROM data from %hX for %hX:",off,len);#endif	for (i = 0; i < len; i++) {		if (wait_eeprom_ready() < 0)			return -1;		/* Now send the EEPROM read command and EEPROM location		   to read */		writereg(PP_EECMD, (off + i) | EEPROM_READ_CMD);		if (wait_eeprom_ready() < 0)			return -1;		buffer[i] = readreg(PP_EEData);#ifdef	EDEBUG		if (!(i%10))			printf("\ncs: ");		printf("%hX ", buffer[i]);#endif	}#ifdef	EDEBUG	putchar('\n');#endif	return(0);}static int get_eeprom_chksum(int off, int len, unsigned short *buffer){	int  i, cksum;	cksum = 0;	for (i = 0; i < len; i++)		cksum += buffer[i];	cksum &= 0xffff;	if (cksum == 0)		return 0;	return -1;}/*************************************************************************Activate all of the available media and probe for network**************************************************************************/static void clrline(void){	int i;	putchar('\r');	for (i = 79; i--; ) putchar(' ');	printf("\rcs: ");	return;}static void control_dc_dc(int on_not_off){	unsigned int selfcontrol;	unsigned long tmo = currticks() + TICKS_PER_SEC;	/* control the DC to DC convertor in the SelfControl register.  */	selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */	if (((eth_adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)		selfcontrol |= HCB1;	else		selfcontrol &= ~HCB1;	writereg(PP_SelfCTL, selfcontrol);	/* Wait for the DC/DC converter to power up - 1000ms */	while (currticks() < tmo);	return;}static int detect_tp(void){	unsigned long tmo;	/* Turn on the chip auto detection of 10BT/ AUI */	clrline(); printf("attempting %s:","TP");        /* If connected to another full duplex capable 10-Base-T card	   the link pulses seem to be lost when the auto detect bit in	   the LineCTL is set.  To overcome this the auto detect bit	   will be cleared whilst testing the 10-Base-T interface.	   This would not be necessary for the sparrow chip but is	   simpler to do it anyway. */	writereg(PP_LineCTL, eth_linectl &~ AUI_ONLY);	control_dc_dc(0);        /* Delay for the hardware to work out if the TP cable is	   present - 150ms */	for (tmo = currticks() + 4; currticks() < tmo; );	if ((readreg(PP_LineST) & LINK_OK) == 0)		return 0;	if (eth_cs_type != CS8900) {		writereg(PP_AutoNegCTL, eth_auto_neg_cnf & AUTO_NEG_MASK);		if ((eth_auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {			printf(" negotiating duplex... ");			while (readreg(PP_AutoNegST) & AUTO_NEG_BUSY) {				if (currticks() - tmo > 40*TICKS_PER_SEC) {					printf("time out ");					break;				}			}		}		if (readreg(PP_AutoNegST) & FDX_ACTIVE)			printf("using full duplex");		else			printf("using half duplex");	}	return A_CNF_MEDIA_10B_T;}/* send a test packet - return true if carrier bits are ok */static int send_test_pkt(struct nic *nic){	static unsigned char testpacket[] = { 0,0,0,0,0,0, 0,0,0,0,0,0,				     0, 46, /*A 46 in network order       */				     0, 0,  /*DSAP=0 & SSAP=0 fields      */				     0xf3,0 /*Control (Test Req+P bit set)*/ };	unsigned long tmo;	writereg(PP_LineCTL, readreg(PP_LineCTL) | SERIAL_TX_ON);	memcpy(testpacket, nic->node_addr, ETH_ALEN);	memcpy(testpacket+ETH_ALEN, nic->node_addr, ETH_ALEN);	outw(TX_AFTER_ALL, eth_nic_base + TX_CMD_PORT);	outw(ETH_ZLEN, eth_nic_base + TX_LEN_PORT);	/* Test to see if the chip has allocated memory for the packet */	for (tmo = currticks() + 2;	     (readreg(PP_BusST) & READY_FOR_TX_NOW) == 0; )		if (currticks() >= tmo)			return(0);