cirrus.c

cs89000的驱动编写。很有助于新手学习。本人看了以后觉得受益非浅。在此与大家分享。希望有帮助。

	cirrus_write (dev,PP_BusCTL,0);
	cirrus_write (dev,PP_TestCTL,0);
	cirrus_write (dev,PP_SelfCTL,0);
	cirrus_write (dev,PP_LineCTL,0);
	cirrus_write (dev,PP_BufCFG,0);
	cirrus_write (dev,PP_TxCFG,0);
	cirrus_write (dev,PP_RxCTL,0);
	cirrus_write (dev,PP_RxCFG,0);

	/* uninstall interrupt handler */
	free_irq (dev->irq,dev);

	/* stop the queue */
	netif_stop_queue (dev);

	MOD_DEC_USE_COUNT;

	return (0);
}

static int cirrus_set_mac_address (struct net_device *dev, void *p)
{
	struct sockaddr *addr = (struct sockaddr *)p;
	int i;

	if (netif_running(dev))
		return -EBUSY;

	memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);

	/* configure MAC address */
	for (i = 0; i < ETH_ALEN; i += 2)
		cirrus_write (dev,PP_IA + i,dev->dev_addr[i] | (dev->dev_addr[i + 1] << 8));

	return 0;
}

static struct net_device_stats *cirrus_get_stats (struct net_device *dev)
{
	cirrus_t *priv = (cirrus_t *) dev->priv;
	return (&priv->stats);
}

static void cirrus_set_receive_mode (struct net_device *dev)
{
	if ((dev->flags & IFF_PROMISC))
		cirrus_set (dev,PP_RxCTL,PromiscuousA);
	else
		cirrus_clear (dev,PP_RxCTL,PromiscuousA);

	if ((dev->flags & IFF_ALLMULTI) && dev->mc_list)
		cirrus_set (dev,PP_RxCTL,MulticastA);
	else
		cirrus_clear (dev,PP_RxCTL,MulticastA);
}

static int cirrus_eeprom_wait (struct net_device *dev)
{
	int i;

	for (i = 0; i < 200; i++) {
		if (!(cirrus_read (dev,PP_SelfST) & SIBUSY))
			return (0);
		udelay (1);
	}

	return (-1);
}

static int cirrus_eeprom_read (struct net_device *dev,u16 *value,u16 offset)
{
	if (cirrus_eeprom_wait (dev) < 0)
		return (-1);

	cirrus_write (dev,PP_EEPROMCommand,offset | EEReadRegister);

	if (cirrus_eeprom_wait (dev) < 0)
		return (-1);

	*value = cirrus_read (dev,PP_EEPROMData);

	return (0);
}

static int cirrus_eeprom (struct net_device *dev,cirrus_eeprom_t *eeprom)
{
	u16 offset,buf[16],*word;
	u8 checksum = 0,*byte;

	if (cirrus_eeprom_read (dev,buf,0) < 0) {
		read_timed_out:
		printk (KERN_DEBUG "%s: EEPROM read timed out\n",dev->name);
		return (-ETIMEDOUT);
	}

	if ((buf[0] >> 8) != 0xa1) {
		printk (KERN_DEBUG "%s: No EEPROM present\n",dev->name);
		return (-ENODEV);
	}

	if ((buf[0] & 0xff) < sizeof (buf)) {
		eeprom_too_small:
		printk (KERN_DEBUG "%s: EEPROM too small\n",dev->name);
		return (-ENODEV);
	}

	for (offset = 1; offset < (buf[0] & 0xff); offset++) {
		if (cirrus_eeprom_read (dev,buf + offset,offset) < 0)
			goto read_timed_out;

		if (buf[offset] == 0xffff)
			goto eeprom_too_small;
	}

	if (buf[1] != 0x2020) {
		printk (KERN_DEBUG "%s: Group Header #1 mismatch\n",dev->name);
		return (-EIO);
	}

	if (buf[5] != 0x502c) {
		printk (KERN_DEBUG "%s: Group Header #2 mismatch\n",dev->name);
		return (-EIO);
	}

	if (buf[12] != 0x2158) {
		printk (KERN_DEBUG "%s: Group Header #3 mismatch\n",dev->name);
		return (-EIO);
	}

	eeprom->io_base = buf[2];
	eeprom->irq = buf[3];
	eeprom->dma = buf[4];
	eeprom->mem_base = (buf[7] << 16) | buf[6];
	eeprom->rom_base = (buf[9] << 16) | buf[8];
	eeprom->rom_mask = (buf[11] << 16) | buf[10];

	word = (u16 *) eeprom->mac;
	for (offset = 0; offset < 3; offset++) word[offset] = buf[13 + offset];

	byte = (u8 *) buf;
	for (offset = 0; offset < sizeof (buf); offset++) checksum += byte[offset];

	if (cirrus_eeprom_read (dev,&offset,0x10) < 0)
		goto read_timed_out;

	if ((offset >> 8) != (u8) (0x100 - checksum)) {
		printk (KERN_DEBUG "%s: Checksum mismatch (expected 0x%.2x, got 0x%.2x instead\n",
				dev->name,
				(u8) (0x100 - checksum),
				offset >> 8);
		return (-EIO);
	}

	return (0);
}

