linux_2_6_14_cs8900.diff

skyeye for pxa270

diff -Nur linux-2.6.14/arch/arm/mach-s3c2410/mach-smdk2410.c linux-2.6.14_cs8900/arch/arm/mach-s3c2410/mach-smdk2410.c
--- linux-2.6.14/arch/arm/mach-s3c2410/mach-smdk2410.c	2005-10-28 08:02:08.000000000 +0800
+++ linux-2.6.14_cs8900/arch/arm/mach-s3c2410/mach-smdk2410.c	2008-02-03 23:08:55.000000000 +0800
@@ -52,9 +52,12 @@
 
 #include "devs.h"
 #include "cpu.h"
+#include <asm/arch-s3c2410/smdk2410.h>
 
 static struct map_desc smdk2410_iodesc[] __initdata = {
   /* nothing here yet */
+  /* Map the ethernet controller CS8900A */
+{vSMDK2410_ETH_IO,pSMDK2410_ETH_IO, SZ_1M, MT_DEVICE}
 };
 
 #define UCON S3C2410_UCON_DEFAULT
diff -Nur linux-2.6.14/drivers/net/arm/cs8900.c linux-2.6.14_cs8900/drivers/net/arm/cs8900.c
--- linux-2.6.14/drivers/net/arm/cs8900.c	1970-01-01 08:00:00.000000000 +0800
+++ linux-2.6.14_cs8900/drivers/net/arm/cs8900.c	2008-02-03 23:15:49.000000000 +0800
@@ -0,0 +1,923 @@
+
+/*
+ * linux/drivers/net/cs8900.c
+ *
+ * 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)"
+
+/*
+ * 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-s3c2410/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
+};
+
+/* 
+ * 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);
+