/*
* 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/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
