r8168_n.c

RT8111/R8168 PCI Express 的linux驱动程序

		mdio_write(ioaddr, 0x1F, 0x0000);
		mdio_write(ioaddr, 0x0D, mdio_read(ioaddr, 0x0D) | (1 << 5));

		mdio_write(ioaddr, 0x1F, 0x0001);
		mdio_write(ioaddr, 0x14, 0xCAA3);
		mdio_write(ioaddr, 0x1C, 0x000A);
		mdio_write(ioaddr, 0x18, 0x65D0);
		
		mdio_write(ioaddr, 0x1F, 0x0003);
		mdio_write(ioaddr, 0x17, 0xB580);
		mdio_write(ioaddr, 0x18, 0xFF54);
		mdio_write(ioaddr, 0x19, 0x3954);

		mdio_write(ioaddr, 0x1F, 0x0002);
		mdio_write(ioaddr, 0x0D, 0x310C);
		mdio_write(ioaddr, 0x0E, 0x310C);
		mdio_write(ioaddr, 0x0F, 0x311C);
		mdio_write(ioaddr, 0x06, 0x0761);

		mdio_write(ioaddr, 0x1F, 0x0003);
		mdio_write(ioaddr, 0x18, 0xFF55);
		mdio_write(ioaddr, 0x19, 0x3955);
		mdio_write(ioaddr, 0x18, 0xFF54);
		mdio_write(ioaddr, 0x19, 0x3954);

		mdio_write(ioaddr, 0x1f, 0x0001);
		mdio_write(ioaddr, 0x17, 0x0CC0);

		mdio_write(ioaddr, 0x1F, 0x0000);
	} else if (tp->mcfg == CFG_METHOD_9) {
		mdio_write(ioaddr, 0x1F, 0x0002);
		mdio_write(ioaddr, 0x0B, 0x0B10);
		mdio_write(ioaddr, 0x0C, 0xA2F7);

		mdio_write(ioaddr, 0x1F, 0x0002);
		mdio_write(ioaddr, 0x06, 0x5561);

		mdio_write(ioaddr, 0x1F, 0x0002);
		data = mdio_read(ioaddr, 0x0D) & 0x00FF;
		data |= 0x0300;
		mdio_write(ioaddr, 0x0C, data);

		mdio_write(ioaddr, 0x1F, 0x0002);
		mdio_write(ioaddr, 0x15, 0x3628);
		mdio_write(ioaddr, 0x16, 0x7670);
		mdio_write(ioaddr, 0x17, 0x7670);
		
		mdio_write(ioaddr, 0x1F, 0x0003);
		mdio_write(ioaddr, 0x17, 0x7BC0);
		mdio_write(ioaddr, 0x18, 0xFF46);
		mdio_write(ioaddr, 0x19, 0x3247);

		mdio_write(ioaddr, 0x1F, 0x0002);
		mdio_write(ioaddr, 0x02, 0xC107);
		mdio_write(ioaddr, 0x03, 0x1002);

		mdio_write(ioaddr, 0x1F, 0x0002);
		mdio_write(ioaddr, 0x15, 0x3628);
		mdio_write(ioaddr, 0x16, 0x7670);
		mdio_write(ioaddr, 0x17, 0x7670);
		mdio_write(ioaddr, 0x1F, 0x0003);
		mdio_write(ioaddr, 0x17, 0x7BC0);
		mdio_write(ioaddr, 0x18, 0xFF46);
		mdio_write(ioaddr, 0x19, 0x3247);

		mdio_write(ioaddr, 0x1F, 0x0002);
		mdio_write(ioaddr, 0x02, 0xC107);
		mdio_write(ioaddr, 0x03, 0x1002);

		mdio_write(ioaddr, 0x1f, 0x0001);
		mdio_write(ioaddr, 0x17, 0x0CC0);

		mdio_write(ioaddr, 0x1F, 0x0000);
	} else if (tp->mcfg == CFG_METHOD_10) {
		mdio_write(ioaddr, 0x1F, 0x0002);
		mdio_write(ioaddr, 0x06, 0x5571);
		
		mdio_write(ioaddr, 0x1F, 0x0002);
		mdio_write(ioaddr, 0x05, 0x1042);

		mdio_write(ioaddr, 0x1F, 0x0000);
		mdio_write(ioaddr, 0x16, 0x5101);

		mdio_write(ioaddr, 0x1F, 0x0002);
		mdio_write(ioaddr, 0x15, 0x3628);
		mdio_write(ioaddr, 0x16, 0x764C);
		mdio_write(ioaddr, 0x17, 0x76B4);
		mdio_write(ioaddr, 0x1F, 0x0003);
		mdio_write(ioaddr, 0x17, 0x7BC0);
		mdio_write(ioaddr, 0x18, 0xFF46);
		mdio_write(ioaddr, 0x19, 0x3247);

		mdio_write(ioaddr, 0x1F, 0x0002);
		mdio_write(ioaddr, 0x02, 0xC107);
		mdio_write(ioaddr, 0x03, 0x1002);

		mdio_write(ioaddr, 0x1F, 0x0001);
		mdio_write(ioaddr, 0x17, 0x0CC0);

		mdio_write(ioaddr, 0x1F, 0x0002);
		mdio_write(ioaddr, 0x0F, 0x0017);

		mdio_write(ioaddr, 0x1F, 0x0005);
		mdio_write(ioaddr, 0x05, 0x8200);
		mdio_write(ioaddr, 0x06, 0xF8F9);
		mdio_write(ioaddr, 0x06, 0xFAEF);
		mdio_write(ioaddr, 0x06, 0x59EE);
		mdio_write(ioaddr, 0x06, 0xF8EA);
		mdio_write(ioaddr, 0x06, 0x00EE);
		mdio_write(ioaddr, 0x06, 0xF8EB);
		mdio_write(ioaddr, 0x06, 0x00E0);
		mdio_write(ioaddr, 0x06, 0xF87C);
		mdio_write(ioaddr, 0x06, 0xE1F8);
		mdio_write(ioaddr, 0x06, 0x7D59);
		mdio_write(ioaddr, 0x06, 0x0FEF);
		mdio_write(ioaddr, 0x06, 0x0139);
		mdio_write(ioaddr, 0x06, 0x029E);
		mdio_write(ioaddr, 0x06, 0x06EF);
		mdio_write(ioaddr, 0x06, 0x1039);
		mdio_write(ioaddr, 0x06, 0x089F);
		mdio_write(ioaddr, 0x06, 0x2AEE);
		mdio_write(ioaddr, 0x06, 0xF8EA);
		mdio_write(ioaddr, 0x06, 0x00EE);
		mdio_write(ioaddr, 0x06, 0xF8EB);
		mdio_write(ioaddr, 0x06, 0x01E0);
		mdio_write(ioaddr, 0x06, 0xF87C);
		mdio_write(ioaddr, 0x06, 0xE1F8);
		mdio_write(ioaddr, 0x06, 0x7D58);
		mdio_write(ioaddr, 0x06, 0x409E);
		mdio_write(ioaddr, 0x06, 0x0F39);
		mdio_write(ioaddr, 0x06, 0x46AA);
		mdio_write(ioaddr, 0x06, 0x0BBF);
		mdio_write(ioaddr, 0x06, 0x8251);
		mdio_write(ioaddr, 0x06, 0xD682);
		mdio_write(ioaddr, 0x06, 0x5902);
		mdio_write(ioaddr, 0x06, 0x014F);
		mdio_write(ioaddr, 0x06, 0xAE09);
		mdio_write(ioaddr, 0x06, 0xBF82);
		mdio_write(ioaddr, 0x06, 0x59D6);
		mdio_write(ioaddr, 0x06, 0x8261);
		mdio_write(ioaddr, 0x06, 0x0201);
		mdio_write(ioaddr, 0x06, 0x4FEF);
		mdio_write(ioaddr, 0x06, 0x95FE);
		mdio_write(ioaddr, 0x06, 0xFDFC);
		mdio_write(ioaddr, 0x06, 0x054D);
		mdio_write(ioaddr, 0x06, 0x2000);
		mdio_write(ioaddr, 0x06, 0x024E);
		mdio_write(ioaddr, 0x06, 0x2200);
		mdio_write(ioaddr, 0x06, 0x024D);
		mdio_write(ioaddr, 0x06, 0xDFFF);
		mdio_write(ioaddr, 0x06, 0x014E);
		mdio_write(ioaddr, 0x06, 0xDDFF);
		mdio_write(ioaddr, 0x06, 0x0100);
		mdio_write(ioaddr, 0x02, 0x6010);
		mdio_write(ioaddr, 0x05, 0xFFF6);
		mdio_write(ioaddr, 0x06, 0x00EC);
		mdio_write(ioaddr, 0x05, 0x83D4);
		mdio_write(ioaddr, 0x06, 0x8200);

		mdio_write(ioaddr, 0x1F, 0x0000);
	}

	spin_unlock_irqrestore(&tp->phy_lock, flags);
}

