cs89x0.c

Linux系统CS网卡驱动

		if (lp->chip_type == CS8900) {
			/* the table that follows is dependent upon how you wired up your cs8900
			 * in your system.  The table is the same as the cs8900 engineering demo
			 * board.  irq_map also depends on the contents of the table.  Also see
			 * write_irq, which is the reverse mapping of the table below. */
			switch(i) {
			case 0: i = 10; break;
			case 1: i = 11; break;
			case 2: i = 12; break;
			case 3: i =  5; break;
			default: printk("\n" KERN_WARNING "cs89x0: bug: isa_config is %d\n", i);
			}
			lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */
		} else {
			int irq_map_buff[IRQ_MAP_LEN/2];

			if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
					    IRQ_MAP_LEN/2,
					    irq_map_buff) >= 0) {
				if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
					lp->irq_map = (irq_map_buff[0]>>8) | (irq_map_buff[1] << 8);
			}
		}
		if (!dev->irq)
			dev->irq = i;
	}

	printk(" IRQ %d,", dev->irq);

#if ALLOW_DMA
	get_dma_channel(dev);
#endif;

	/* print the ethernet address. */
	for (i = 0; i < ETH_ALEN; i++)
		printk(" %2.2x", dev->dev_addr[i]);

	/* Grab the region so we can find another board if autoIRQ fails. */
	request_region(ioaddr, NETCARD_IO_EXTENT,"cs89x0");

	dev->open		= net_open;
	dev->stop		= net_close;
	dev->hard_start_xmit = net_send_packet;
	dev->get_stats	= net_get_stats;
	dev->set_multicast_list = &set_multicast_list;
	dev->set_mac_address = &set_mac_address;

	/* Fill in the fields of the device structure with ethernet values. */
	ether_setup(dev);

	printk("\n");

	return 0;
}

#if 0

