/*
 * Author: Abraham van der Merwe <abraham at 2d3d.co.za> 
 * 
 * A Cirrus Logic CS8900A driver for Linux 
 * based on the cs89x0 driver written by Russell Nelson, 
 * Donald Becker, and others. 
 * 
 * This source code is free software; you can redistribute it and/or 
 * modify it under the terms of the GNU General Public License 
 * version 2 as published by the Free Software Foundation. 
 * 
 * History: 
 * 22-May-2002 Initial version (Abraham vd Merwe) 
 * 30-May-2002 Added char device support for eeprom (Frank Becker) 
 * 24-Jan-2004 Fixups for 2.6 (Frank Becker) 
 * 15-July-2004 Modified for SMDK2410 (Roc Wu pwu at jadechip.com) 
 */ 
 
#define VERSION_STRING "Cirrus Logic CS8900A driver for Linux (Modified for SMDK2410)" 
//add by zsyddl
#define CONFIG_ARCH_SMDK2410 1 
//add end;
/* 
 * At the moment the driver does not support memory mode operation. 
 * It is trivial to implement this, but not worth the effort. 
 */ 
 
/* 
 * TODO: 
 * 
 * 1. Sort out ethernet checksum 
 * 2. If !ready in send_start(), queue buffer and send it in interrupt 
handler 
 * when we receive a BufEvent with Rdy4Tx, send it again. dangerous! 
 * 3. how do we prevent interrupt handler destroying integrity of get_stats()
? 
 * 4. Change reset code to check status. 
 * 5. Implement set_mac_address and remove fake mac address 
 * 7. Link status detection stuff 
 * 8. Write utility to write EEPROM, do self testing, etc. 
 * 9. Implement DMA routines (I need a board w/ DMA support for that) 
 * 10. Power management 
 * 11. Add support for multiple ethernet chips 
 */ 
 
// added BSt 
#include <linux/config.h> 
 
#include <linux/kernel.h> 
#include <linux/module.h> 
#include <linux/types.h> 
#include <linux/version.h> 
#include <linux/errno.h> 
#include <linux/init.h> 
#include <linux/delay.h> 
#include <linux/ioport.h> 
#include <asm/irq.h> 
#include <asm/hardware.h> 
#include <asm/io.h> 
#include <asm/uaccess.h> 
#include <linux/netdevice.h> 
#include <linux/etherdevice.h> 
#include <linux/skbuff.h> 
 
// Added BSt 
#include <asm/mach-types.h> 
 
#ifdef CONFIG_SA1100_CERF 
#include "asm/arch/cerf.h" 
#endif 
 
#ifdef CONFIG_ARCH_SMDK2410 
//#include "asm/arch/smdk2410.h" 
#endif 
 
#include "cs8900.h" 
 
//#define FULL_DUPLEX 
//#define DEBUG 
 
typedef struct { 
	struct net_device_stats stats; 
	u16 txlen; 
	int char_devnum; 
 
	spinlock_t lock; 
} cs8900_t; 
 
int cs8900_probe (struct net_device *dev); 
// static struct net_device cs8900_dev = 
// { 
// 	init: cs8900_probe 
// }; 
//  
static struct net_device cs8900_dev;

 
/* 
 * There seems to be no way to determine the exact size of the eeprom, 
 * so we use the largest size. 
 * FIXME: Verify it's safe to read/write past the end of a 64/128 
 * byte eeprom. 
 * 
 * Possible eeprom sizes: 
 * Cx46 - 64 bytes 
 * Cx56 - 128 bytes 
 * Cx66 - 256 bytes 
 */ 
#define MAX_EEPROM_SIZE 256 
 
static int cs8900_eeprom_fopen(struct inode *inode, struct file *file); 
static int cs8900_eeprom_frelease(struct inode *inode, struct file *file); 
static loff_t cs8900_eeprom_fllseek(struct file * file,loff_t offset, int 
		flags); 
static ssize_t cs8900_eeprom_fread(struct file *file, char *buf, size_t count
		, loff_t *f_pos); 
static ssize_t cs8900_eeprom_fwrite(struct file *file, const char *buf, 
				    size_t count, loff_t *f_pos); 
