dw4002.c

linux下DVB/IP驱动原代码 DVBWorld 公司产品 www.worlddvb.com

void	dm1105_set_rx_mode (struct net_device *dev);
void	__set_rx_mode (struct net_device *dev);

void	dm1105_hw_start (struct net_device *dev);
void	find_dev_version( struct dm1105_private *pdev );


static const u8 dm1105_intr_mask = RxOK | RxErr;


#define	IIC_StartBitMask	0x80
#define	IIC_LenBitMask		0x7F
#define	IIC_BusyBitMask		0x80
#define	IIC_OKBitMask		0x40

/////////////////////////////// Added by Kully 11-01-2006
void IP_RX_tasklet_action(unsigned long t);
int need_reception = 0;
int need_reception_count =0;
unsigned int stop_tasklet =0;
struct net_device *local_dev = NULL;
DECLARE_TASKLET(my_tasklet, IP_RX_tasklet_action, 0);
unsigned char DMARSTFLAG = 0;
void My_Task_Clean()
{
	stop_tasklet =1;
	need_reception =0;
	need_reception_count =0;
	tasklet_kill(&my_tasklet);
	local_dev = NULL;
}

void  find_dev_version( struct dm1105_private *pdev )
{
	card_info *pdev_info = &(pdev->dev_info);

	if(pdev_info->vendor_id == DM1105_VENDOR_ID)
	{
		switch( pdev_info->device_id  )
		{
		case DM1105_DEVICE_ID:
			pdev->Version = DW4002;
			printk("\n DVBWORLD DW4002 DVBS PCI NIC!\n");
			break;

		default:
			pdev->Version = UNKNOWN_DEV;
			break;

		}
		return ;
	}
	else
	{
		pdev->Version = UNKNOWN_DEV;
	}
}