/*
 * Architecture dependant code
 */

#ifdef CONFIG_SA1100_FRODO
static void frodo_reset (struct net_device *dev)
{
	int i;
	volatile u16 value;

	/* reset ethernet controller */
	FRODO_CPLD_ETHERNET |= FRODO_ETH_RESET;
	mdelay (50);
	FRODO_CPLD_ETHERNET &= ~FRODO_ETH_RESET;
	mdelay (50);

	/* we tied SBHE to CHIPSEL, so each memory access ensure the chip is in 16-bit mode */
	for (i = 0; i < 3; i++) value = cirrus_read (dev,0);

	/* FIXME: poll status bit */
}
#endif	/* #ifdef CONFIG_SA1100_FRODO */

/*
 * Driver initialization routines
 */

void  __init reset_chip(struct net_device *dev)
{
    int reset_start_time;

    cirrus_write(dev, PP_SelfCTL, cirrus_read(dev, PP_SelfCTL) | RESET);

    /* wait 30 ms */
    current->state = TASK_INTERRUPTIBLE;
    schedule_timeout(30*HZ/1000);

    /* Wait until the chip is reset */
    reset_start_time = jiffies;
    while( (cirrus_read(dev, PP_SelfST) & INITD) == 0 &&
	   jiffies - reset_start_time < 4)
      ;
}

static int io = 0;
static int irq = 0;

static u32 WaitNFBusy(void)	// R/B 未接好?
{
	u8 stat;
	
	__raw_writel(0x70, S3C2410_NFCMD);
	do {
		stat = __raw_readl(S3C2410_NFSTAT)&1;
		//printk("%x\n", stat);
	}while(!stat);
	__raw_writel(0, S3C2410_NFCMD);
	return stat;
}

static void ReadPage(u32 addr, u8 *buf)
{
	u32 i;
	
	__raw_writel(__raw_readl(S3C2410_NFCONF)|(1<<15)|(1<<12)|(1<<11)|(7<<8)|(7<<4)|(7), S3C2410_NFCONF); //InitNandCfg
	__raw_writel(__raw_readl(S3C2410_NFCONF)&(~0x800), S3C2410_NFCONF);//0 : NAND flash nFCE = L (active)
	__raw_writel(0, S3C2410_NFCMD);
	__raw_writel(0, S3C2410_NFADDR);
	__raw_writel(addr, S3C2410_NFADDR);
	__raw_writel(addr>>8, S3C2410_NFADDR);
	__raw_writel(addr>>16, S3C2410_NFADDR);
	//__raw_writel(__raw_readl(S3C2410_NFCONF)| 0x1000, S3C2410_NFCONF);//InitEcc();
	WaitNFBusy();	
	for(i=0; i<512; i++)
		buf[i] = __raw_readl(S3C2410_NFDATA)& 0xff;
	__raw_writel(__raw_readl(S3C2410_NFCONF)|0x800, S3C2410_NFCONF);
}

