dev_net_cs8900a.c

cs8900网卡驱动for linux 在arm处理器上的

	/* set control and status registers low 6 bits. see P49. */
	for (i = 0; i < 16; i++) {
		io->ctrl_st[i] |= i * 2 + 1;
		io->ctrl_st[i + 16] |= i * 2;

	}
	io->ctrl_st[CtrlStNum (PP_BusST)] |= Rdy4TxNOW;

	eeprom_reset (dev);

	/* init tx/rx buffer */
	if (!io->rx_frame)
		io->rx_frame = (u16 *) malloc (Rx_Frame_Count);
	memset (io->rx_frame, 0, Rx_Frame_Count);
	io->rx_status_p = &(io->rx_frame[0]);
	io->rx_length_p = &(io->rx_frame[1]);
	io->rx_head = io->rx_tail = 0;

	if (!io->tx_frame)
		io->tx_frame = (u16 *) malloc (Tx_Frame_Count);
	memset (io->tx_frame, 0, Tx_Frame_Count);
	io->tx_head = io->tx_tail = 0;
	io->ctrl_st[CtrlStNum (PP_SelfST)] |= INITD;
	io->ctrl_st[CtrlStNum (PP_LineST)] |= LINK_OK;
	io->ctrl_st[CtrlStNum (PP_TxEvent)] &= 0x3f;
}

static void
net_cs8900a_update (struct device_desc *dev)
{
	struct device_interrupt *intr = &dev->intr;
	struct net_device *net_dev = (struct net_device *) dev->dev;
	struct net_cs8900a_io *io = (struct net_cs8900a_io *) dev->data;
	struct machine_config *mc = (struct machine_config *) dev->mach;
	if ((!mc->mach_pending_intr (intr->interrupts[INT_CS8900A]))) {
		struct timeval tv;
		tv.tv_sec = 0;
		tv.tv_usec = 0;
		if(net_dev->net_wait_packet (net_dev, &tv) == 0) cs8900a_input (dev);
	}

}


int
net_cs8900a_read_halfword (struct device_desc *dev, u32 addr, u16 * data)
{
	struct net_device *net_dev = (struct net_device *) dev->dev;
	struct net_cs8900a_io *io = (struct net_cs8900a_io *) dev->data;

	int offset = (u16) (addr - dev->base);
	int ret = ADDR_HIT;

	*data = 0;
	switch (offset) {
	case Rx_Frame_Port:
		frame_read (dev, data);
		break;
	case IO_ISQ:
		isq_read (dev, data);
		break;
	case PP_Address:
		*data = io->pp_address | 0x3000;
		break;
	case PP_Data:
		if (io->pp_address >= 0x100 && io->pp_address < 0x140) {

			ctrl_status_read (dev, data);
		}
		switch (io->pp_address) {
		case PP_ProductID:
			*data = io->product_id[0];
			break;
		case PP_ProductID + 2:
			*data = io->product_id[1];
			break;
		case PP_IntNum:
			*data = io->int_num;
			break;
		case PP_EEPROMCommand:
			*data = io->eeprom_cmd;
			break;
		case PP_EEPROMData:
			eeprom_read (dev, data);
			break;

		case PP_IA:
		case PP_IA + 2:
		case PP_IA + 4:
			*data = io->ieee_addr[io->pp_address - PP_IA] |
				(io->
				 ieee_addr[io->pp_address - PP_IA + 1] << 8);
			break;
		case PP_ISQ:
			isq_read (dev, data);
			break;

		case PP_RxStatus:
			*data = *(io->rx_status_p);
			*(io->rx_status_p) = 0;
			io->rx_tail++;
			break;
		case PP_RxLength:
			*data = *(io->rx_length_p);
			*(io->rx_length_p) = 0;
			io->rx_tail++;
			break;
		}
		//printf("addr:%x, data:%x\n", io->pp_address, *data);
		break;
	default:
		break;
	}
	return ret;

}

int
net_cs8900a_write_halfword (struct device_desc *dev, u32 addr, u16 data)
{
	struct net_device *net_dev = (struct net_device *) dev->dev;
	struct net_cs8900a_io *io = (struct net_cs8900a_io *) dev->data;

	int offset = (u16) (addr - dev->base);
	int ret = ADDR_HIT;

	switch (offset) {
	case Tx_Frame_Port:
		frame_write (dev, data);
		break;
	case IO_TxCMD:
		io->tx_cmd = data;
		break;
	case IO_TxLength:
		io->tx_length = data;
		break;
	case PP_Address:
		io->pp_address = data;
		break;
	case PP_Data:
		if (io->pp_address >= 0x100 && io->pp_address < 0x140) {

			ctrl_status_write (dev, data);
		}
		switch (io->pp_address) {
		case PP_IntNum:
			io->int_num = data;
			break;
		case PP_EEPROMCommand:
			io->eeprom_cmd = data;
			eeprom_write (dev, data);
			break;
		case PP_EEPROMData:
			if (io->eeprom_writable == 1)
				io->eeprom_data = data;
			break;
		case PP_IA:
		case PP_IA + 2:
		case PP_IA + 4:
			io->ieee_addr[io->pp_address - PP_IA] = data & 0xff;
			io->ieee_addr[io->pp_address - PP_IA + 1] =
				(data >> 8) & 0xff;
			break;
		case PP_TxCMD:
			io->tx_cmd = data;
			break;
		case PP_TxLength:
			io->tx_length = data;
			break;
		}
		break;
	default:
		break;
	}

	return ret;
}