static void
print_registers(struct device *dev)
{
	int value;
	int ioaddr = dev->base_addr;

	printk("cs89x0: PP_RxCFG:");
	value = readreg(dev, PP_RxCFG);
	printk(" %sSKIP_1", value & SKIP_1?"":"~");
	printk(" %sRX_STREAM_ENBL", value & RX_STREAM_ENBL?"":"~");
	printk(" %sRX_OK_ENBL", value & RX_OK_ENBL?"":"~");
	printk(" %sRX_DMA_ONLY", value & RX_DMA_ONLY?"":"~");
	printk(" %sAUTO_RX_DMA", value & AUTO_RX_DMA?"":"~");
	printk(" %sBUFFER_CRC", value & BUFFER_CRC?"":"~");
	printk(" %sRX_CRC_ERROR_ENBL", value & RX_CRC_ERROR_ENBL?"":"~");
	printk(" %sRX_RUNT_ENBL", value & RX_RUNT_ENBL?"":"~");
	printk(" %sRX_EXTRA_DATA_ENBL", value & RX_EXTRA_DATA_ENBL?"":"~");
	printk("\n");

	printk("cs89x0: PP_RxCTL:");
	value = readreg(dev, PP_RxCTL);
	printk(" %sRX_IA_HASH_ACCEPT", value & RX_IA_HASH_ACCEPT?"":"~");
	printk(" %sRX_PROM_ACCEPT", value & RX_PROM_ACCEPT?"":"~");
	printk(" %sRX_OK_ACCEPT", value & RX_OK_ACCEPT?"":"~");
	printk(" %sRX_MULTCAST_ACCEPT", value & RX_MULTCAST_ACCEPT?"":"~");
	printk(" %sRX_IA_ACCEPT", value & RX_IA_ACCEPT?"":"~");
	printk(" %sRX_BROADCAST_ACCEPT", value & RX_BROADCAST_ACCEPT?"":"~");
	printk(" %sRX_BAD_CRC_ACCEPT", value & RX_BAD_CRC_ACCEPT?"":"~");
	printk(" %sRX_RUNT_ACCEPT", value & RX_RUNT_ACCEPT?"":"~");
	printk(" %sRX_EXTRA_DATA_ACCEPT", value & RX_EXTRA_DATA_ACCEPT?"":"~");
	printk("\n");

	printk("cs89x0: PP_TxCFG:");
	value = readreg(dev, PP_TxCFG);
	printk(" %sTX_LOST_CRS_ENBL", value & TX_LOST_CRS_ENBL?"":"~");
	printk(" %sTX_SQE_ERROR_ENBL", value & TX_SQE_ERROR_ENBL?"":"~");
	printk(" %sTX_OK_ENBL", value & TX_OK_ENBL?"":"~");
	printk(" %sTX_LATE_COL_ENBL", value & TX_LATE_COL_ENBL?"":"~");
	printk(" %sTX_JBR_ENBL", value & TX_JBR_ENBL?"":"~");
	printk(" %sTX_ANY_COL_ENBL", value & TX_ANY_COL_ENBL?"":"~");
	printk(" %sTX_16_COL_ENBL", value & TX_16_COL_ENBL?"":"~");
	printk("\n");

	printk("cs89x0: PP_TxCMD:");
	value = readreg(dev, PP_TxCMD);
	switch(value & TX_START_ALL_BYTES) {
	case TX_START_4_BYTES:	printk(" TX_START_4_BYTES"); break;
	case TX_START_64_BYTES:	printk(" TX_START_64_BYTES"); break;
	case TX_START_128_BYTES:	printk(" TX_START_128_BYTES"); break;
	case TX_START_ALL_BYTES:	printk(" TX_START_ALL_BYTES"); break;
	}
	printk(" %sTX_FORCE", value & TX_FORCE?"":"~");
	printk(" %sTX_ONE_COL", value & TX_ONE_COL?"":"~");
	printk(" %sTX_TWO_PART_DEFF_DISABLE", value & TX_TWO_PART_DEFF_DISABLE?"":"~");
	printk(" %sTX_NO_CRC", value & TX_NO_CRC?"":"~");
	printk(" %sTX_RUNT", value & TX_RUNT?"":"~");
	printk("\n");

	printk("cs89x0: PP_BufCFG:");
	value = readreg(dev, PP_BufCFG);
	printk(" %sGENERATE_SW_INTERRUPT", value & GENERATE_SW_INTERRUPT?"":"~");
	printk(" %sRX_DMA_ENBL", value & RX_DMA_ENBL?"":"~");
	printk(" %sREADY_FOR_TX_ENBL", value & READY_FOR_TX_ENBL?"":"~");
	printk(" %sTX_UNDERRUN_ENBL", value & TX_UNDERRUN_ENBL?"":"~");
	printk(" %sRX_MISS_ENBL", value & RX_MISS_ENBL?"":"~");
	printk(" %sRX_128_BYTE_ENBL", value & RX_128_BYTE_ENBL?"":"~");
	printk(" %sTX_COL_COUNT_OVRFLOW_ENBL", value & TX_COL_COUNT_OVRFLOW_ENBL?"":"~");
	printk(" %sRX_MISS_COUNT_OVRFLOW_ENBL", value & RX_MISS_COUNT_OVRFLOW_ENBL?"":"~");
	printk(" %sRX_DEST_MATCH_ENBL", value & RX_DEST_MATCH_ENBL?"":"~");
	printk("\n");

	printk("cs89x0: PP_LineCTL:");
	value = readreg(dev, PP_LineCTL);
	printk(" %sSERIAL_RX_ON", value & SERIAL_RX_ON?"":"~");
	printk(" %sSERIAL_TX_ON", value & SERIAL_TX_ON?"":"~");
	printk(" %sAUI_ONLY", value & AUI_ONLY?"":"~");
	printk(" %sAUTO_AUI_10BASET", value & AUTO_AUI_10BASET?"":"~");
	printk(" %sMODIFIED_BACKOFF", value & MODIFIED_BACKOFF?"":"~");
	printk(" %sNO_AUTO_POLARITY", value & NO_AUTO_POLARITY?"":"~");
	printk(" %sTWO_PART_DEFDIS", value & TWO_PART_DEFDIS?"":"~");
	printk(" %sLOW_RX_SQUELCH", value & LOW_RX_SQUELCH?"":"~");
	printk("\n");

	printk("cs89x0: PP_SelfCTL:");
	value = readreg(dev, PP_SelfCTL);
	printk(" %sPOWER_ON_RESET", value & POWER_ON_RESET?"":"~");
	printk(" %sSW_STOP", value & SW_STOP?"":"~");
	printk(" %sSLEEP_ON", value & SLEEP_ON?"":"~");
	printk(" %sAUTO_WAKEUP", value & AUTO_WAKEUP?"":"~");
	printk(" %sHCB0_ENBL", value & HCB0_ENBL?"":"~");
	printk(" %sHCB1_ENBL", value & HCB1_ENBL?"":"~");
	printk(" %sHCB0", value & HCB0?"":"~");
	printk(" %sHCB1", value & HCB1?"":"~");
	printk("\n");

	printk("cs89x0: PP_BusCTL:");
	value = readreg(dev, PP_BusCTL);
	printk(" %sRESET_RX_DMA", value & RESET_RX_DMA?"":"~");
	printk(" %sMEMORY_ON", value & MEMORY_ON?"":"~");
	printk(" %sDMA_BURST_MODE", value & DMA_BURST_MODE?"":"~");
	printk(" %sIO_CHANNEL_READY_ON", value & IO_CHANNEL_READY_ON?"":"~");
	printk(" %sRX_DMA_SIZE_64K", value & RX_DMA_SIZE_64K?"":"~");
	printk(" %sENABLE_IRQ", value & ENABLE_IRQ?"":"~");
	printk("\n");

	printk("cs89x0: PP_TestCTL:");
	value = readreg(dev, PP_TestCTL);
	printk(" %sLINK_OFF", value & LINK_OFF?"":"~");
	printk(" %sENDEC_LOOPBACK", value & ENDEC_LOOPBACK?"":"~");
	printk(" %sAUI_LOOPBACK", value & AUI_LOOPBACK?"":"~");
	printk(" %sBACKOFF_OFF", value & BACKOFF_OFF?"":"~");
	printk(" %sFAST_TEST", value & FAST_TEST?"":"~");
	printk("\n");

	printk("cs89x0: PP_RxEvent:");
	value = readreg(dev, PP_RxEvent);
	printk(" %sRX_IA_HASHED", value & RX_IA_HASHED?"":"~");
	printk(" %sRX_DRIBBLE", value & RX_DRIBBLE?"":"~");
	printk(" %sRX_OK", value & RX_OK?"":"~");
	printk(" %sRX_HASHED", value & RX_HASHED?"":"~");
	printk(" %sRX_IA", value & RX_IA?"":"~");
	printk(" %sRX_BROADCAST", value & RX_BROADCAST?"":"~");
	printk(" %sRX_CRC_ERROR", value & RX_CRC_ERROR?"":"~");
	printk(" %sRX_RUNT", value & RX_RUNT?"":"~");
	printk(" %sRX_EXTRA_DATA", value & RX_EXTRA_DATA?"":"~");
	printk("\n");

	printk("cs89x0: PP_TxEvent:");
	value = readreg(dev, PP_TxEvent);
	printk(" %sTX_LOST_CRS", value & TX_LOST_CRS?"":"~");
	printk(" %sTX_SQE_ERROR", value & TX_SQE_ERROR?"":"~");
	printk(" %sTX_OK", value & TX_OK?"":"~");
	printk(" %sTX_LATE_COL", value & TX_LATE_COL?"":"~");
	printk(" %sTX_JBR", value & TX_JBR?"":"~");
	printk(" %sTX_16_COL", value & TX_16_COL?"":"~");
	printk(" %sTX_SEND_OK_BITS", value & TX_SEND_OK_BITS?"":"~");
	printk(" %sTX_COL_COUNT_MASK", value & TX_COL_COUNT_MASK?"":"~");
	printk("\n");

	printk("cs89x0: PP_BufEvent:");
	value = readreg(dev, PP_BufEvent);
	printk(" %sSW_INTERRUPT", value & SW_INTERRUPT?"":"~");
	printk(" %sRX_DMA", value & RX_DMA?"":"~");
	printk(" %sREADY_FOR_TX", value & READY_FOR_TX?"":"~");
	printk(" %sTX_UNDERRUN", value & TX_UNDERRUN?"":"~");
	printk(" %sRX_MISS", value & RX_MISS?"":"~");
	printk(" %sRX_128_BYTE", value & RX_128_BYTE?"":"~");
	printk(" %sTX_COL_OVRFLW", value & TX_COL_OVRFLW?"":"~");
	printk(" %sRX_MISS_OVRFLW", value & RX_MISS_OVRFLW?"":"~");
	printk(" %sRX_DEST_MATCH", value & RX_DEST_MATCH?"":"~");
	printk("\n");

	printk("cs89x0: PP_LineST:");
	value = readreg(dev, PP_LineST);
	printk(" %sLINK_OK", value & LINK_OK?"":"~");
	printk(" %sAUI_ON", value & AUI_ON?"":"~");
	printk(" %sTENBASET_ON", value & TENBASET_ON?"":"~");
	printk(" %sPOLARITY_OK", value & POLARITY_OK?"":"~");
	printk(" %sCRS_OK", value & CRS_OK?"":"~");
	printk("\n");

	printk("cs89x0: PP_SelfST:");
	value = readreg(dev, PP_SelfST);
	printk(" %sACTIVE_33V", value & ACTIVE_33V?"":"~");
	printk(" %sINIT_DONE", value & INIT_DONE?"":"~");
	printk(" %sSI_BUSY", value & SI_BUSY?"":"~");
	printk(" %sEEPROM_PRESENT", value & EEPROM_PRESENT?"":"~");
	printk(" %sEEPROM_OK", value & EEPROM_OK?"":"~");
	printk(" %sEL_PRESENT", value & EL_PRESENT?"":"~");
	printk(" %sEE_SIZE_64", value & EE_SIZE_64?"":"~");
	printk("\n");

	printk("cs89x0: PP_BusST:");
	value = readreg(dev, PP_BusST);
	printk(" %sTX_BID_ERROR", value & TX_BID_ERROR?"":"~");
	printk(" %sREADY_FOR_TX_NOW", value & READY_FOR_TX_NOW?"":"~");
	printk("\n");

	printk("cs89x0: PP_AutoNegCTL:");
	value = readreg(dev, PP_AutoNegCTL);
	printk(" %sRE_NEG_NOW", value & RE_NEG_NOW?"":"~");
	printk(" %sALLOW_FDX", value & ALLOW_FDX?"":"~");
	printk(" %sAUTO_NEG_ENABLE", value & AUTO_NEG_ENABLE?"":"~");
	printk(" %sNLP_ENABLE", value & NLP_ENABLE?"":"~");
	printk(" %sFORCE_FDX", value & FORCE_FDX?"":"~");
	printk(" %sAUTO_NEG_BITS", value & AUTO_NEG_BITS?"":"~");
	printk(" %sAUTO_NEG_MASK", value & AUTO_NEG_MASK?"":"~");
	printk("\n");

	printk("cs89x0: PP_AutoNegST:");
	value = readreg(dev, PP_AutoNegST);
	printk(" %sAUTO_NEG_BUSY", value & AUTO_NEG_BUSY?"":"~");
	printk(" %sFLP_LINK", value & FLP_LINK?"":"~");
	printk(" %sFLP_LINK_GOOD", value & FLP_LINK_GOOD?"":"~");
	printk(" %sLINK_FAULT", value & LINK_FAULT?"":"~");
	printk(" %sHDX_ACTIVE", value & HDX_ACTIVE?"":"~");
	printk(" %sFDX_ACTIVE", value & FDX_ACTIVE?"":"~");
	printk("\n");

	if (0) { int i;
	for (i = 0x158; i < 0x15e; i++) {
		outw(i, ioaddr + ADD_PORT);
		if ((i & 0x7) == 0)
			printk("%04x:", i);
		printk(" %04x", inw(ioaddr + DATA_PORT));
		if ((i & 0x7) == 0x7)
			printk("\n");
	}
	}

#if ALLOW_DMA
	if (dev->dma) { int i;
	struct net_local *lp = (struct net_local *)dev->priv;

	for (i = 0; i < 0x100; i++) {
		if ((i & 0xf) == 0)
			printk("%04x:", i);
		printk(" %02x", lp->dma_buff[i]);
		if ((i & 0xf) == 0xf)
			printk("\n");
	}
	}
	printk("\n");
#endif
}