static struct file_operations cs8900_eeprom_fops = { 
	owner: THIS_MODULE, 
	open: cs8900_eeprom_fopen, 
	release: cs8900_eeprom_frelease, 
	llseek: cs8900_eeprom_fllseek, 
	read: cs8900_eeprom_fread, 
	write: cs8900_eeprom_fwrite, 
}; 
 
static u16 cs8900_eeprom_cache[MAX_EEPROM_SIZE/2]; 
 
/* 
 * I/O routines 
 */ 
 
static inline u16 cs8900_read (struct net_device *dev,u16 reg) 
{ 
	outw (reg,dev->base_addr + PP_Address); 
	return (inw (dev->base_addr + PP_Data)); 
} 
 
static inline void cs8900_write (struct net_device *dev,u16 reg,u16 value) 
{ 
	outw (reg,dev->base_addr + PP_Address); 
	outw (value,dev->base_addr + PP_Data); 
} 
 
static inline void cs8900_set (struct net_device *dev,u16 reg,u16 value) 
{ 
	cs8900_write (dev,reg,cs8900_read (dev,reg) | value); 
} 
 
static inline void cs8900_clear (struct net_device *dev,u16 reg,u16 value) 
{ 
	cs8900_write (dev,reg,cs8900_read (dev,reg) & ~value); 
} 
 
static inline void cs8900_frame_read (struct net_device *dev,struct sk_buff *
		skb,u16 length) 
{ 
	insw (dev->base_addr,skb_put (skb,length),(length + 1) / 2); 
} 
 
static inline void cs8900_frame_write (struct net_device *dev,struct sk_buff 
		*skb) 
{ 
	outsw (dev->base_addr,skb->data,(skb->len + 1) / 2); 
} 
 
/* 
 * EEPROM I/O routines 
 */ 
 
static int cs8900_eeprom_wait (struct net_device *dev) 
{ 
	int i; 
 
	for (i = 0; i < 3000; i++) { 
		if (!(cs8900_read (dev,PP_SelfST) & SIBUSY)) 
			return (0); 
		udelay (1); 
	} 
 
	return (-1); 
} 
 
static int cs8900_eeprom_read (struct net_device *dev,u16 *value,u16 offset) 
{ 
	if (cs8900_eeprom_wait (dev) < 0) 
		return (-1); 
 
	cs8900_write (dev,PP_EEPROMCommand,offset | EEReadRegister); 
 
	if (cs8900_eeprom_wait (dev) < 0) 
		return (-1); 
 
	*value = cs8900_read (dev,PP_EEPROMData); 
 
	return (0); 
} 
 
static int cs8900_eeprom_write (struct net_device *dev,u16 *value,u16 offset) 
{ 
	cs8900_eeprom_wait(dev); 
	cs8900_write(dev, PP_EEPROMCommand, (EEWriteEnable)); 
	cs8900_eeprom_wait(dev); 
	cs8900_write(dev, PP_EEPROMData, *value); 
	cs8900_eeprom_wait(dev); 
	cs8900_write(dev, PP_EEPROMCommand, (offset | EEWriteRegister)); 
	cs8900_eeprom_wait(dev); 
	cs8900_write(dev, PP_EEPROMCommand, (EEWriteDisable)); 
	cs8900_eeprom_wait(dev); 
 
	return 0; 
} 
 
/* 
 * Debugging functions 
 */ 
 
#ifdef DEBUG 
static inline int printable (int c) 
{ 
	return ((c >= 32 && c <= 126) || 
			(c >= 174 && c <= 223) || 
			(c >= 242 && c <= 243) || 
			(c >= 252 && c <= 253)); 
} 
 
static void dump16 (struct net_device *dev,const u8 *s,size_t len) 
{ 
	int i; 
	char str[128]; 
 
	if (!len) return; 
 
	*str = '\0'; 
 
	for (i = 0; i < len; i++) { 
		if (i && !(i % 4)) strcat (str," "); 
		sprintf (str,"%s%.2x ",str,s[i]); 
	} 
 
	for ( ; i < 16; i++) { 
		if (i && !(i % 4)) strcat (str," "); 
		strcat (str," "); 
	} 
 
	strcat (str," "); 
 for (i = 0; i < len; i++) sprintf (str,"%s%c",str,printable (s[i]) ? s[i] : 
			 '.'); 
 
 printk (KERN_DEBUG "%s: %s\n",dev->name,str); 
} 
 