static void
cs8900a_input (struct device_desc *dev)
{
	struct net_device *net_dev = (struct net_device *) dev->dev;
	struct net_cs8900a_io *io = (struct net_cs8900a_io *) dev->data;
	int packet_len, cs8900a_len;
	u8 *bufptr;
     /*When the CS8900A commits buffer space to a par-
       ticular held receive frame ,data from subsequent frames can be written P85*/
	if (io->ctrl_st[CtrlStNum (PP_RxEvent)] & 0x100)
		return;
	bufptr = (u8 *) & (io->rx_frame[2]);
	packet_len = net_dev->net_read (net_dev, bufptr, Rx_Max_Count);
	if (packet_len < 0)
		return;

	*(io->rx_status_p) |= RxOK;
	*(io->rx_length_p) = packet_len;

	io->rx_head = 2;

	io->rx_head = io->rx_head + ((packet_len + 1) / 2) - 1;

	io->rx_tail = 0;

	//printf("io->rx_head:%d, io->rx_tail:%d, packet_len:%d\n", io->rx_head, io->rx_tail, packet_len);

#if 0
	print_packet (bufptr, packet_len);
#endif

	io->ctrl_st[CtrlStNum (PP_RxEvent)] |= 0x100;	//TxOK
	if (io->ctrl_st[CtrlStNum (PP_BusCTL)] & EnableRQ) {
		//printf("%s:%x, packet_len:%d\n", __FUNCTION__, io->ctrl_st[CtrlStNum(PP_RxEvent)], packet_len);
		set_time (io->index, packet_len);
		io->need_update = 1;
		net_cs8900a_set_update_intr (dev);
	}
}

static u8
cs8900a_output (struct device_desc *dev, u8 * buf, u16 packet_len)
{
	struct net_device *net_dev = (struct net_device *) dev->dev;
	struct net_cs8900a_io *io = (struct net_cs8900a_io *) dev->data;
	int len;

	//printf("%s: packet_len:%d\n", __FUNCTION__, packet_len);
#if 0
	print_packet (buf, packet_len);
#endif
	if ((len = net_dev->net_write (net_dev, buf, packet_len)) == -1) {
		fprintf (stderr, "write to tapif error in skyeye-ne2k.c\n");
		return -1;
	}
	io->ctrl_st[CtrlStNum (PP_TxEvent)] |= 0x100;
	io->ctrl_st[CtrlStNum (PP_BusST)] |= Rdy4TxNOW;

	if (io->ctrl_st[CtrlStNum (PP_BusCTL)] & EnableRQ) {
		set_time (io->index, packet_len);
		io->need_update = 1;
		net_cs8900a_set_update_intr (dev);
	}
	return 0;
}
static int
net_cs8900a_setup (struct device_desc *dev)
{
	int i;
	int enough = 0;
	struct net_cs8900a_io *io;
	struct device_interrupt *intr = &dev->intr;

	dev->fini = net_cs8900a_fini;
	dev->reset = net_cs8900a_reset;
	dev->update = net_cs8900a_update;
	dev->read_halfword = net_cs8900a_read_halfword;
	dev->write_halfword = net_cs8900a_write_halfword;

	io = (struct net_cs8900a_io *)
		malloc (sizeof (struct net_cs8900a_io));
	memset (io, 0, sizeof (struct net_cs8900a_io));
	if (io == NULL)
		return 1;
	dev->data = (void *) io;

	net_cs8900a_reset (dev);

	/* see if we need to set default values.
	 * */
	set_device_default (dev, cs8900a_net_def);

	for (i = 0; i < MAX_DEVICE_NUM; i++) {
		if (cs8900a_devs[i] == NULL) {
			cs8900a_devs[i] = dev;
			io->index = i;
			enough = 1;
			break;
		}
	}
	if (enough == 0)
		return 1;

	return 0;
}

void
net_cs8900a_init (struct device_module_set *mod_set)
{
	int i;
	register_device_module ("cs8900a", mod_set, &net_cs8900a_setup);

	for (i = 0; i < MAX_DEVICE_NUM; i++)
		cs8900a_devs[i] = NULL;

}