int find_mac_addr(struct net_device *dev)
{
	struct dm1105_private *tp;
	void *ioaddr;
	u8 status;
	int i;
	
	assert (dev != NULL);
	assert (dev->priv != NULL);
	
	tp = dev->priv;
	ioaddr = tp->base_addr;
	
	ANY_W8 (NIC_I2CCTR, 0x00);
	ANY_W8 (NIC_I2CDAT, IIC_24C01_addr);
/* Kully 10-25-2006
	ANY_W8 (NIC_I2C_RA, 0x00);     // MAC address
*/
	ANY_W8 (NIC_I2C_RA, 0x20);     //Kully 10-25-2006

	ANY_W8 (NIC_I2CCTR, 0x82);
	
	for (i = 0; i < 10; i++) 
	{
		mdelay (10);  // 10ms
		status = ANY_R8 (NIC_I2CSTS);
		if ((status & 0xc0) == 0x40)
			break;
	}
	
	if (i >= 10) 
	{
		//DPRINTK ("read 24C01 data error.\n");
		return -1;
	}
	
	ANY_W8 (NIC_I2CCTR, 0x00);
	ANY_W8 (NIC_I2CDAT, IIC_24C01_addr+1);
	
	for (i = 0; i < 14; i++)		// "6" --> "14" Kully 10-25-2006
		ANY_W8 (NIC_I2C_RA+i, 0x00);
/* Kully 10-25-2006
	ANY_W8 (NIC_I2CCTR, 0x87);  // 6 + 1
*/	
	ANY_W8 (NIC_I2CCTR, 0x81+14);  // 14 + 1 Kully 10-25-2006

	mdelay(10);
	for (i = 0; i < 25; i++)		// "10" ---> "25" Kully 10-25-2006
	{
		mdelay (10);
		status = ANY_R8 (NIC_I2CSTS);
		if ((status & 0xc0) == 0x40)
			break;
	}
	
	if (i >= 25)					// "10" ---> "25" Kully 10-25-2006
	{
		//		DPRINTK ("read 24C01 data error.\n");
		return -1;
	}
	
	mdelay (10);
/* Kully 10-25-2006
	for (i = 0; i < 6; i++) 
	{
		dev->dev_addr[i] = ANY_R8 (NIC_I2C_RA+i);
	}
*/
	//ANY_W8 (NIC_I2CCTR, 0x87);  // 6 + 1

	for (i = 0; i < 14; i++)		//Kully 10-25-2006
	{
		 dev->dev_addr[i] = ANY_R8 (NIC_I2C_RA+i);
	}

/* Kully 10-25-2006
	mdelay (8*10);
	for (i = 0; i < 10; i++) 
	{
		status = ANY_R8 (NIC_I2CSTS);
		if ((status & 0xc0) == 0x40)
			break;
		mdelay (10);
	}
*/
/* Kully 10-25-2006
	memcpy (tp->MACaddr, dev->dev_addr, 6);
*/
	//////////////////////////////////////// Kully 10-25-2006
	memcpy (tp->MACaddr, &dev->dev_addr[8], 6);

	printk ("\n  MAC Address : ");

	for(i = 0; i < 6; i++)
	{
		printk (" %2.2x  ",dev->dev_addr[8+i]);
	}
	printk("\n");
	////////////////////////////////////////

	return 1;
}
/*
int find_mac_addr(struct net_device *dev)
{
	struct dm1105_private *tp;
	void *ioaddr;
	u8 status;
	int i;
	
	assert (dev != NULL);
	assert (dev->priv != NULL);
	
	tp = dev->priv;
	ioaddr = tp->base_addr;
	
	ANY_W8 (NIC_I2CCTR, 0x00);
	ANY_W8 (NIC_I2CDAT, IIC_24C01_addr);
	ANY_W8 (NIC_I2C_RA, 0x00);     // MAC address
	ANY_W8 (NIC_I2CCTR, 0x82);
	
	for (i = 0; i < 10; i++) 
	{
		mdelay (10);  // 10ms
		status = ANY_R8 (NIC_I2CSTS);
		if ((status & 0xc0) == 0x40)
			break;
	}
	
	if (i >= 10) 
	{
		//DPRINTK ("read 24C01 data error.\n");
		return -1;
	}
	
	ANY_W8 (NIC_I2CCTR, 0x00);
	ANY_W8 (NIC_I2CDAT, IIC_24C01_addr+1);
	for (i = 0; i < 6; i++)
		ANY_W8 (NIC_I2C_RA+i, 0x00);
	
	ANY_W8 (NIC_I2CCTR, 0x87);  // 6 + 1
	
	mdelay(10);
	for (i = 0; i < 10; i++) 
	{
		mdelay (10);
		status = ANY_R8 (NIC_I2CSTS);
		if ((status & 0xc0) == 0x40)
			break;
	}
	
	if (i >= 10) 
	{
		return -1;
	}
	
	mdelay (10);
	for (i = 0; i < 6; i++) 
	{
		dev->dev_addr[i] = ANY_R8 (NIC_I2C_RA+i+0x28);
	}
	//ANY_W8 (NIC_I2CCTR, 0x87);  // 6 + 1
	
	mdelay (8*10);
	for (i = 0; i < 10; i++) 
	{
		status = ANY_R8 (NIC_I2CSTS);
		if ((status & 0xc0) == 0x40)
			break;
		mdelay (10);
	}


//	for (i = 0; i < 6; i++) 
//	{
//		dev->dev_addr[i] = ANY_R8 (NIC_I2C_RA+i+0x28);
//	}

	dev->dev_addr[0] = 0;
	dev->dev_addr[1] = 0x18;
	dev->dev_addr[2] = 0xbd;
	dev->dev_addr[3] = 0;
	dev->dev_addr[4] = 0x12;
	dev->dev_addr[5] = 0x0c;
	
	memcpy (tp->MACaddr, dev->dev_addr, 6);
	printk ("Ethernet address : %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x\n",
		dev->dev_addr[0], dev->dev_addr[1],
		dev->dev_addr[2], dev->dev_addr[3],
		dev->dev_addr[4], dev->dev_addr[5]);
	
	return 1;
}
*/