static inline void rtl8168_delete_esd_timer(struct net_device *dev, struct timer_list *timer)
{
	struct rtl8168_private *tp = netdev_priv(dev);

	spin_lock_irq(&tp->lock);
	del_timer_sync(timer);
	spin_unlock_irq(&tp->lock);
}

static inline void rtl8168_request_esd_timer(struct net_device *dev)
{
	struct rtl8168_private *tp = netdev_priv(dev);
	struct timer_list *timer = &tp->esd_timer;

	init_timer(timer);
	timer->expires = jiffies + RTL8168_ESD_TIMEOUT;
	timer->data = (unsigned long)(dev);
	timer->function = rtl8168_esd_timer;
	add_timer(timer);
}

#ifdef CONFIG_NET_POLL_CONTROLLER
/*
 * Polling 'interrupt' - used by things like netconsole to send skbs
 * without having to re-enable interrupts. It's not called while
 * the interrupt routine is executing.
 */
static void 
rtl8168_netpoll(struct net_device *dev)
{
	struct rtl8168_private *tp = netdev_priv(dev);
	struct pci_dev *pdev = tp->pci_dev;

	disable_irq(pdev->irq);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19)
	rtl8168_interrupt(pdev->irq, dev, NULL);
#else
	rtl8168_interrupt(pdev->irq, dev);
