dm9000x.c

linux-2.6.12下的百兆网卡芯片dm9000ae驱动程序

	reg_save = readb(db->io_addr);

	/* Disable all interrupts */
	iow(db, DMFE_IMR, IMR_PAR);

	/* Got DM9000 interrupt status */
	int_status = ior(db, DMFE_ISR);	/* Got ISR */
	iow(db, DMFE_ISR, int_status);	/* Clear ISR status */

	/* Received the coming packet */
	if (int_status & ISR_PRS)
		dmfe_rx(dev);

	/* Trnasmit Interrupt check */
	if (int_status & ISR_PTS)
		dmfe_tx_done(dev, db);

	/* Re-enable interrupt mask */
	iow(db, DMFE_IMR, IMR_PAR | IMR_PTM | IMR_PRM);

	/* Restore previous register address */
	writeb(reg_save, db->io_addr);

	spin_unlock(&db->lock);

//	scb9328_ledoff(4);
	return IRQ_HANDLED;
}

/*
 *  Get statistics from driver.
 */
static struct net_device_stats *
dmfe_get_stats(struct net_device *dev)
{
	board_info_t *db = (board_info_t *) dev->priv;
	return &db->stats;
}

/*
 *  Process the upper socket ioctl command
 */
static int
dmfe_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
	PRINTK1("entering %s\n",__FUNCTION__);
	return 0;
}

/*
 *  A periodic timer routine
 *  Dynamic media sense, allocated Rx buffer...
 */
static void
dmfe_timer(unsigned long data)
{
	struct net_device *dev = (struct net_device *) data;
	board_info_t *db = (board_info_t *) dev->priv;
	u8 reg_save;

	PRINTK3("dmfe_timer()\n");

	/* Save previous register address */
	reg_save = readb(db->io_addr);

	/* TX timeout check */
	if (dev->trans_start
	    && ((jiffies - dev->trans_start) > DMFE_TX_TIMEOUT)) {
		//printk("tx timeout\n");
		db->device_wait_reset = 1;
		db->reset_tx_timeout++;
	}

	/* DM9000 dynamic RESET check and do */
	if (db->device_wait_reset) {
		netif_stop_queue(dev);
		db->reset_counter++;
		db->device_wait_reset = 0;
		dev->trans_start = 0;
		dmfe_reset(db);
		dmfe_init_dm9000(dev);
		netif_wake_queue(dev);
	}

	mii_check_media(&db->mii, netif_msg_link(db), 0);

	/* Restore previous register address */
	writeb(reg_save, db->io_addr);

	/* Set timer again */
	db->timer.expires = DMFE_TIMER_WUT;
	add_timer(&db->timer);
}

#if 0
/* dump a packet to screen */
static void
dump_packet(unsigned char *buf, int len)
{
	int i = 0;
	printk("\n------------------------\n");
	while (i < len) {
		printk("%02x ", buf[i]);
		i++;
		if (!(i % 8))
			printk("\n");
	}

	printk("----------------------\n");
}
#endif

struct dm9000_rxhdr {
	u16	RxStatus;
	u16	RxLen;
} __attribute__((__packed__));

/*
 *  Received a packet and pass to upper layer
 */