/*
int WriteEthernetAddressFrom24C01 (struct net_device *dev)
{
	struct dm1105_private *tp;
	void *ioaddr;
	u8 status;
	int i;
	
	assert (dev != NULL);
	assert (dev->priv != NULL);
	
	tp = dev->priv;
	ioaddr = tp->base_addr;
	
	ANY_W8 (NIC_I2CCTR, 0x00);
	ANY_W8 (NIC_I2CDAT, IIC_24C01_addr);
	ANY_W8 (NIC_I2C_RA, 0x00);     // MAC address
	for (i = 0; i < 6; i++)
		ANY_W8 (NIC_I2C_RA+i, tp->MACaddr[i]);
	
	ANY_W8 (NIC_I2CCTR, 0x88);  // 6 + 2
	
	mdelay(10);
	for (i = 0; i < 10; i++) 
	{
		mdelay (10);
		status = ANY_R8 (NIC_I2CSTS);
		if ((status & 0xc0) == 0x40)
			break;
	}
	
	if (i >= 10) 
	{
		//DPRINTK ("write 24C01 data error.\n");
		return -1;
	}
	
	memcpy (dev->dev_addr, tp->MACaddr, 6);
	printk ("Ethernet address : %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x\n",
		dev->dev_addr[0], dev->dev_addr[1],
		dev->dev_addr[2], dev->dev_addr[3],
		dev->dev_addr[4], dev->dev_addr[5]);
	
	return 1;
}
*/

void __dm1105_cleanup_dev (struct net_device *dev)
{
	struct dm1105_private *tp;
	struct pci_dev *pdev;
	
	assert (dev != NULL);
	assert (dev->priv != NULL);
	
	tp = dev->priv;
	assert (tp->pci_dev != NULL);
	pdev = tp->pci_dev;
	
	/* it's ok to call this even if we have no regions to free */
	pci_release_regions (pdev);
	
#ifndef DM1105_NDEBUG
	/* poison memory before freeing */
	memset (dev, 0xBC, sizeof (struct net_device) + sizeof (struct dm1105_private));
#endif 
	
	kfree (dev);
	
	pci_set_drvdata (pdev, NULL);
}