#endif
	enable_irq(pdev->irq);
}
#endif

static void 
rtl8168_release_board(struct pci_dev *pdev, 
		      struct net_device *dev,
		      void __iomem *ioaddr)
{
	iounmap(ioaddr);
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	free_netdev(dev);
}

/**
 * rtl8168_set_mac_address - Change the Ethernet Address of the NIC
 * @dev: network interface device structure 
 * @p:   pointer to an address structure
 *
 * Return 0 on success, negative on failure
 **/
static int
rtl8168_set_mac_address(struct net_device *dev, 
			void *p)
{
	struct rtl8168_private *tp = netdev_priv(dev);
	struct sockaddr *addr = p;

	if (!is_valid_ether_addr(addr->sa_data))
		return -EADDRNOTAVAIL;

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

	rtl8168_rar_set(tp, tp->mac_addr, 0);
	
	return 0;
}

/******************************************************************************
 * rtl8168_rar_set - Puts an ethernet address into a receive address register.
 *
 * tp - The private data structure for driver
 * addr - Address to put into receive address register
 * index - Receive address register to write
 *****************************************************************************/
void
rtl8168_rar_set(struct rtl8168_private *tp, 
		uint8_t *addr, 
		uint32_t index)
{
	void __iomem *ioaddr = tp->mmio_addr;
	uint32_t rar_low = 0;
	uint32_t rar_high = 0;

	rar_low = ((uint32_t) addr[0] |
		  ((uint32_t) addr[1] << 8) |
		  ((uint32_t) addr[2] << 16) | 
		  ((uint32_t) addr[3] << 24));

	rar_high = ((uint32_t) addr[4] | 
		   ((uint32_t) addr[5] << 8));

	RTL_W8(Cfg9346, Cfg9346_Unlock);
	RTL_W32(MAC0, rar_low);
	RTL_W32(MAC4, rar_high);
	RTL_W8(Cfg9346, Cfg9346_Lock);
}

#ifdef ETHTOOL_OPS_COMPAT
static int ethtool_get_settings(struct net_device *dev, void *useraddr)
{
	struct ethtool_cmd cmd = { ETHTOOL_GSET };
	int err;

	if (!ethtool_ops->get_settings)
		return -EOPNOTSUPP;

	err = ethtool_ops->get_settings(dev, &cmd);
	if (err < 0)
		return err;

	if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
		return -EFAULT;
	return 0;
}

static int ethtool_set_settings(struct net_device *dev, void *useraddr)
{
	struct ethtool_cmd cmd;

	if (!ethtool_ops->set_settings)
		return -EOPNOTSUPP;

	if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
		return -EFAULT;

	return ethtool_ops->set_settings(dev, &cmd);
}

static int ethtool_get_drvinfo(struct net_device *dev, void *useraddr)
{
	struct ethtool_drvinfo info;
	struct ethtool_ops *ops = ethtool_ops;

	if (!ops->get_drvinfo)
		return -EOPNOTSUPP;

	memset(&info, 0, sizeof(info));
	info.cmd = ETHTOOL_GDRVINFO;
	ops->get_drvinfo(dev, &info);

	if (ops->self_test_count)
		info.testinfo_len = ops->self_test_count(dev);
	if (ops->get_stats_count)
		info.n_stats = ops->get_stats_count(dev);
	if (ops->get_regs_len)
		info.regdump_len = ops->get_regs_len(dev);
	if (ops->get_eeprom_len)
		info.eedump_len = ops->get_eeprom_len(dev);

	if (copy_to_user(useraddr, &info, sizeof(info)))
		return -EFAULT;
	return 0;
}