static void hexdump (struct net_device *dev,const void *ptr,size_t size) 
{ 
	const u8 *s = (u8 *) ptr; 
	int i; 
	for (i = 0; i < size / 16; i++, s += 16) dump16 (dev,s,16); 
	dump16 (dev,s,size % 16); 
} 
 
static void dump_packet (struct net_device *dev,struct sk_buff *skb,const 
		char *type) 
{ 
	printk (KERN_INFO "%s: %s %d byte frame %.2x:%.2x:%.2x:%.2x:%.2x:%.2x to %.
			2x:%.2x:%.2x:%.2x:%.2x:%.2x type %.4x\n", 
	dev->name, 
	type, 
	skb->len, 
	skb->data[0],skb->data[1],skb->data[2],skb->data[3],skb->data[4],skb->data[5
			], 
			skb->data[6],skb->data[7],skb->data[8],skb->data[9],skb->data[10],skb->data[
					11], 
					(skb->data[12] << 8) | skb->data[13]); 
	if (skb->len < 0x100) hexdump (dev,skb->data,skb->len); 
} 
 
static void eepromdump( struct net_device *dev) 
{ 
	u16 buf[0x80]; 
	u16 i; 
	int count; 
	int total; 
 
	if( cs8900_read( dev, PP_SelfST) & EEPROMpresent) 
	{ 
		printk (KERN_INFO "%s: EEPROM present\n",dev->name); 
	} 
	else 
	{ 
		printk (KERN_INFO "%s: NO EEPROM present\n",dev->name); 
		return; 
	} 
 
	if( cs8900_read( dev, PP_SelfST) & EEPROMOK) 
	{ 
		printk (KERN_INFO "%s: EEPROM OK\n",dev->name); 
	} 
	else 
	{ 
		printk (KERN_INFO "%s: EEPROM checksum mismatch - fixing...\n",dev->name); 
	} 
 
	printk (KERN_INFO "%s: Hexdump\n",dev->name); 
	for( i=0; i<0x80; i++) 
	{ 
		cs8900_eeprom_read( dev, &buf[i], i); 
	} 
	hexdump( dev, buf, 0x100); 
 
	if( buf[0] & 0x0100) 
	{ 
		printk (KERN_INFO "%s: non-sequential EEPROM\n",dev->name); 
	} 
	else 
	{ 
		printk (KERN_INFO "%s: sequential EEPROM\n",dev->name); 
	} 
 
	if( (buf[0] & 0xe000) == 0xa000) 
	{ 
		printk (KERN_INFO "%s: Found reset configuration block\n",dev->name); 
	} 
	else 
	{ 
		printk (KERN_INFO "%s: Reset configuration block not found\n",dev->name); 
		return; 
	} 
 
	count = 2; 
	total = buf[0] & 0xff; 
	printk (KERN_INFO "%s: Reset configuration block size = %d bytes\n",dev->
			name, total); 
 
	while( count < total) 
	{ 
		int groupsize = (buf[count/2] >> 12) + 1; 
		int basereg = (buf[count/2] &0x1ff); 
		printk (KERN_INFO "%s: Group size = %d words\n",dev->name, groupsize); 
		printk (KERN_INFO "%s: Base register = %x\n",dev->name, basereg); 
		count += (groupsize + 1)*2; 
	} 
} 
 
#endif /* #ifdef DEBUG */ 
 
/* 
 * Driver functions 
 */ 
 