static void
dmfe_rx(struct net_device *dev)
{
	board_info_t *db = (board_info_t *) dev->priv;
	struct dm9000_rxhdr rxhdr;
	struct sk_buff *skb;
	u8 rxbyte, *rdptr;
	int GoodPacket;
	int RxLen;

	/* Check packet ready or not */
	do {
		ior(db, DMFE_MRCMDX);	/* Dummy read */
		
		/* Get most updated data */
		rxbyte = readb(db->io_data);

		/* Status check: this byte must be 0 or 1 */
		if (rxbyte > DM9000_PKT_RDY) {
			printk("status check failed: %d\n", rxbyte);
			iow(db, DMFE_RCR, 0x00);	/* Stop Device */
			iow(db, DMFE_ISR, IMR_PAR);	/* Stop INT request */
			db->device_wait_reset = TRUE;
			db->reset_rx_status++;
			return;
		}

		if (rxbyte != DM9000_PKT_RDY)
			return;

		/* A packet ready now  & Get status/length */
		GoodPacket = TRUE;
		writeb(DMFE_MRCMD, db->io_addr);

		(db->inblk)(db->io_data, &rxhdr, sizeof(rxhdr));

		RxLen = rxhdr.RxLen;

		/* Packet Status check */
		if (RxLen < 0x40) {
			GoodPacket = FALSE;
			db->runt_length_counter++;
			PRINTK1("Bad Packet received (runt)\n");
		}

		if (RxLen > DM9000_PKT_MAX) {
			PRINTK1("RST: RX Len:%x\n", RxLen);
			db->device_wait_reset = TRUE;
			db->long_length_counter++;
		}

		if (rxhdr.RxStatus & 0xbf00) {
			GoodPacket = FALSE;
			if (rxhdr.RxStatus & 0x100) {
				PRINTK1("fifo error\n");
				db->stats.rx_fifo_errors++;
			}
			if (rxhdr.RxStatus & 0x200) {
				PRINTK1("crc error\n");
				db->stats.rx_crc_errors++;
			}
			if (rxhdr.RxStatus & 0x8000) {
				PRINTK1("length error\n");
				db->stats.rx_length_errors++;
			}
		}

		/* Move data from DM9000 */
		if (GoodPacket
		    && ((skb = dev_alloc_skb(RxLen + 4)) != NULL)) {
			skb->dev = dev;
			skb_reserve(skb, 2);
			rdptr = (u8 *) skb_put(skb, RxLen - 4);
			
			/* Read received packet from RX SRAM */
			
			(db->inblk)(db->io_data, rdptr, RxLen);

			/* Pass to upper layer */
			skb->protocol = eth_type_trans(skb, dev);
			netif_rx(skb);
			db->stats.rx_packets++;

		} else {
			/* need to dump the packet's data */
			
			(db->dumpblk)(db->io_data, RxLen);
		}
	} while (rxbyte == DM9000_PKT_RDY);
}

/*
 *  Read a word data from SROM
 */
static u16
read_srom_word(board_info_t * db, int offset)
{
	iow(db, DMFE_EPAR, offset);
	iow(db, DMFE_EPCR, EPCR_ERPRR);
	udelay(2000);		/* according to the datasheet 200us should be enough,
				   but it doesn't work */
	iow(db, DMFE_EPCR, 0x0);
	return (ior(db, DMFE_EPDRL) + (ior(db, DMFE_EPDRH) << 8));
}

#ifdef DM9000_PROGRAM_EEPROM
/*
 * Write a word data to SROM
 */
static void
write_srom_word(board_info_t * db, int offset, u16 val)
{
	iow(db, DMFE_EPAR, offset);
	iow(db, DMFE_EPDRH, ((val >> 8) & 0xff));
	iow(db, DMFE_EPDRL, (val & 0xff));
	iow(db, DMFE_EPCR, EPCR_WEP | EPCR_ERPRW);
	udelay(2000);		/* same shit */
	iow(db, DMFE_EPCR, 0);
}

/*
 * Only for development:
 * Here we write static data to the eeprom in case
 * we don't have valid content on a new board
 */
static void
program_eeprom(board_info_t * db)
{
	u16 eeprom[] = { 0x0c00, 0x007f, 0x1300,	/* MAC Address */
		0x0000,		/* Autoload: accept nothing */
		0x0a46, 0x9000,	/* Vendor / Product ID */
		0x0000,		/* pin control */
		0x0000,
	};			/* Wake-up mode control */
	int i;
	for (i = 0; i < 8; i++)
		write_srom_word(db, i, eeprom[i]);
}
#endif


/*
 *  Calculate the CRC valude of the Rx packet
 *  flag = 1 : return the reverse CRC (for the received packet CRC)
 *         0 : return the normal CRC (for Hash Table index)
 */

static unsigned long
cal_CRC(unsigned char *Data, unsigned int Len, u8 flag)
{

       u32 crc = ether_crc_le(Len, Data);

       if (flag)
               return ~crc;

       return crc;
}

/*
 *  Set DM9000 multicast address
 */
static void
dm9000_hash_table(struct net_device *dev)
{
	board_info_t *db = (board_info_t *) dev->priv;
	struct dev_mc_list *mcptr = dev->mc_list;
	int mc_cnt = dev->mc_count;
	u32 hash_val;
	u16 i, oft, hash_table[4];

	PRINTK2("dm9000_hash_table()\n");

	for (i = 0, oft = 0x10; i < 6; i++, oft++)
		iow(db, oft, dev->dev_addr[i]);

	/* Clear Hash Table */
	for (i = 0; i < 4; i++)
		hash_table[i] = 0x0;

	/* broadcast address */
	hash_table[3] = 0x8000;

	/* the multicast address in Hash Table : 64 bits */
	for (i = 0; i < mc_cnt; i++, mcptr = mcptr->next) {
		hash_val = cal_CRC((char *) mcptr->dmi_addr, 6, 0) & 0x3f;
		hash_table[hash_val / 16] |= (u16) 1 << (hash_val % 16);
	}

	/* Write the hash table to MAC MD table */
	for (i = 0, oft = 0x16; i < 4; i++) {
		iow(db, oft++, hash_table[i] & 0xff);
		iow(db, oft++, (hash_table[i] >> 8) & 0xff);
	}
}