static int ethtool_get_regs(struct net_device *dev, char *useraddr)
{
	struct ethtool_regs regs;
	struct ethtool_ops *ops = ethtool_ops;
	void *regbuf;
	int reglen, ret;

	if (!ops->get_regs || !ops->get_regs_len)
		return -EOPNOTSUPP;

	if (copy_from_user(&regs, useraddr, sizeof(regs)))
		return -EFAULT;

	reglen = ops->get_regs_len(dev);
	if (regs.len > reglen)
		regs.len = reglen;

	regbuf = kmalloc(reglen, GFP_USER);
	if (!regbuf)
		return -ENOMEM;

	ops->get_regs(dev, &regs, regbuf);

	ret = -EFAULT;
	if (copy_to_user(useraddr, &regs, sizeof(regs)))
		goto out;
	useraddr += offsetof(struct ethtool_regs, data);
	if (copy_to_user(useraddr, regbuf, reglen))
		goto out;
	ret = 0;

out:
	kfree(regbuf);
	return ret;
}

static int ethtool_get_wol(struct net_device *dev, char *useraddr)
{
	struct ethtool_wolinfo wol = { ETHTOOL_GWOL };

	if (!ethtool_ops->get_wol)
		return -EOPNOTSUPP;

	ethtool_ops->get_wol(dev, &wol);

	if (copy_to_user(useraddr, &wol, sizeof(wol)))
		return -EFAULT;
	return 0;
}

static int ethtool_set_wol(struct net_device *dev, char *useraddr)
{
	struct ethtool_wolinfo wol;

	if (!ethtool_ops->set_wol)
		return -EOPNOTSUPP;

	if (copy_from_user(&wol, useraddr, sizeof(wol)))
		return -EFAULT;

	return ethtool_ops->set_wol(dev, &wol);
}

static int ethtool_get_msglevel(struct net_device *dev, char *useraddr)
{
	struct ethtool_value edata = { ETHTOOL_GMSGLVL };

	if (!ethtool_ops->get_msglevel)
		return -EOPNOTSUPP;

	edata.data = ethtool_ops->get_msglevel(dev);

	if (copy_to_user(useraddr, &edata, sizeof(edata)))
		return -EFAULT;
	return 0;
}

static int ethtool_set_msglevel(struct net_device *dev, char *useraddr)
{
	struct ethtool_value edata;

	if (!ethtool_ops->set_msglevel)
		return -EOPNOTSUPP;

	if (copy_from_user(&edata, useraddr, sizeof(edata)))
		return -EFAULT;

	ethtool_ops->set_msglevel(dev, edata.data);
	return 0;
}

static int ethtool_nway_reset(struct net_device *dev)
{
	if (!ethtool_ops->nway_reset)
		return -EOPNOTSUPP;

	return ethtool_ops->nway_reset(dev);
}

static int ethtool_get_link(struct net_device *dev, void *useraddr)
{
	struct ethtool_value edata = { ETHTOOL_GLINK };

	if (!ethtool_ops->get_link)
		return -EOPNOTSUPP;

	edata.data = ethtool_ops->get_link(dev);

	if (copy_to_user(useraddr, &edata, sizeof(edata)))
		return -EFAULT;
	return 0;
}

static int ethtool_get_eeprom(struct net_device *dev, void *useraddr)
{
	struct ethtool_eeprom eeprom;
	struct ethtool_ops *ops = ethtool_ops;
	u8 *data;
	int ret;

	if (!ops->get_eeprom || !ops->get_eeprom_len)
		return -EOPNOTSUPP;

	if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
		return -EFAULT;

	/* Check for wrap and zero */
	if (eeprom.offset + eeprom.len <= eeprom.offset)
		return -EINVAL;

	/* Check for exceeding total eeprom len */
	if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
		return -EINVAL;

	data = kmalloc(eeprom.len, GFP_USER);
	if (!data)
		return -ENOMEM;

	ret = -EFAULT;
	if (copy_from_user(data, useraddr + sizeof(eeprom), eeprom.len))
		goto out;

	ret = ops->get_eeprom(dev, &eeprom, data);
	if (ret)
		goto out;

	ret = -EFAULT;
	if (copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
		goto out;
	if (copy_to_user(useraddr + sizeof(eeprom), data, eeprom.len))
		goto out;
	ret = 0;

out:
	kfree(data);
	return ret;
}

static int ethtool_set_eeprom(struct net_device *dev, void *useraddr)
{
	struct ethtool_eeprom eeprom;
	struct ethtool_ops *ops = ethtool_ops;
	u8 *data;
	int ret;

	if (!ops->set_eeprom || !ops->get_eeprom_len)
		return -EOPNOTSUPP;

	if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
		return -EFAULT;

	/* Check for wrap and zero */
	if (eeprom.offset + eeprom.len <= eeprom.offset)
		return -EINVAL;

	/* Check for exceeding total eeprom len */
	if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
		return -EINVAL;

	data = kmalloc(eeprom.len, GFP_USER);
	if (!data)
		return -ENOMEM;

	ret = -EFAULT;
	if (copy_from_user(data, useraddr + sizeof(eeprom), eeprom.len))
		goto out;