static void cs8900_receive (struct net_device *dev) 
{ 
	cs8900_t *priv = (cs8900_t *) dev->priv; 
	struct sk_buff *skb; 
	u16 status,length; 
 
	status = cs8900_read (dev,PP_RxStatus); 
	length = cs8900_read (dev,PP_RxLength); 
 
	if (!(status & RxOK)) { 
		priv->stats.rx_errors++; 
		if ((status & (Runt | Extradata))) priv->stats.rx_length_errors++; 
		if ((status & CRCerror)) priv->stats.rx_crc_errors++; 
		return; 
	} 
 
	if ((skb = dev_alloc_skb (length + 4)) == NULL) { 
		priv->stats.rx_dropped++; 
		return; 
	} 
 
	skb->dev = dev; 
	skb_reserve (skb,2); 
 
	cs8900_frame_read (dev,skb,length); 
 
#ifdef FULL_DUPLEX 
	dump_packet (dev,skb,"recv"); 
#endif /* #ifdef FULL_DUPLEX */ 
 
	skb->protocol = eth_type_trans (skb,dev); 
 
	netif_rx (skb); 
	dev->last_rx = jiffies; 
 
	priv->stats.rx_packets++; 
	priv->stats.rx_bytes += length; 
} 
 
static int cs8900_send_start (struct sk_buff *skb,struct net_device *dev) 
{ 
	cs8900_t *priv = (cs8900_t *) dev->priv; 
	u16 status; 
 
	spin_lock_irq(&priv->lock); 
	netif_stop_queue (dev); 
 
	cs8900_write (dev,PP_TxCMD,TxStart (After5)); 
	cs8900_write (dev,PP_TxLength,skb->len); 
 
	status = cs8900_read (dev,PP_BusST); 
 
	if ((status & TxBidErr)) { 
		spin_unlock_irq(&priv->lock); 
		printk (KERN_WARNING "%s: Invalid frame size %d!\n",dev->name,skb->len); 
		priv->stats.tx_errors++; 
		priv->stats.tx_aborted_errors++; 
		priv->txlen = 0; 
		return (1); 
	} 
 
	if (!(status & Rdy4TxNOW)) { 
		spin_unlock_irq(&priv->lock); 
		printk (KERN_WARNING "%s: Transmit buffer not free!\n",dev->name); 
		priv->stats.tx_errors++; 
		priv->txlen = 0; 
		/* FIXME: store skb and send it in interrupt handler */ 
		return (1); 
	} 
 
	cs8900_frame_write (dev,skb); 
	spin_unlock_irq(&priv->lock); 
 
#ifdef DEBUG 
	dump_packet (dev,skb,"send"); 
#endif /* #ifdef DEBUG */ 
 
	dev->trans_start = jiffies; 
 
	dev_kfree_skb (skb); 
 
	priv->txlen = skb->len; 
 
	return (0); 
} 
 
static irqreturn_t cs8900_interrupt (int irq,void *id,struct pt_regs *regs) 
{ 
	struct net_device *dev = (struct net_device *) id; 
	cs8900_t *priv; 
	volatile u16 status; 
	irqreturn_t handled = 0; 
 
	if (dev->priv == NULL) { 
		printk (KERN_WARNING "%s: irq %d for unknown device.\n",dev->name,irq); 
		return 0; 
	} 
 
	priv = (cs8900_t *) dev->priv; 
 
	while ((status = cs8900_read (dev, PP_ISQ))) { 
		handled = 1; 
 
		switch (RegNum (status)) { 
			case RxEvent: 
				cs8900_receive (dev); 
				break; 
 
			case TxEvent: 
				priv->stats.collisions += ColCount (cs8900_read (dev,PP_TxCOL)); 
				if (!(RegContent (status) & TxOK)) { 
					priv->stats.tx_errors++; 
					if ((RegContent (status) & Out_of_window)) priv->stats.tx_window_errors++; 
					if ((RegContent (status) & Jabber)) priv->stats.tx_aborted_errors++; 
					break; 
				} else if (priv->txlen) { 
					priv->stats.tx_packets++; 
					priv->stats.tx_bytes += priv->txlen; 
				} 
				priv->txlen = 0; 
				netif_wake_queue (dev); 
				break; 
 
			case BufEvent: 
				if ((RegContent (status) & RxMiss)) { 
					u16 missed = MissCount (cs8900_read (dev,PP_RxMISS)); 
					priv->stats.rx_errors += missed; 
					priv->stats.rx_missed_errors += missed; 
				} 
				if ((RegContent (status) & TxUnderrun)) {