static void
print_packet_page(int ioaddr)
{
	int i;

	for (i = 0x100; i < 0x140; i++) {
		outw(i, ioaddr + ADD_PORT);
		if ((i & 0x7) == 0)
			printk("%04x:", i);
		printk(" %04x", inw(ioaddr + DATA_PORT));
		if ((i & 0x7) == 0x7)
			printk("\n");
	}
}
#endif

/*******************************************************
 * This page contains DMA routines that are either enabled or disabled
 * by ALLOW_DMA.
 *******************************************************/

#define dma_page_eq(ptr1, ptr2) ((long)(ptr1)>>17 == (long)(ptr2)>>17)

static void
get_dma_channel(struct device *dev)
{
#if ALLOW_DMA
	struct net_local *lp = (struct net_local *)dev->priv;

	if (lp->dma) {
		dev->dma = lp->dma;
		lp->isa_config |= ISA_RxDMA;
	} else {
		if ((lp->isa_config & ANY_ISA_DMA) == 0)
			return;
		dev->dma = lp->isa_config & DMA_NO_MASK;
		if (lp->chip_type == CS8900)
			dev->dma += 5;
		if (dev->dma < 5 || dev->dma > 7) {
			lp->isa_config &= ~ANY_ISA_DMA;
			return;
		}
	}
	printk(" DMA %d,", dev->dma);
	return;
#endif
}