int __init cirrus_probe (struct net_device *dev)
{
	u8 str[512];
	static cirrus_t priv;
	int i,result;
	u16 value;
	cirrus_eeprom_t eeprom;
		
	printk ("Cirrus Logic CS8900A driver for Linux (V0.02)\n");
	memset(&priv,0,sizeof(cirrus_t));
	dev->priv      = (void *) &priv;
	SET_MODULE_OWNER (dev);
	if (!request_region (dev->base_addr,16,dev->name)) {
		printk (KERN_ERR "%s: can't get I/O port address 0x%lx\n",dev->name,dev->base_addr);
		return -EBUSY;
	}

	sprintf(dev->name, "eth%d", unit);
	netdev_boot_setup_check(dev);
	io = dev->base_addr;
	irq = dev->irq;
        ReadPage(0x160,str);
        for(i=0; i<12; i++){
		if((str[i]-'0'>=0)&&(str[i]-'0'<=9))
		   str[i] -='0';
		else if((str[i]-'a'>=0)&&(str[i]-'a'<=5))
		   str[i] -=87;
		else if((str[i]-'A'>=0)&&(str[i]-'A'<=5))
		   str[i] -=55;
	}
        dev->dev_addr[0] = str[1]|(str[0]<<4);
        dev->dev_addr[1] = str[3]|(str[2]<<4);
        dev->dev_addr[2] = str[5]|(str[4]<<4);
        dev->dev_addr[3] = str[7]|(str[6]<<4);
        dev->dev_addr[4] = str[9]|(str[8]<<4);
        dev->dev_addr[5] = str[11]|(str[10]<<4);
	dev->if_port   = IF_PORT_10BASET;
	dev->base_addr = CIRRUS_IOADDR;
	dev->irq = CIRRUS_IRQ;

	/* module parameters override everything */
	if (io > 0) dev->base_addr = io;
	if (irq > 0) dev->irq = irq;

	if (!dev->base_addr) {
		printk (KERN_ERR
				"%s: No default I/O base address defined. Use io=... or\n"
				"%s: define CIRRUS_DEFAULT_IO for your platform\n",
				dev->name,dev->name);
		return (-EINVAL);
	}

	if (!dev->irq) {
		printk (KERN_ERR
				"%s: No default IRQ number defined. Use irq=... or\n"
				"%s: define CIRRUS_DEFAULT_IRQ for your platform\n",
				dev->name,dev->name);
		return (-EINVAL);
	}

#ifdef CONFIG_SA1100_FRODO
	frodo_reset (dev);
#endif	/* #ifdef CONFIG_SA1100_FRODO */

	reset_chip(dev);

	/* if an EEPROM is present, use it's MAC address */
	if (!cirrus_eeprom (dev,&eeprom))
		for (i = 0; i < 6; i++)
			dev->dev_addr[i] = eeprom.mac[i];

	/* verify EISA registration number for Cirrus Logic */
	if ((value = cirrus_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 = cirrus_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);
	}
	printk (KERN_INFO "%s: CS8900A rev %c detected\n",dev->name,'B' + REVISION (value) - REV_B);

	/* setup interrupt number */
	cirrus_write (dev,PP_IntNum,0);

	/* configure MAC address */
	for (i = 0; i < ETH_ALEN; i += 2)
		cirrus_write (dev,PP_IA + i,dev->dev_addr[i] | (dev->dev_addr[i + 1] << 8));
	
	dev->open               = cirrus_start;
	dev->stop               = cirrus_stop;
	dev->hard_start_xmit    = cirrus_send_start;
	dev->get_stats          = cirrus_get_stats;
	dev->set_multicast_list = cirrus_set_receive_mode;
	dev->set_mac_address	= cirrus_set_mac_address;
	dev->tx_timeout         = cirrus_transmit_timeout;
	dev->watchdog_timeo     = HZ;
	
	ether_setup(dev); 
	return (0);
}

EXPORT_NO_SYMBOLS;

static struct net_device dev;

static int __init cirrus_init (void)
{
	struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
		struct net_local *lp;
		int ret = 0;
	
		if (!dev)
			return -ENOMEM;
	
		dev->irq = irq;
		dev->base_addr = io;
		lp = netdev_priv(dev);
	
#if ALLOW_DMA
		if (use_dma) {
			lp->use_dma = use_dma;
			lp->dma = dma;
			lp->dmasize = dmasize;
		}
#endif
	
		spin_lock_init(&lp->lock);
	
	
			/* boy, they'd better get these right */
			if (!strcmp(media, "rj45"))
			lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
		else if (!strcmp(media, "aui"))
			lp->adapter_cnf = A_CNF_MEDIA_AUI	| A_CNF_AUI;
		else if (!strcmp(media, "bnc"))
			lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
		else
			lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
	
			if (duplex==-1)
			lp->auto_neg_cnf = AUTO_NEG_ENABLE;
			
			if (io == 0) {
							printk(KERN_ERR "cirrus.c: Module autoprobing not allowed.\n");
							printk(KERN_ERR "cirrus.c: Append io=0xNNN\n");
							ret = -EPERM;
					goto out;
					} else if (io <= 0x1ff) {
					ret = -ENXIO;
					goto out;
				}
			
#if ALLOW_DMA
				if (use_dma && dmasize != 16 && dmasize != 64) {
					printk(KERN_ERR "cs89x0.c: dma size must be either 16K or 64K, not %dK\n", dmasize);
					ret = -EPERM;
					goto out;
				}
#endif
	unsigned long extint1;
		extint1 = __raw_readl(S3C2410_EXTINT1);
		extint1 &= ~(7<<4);
		extint1 |= (4<<4);
		__raw_writel(extint1, S3C2410_EXTINT1);
	memset (&dev,0,sizeof (struct net_device));
	dev.init = cirrus_probe;
	return (register_netdev (&dev));
out:
	free_netdev(dev);
	return ret;
}

static void __exit cirrus_cleanup (void)
{
	unregister_netdev (&dev);
	writeword(dev->base_addr, ADD_PORT, PP_ChipID);
	release_region (dev.base_addr,16);
	free_netdev(dev);
}

MODULE_AUTHOR ("Abraham van der Merwe <[e-mail]>");
MODULE_DESCRIPTION ("Cirrus Logic CS8900A driver for Linux (V0.02)");
MODULE_LICENSE ("GPL");
MODULE_PARM_DESC (io,"I/O Base Address");
MODULE_PARM (io,"i");
MODULE_PARM_DESC (irq,"IRQ Number");
MODULE_PARM (irq,"i");

module_init (cirrus_init);
module_exit (cirrus_cleanup);