int __devinit dm1105_probe_one( struct pci_dev *pdev, const struct pci_device_id *ent )
{

	struct	net_device *dev = NULL;
	struct	dm1105_private *tp;

	//struct	card_info device_info;

	int		i, option;
	static int	board_idx = -1;
	u8			pci_rev;
	u16			vendor_id;
	u16			device_id;

	void	*ioaddr;
	u32	pio_start, pio_end, pio_flags, pio_len;
	
	assert (pdev != NULL);
	assert (ent != NULL);
	
	board_idx++;
	
	pci_read_config_byte(pdev, PCI_REVISION_ID, &pci_rev);

	pci_read_config_word(pdev, PCI_DEVICE_ID, &device_id );
	pci_read_config_word(pdev, PCI_VENDOR_ID, &vendor_id );
	

#ifndef MODULE
	{
		static int printed_version;
	}
#endif
	
	
	// enable device (incl. PCI PM wakeup and hotplug setup) 
	i = pci_enable_device (pdev);
	if (i)
		goto err_out;
	
	// dev and dev->priv zeroed in alloc_etherdev
	dev = alloc_etherdev( sizeof (*tp));
	if (dev == NULL) 
	{
		return -ENOMEM;
	}
	
//	printk("DEVICE_ID : 0x%x; VENDOR_ID : 0x%x\n", device_id,vendor_id);
	
	SET_MODULE_OWNER(dev);

	tp = dev->priv;
	tp->pci_dev = pdev;

	tp->dev_info.device_id = device_id;
	tp->dev_info.vendor_id = vendor_id;	

	pio_start = pci_resource_start (pdev, 0);
	pio_end = pci_resource_end (pdev, 0);
	pio_flags = pci_resource_flags (pdev, 0);
	pio_len = pci_resource_len (pdev, 0);

	
	// make sure PCI base addr 0 is PIO 
	if (!(pio_flags & IORESOURCE_IO)) 
	{
//		printk ("KERN_ERR PFX %s: region #0 not a PIO resource, aborting\n", pdev->slot_name);      
		i = -ENODEV;
		goto err_out;
	}
	// check for weird/broken PCI region reporting
	if (pio_len < ANY_MIN_IO_SIZE) 
	{
//		printk ("KERN_ERR PFX %s: Invalid PCI I/O region size(s), aborting\n", pdev->slot_name);
		i = -ENODEV;
		goto err_out;
	}
	
	i = pci_request_regions( pdev, DRV_NAME );
	if(i)
		goto err_out;
	
	// enable PCI bus-mastering
	pci_set_master (pdev);
	
	ioaddr = (void *) pio_start;
	dev->base_addr = pio_start;
	tp->base_addr = ioaddr;
	tp->regs_len = pio_len;

	/////////////////////////////////////////////////////////////Kully 10-26-2006
	local_ioaddr = ((struct dm1105_private *)(dev->priv))->base_addr;
	/////////////////////////////////////////////////////////////
	
	find_dev_version( tp );	
	find_mac_addr(dev);

	///////////////////////// Check EEPROM Data, Kully 10-26-2006
	if(dev->dev_addr[0] != 0xc0) 
	{
		i = -ENODEV;
//		printk("\n Card error0!\n");
		goto err_out;
	}
	if(dev->dev_addr[1] != 0xb4) 
	{
		i = -ENODEV;
//		printk("\n Card error1!\n");
		goto err_out;
	}
	if(dev->dev_addr[2] != 0x04) 
	{
		i = -ENODEV;
//		printk("\n Card error2!\n");
		goto err_out;
	}
	if(dev->dev_addr[3] != 0x02) 
	{
		i = -ENODEV;
//		printk("\n Card error3!\n");
		goto err_out;
	}
	if(dev->dev_addr[4] != 0x40) 
	{
		i = -ENODEV;
//		printk("\n Card error4!\n");
		goto err_out;
	}
	if(dev->dev_addr[5] != 0x42) 
	{
		i = -ENODEV;
//		printk("\n Card error5!\n");
		goto err_out;
	}
	if(dev->dev_addr[6] != 0x02) 
	{
		i = -ENODEV;
//		printk("\n Card error6!\n");
		goto err_out;
	}
	if(dev->dev_addr[7] != 0x00) 
	{
		i = -ENODEV;
//		printk("\n Card error7!\n");
		goto err_out;
	}
	memcpy (dev->dev_addr, tp->MACaddr, 6);

	/////////////////////////
	/////////////////////////

	dev->open = dm1105_open;
	dev->stop = dm1105_close;
	
	dev->do_ioctl = netdev_ioctl;
	
	dev->hard_start_xmit = dm1105_start_xmit;
	dev->get_stats = dm1105_get_stats;
	dev->set_multicast_list = dm1105_set_rx_mode;
	dev->tx_timeout = NULL;//dm1105_tx_timeout;
	dev->watchdog_timeo = TX_TIMEOUT;
	

	dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;// | NETIF_F_HIGHDMA;
	dev->irq = pdev->irq;
	
	spin_lock_init (&tp->lock);
	
	/* dev is fully set up and ready to use now */
	i = register_netdev( dev );
	if (i)
		goto err_out;
	
	pci_set_drvdata (pdev, dev);
	
	//	printk ("%s(%p): %s at 0x%lx, "
	//		 "%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x, "
	//		"IRQ %d\n",
	//		dev->name, dev,
	//		board_info[ent->driver_data].name,
	//		dev->base_addr,
	//		dev->dev_addr[0], dev->dev_addr[1],
	//		dev->dev_addr[2], dev->dev_addr[3],
	//		dev->dev_addr[4], dev->dev_addr[5],
	//		dev->irq);
	
	option = (board_idx >= MAX_UNITS) ? 0 : media[board_idx];
	if (option > 0)
	{
		tp->default_port = option & 0xFF;
	}
	else
	{
		tp->default_port = 0;
	}
	

	tp->found_and_inuse = 0;
	tp->PacketErrorCount=0;
	
	return 0;
	
err_out:
	__dm1105_cleanup_dev (dev);
	return i;
}


void __devexit dm1105_remove_one (struct pci_dev *pdev)
{