/*
 *   Read a word from phyxcer
 */
static int
dmfe_phy_read(struct net_device *dev, int phy_reg_unused, int reg)
{
	board_info_t *db = (board_info_t *) dev->priv;

	/* Fill the phyxcer register into REG_0C */
	iow(db, DMFE_EPAR, DM9000_PHY | reg);

	iow(db, DMFE_EPCR, 0xc);	/* Issue phyxcer read command */
	udelay(100);		/* Wait read complete */
	iow(db, DMFE_EPCR, 0x0);	/* Clear phyxcer read command */

	/* The read data keeps on REG_0D & REG_0E */
	return (ior(db, DMFE_EPDRH) << 8) | ior(db, DMFE_EPDRL);
}

/*
 *   Write a word to phyxcer
 */
static void
dmfe_phy_write(struct net_device *dev, int phyaddr_unused, int reg, int value)
{
	board_info_t *db = (board_info_t *) dev->priv;
	/* Fill the phyxcer register into REG_0C */
	iow(db, DMFE_EPAR, DM9000_PHY | reg);

	/* Fill the written data into REG_0D & REG_0E */
	iow(db, DMFE_EPDRL, (value & 0xff));
	iow(db, DMFE_EPDRH, ((value >> 8) & 0xff));

	iow(db, DMFE_EPCR, 0xa);	/* Issue phyxcer write command */
	udelay(500);		/* Wait write complete */
	iow(db, DMFE_EPCR, 0x0);	/* Clear phyxcer write command */
}

MODULE_PARM(debug, "i");
MODULE_PARM(mode, "i");
MODULE_PARM(reg5, "i");
MODULE_PARM(reg9, "i");
MODULE_PARM(rega, "i");
MODULE_PARM(nfloor, "i");

static int
dmfe_drv_suspend(struct device *dev, u32 state, u32 level)
{
	struct net_device *ndev = dev_get_drvdata(dev);

	if (ndev && level == SUSPEND_DISABLE) {
		if (netif_running(ndev)) {
			netif_device_detach(ndev);
			dmfe_shutdown(ndev);
		}
	}
	return 0;
}

static int
dmfe_drv_resume(struct device *dev, u32 level)
{
	struct net_device *ndev = dev_get_drvdata(dev);
	board_info_t *db = (board_info_t *) ndev->priv;

	if (ndev && level == RESUME_ENABLE) {

		if (netif_running(ndev)) {
			dmfe_reset(db);
			dmfe_init_dm9000(ndev);

			netif_device_attach(ndev);
		}
	}
	return 0;
}

static int
dmfe_drv_remove(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct net_device *ndev = dev_get_drvdata(dev);

	dev_set_drvdata(dev, NULL);

	unregister_netdev(ndev);
	dmfe_release_board(pdev, (board_info_t *) ndev->priv);
	kfree(ndev);		/* free device structure */

	PRINTK1("clean_module() exit\n");

	return 0;
}

static struct device_driver dmfe_driver = {
	.name    = "dm9000",
	.bus     = &platform_bus_type,
	.probe   = dmfe_probe,
	.remove  = dmfe_drv_remove,
	.suspend = dmfe_drv_suspend,
	.resume  = dmfe_drv_resume,
};

static int __init
dmfe_init(void)
{
	if (debug)
		dmfe_debug = debug;	/* set debug flag */

	switch (mode) {
	case DM9000_10MHD:
	case DM9000_100MHD:
	case DM9000_10MFD:
	case DM9000_100MFD:
	case DM9000_1M_HPNA:
		media_mode = mode;
		break;
	default:
		media_mode = DM9000_AUTO;
	}

	nfloor = (nfloor > 15) ? 0 : nfloor;

	return driver_register(&dmfe_driver);	/* search board and register */
}

static void __exit
dmfe_cleanup(void)
{
	driver_unregister(&dmfe_driver);
}

module_init(dmfe_init);
module_exit(dmfe_cleanup);

MODULE_AUTHOR("Sascha Hauer, Ben Dooks");
MODULE_DESCRIPTION("Davicom DM9000 network driver");
MODULE_LICENSE("GPL");