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 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 + * + * 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 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Added BSt +#include + +#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); + + 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)) { + priv->stats.tx_errors++; + priv->stats.tx_fifo_errors++; + + priv->txlen = 0; + netif_wake_queue (dev); + } + /* FIXME: if Rdy4Tx, transmit last sent packet (if any) */ + break; + + case TxCOL: + priv->stats.collisions += ColCount (cs8900_read (dev,PP_TxCOL)); + break; + + case RxMISS: + status = MissCount (cs8900_read (dev,PP_RxMISS)); + priv->stats.rx_errors += status; + priv->stats.rx_missed_errors += status; + break; + } + } + return IRQ_RETVAL(handled); +} + +static void cs8900_transmit_timeout (struct net_device *dev) +{ + cs8900_t *priv = (cs8900_t *) dev->priv; + priv->stats.tx_errors++; + priv->stats.tx_heartbeat_errors++; + priv->txlen = 0; + netif_wake_queue (dev); +} + +static int cs8900_start (struct net_device *dev) +{ + int result; + +#if defined(CONFIG_ARCH_SMDK2410) + set_irq_type(dev->irq, IRQT_RISING); + + /* enable the ethernet controller */ + cs8900_set (dev,PP_RxCFG,RxOKiE | BufferCRC | CRCerroriE | RuntiE | ExtradataiE); + cs8900_set (dev,PP_RxCTL,RxOKA | IndividualA | BroadcastA); + cs8900_set (dev,PP_TxCFG,TxOKiE | Out_of_windowiE | JabberiE); + cs8900_set (dev,PP_BufCFG,Rdy4TxiE | RxMissiE | TxUnderruniE | TxColOvfiE | MissOvfloiE); + cs8900_set (dev,PP_LineCTL,SerRxON | SerTxON); + cs8900_set (dev,PP_BusCTL,EnableRQ); + +#ifdef FULL_DUPLEX + cs8900_set (dev,PP_TestCTL,FDX); +#endif /* #ifdef FULL_DUPLEX */ + udelay(200); + /* install interrupt handler */ + if ((result = request_irq (dev->irq, &cs8900_interrupt, 0, dev->name, dev)) < 0) { + printk ("%s: could not register interrupt %d\n",dev->name, dev->irq); + return (result); + } +#else + + /* install interrupt handler */ + if ((result = request_irq (dev->irq, &cs8900_interrupt, 0, dev->name, dev)) < 0) { + printk ("%s: could not register interrupt %d\n",dev->name, dev->irq); + return (result); + } + + set_irq_type(dev->irq, IRQT_RISING); + + /* enable the ethernet controller */ + cs8900_set (dev,PP_RxCFG,RxOKiE | BufferCRC | CRCerroriE | RuntiE | ExtradataiE); + cs8900_set (dev,PP_RxCTL,RxOKA | IndividualA | BroadcastA); + cs8900_set (dev,PP_TxCFG,TxOKiE | Out_of_windowiE | JabberiE); + cs8900_set (dev,PP_BufCFG,Rdy4TxiE | RxMissiE | TxUnderruniE | TxColOvfiE | MissOvfloiE); + cs8900_set (dev,PP_LineCTL,SerRxON | SerTxON); + cs8900_set (dev,PP_BusCTL,EnableRQ); + +#ifdef FULL_DUPLEX + cs8900_set (dev,PP_TestCTL,FDX); +#endif /* #ifdef FULL_DUPLEX */ + +#endif /* #if defined(CONFIG_ARCH_SMDK2410) */ + + /* start the queue */ + netif_start_queue (dev); + + return (0); +} + +static int cs8900_stop (struct net_device *dev) +{ + /* disable ethernet controller */ + cs8900_write (dev,PP_BusCTL,0); + cs8900_write (dev,PP_TestCTL,0); + cs8900_write (dev,PP_SelfCTL,0); + cs8900_write (dev,PP_LineCTL,0); + cs8900_write (dev,PP_BufCFG,0); + cs8900_write (dev,PP_TxCFG,0); + cs8900_write (dev,PP_RxCTL,0); + cs8900_write (dev,PP_RxCFG,0); + + /* uninstall interrupt handler */ + free_irq (dev->irq,dev); + + /* stop the queue */ + netif_stop_queue (dev); + + return (0); +} + +static struct net_device_stats *cs8900_get_stats (struct net_device *dev) +{ + cs8900_t *priv = (cs8900_t *) dev->priv; + return (&priv->stats); +} + +static void cs8900_set_receive_mode (struct net_device *dev) +{ + if ((dev->flags & IFF_PROMISC)) + cs8900_set (dev,PP_RxCTL,PromiscuousA); + else + cs8900_clear (dev,PP_RxCTL,PromiscuousA); + + if ((dev->flags & IFF_ALLMULTI) && dev->mc_list) + cs8900_set (dev,PP_RxCTL,MulticastA); + else + cs8900_clear (dev,PP_RxCTL,MulticastA); +} + +static int cs8900_eeprom (struct net_device *dev) +{ + cs8900_t *priv = (cs8900_t *) dev->priv; + int i; + + /* SMDK2410 CS8900A without EEPROM at all */ +#if defined(CONFIG_ARCH_SMDK2410) + return (-ENODEV); +#endif + +#ifdef DEBUG + eepromdump (dev); +#endif + + if( (cs8900_read( dev, PP_SelfST) & EEPROMpresent) == 0) + { + /* no eeprom */ + return (-ENODEV); + } + + /* add character device for easy eeprom programming */ + if( (priv->char_devnum=register_chrdev(0,"cs8900_eeprom",&cs8900_eeprom_fops)) != 0) + printk (KERN_INFO "%s: Registered cs8900_eeprom char device (major #%d)\n", + dev->name, priv->char_devnum); + else + printk (KERN_WARNING "%s: Failed to register char device cs8900_eeprom\n",dev->name); + + if( (cs8900_read( dev, PP_SelfST) & EEPROMOK) == 0) + { + /* bad checksum, invalid config block */ + return (-EFAULT); + } + + /* If we get here, the chip will have initialized the registers + * that were specified in the eeprom configuration block + * We assume this is at least the mac address. + */ + for (i = 0; i < ETH_ALEN; i += 2) + { + u16 mac = cs8900_read (dev,PP_IA + i); + dev->dev_addr[i] = mac & 0xff; + dev->dev_addr[i+1] = (mac>>8) & 0xff; + } + + return (0); +} + +/* + * EEPROM Charater device + */ + +static int cs8900_eeprom_fopen(struct inode *inode, struct file *file) +{ + u16 i; + for( i=0; if_pos + offset; + break; + case 2: /* SEEK_END */ + newpos = (MAX_EEPROM_SIZE-1) - offset; + break; + default: /* can't happen */ + return -EINVAL; + + } + + if( (newpos<0) || (newpos>=MAX_EEPROM_SIZE)) return -EINVAL; + + file->f_pos = newpos; + return newpos; +} + +static ssize_t cs8900_eeprom_fread(struct file *file, char *buf, size_t count, loff_t *f_pos) +{ + unsigned char *temp = (unsigned char *)cs8900_eeprom_cache; + + if (*f_pos >= MAX_EEPROM_SIZE) + return 0; + + if (*f_pos + count > MAX_EEPROM_SIZE) + count = MAX_EEPROM_SIZE - *f_pos; + + if (count<1) + return 0; + + if (copy_to_user(buf, &temp[*f_pos], count)){ + return -EFAULT; + } + *f_pos += count; + return count; +} + +static ssize_t cs8900_eeprom_fwrite(struct file *file, const char *buf, size_t count, loff_t *f_pos) +{ + u16 i; + unsigned char *temp = (unsigned char *)cs8900_eeprom_cache; + + if (*f_pos >= MAX_EEPROM_SIZE) + return 0; + + if (*f_pos + count > MAX_EEPROM_SIZE) + count = MAX_EEPROM_SIZE - *f_pos; + + if (count<1) + return 0; + + /* FIXME: lock critical section */ + + /* update the cache */ + if (copy_from_user(&temp[*f_pos], buf, count)){ + return -EFAULT; + } + + /* not concerned about performance, so write the entire thing */ + for( i=0; iopen = cs8900_start; + dev->stop = cs8900_stop; + dev->hard_start_xmit = cs8900_send_start; + dev->get_stats = cs8900_get_stats; + dev->set_multicast_list = cs8900_set_receive_mode; + dev->tx_timeout = cs8900_transmit_timeout; + dev->watchdog_timeo = HZ; + +#if defined(CONFIG_ARCH_SMDK2410) + dev->dev_addr[0] = 0x08; + dev->dev_addr[1] = 0x00; + dev->dev_addr[2] = 0x3e; + dev->dev_addr[3] = 0x26; + dev->dev_addr[4] = 0x0a; + dev->dev_addr[5] = 0x5b; +#else + dev->dev_addr[0] = 0x00; + dev->dev_addr[1] = 0x12; + dev->dev_addr[2] = 0x34; + dev->dev_addr[3] = 0x56; + dev->dev_addr[4] = 0x78; + dev->dev_addr[5] = 0x9a; +#endif + + dev->if_port = IF_PORT_10BASET; + dev->priv = (void *) &priv; + + spin_lock_init(&priv.lock); + + SET_MODULE_OWNER (dev); + +#ifdef CONFIG_SA1100_FRODO + dev->base_addr = FRODO_ETH_IO + 0x300; + dev->irq = FRODO_ETH_IRQ; + frodo_reset (dev); +#endif /* #ifdef CONFIG_SA1100_FRODO */ + +#if defined(CONFIG_SA1100_CERF) + dev->base_addr = CERF_ETH_IO + 0x300; + dev->irq = CERF_ETH_IRQ; +#endif /* #if defined(CONFIG_SA1100_CERF) */ + +#if defined(CONFIG_ARCH_SMDK2410) + dev->base_addr = vSMDK2410_ETH_IO + 0x300; + dev->irq = SMDK2410_ETH_IRQ; +#endif /* #if defined(CONFIG_ARCH_SMDK2410) */ + + if ((result = check_mem_region (dev->base_addr, 16))) { + printk (KERN_ERR "%s: can't get I/O port address 0x%lx\n",dev->name,dev->base_addr); + return (result); + } + request_mem_region (dev->base_addr, 16, dev->name); + + /* verify EISA registration number for Cirrus Logic */ + if ((value = cs8900_read (dev,PP_ProductID)) != EISA_REG_CODE) { + printk (KERN_ERR "%s: incorrect signature 0x%.4x\n",dev->name,value); + return (-ENXIO); + } + + /* verify chip version */ + value = cs8900_read (dev,PP_ProductID + 2); + if (VERSION (value) != CS8900A) { + printk (KERN_ERR "%s: unknown chip version 0x%.8x\n",dev->name,VERSION (value)); + return (-ENXIO); + } + /* setup interrupt number */ + cs8900_write (dev,PP_IntNum,0); + + /* If an EEPROM is present, use it's MAC address. A valid EEPROM will + * initialize the registers automatically. + */ + result = cs8900_eeprom (dev); + + printk (KERN_INFO "%s: CS8900A rev %c at %#lx irq=%d", + dev->name,'B' + REVISION (value) - REV_B, dev->base_addr, dev->irq); + if (result == -ENODEV) { + /* no eeprom or invalid config block, configure MAC address by hand */ + for (i = 0; i < ETH_ALEN; i += 2) + cs8900_write (dev,PP_IA + i,dev->dev_addr[i] | (dev->dev_addr[i + 1] << 8)); + printk (", no eeprom "); + } + else if( result == -EFAULT) + { +#if defined(CONFIG_SA1100_CERF) + /* The default eeprom layout doesn't follow the cs8900 layout + * that enables automatic cs8900 initialization. Doh! + * Read the mac address manually. + */ + u16 MAC_addr[3] = {0, 0, 0}; + + if (cs8900_eeprom_read(dev, &MAC_addr[0], 0x1c) == -1) + printk("\ncs8900: [CERF] EEPROM[0] read failed\n"); + if (cs8900_eeprom_read(dev, &MAC_addr[1], 0x1d) == -1) + printk("\ncs8900: [CERF] EEPROM[1] read failed\n"); + if (cs8900_eeprom_read(dev, &MAC_addr[2], 0x1e) == -1) + printk("\ncs8900: [CERF] EEPROM[2] read failed\n"); + + for (i = 0; i < ETH_ALEN / 2; i++) + { + dev->dev_addr[i*2] = MAC_addr[i] & 0xff; + dev->dev_addr[i*2+1] = (MAC_addr[i] >> 8) & 0xff; + + cs8900_write (dev,PP_IA + i*2,dev->dev_addr[i*2] | (dev->dev_addr[i*2 + 1] << 8)); + } + printk (", eeprom (smdk2410 layout)"); +#else + printk (", eeprom (invalid config block)"); +#endif /* #if defined(CONFIG_SA1100_CERF) */ + } + else + { + printk (", eeprom ok"); + } + + printk (", addr:"); + for (i = 0; i < ETH_ALEN; i += 2) + { + u16 mac = cs8900_read (dev,PP_IA + i); + printk ("%c%02X:%2X", (i==0)?' ':':', mac & 0xff, (mac >> 8)); + } + printk ("\n"); + + return (0); +} + +static int __init cs8900_init (void) +{ + strcpy(cs8900_dev.name, "eth%d"); + + return (register_netdev (&cs8900_dev)); +} + +static void __exit cs8900_cleanup (void) +{ + cs8900_t *priv = (cs8900_t *) cs8900_dev.priv; + if( priv->char_devnum) + { + unregister_chrdev(priv->char_devnum,"cs8900_eeprom"); + } + release_mem_region (cs8900_dev.base_addr,16); + unregister_netdev (&cs8900_dev); +} + +MODULE_AUTHOR ("Abraham van der Merwe "); +MODULE_DESCRIPTION (VERSION_STRING); +MODULE_LICENSE ("GPL"); + +module_init (cs8900_init); +module_exit (cs8900_cleanup); diff -Nur linux-2.6.14/drivers/net/arm/cs8900.h linux-2.6.14_cs8900/drivers/net/arm/cs8900.h --- linux-2.6.14/drivers/net/arm/cs8900.h 1970-01-01 08:00:00.000000000 +0800 +++ linux-2.6.14_cs8900/drivers/net/arm/cs8900.h 2008-02-03 23:15:49.000000000 +0800 @@ -0,0 +1,237 @@ +#ifndef CS8900_H +#define CS8900_H + +/* + * linux/drivers/net/cs8900.h + * + * Author: Abraham van der Merwe + * + * 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. + */ + +/* + * Ports + */ + +#define PP_Address 0x0a /* PacketPage Pointer Port (Section 4.10.10) */ +#define PP_Data 0x0c /* PacketPage Data Port (Section 4.10.10) */ + +/* + * Registers + */ + +#define PP_ProductID 0x0000 /* Section 4.3.1 Product Identification Code */ +#define PP_MemBase 0x002c /* Section 4.9.2 Memory Base Address Register */ +#define PP_IntNum 0x0022 /* Section 3.2.3 Interrupt Number */ +#define PP_EEPROMCommand 0x0040 /* Section 4.3.11 EEPROM Command */ +#define PP_EEPROMData 0x0042 /* Section 4.3.12 EEPROM Data */ +#define PP_RxCFG 0x0102 /* Section 4.4.6 Receiver Configuration */ +#define PP_RxCTL 0x0104 /* Section 4.4.8 Receiver Control */ +#define PP_TxCFG 0x0106 /* Section 4.4.9 Transmit Configuration */ +#define PP_BufCFG 0x010a /* Section 4.4.12 Buffer Configuration */ +#define PP_LineCTL 0x0112 /* Section 4.4.16 Line Control */ +#define PP_SelfCTL 0x0114 /* Section 4.4.18 Self Control */ +#define PP_BusCTL 0x0116 /* Section 4.4.20 Bus Control */ +#define PP_TestCTL 0x0118 /* Section 4.4.22 Test Control */ +#define PP_ISQ 0x0120 /* Section 4.4.5 Interrupt Status Queue */ +#define PP_TxEvent 0x0128 /* Section 4.4.10 Transmitter Event */ +#define PP_BufEvent 0x012c /* Section 4.4.13 Buffer Event */ +#define PP_RxMISS 0x0130 /* Section 4.4.14 Receiver Miss Counter */ +#define PP_TxCOL 0x0132 /* Section 4.4.15 Transmit Collision Counter */ +#define PP_SelfST 0x0136 /* Section 4.4.19 Self Status */ +#define PP_BusST 0x0138 /* Section 4.4.21 Bus Status */ +#define PP_TxCMD 0x0144 /* Section 4.4.11 Transmit Command */ +#define PP_TxLength 0x0146 /* Section 4.5.2 Transmit Length */ +#define PP_IA 0x0158 /* Section 4.6.2 Individual Address (IEEE Address) */ +#define PP_RxStatus 0x0400 /* Section 4.7.1 Receive Status */ +#define PP_RxLength 0x0402 /* Section 4.7.1 Receive Length (in bytes) */ +#define PP_RxFrame 0x0404 /* Section 4.7.2 Receive Frame Location */ +#define PP_TxFrame 0x0a00 /* Section 4.7.2 Transmit Frame Location */ + +/* + * Values + */ + +/* PP_IntNum */ +#define INTRQ0 0x0000 +#define INTRQ1 0x0001 +#define INTRQ2 0x0002 +#define INTRQ3 0x0003 + +/* PP_ProductID */ +#define EISA_REG_CODE 0x630e +#define REVISION(x) (((x) & 0x1f00) >> 8) +#define VERSION(x) ((x) & ~0x1f00) + +#define CS8900A 0x0000 +#define REV_B 7 +#define REV_C 8 +#define REV_D 9 + +/* PP_RxCFG */ +#define Skip_1 0x0040 +#define StreamE 0x0080 +#define RxOKiE 0x0100 +#define RxDMAonly 0x0200 +#define AutoRxDMAE 0x0400 +#define BufferCRC 0x0800 +#define CRCerroriE 0x1000 +#define RuntiE 0x2000 +#define ExtradataiE 0x4000 + +/* PP_RxCTL */ +#define IAHashA 0x0040 +#define PromiscuousA 0x0080 +#define RxOKA 0x0100 +#define MulticastA 0x0200 +#define IndividualA 0x0400 +#define BroadcastA 0x0800 +#define CRCerrorA 0x1000 +#define RuntA 0x2000 +#define ExtradataA 0x4000 + +/* PP_TxCFG */ +#define Loss_of_CRSiE 0x0040 +#define SQErroriE 0x0080 +#define TxOKiE 0x0100 +#define Out_of_windowiE 0x0200 +#define JabberiE 0x0400 +#define AnycolliE 0x0800 +#define T16colliE 0x8000 + +/* PP_BufCFG */ +#define SWint_X 0x0040 +#define RxDMAiE 0x0080 +#define Rdy4TxiE 0x0100 +#define TxUnderruniE 0x0200 +#define RxMissiE 0x0400 +#define Rx128iE 0x0800 +#define TxColOvfiE 0x1000 +#define MissOvfloiE 0x2000 +#define RxDestiE 0x8000 + +/* PP_LineCTL */ +#define SerRxON 0x0040 +#define SerTxON 0x0080 +#define AUIonly 0x0100 +#define AutoAUI_10BT 0x0200 +#define ModBackoffE 0x0800 +#define PolarityDis 0x1000 +#define L2_partDefDis 0x2000 +#define LoRxSquelch 0x4000 + +/* PP_SelfCTL */ +#define RESET 0x0040 +#define SWSuspend 0x0100 +#define HWSleepE 0x0200 +#define HWStandbyE 0x0400 +#define HC0E 0x1000 +#define HC1E 0x2000 +#define HCB0 0x4000 +#define HCB1 0x8000 + +/* PP_BusCTL */ +#define ResetRxDMA 0x0040 +#define DMAextend 0x0100 +#define UseSA 0x0200 +#define MemoryE 0x0400 +#define DMABurst 0x0800 +#define IOCHRDYE 0x1000 +#define RxDMAsize 0x2000 +#define EnableRQ 0x8000 + +/* PP_TestCTL */ +#define DisableLT 0x0080 +#define ENDECloop 0x0200 +#define AUIloop 0x0400 +#define DisableBackoff 0x0800 +#define FDX 0x4000 + +/* PP_ISQ */ +#define RegNum(x) ((x) & 0x3f) +#define RegContent(x) ((x) & ~0x3d) + +#define RxEvent 0x0004 +#define TxEvent 0x0008 +#define BufEvent 0x000c +#define RxMISS 0x0010 +#define TxCOL 0x0012 + +/* PP_RxStatus */ +#define IAHash 0x0040 +#define Dribblebits 0x0080 +#define RxOK 0x0100 +#define Hashed 0x0200 +#define IndividualAdr 0x0400 +#define Broadcast 0x0800 +#define CRCerror 0x1000 +#define Runt 0x2000 +#define Extradata 0x4000 + +#define HashTableIndex(x) ((x) >> 0xa) + +/* PP_TxCMD */ +#define After5 0 +#define After381 1 +#define After1021 2 +#define AfterAll 3 +#define TxStart(x) ((x) << 6) + +#define Force 0x0100 +#define Onecoll 0x0200 +#define InhibitCRC 0x1000 +#define TxPadDis 0x2000 + +/* PP_BusST */ +#define TxBidErr 0x0080 +#define Rdy4TxNOW 0x0100 + +/* PP_TxEvent */ +#define Loss_of_CRS 0x0040 +#define SQEerror 0x0080 +#define TxOK 0x0100 +#define Out_of_window 0x0200 +#define Jabber 0x0400 +#define T16coll 0x8000 + +#define TX_collisions(x) (((x) >> 0xb) & ~0x8000) + +/* PP_BufEvent */ +#define SWint 0x0040 +#define RxDMAFrame 0x0080 +#define Rdy4Tx 0x0100 +#define TxUnderrun 0x0200 +#define RxMiss 0x0400 +#define Rx128 0x0800 +#define RxDest 0x8000 + +/* PP_RxMISS */ +#define MissCount(x) ((x) >> 6) + +/* PP_TxCOL */ +#define ColCount(x) ((x) >> 6) + +/* PP_SelfST */ +#define T3VActive 0x0040 +#define INITD 0x0080 +#define SIBUSY 0x0100 +#define EEPROMpresent 0x0200 +#define EEPROMOK 0x0400 +#define ELpresent 0x0800 +#define EEsize 0x1000 + +/* PP_EEPROMCommand */ +#define EEWriteEnable 0x00F0 +#define EEWriteDisable 0x0000 +#define EEWriteRegister 0x0100 +#define EEReadRegister 0x0200 +#define EEEraseRegister 0x0300 +#define ELSEL 0x0400 + +#endif /* #ifndef CS8900_H */ diff -Nur linux-2.6.14/drivers/net/arm/Kconfig linux-2.6.14_cs8900/drivers/net/arm/Kconfig --- linux-2.6.14/drivers/net/arm/Kconfig 2005-10-28 08:02:08.000000000 +0800 +++ linux-2.6.14_cs8900/drivers/net/arm/Kconfig 2008-02-03 23:16:28.000000000 +0800 @@ -44,3 +44,11 @@ will generate a suitable hw address based on the board serial number (MTD support is required for this). Otherwise you will need to set a suitable hw address using ifconfig. +config ARM_CS8900 + tristate "CS8900 support" + depends on NET_ETHERNET && ARM && ARCH_SMDK2410 + help + Support for CS8900A chipset based Ethernet cards. If you have a network + (Ethernet) card of this type, say Y and read the Ethernet-HOWTO, available + from as well as .To compile this driver as a module, choose M here and read. + The module will be called cs8900.o. diff -Nur linux-2.6.14/drivers/net/arm/Makefile linux-2.6.14_cs8900/drivers/net/arm/Makefile --- linux-2.6.14/drivers/net/arm/Makefile 2005-10-28 08:02:08.000000000 +0800 +++ linux-2.6.14_cs8900/drivers/net/arm/Makefile 2008-02-03 23:44:15.000000000 +0800 @@ -8,3 +8,4 @@ obj-$(CONFIG_ARM_ETHERH) += etherh.o obj-$(CONFIG_ARM_ETHER3) += ether3.o obj-$(CONFIG_ARM_ETHER1) += ether1.o +obj-$(CONFIG_ARM_CS8900) += cs8900.o diff -Nur linux-2.6.14/include/asm-arm/arch-s3c2410/smdk2410.h linux-2.6.14_cs8900/include/asm-arm/arch-s3c2410/smdk2410.h --- linux-2.6.14/include/asm-arm/arch-s3c2410/smdk2410.h 1970-01-01 08:00:00.000000000 +0800 +++ linux-2.6.14_cs8900/include/asm-arm/arch-s3c2410/smdk2410.h 2008-02-03 23:05:36.000000000 +0800 @@ -0,0 +1,7 @@ +#ifndef _INCLUDE_SMDK2410_H_ +#define _INCLUDE_SMDK2410_H_ +#include +#define pSMDK2410_ETH_IO 0x19000000 +#define vSMDK2410_ETH_IO 0xE0000000 +#define SMDK2410_ETH_IRQ IRQ_EINT9 +#endif // _INCLUDE_SMDK2410_H_