📄 cs8900网卡移植.txt
字号:
/*
* 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; /*然后在drivers/net/arm/Kconfig中添加了
config ARM_CS8900
tristate "CS8900 support"
depends on NET_ETHERNET && ARM && ARCH_SMDK2410
在drivers/net/arm/Makefile中添加了
obj-$(CONFIG_ARM_CS8900) += cs8900.o
include/asm-arm/arch-s3c2410目录下创建了一个文件smdk2410.h
#ifndef _INCLUDE_SMDK2410_H_
#define _INCLUDE_SMDK2410_H_
#include <linux/config.h>
#define SMDK2410_ETH_IO 0xE0000000
#define SMDK2410_ETH_IRQ IRQ_EINT9
#endif // _INCLUDE_SMDK2410_H_
*/
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);
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -