cs8900.c

QQ2440下的cs8900的驱动代码。

 
#define VERSION_STRING "Cirrus Logic CS8900A driver for Linux (Modified for SMDK2410)"


// 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_ARCH_QQ2440
#include "asm/arch/sbc2440v3-map.h"
#include <asm/arch/regs-mem.h>
#endif

#ifdef CONFIG_ARCH_SMDK2410
//#include "asm/arch/smdk2410.h"
#include <asm/arch/regs-mem.h>
#endif

#include "cs8900.h"

static char cirrus_mac[18] = "08:00:3e:21:c7:f7";

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
};



/*
 * I/O routines
 */

static inline u16 cs8900_read (struct net_device *dev,u16 reg)
{
	outw (reg,dev->base_addr + PP_Address);//void outw(unsigned char data, unsigned short port) write,把要读的reg先写到address上，再从data口读出来。这样就能达到读的效果。
	return (inw (dev->base_addr + PP_Data));//unsigned inw(unsigned short port)                 read
}

static inline void cs8900_write (struct net_device *dev,u16 reg,u16 value)
{
	outw (reg,dev->base_addr + PP_Address);//把要写的寄存器写到address，再把value写到data上，这样就能达到对cs8900芯片的reg寄存器进行控制。
	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);
}



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);
	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);

	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)|defined(CONFIG_ARCH_QQ2440)
	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 int cs8900_set_mac_address (struct net_device *dev, void *p)
{
        cs8900_t *priv = netdev_priv(dev);
        struct sockaddr *addr = (struct sockaddr *)p;
        int i;
                  
        if (netif_running(dev))
                return -EBUSY;
                                                                                                 
        spin_lock(&priv->lock);
                                                                                                 
        memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
                                                                                                 
        /* configure MAC address */
        for (i = 0; i < ETH_ALEN; i += 2)
                cs8900_write (dev,PP_IA + i,dev->dev_addr[i] | (dev->dev_addr[i + 1] << 8));
                                                                                                 
        spin_unlock(&priv->lock);
                                                                                                 
        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);
}





/*
 * Architecture dependant code
 */



/*
 * Driver initialization routines
 */
void cirrus_parse_mac (const char *macstr, char *mac)
{
        int i;
        if (strlen(macstr) != 17)
                printk("invalid MAC string format\n");
        for (i = 0; i < 6; i++) {
                mac[i] = simple_strtoul(macstr + i * 3, NULL, 16);
        }
}

int __init cs8900_probe (struct net_device *dev)
{
	static cs8900_t  ;
	int result;
	u16 value;
	struct cs8900_t *priv;
	printk (VERSION_STRING"\n");

	memset (&priv,0,sizeof (cs8900_t));

	__raw_writel(0x2211d110,S3C2410_BWSCON);
	__raw_writel(0x1f7c,S3C2410_BANKCON3);
	ether_setup (dev);

	dev->open               = 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->set_mac_address    = cs8900_set_mac_address;
	dev->tx_timeout         = cs8900_transmit_timeout;
	dev->watchdog_timeo     = HZ;

	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] = 0x5c;
	cirrus_parse_mac(cirrus_mac, dev->dev_addr);
	dev->if_port   = IF_PORT_10BASET;
	dev->priv      = (void *) &priv;

	//spin_lock_init(&priv.lock);

	SET_MODULE_OWNER (dev);

	dev->base_addr = vSMDK2410_ETH_IO + 0x300;
	dev->irq = SMDK2410_ETH_IRQ;

//int check_mem_region( unsigned long from, unsigned long extent);
	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);
	}
//void request_mem_region( unsigned long from, unsigned long extent, sonst char *name);
	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 */
	char CS8900, CS8920M;
	cs8900_write (dev,PP_IntNum,0);
	printk(KERN_INFO "%s:cs89%c0%s rev %c(%s) found at %#3lx\n",
	dev->name,
	VERSION (value) == CS8900 ? '0':'2',
	VERSION (value) == CS8920M ? "M":"",
	VERSION (value),
	cs8900(dev, PP_SelfST)&	0x0136 ? "3.3volts":"5volts",
	dev->base_addr);
	printk(KERN_INFO "probe successfuuly!! \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;
	release_mem_region (cs8900_dev.base_addr,16);
	unregister_netdev (&cs8900_dev);
}

MODULE_AUTHOR ("Abraham van der Merwe <abraham at 2d3d.co.za>");
MODULE_DESCRIPTION (VERSION_STRING);
MODULE_LICENSE ("GPL");

module_init (cs8900_init);
module_exit (cs8900_cleanup);