static void
write_dma(struct device *dev, int chip_type, int dma)
{
	struct net_local *lp = (struct net_local *)dev->priv;

#if ALLOW_DMA
	if ((lp->isa_config & ANY_ISA_DMA) == 0)
		return;
	if (chip_type == CS8900) {
		writereg(dev, PP_CS8900_ISADMA, dma-5);
	} else {
		writereg(dev, PP_CS8920_ISADMA, dma);
	}
#endif
}

static void
set_dma_cfg(struct device *dev)
{
#if ALLOW_DMA
	struct net_local *lp = (struct net_local *)dev->priv;

	if ((lp->isa_config & ANY_ISA_DMA) == 0)
		return;
	if (lp->isa_config & ISA_RxDMA)
		lp->curr_rx_cfg |= RX_DMA_ONLY;
	else
		lp->curr_rx_cfg |= AUTO_RX_DMA;	/* not that we support it... */
#endif
}

static int
dma_bufcfg(struct device *dev)
{
	struct net_local *lp = (struct net_local *)dev->priv;

#if ALLOW_DMA
	return (lp->isa_config & ANY_ISA_DMA)? RX_DMA_ENBL : 0;
#else
	return 0;
#endif
}



static int inline
dma_busctl(struct device *dev)
{
	struct net_local *lp = (struct net_local *)dev->priv;
	int retval = 0;

#if ALLOW_DMA
	if (lp->isa_config & ANY_ISA_DMA)
		retval |= RESET_RX_DMA; /* Reset the DMA pointer */
	if (lp->isa_config & DMA_BURST)
		retval |= DMA_BURST_MODE; /* Does ISA config specify DMA burst ? */
	if (lp->dmasize == 64)
		retval |= RX_DMA_SIZE_64K; /* did they ask for 64K? */
	retval |= MEMORY_ON;	/* we need memory enabled to use DMA. */
#endif
	return retval;
}

#if ALLOW_DMA
static void
dma_rx(struct device *dev)
{
	struct net_local *lp = (struct net_local *)dev->priv;
	struct sk_buff *skb;
	int status, length;
	unsigned char *bp = lp->rx_dma_ptr;

	status = bp[0] + (bp[1]<<8);
	length = bp[2] + (bp[3]<<8);
	bp += 4;
	if (net_debug > 5)printk(KERN_NOTICE "%s: receiving packet at %lx, status %x, length %x\n", dev->name, (unsigned long)bp, status, length);
	if ((status & RX_OK) == 0) {
		count_rx_errors(status, lp);
		bp += (length + 3) & ~3;
		if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024;
		lp->rx_dma_ptr = bp;
		return;
	}

	/* Malloc up new buffer. */
	skb = alloc_skb(length, GFP_ATOMIC);
	if (skb == NULL) {
		printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name);
		lp->stats.rx_dropped++;
		return;
	}
	skb->len = length;
	skb->dev = dev;

	if (bp + length > lp->end_dma_buff) {
		int semi_cnt = lp->end_dma_buff - bp;
		memcpy(skb_put(skb,semi_cnt), bp, semi_cnt);
		memcpy(skb_put(skb,length - semi_cnt), lp->dma_buff,
		       length - semi_cnt);
		bp = lp->dma_buff + length - semi_cnt;
	} else {
		memcpy(skb_put(skb,length), bp, length);
		bp += length;
	}
	if ((int)bp & 1) bp++;
	if ((int)bp & 2) bp+=2;
	/* should never be greater than, but might be equal to */
	if (bp >= lp->end_dma_buff) bp = lp->dma_buff;
	lp->rx_dma_ptr = bp;

	if (net_debug > 3)printk(KERN_DEBUG "%s: received %d byte packet of type %x\n",
                                 dev->name, length,
                                 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
        skb->protocol=eth_type_trans(skb,dev);
	netif_rx(skb);
	lp->stats.rx_packets++;