为什么要在自制操作系统上写网卡驱动？请看这里：

如何在自制操作系统写网卡驱动程序(1)

那么今天，我们就开始第一步：看看其他操作系统上的网卡驱动是如何写的？

先看下linux操作系统中，是如何和网卡通信的。

在硬件加电初始化时，BIOS统一检查所有的PCI设备，并为每个设备分配一个物理地址，该地址通过BIOS获得并写到设备的配置空间内，驱动程序就可以将网卡的普通控制寄存器映射到一段内存空间内，CPU通过访问映射后的虚拟地址来操控网卡的寄存器。

当操作系统初始化时，其为每个PCI设备分配一个pci_dev结构，并将前面分配的物理地址写到pci_dev的resource字段中。

在网卡驱动程序中则可以通过读取pci_dev中的resource字段获得网卡的寄存器配置空间地址，其由函数pci_resource_start()和pci_resource_end()获得该空间的起始位置，通过ioremap()将该段位置映射到主存中，以便CPU访问控制网卡的I/O和内存空间。

调用pci_resource_start

ioremap(  pci_resource_start(pdev, BAR_1), pci_resource_len(pdev, BAR_1) );

pci_resource_start只是一个宏定义：

/* * These helpers provide future and backwards compatibility * for accessing popular PCI BAR info */// 开始地址#define pci_resource_start(dev, bar)	((dev)->resource[(bar)].start)// 结束地址#define pci_resource_end(dev, bar)	((dev)->resource[(bar)].end)// 设置标志#define pci_resource_flags(dev, bar)	((dev)->resource[(bar)].flags)// 获取长度：(start==0 && start==end)?0:end-start+1;// 这句话是简写，展开后:// if（start==0 && start==end){ return 0;}else{ return end-start+1;}#define pci_resource_len(dev,bar) \	((pci_resource_start((dev), (bar)) == 0 &&	\	  pci_resource_end((dev), (bar)) ==		\	  pci_resource_start((dev), (bar))) ? 0 :	\							\	 (pci_resource_end((dev), (bar)) -		\	  pci_resource_start((dev), (bar)) + 1))

它定义了对resouce结构体列表中的resource的start,end字段赋值的动作

struct resource resource[DEVICE_COUNT_RESOURCE]; /* I/O and memory regions + expansion ROMs */

/* * Resources are tree-like, allowing * nesting etc.. */struct resource {	resource_size_t start;	resource_size_t end;	const char *name;	unsigned long flags;	unsigned long desc;	struct resource *parent, *sibling, *child;};

在linux使用e1000网卡时，初始化的函数为e1000_probe.

这个函数执行完，网卡以及相关协议的结构体都完成配置，中断函数也完成了绑定，操作系统就可以收到网卡的中断信息了，所以这个函数里的代码时可以参考的。

/** * e1000_probe - Device Initialization Routine * @pdev: PCI device information struct * @ent: entry in e1000_pci_tbl * * Returns 0 on success, negative on failure * * e1000_probe initializes an adapter identified by a pci_dev structure. * The OS initialization, configuring of the adapter private structure, * and a hardware reset occur. **/static int e1000_probe(struct pci_dev *pdev, const struct pci_device_id *ent){	struct net_device *netdev;	struct e1000_adapter *adapter = NULL;	struct e1000_hw *hw;	static int cards_found;	static int global_quad_port_a; /* global ksp3 port a indication */	int i, err, pci_using_dac;	u16 eeprom_data = 0;	u16 tmp = 0;	u16 eeprom_apme_mask = E1000_EEPROM_APME;	int bars, need_ioport;	bool disable_dev = false;	/* do not allocate ioport bars when not needed */	need_ioport = e1000_is_need_ioport(pdev);	if (need_ioport) {		bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO);		err = pci_enable_device(pdev);	} else {		bars = pci_select_bars(pdev, IORESOURCE_MEM);		err = pci_enable_device_mem(pdev);	}	if (err)		return err;	err = pci_request_selected_regions(pdev, bars, e1000_driver_name);	if (err)		goto err_pci_reg;	pci_set_master(pdev);	err = pci_save_state(pdev);	if (err)		goto err_alloc_etherdev;	err = -ENOMEM;	netdev = alloc_etherdev(sizeof(struct e1000_adapter));	if (!netdev)		goto err_alloc_etherdev;	SET_NETDEV_DEV(netdev, &pdev->dev);	pci_set_drvdata(pdev, netdev);	adapter = netdev_priv(netdev);	adapter->netdev = netdev;	adapter->pdev = pdev;	adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);	adapter->bars = bars;	adapter->need_ioport = need_ioport;	hw = &adapter->hw;	hw->back = adapter;	err = -EIO;	hw->hw_addr = pci_ioremap_bar(pdev, BAR_0);	if (!hw->hw_addr)		goto err_ioremap;	if (adapter->need_ioport) {		for (i = BAR_1; i < PCI_STD_NUM_BARS; i++) {			if (pci_resource_len(pdev, i) == 0)				continue;			if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {				hw->io_base = pci_resource_start(pdev, i);				break;			}		}	}	/* make ready for any if (hw->...) below */	err = e1000_init_hw_struct(adapter, hw);	if (err)		goto err_sw_init;	/* there is a workaround being applied below that limits	 * 64-bit DMA addresses to 64-bit hardware.  There are some	 * 32-bit adapters that Tx hang when given 64-bit DMA addresses	 */	pci_using_dac = 0;	if ((hw->bus_type == e1000_bus_type_pcix) &&	    !dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64))) {		pci_using_dac = 1;	} else {		err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));		if (err) {			pr_err("No usable DMA config, aborting\n");			goto err_dma;		}	}	netdev->netdev_ops = &e1000_netdev_ops;	e1000_set_ethtool_ops(netdev);	netdev->watchdog_timeo = 5 * HZ;	netif_napi_add(netdev, &adapter->napi, e1000_clean, 64);	strncpy(netdev->name, pci_name(pdev), sizeof(netdev->name) - 1);	adapter->bd_number = cards_found;	/* setup the private structure */	err = e1000_sw_init(adapter);	if (err)		goto err_sw_init;	err = -EIO;	if (hw->mac_type == e1000_ce4100) {		hw->ce4100_gbe_mdio_base_virt =					ioremap(pci_resource_start(pdev, BAR_1),						pci_resource_len(pdev, BAR_1));		if (!hw->ce4100_gbe_mdio_base_virt)			goto err_mdio_ioremap;	}	if (hw->mac_type >= e1000_82543) {		netdev->hw_features = NETIF_F_SG |				   NETIF_F_HW_CSUM |				   NETIF_F_HW_VLAN_CTAG_RX;		netdev->features = NETIF_F_HW_VLAN_CTAG_TX |				   NETIF_F_HW_VLAN_CTAG_FILTER;	}	if ((hw->mac_type >= e1000_82544) &&	   (hw->mac_type != e1000_82547))		netdev->hw_features |= NETIF_F_TSO;	netdev->priv_flags |= IFF_SUPP_NOFCS;	netdev->features |= netdev->hw_features;	netdev->hw_features |= (NETIF_F_RXCSUM |				NETIF_F_RXALL |				NETIF_F_RXFCS);	if (pci_using_dac) {		netdev->features |= NETIF_F_HIGHDMA;		netdev->vlan_features |= NETIF_F_HIGHDMA;	}	netdev->vlan_features |= (NETIF_F_TSO |				  NETIF_F_HW_CSUM |				  NETIF_F_SG);	/* Do not set IFF_UNICAST_FLT for VMWare's 82545EM */	if (hw->device_id != E1000_DEV_ID_82545EM_COPPER ||	    hw->subsystem_vendor_id != PCI_VENDOR_ID_VMWARE)		netdev->priv_flags |= IFF_UNICAST_FLT;	/* MTU range: 46 - 16110 */	netdev->min_mtu = ETH_ZLEN - ETH_HLEN;	netdev->max_mtu = MAX_JUMBO_FRAME_SIZE - (ETH_HLEN + ETH_FCS_LEN);	adapter->en_mng_pt = e1000_enable_mng_pass_thru(hw);	/* initialize eeprom parameters */	if (e1000_init_eeprom_params(hw)) {		e_err(probe, "EEPROM initialization failed\n");		goto err_eeprom;	}	/* before reading the EEPROM, reset the controller to	 * put the device in a known good starting state	 */	e1000_reset_hw(hw);	/* make sure the EEPROM is good */	if (e1000_validate_eeprom_checksum(hw) < 0) {		e_err(probe, "The EEPROM Checksum Is Not Valid\n");		e1000_dump_eeprom(adapter);		/* set MAC address to all zeroes to invalidate and temporary		 * disable this device for the user. This blocks regular		 * traffic while still permitting ethtool ioctls from reaching		 * the hardware as well as allowing the user to run the		 * interface after manually setting a hw addr using		 * `ip set address`		 */		memset(hw->mac_addr, 0, netdev->addr_len);	} else {		/* copy the MAC address out of the EEPROM */		if (e1000_read_mac_addr(hw))			e_err(probe, "EEPROM Read Error\n");	}	/* don't block initialization here due to bad MAC address */	memcpy(netdev->dev_addr, hw->mac_addr, netdev->addr_len);	if (!is_valid_ether_addr(netdev->dev_addr))		e_err(probe, "Invalid MAC Address\n");	INIT_DELAYED_WORK(&adapter->watchdog_task, e1000_watchdog);	INIT_DELAYED_WORK(&adapter->fifo_stall_task,			  e1000_82547_tx_fifo_stall_task);	INIT_DELAYED_WORK(&adapter->phy_info_task, e1000_update_phy_info_task);	INIT_WORK(&adapter->reset_task, e1000_reset_task);	e1000_check_options(adapter);	/* Initial Wake on LAN setting	 * If APM wake is enabled in the EEPROM,	 * enable the ACPI Magic Packet filter	 */	switch (hw->mac_type) {	case e1000_82542_rev2_0:	case e1000_82542_rev2_1:	case e1000_82543:		break;	case e1000_82544:		e1000_read_eeprom(hw,			EEPROM_INIT_CONTROL2_REG, 1, &eeprom_data);		eeprom_apme_mask = E1000_EEPROM_82544_APM;		break;	case e1000_82546:	case e1000_82546_rev_3:		if (er32(STATUS) & E1000_STATUS_FUNC_1) {			e1000_read_eeprom(hw,				EEPROM_INIT_CONTROL3_PORT_B, 1, &eeprom_data);			break;		}		/* Fall Through */	default:		e1000_read_eeprom(hw,			EEPROM_INIT_CONTROL3_PORT_A, 1, &eeprom_data);		break;	}	if (eeprom_data & eeprom_apme_mask)		adapter->eeprom_wol |= E1000_WUFC_MAG;	/* now that we have the eeprom settings, apply the special cases	 * where the eeprom may be wrong or the board simply won't support	 * wake on lan on a particular port	 */	switch (pdev->device) {	case E1000_DEV_ID_82546GB_PCIE:		adapter->eeprom_wol = 0;		break;	case E1000_DEV_ID_82546EB_FIBER:	case E1000_DEV_ID_82546GB_FIBER:		/* Wake events only supported on port A for dual fiber		 * regardless of eeprom setting		 */		if (er32(STATUS) & E1000_STATUS_FUNC_1)			adapter->eeprom_wol = 0;		break;	case E1000_DEV_ID_82546GB_QUAD_COPPER_KSP3:		/* if quad port adapter, disable WoL on all but port A */		if (global_quad_port_a != 0)			adapter->eeprom_wol = 0;		else			adapter->quad_port_a = true;		/* Reset for multiple quad port adapters */		if (++global_quad_port_a == 4)			global_quad_port_a = 0;		break;	}	/* initialize the wol settings based on the eeprom settings */	adapter->wol = adapter->eeprom_wol;	device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);	/* Auto detect PHY address */	if (hw->mac_type == e1000_ce4100) {		for (i = 0; i < 32; i++) {			hw->phy_addr = i;			e1000_read_phy_reg(hw, PHY_ID2, &tmp);			if (tmp != 0 && tmp != 0xFF)				break;		}		if (i >= 32)			goto err_eeprom;	}	/* reset the hardware with the new settings */	e1000_reset(adapter);	strcpy(netdev->name, "eth%d");	err = register_netdev(netdev);	if (err)		goto err_register;	e1000_vlan_filter_on_off(adapter, false);	/* print bus type/speed/width info */	e_info(probe, "(PCI%s:%dMHz:%d-bit) %pM\n",	       ((hw->bus_type == e1000_bus_type_pcix) ? "-X" : ""),	       ((hw->bus_speed == e1000_bus_speed_133) ? 133 :		(hw->bus_speed == e1000_bus_speed_120) ? 120 :		(hw->bus_speed == e1000_bus_speed_100) ? 100 :		(hw->bus_speed == e1000_bus_speed_66) ? 66 : 33),	       ((hw->bus_width == e1000_bus_width_64) ? 64 : 32),	       netdev->dev_addr);	/* carrier off reporting is important to ethtool even BEFORE open */	netif_carrier_off(netdev);	e_info(probe, "Intel(R) PRO/1000 Network Connection\n");	cards_found++;	return 0;err_register:err_eeprom:	e1000_phy_hw_reset(hw);	if (hw->flash_address)		iounmap(hw->flash_address);	kfree(adapter->tx_ring);	kfree(adapter->rx_ring);err_dma:err_sw_init:err_mdio_ioremap:	iounmap(hw->ce4100_gbe_mdio_base_virt);	iounmap(hw->hw_addr);err_ioremap:	disable_dev = !test_and_set_bit(__E1000_DISABLED, &adapter->flags);	free_netdev(netdev);err_alloc_etherdev:	pci_release_selected_regions(pdev, bars);err_pci_reg:	if (!adapter || disable_dev)		pci_disable_device(pdev);	return err;}

其中，函数e1000_is_need_ioport，表示当前网卡是否要通过ip口配置：

/** * e1000_is_need_ioport - determine if an adapter needs ioport resources or not * @pdev: PCI device information struct * * Return true if an adapter needs ioport resources **/static int e1000_is_need_ioport(struct pci_dev *pdev){	switch (pdev->device) {	case E1000_DEV_ID_82540EM:	case E1000_DEV_ID_82540EM_LOM:	case E1000_DEV_ID_82540EP:	case E1000_DEV_ID_82540EP_LOM:	case E1000_DEV_ID_82540EP_LP:	case E1000_DEV_ID_82541EI:	case E1000_DEV_ID_82541EI_MOBILE:	case E1000_DEV_ID_82541ER:	case E1000_DEV_ID_82541ER_LOM:	case E1000_DEV_ID_82541GI:	case E1000_DEV_ID_82541GI_LF:	case E1000_DEV_ID_82541GI_MOBILE:	case E1000_DEV_ID_82544EI_COPPER:	case E1000_DEV_ID_82544EI_FIBER:	case E1000_DEV_ID_82544GC_COPPER:	case E1000_DEV_ID_82544GC_LOM:	case E1000_DEV_ID_82545EM_COPPER:	case E1000_DEV_ID_82545EM_FIBER:	case E1000_DEV_ID_82546EB_COPPER:	case E1000_DEV_ID_82546EB_FIBER:	case E1000_DEV_ID_82546EB_QUAD_COPPER:		return true;	default:		return false;	}}

/** * 内存映射相关：想尝试追踪到底层汇编的代码上 * pci_select_bars - Make BAR mask from the type of resource * @dev: the PCI device for which BAR mask is made * @flags: resource type mask to be selected * * This helper routine makes bar mask from the type of resource. */int pci_select_bars(struct pci_dev *dev, unsigned long flags){	int i, bars = 0;	for (i = 0; i < PCI_NUM_RESOURCES; i++)		if (pci_resource_flags(dev, i) & flags)			bars |= (1 << i);	return bars;}EXPORT_SYMBOL(pci_select_bars);

具体这里的EXPORT_SYMBOL是啥？

#define EXPORT_SYMBOL(sym) _EXPORT_SYMBOL(sym, "")#define __EXPORT_SYMBOL(sym, sec, ns)	___EXPORT_SYMBOL(sym, sec, ns)#endif /* CONFIG_MODULES */#ifdef DEFAULT_SYMBOL_NAMESPACE#include <linux/stringify.h>#define _EXPORT_SYMBOL(sym, sec)	__EXPORT_SYMBOL(sym, sec, __stringify(DEFAULT_SYMBOL_NAMESPACE))#else#define _EXPORT_SYMBOL(sym, sec)	__EXPORT_SYMBOL(sym, sec, "")#endif#define EXPORT_SYMBOL(sym)		_EXPORT_SYMBOL(sym, "")#define EXPORT_SYMBOL_GPL(sym)		_EXPORT_SYMBOL(sym, "_gpl")#define EXPORT_SYMBOL_GPL_FUTURE(sym)	_EXPORT_SYMBOL(sym, "_gpl_future")#define EXPORT_SYMBOL_NS(sym, ns)	__EXPORT_SYMBOL(sym, "", #ns)#define EXPORT_SYMBOL_NS_GPL(sym, ns)	__EXPORT_SYMBOL(sym, "_gpl", #ns)#ifdef CONFIG_UNUSED_SYMBOLS#define EXPORT_UNUSED_SYMBOL(sym)	_EXPORT_SYMBOL(sym, "_unused")#define EXPORT_UNUSED_SYMBOL_GPL(sym)	_EXPORT_SYMBOL(sym, "_unused_gpl")/* * For every exported symbol, do the following: * * - If applicable, place a CRC entry in the __kcrctab section. * - Put the name of the symbol and namespace (empty string "" for none) in *   __ksymtab_strings. * - Place a struct kernel_symbol entry in the __ksymtab section. * * note on .section use: we specify progbits since usage of the "M" (SHF_MERGE) * section flag requires it. Use '%progbits' instead of '@progbits' since the * former apparently works on all arches according to the binutils source. */#define ___EXPORT_SYMBOL(sym, sec, ns)						\	extern typeof(sym) sym;							\	extern const char __kstrtab_##sym[];					\	extern const char __kstrtabns_##sym[];					\	__CRC_SYMBOL(sym, sec);							\	asm("	.section \"__ksymtab_strings\",\"aMS\",%progbits,1	\n"	\	    "__kstrtab_" #sym ":					\n"	\	    "	.asciz 	\"" #sym "\"					\n"	\	    "__kstrtabns_" #sym ":					\n"	\	    "	.asciz 	\"" ns "\"					\n"	\	    "	.previous						\n");	\	__KSYMTAB_ENTRY(sym, sec)

#define __CRC_SYMBOL(sym, sec)						\	asm("	.section \"___kcrctab" sec "+" #sym "\", \"a\"	\n"	\	    "	.weak	__crc_" #sym "				\n"	\	    "	.long	__crc_" #sym " - .			\n"	\	    "	.previous					\n")#else#define __CRC_SYMBOL(sym, sec)						\	asm("	.section \"___kcrctab" sec "+" #sym "\", \"a\"	\n"	\	    "	.weak	__crc_" #sym "				\n"	\	    "	.long	__crc_" #sym "				\n"	\	    "	.previous					\n")#endif

/* * Emit the ksymtab entry as a pair of relative references: this reduces * the size by half on 64-bit architectures, and eliminates the need for * absolute relocations that require runtime processing on relocatable * kernels. */#define __KSYMTAB_ENTRY(sym, sec)					\	__ADDRESSABLE(sym)						\	asm("	.section \"___ksymtab" sec "+" #sym "\", \"a\"	\n"	\	    "	.balign	4					\n"	\	    "__ksymtab_" #sym ":				\n"	\	    "	.long	" #sym "- .				\n"	\	    "	.long	__kstrtab_" #sym "- .			\n"	\	    "	.long	__kstrtabns_" #sym "- .			\n"	\	    "	.previous					\n")

原来是汇编。

其中，对pci设备初始化的函数也很重要：

函数 pci_enable_device(pdev)

/** * pci_enable_device - Initialize device before it's used by a driver. * @dev: PCI device to be initialized * * Initialize device before it's used by a driver. Ask low-level code * to enable I/O and memory. Wake up the device if it was suspended. * Beware, this function can fail. * * Note we don't actually enable the device many times if we call * this function repeatedly (we just increment the count). */#define IORESOURCE_IO		0x00000100	/* PCI/ISA I/O ports */#define IORESOURCE_MEM		0x00000200int pci_enable_device(struct pci_dev *dev){	return pci_enable_device_flags(dev, IORESOURCE_MEM | IORESOURCE_IO);}EXPORT_SYMBOL(pci_enable_device);

static int pci_enable_device_flags(struct pci_dev *dev, unsigned long flags){	struct pci_dev *bridge;	int err;	int i, bars = 0;	/*	 * Power state could be unknown at this point, either due to a fresh	 * boot or a device removal call.  So get the current power state	 * so that things like MSI message writing will behave as expected	 * (e.g. if the device really is in D0 at enable time).	 */	if (dev->pm_cap) {		u16 pmcsr;		pci_read_config_word(dev, dev->pm_cap + PCI_PM_CTRL, &pmcsr);		dev->current_state = (pmcsr & PCI_PM_CTRL_STATE_MASK);	}	if (atomic_inc_return(&dev->enable_cnt) > 1)		return 0;		/* already enabled */	bridge = pci_upstream_bridge(dev);	if (bridge)		pci_enable_bridge(bridge);	/* only skip sriov related */	for (i = 0; i <= PCI_ROM_RESOURCE; i++)		if (dev->resource[i].flags & flags)			bars |= (1 << i);	for (i = PCI_BRIDGE_RESOURCES; i < DEVICE_COUNT_RESOURCE; i++)		if (dev->resource[i].flags & flags)			bars |= (1 << i);	err = do_pci_enable_device(dev, bars);	if (err < 0)		atomic_dec(&dev->enable_cnt);	return err;}

最终的执行函数为do_pci_enable_device

#define PCI_D0		((pci_power_t __force) 0)#define PCI_INTERRUPT_PIN	0x3d	/* 8 bits */#define PCI_COMMAND		0x04	/* 16 bits */#define  PCI_COMMAND_INTX_DISABLE 0x400 /* INTx Emulation Disable */static int do_pci_enable_device(struct pci_dev *dev, int bars){	int err;	struct pci_dev *bridge;	u16 cmd;	u8 pin;	err = pci_set_power_state(dev, PCI_D0);	if (err < 0 && err != -EIO)		return err;	bridge = pci_upstream_bridge(dev);	if (bridge)		pcie_aspm_powersave_config_link(bridge);	err = pcibios_enable_device(dev, bars);	if (err < 0)		return err;	pci_fixup_device(pci_fixup_enable, dev);	if (dev->msi_enabled || dev->msix_enabled)		return 0;	pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin);	if (pin) {		pci_read_config_word(dev, PCI_COMMAND, &cmd);		if (cmd & PCI_COMMAND_INTX_DISABLE)			pci_write_config_word(dev, PCI_COMMAND,					      cmd & ~PCI_COMMAND_INTX_DISABLE);	}	return 0;}

int __weak pcibios_enable_device(struct pci_dev *dev, int bars){return pci_enable_resources(dev, bars);}

int pci_enable_resources(struct pci_dev *dev, int mask){	u16 cmd, old_cmd;	int i;	struct resource *r;  // 重点解读函数	pci_read_config_word(dev, PCI_COMMAND, &cmd);	old_cmd = cmd;	for (i = 0; i < PCI_NUM_RESOURCES; i++) {		if (!(mask & (1 << i)))			continue;		r = &dev->resource[i];		if (!(r->flags & (IORESOURCE_IO | IORESOURCE_MEM)))			continue;		if ((i == PCI_ROM_RESOURCE) &&				(!(r->flags & IORESOURCE_ROM_ENABLE)))			continue;		if (r->flags & IORESOURCE_UNSET) {			pci_err(dev, "can't enable device: BAR %d %pR not assigned\n",				i, r);			return -EINVAL;		}		if (!r->parent) {			pci_err(dev, "can't enable device: BAR %d %pR not claimed\n",				i, r);			return -EINVAL;		}		if (r->flags & IORESOURCE_IO)			cmd |= PCI_COMMAND_IO;		if (r->flags & IORESOURCE_MEM)			cmd |= PCI_COMMAND_MEMORY;	}	if (cmd != old_cmd) {		pci_info(dev, "enabling device (%04x -> %04x)\n", old_cmd, cmd);    //重点解读函数		pci_write_config_word(dev, PCI_COMMAND, cmd);	}	return 0;}

int pci_read_config_word(const struct pci_dev *dev, int where, u16 *val){	if (pci_dev_is_disconnected(dev)) {		*val = ~0;		return PCIBIOS_DEVICE_NOT_FOUND;	}	return pci_bus_read_config_word(dev->bus, dev->devfn, where, val);}

顺着代码往深了找，希望能找到读写配置文件的汇编代码

#define PCI_byte_BAD 0#define PCI_word_BAD (pos & 1)#define PCI_dword_BAD (pos & 3)#ifdef CONFIG_PCI_LOCKLESS_CONFIG# define pci_lock_config(f)	do { (void)(f); } while (0)# define pci_unlock_config(f)	do { (void)(f); } while (0)#else# define pci_lock_config(f)	raw_spin_lock_irqsave(&pci_lock, f)# define pci_unlock_config(f)	raw_spin_unlock_irqrestore(&pci_lock, f)#endif#define PCI_OP_READ(size, type, len) \int noinline pci_bus_read_config_##size \	(struct pci_bus *bus, unsigned int devfn, int pos, type *value)	\{									\	int res;							\	unsigned long flags;						\	u32 data = 0;							\	if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;	\	pci_lock_config(flags);						\	res = bus->ops->read(bus, devfn, pos, len, &data);		\	*value = (type)data;						\	pci_unlock_config(flags);					\	return res;							\}#define PCI_OP_WRITE(size, type, len) \int noinline pci_bus_write_config_##size \	(struct pci_bus *bus, unsigned int devfn, int pos, type value)	\{									\	int res;							\	unsigned long flags;						\	if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;	\	pci_lock_config(flags);						\	res = bus->ops->write(bus, devfn, pos, len, value);		\	pci_unlock_config(flags);					\	return res;							\}PCI_OP_READ(byte, u8, 1)PCI_OP_READ(word, u16, 2)PCI_OP_READ(dword, u32, 4)PCI_OP_WRITE(byte, u8, 1)PCI_OP_WRITE(word, u16, 2)PCI_OP_WRITE(dword, u32, 4)EXPORT_SYMBOL(pci_bus_read_config_byte);EXPORT_SYMBOL(pci_bus_read_config_word);EXPORT_SYMBOL(pci_bus_read_config_dword);EXPORT_SYMBOL(pci_bus_write_config_byte);EXPORT_SYMBOL(pci_bus_write_config_word);EXPORT_SYMBOL(pci_bus_write_config_dword);

es = bus->ops->write(bus, devfn, pos, len, value);

bus->ops->write

这个write是不是就是我要找的往IO端口写操作？

/* Low-level architecture-dependent routines */struct pci_ops {	int (*add_bus)(struct pci_bus *bus);	void (*remove_bus)(struct pci_bus *bus);	void __iomem *(*map_bus)(struct pci_bus *bus, unsigned int devfn, int where);	int (*read)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *val);	int (*write)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 val);};

pci_ops里都是函数指针了

这种函数指针不太好找源头了，只要把函数的地址给它，它就可以调用那个函数。

所以，要想知道它具体执行的是哪段代码，就不太好找了。我还没找到。

看来，直接读linux操作系统的源码，找到一些非常底层，非常细节的信息还是比较困难的。因为这里有大量的宏定义的使用，导致我们使用字符串查找去跟踪函数调用的方法失败了。

不过，从代码的上下文来猜测的话，应该是读PCI的配置信息的。

其实读PCI的配置信息可以直接从IO端口读。

我们可以从底层出发，直接自己写IO端口的读写程序，写完以后再尝试来参考linxu操作系统的相关代码。

直接从IO端口读

在内核的：arch/x86/pci/early.c

文件内，有从IO端口读取PCI配置信息的代码

// SPDX-License-Identifier: GPL-2.0#include <linux/kernel.h>#include <linux/pci.h>#include <asm/pci-direct.h>#include <asm/io.h>#include <asm/pci_x86.h>/* Direct PCI access. This is used for PCI accesses in early boot before   the PCI subsystem works. */u32 read_pci_config(u8 bus, u8 slot, u8 func, u8 offset){	u32 v;	outl(0x80000000 | (bus<<16) | (slot<<11) | (func<<8) | offset, 0xcf8);	v = inl(0xcfc);	return v;}u8 read_pci_config_byte(u8 bus, u8 slot, u8 func, u8 offset){	u8 v;	outl(0x80000000 | (bus<<16) | (slot<<11) | (func<<8) | offset, 0xcf8);	v = inb(0xcfc + (offset&3));	return v;}u16 read_pci_config_16(u8 bus, u8 slot, u8 func, u8 offset){	u16 v;	outl(0x80000000 | (bus<<16) | (slot<<11) | (func<<8) | offset, 0xcf8);	v = inw(0xcfc + (offset&2));	return v;}void write_pci_config(u8 bus, u8 slot, u8 func, u8 offset,				    u32 val){	outl(0x80000000 | (bus<<16) | (slot<<11) | (func<<8) | offset, 0xcf8);	outl(val, 0xcfc);}void write_pci_config_byte(u8 bus, u8 slot, u8 func, u8 offset, u8 val){	outl(0x80000000 | (bus<<16) | (slot<<11) | (func<<8) | offset, 0xcf8);	outb(val, 0xcfc + (offset&3));}void write_pci_config_16(u8 bus, u8 slot, u8 func, u8 offset, u16 val){	outl(0x80000000 | (bus<<16) | (slot<<11) | (func<<8) | offset, 0xcf8);	outw(val, 0xcfc + (offset&2));}int early_pci_allowed(void){	return (pci_probe & (PCI_PROBE_CONF1|PCI_PROBE_NOEARLY)) ==			PCI_PROBE_CONF1;}

这个代码我们是可以移植到30天操作系统harios上的，把这个代码中的outl和inl换成harios内的io_out,io_in函数就可以了。

也就是说，我们可以按照以上代码读取，或者写入到配置信息了。

这里的配置信息到底是什么呢？，就是如下图中的4x16=64Bytes的信息

配置信息

参考：

通过读这个配置信息的class_code字段，我们就知道PCI连接的设备是网卡？还是显卡？还是硬盘？还是声卡？

这个配置信息的Device ID，Vendor ID,表明PCI连接的设备的型号和制造厂商.

这个配置信息的Base Address 0 里存储了PCI连接的设备的地址映射内存中的地址。

总之，只要读到这个配置信息，我们就可以找到网卡，找到网卡，才能控制网卡向外发送信息，接收信息等。

那么具体如何读取这个配置信息呢？通过I/O口0xCF8和0xCFC,通过这两个端口，就可以读取到配置信息了。如下两行代码：

io_out32(0xCF8, addr);// 把配置信息的地址addr输出到I/O端口0xCF8indata = io_in32(0xCFC); //从I/O端口0xCFC获取到配置信息。

这里面的addr是什么？是配置信息所在的地址，可以这样生成：

  unsigned int bus_max=0xff;  unsigned int dev_max=0x1f;  unsigned int func_max=0x07;  // 遍历配置信息	for(bus=0;bus<=bus_max;++bus)	{		for(dev=0;dev<=dev_max;++dev)		{			for(func=0;func<=func_max;++func)			{          // 生成配置信息的地址 				  unsigned int addr = 0x80000000L | (bus<<16) | (dev<<11) | (func<<8) | (0<<2);    			io_out32(0xCF8, addr);    			indata = io_in32(0xCFC);      }    }  }

这里生成配置信息的地址：0x80000000 | (bus<16) | (dev<<11) | (func<<8) | (0<<2);

这是什么意思呢？

首先这是一个8*4=32bits的数，4个bytes,这4个bytes的意义：

最高位31位要设置成1，才能表示对PCI的配置信息操作。如果此位为0，表示要PCI所连接的设备的操作。

30--24是保留位，我们可以写入我们特定信息。

23--16位是总线号，15--11位是设备号，10--8位是功能号，7--2位是配置信息中某条信息的偏移地址。

所以，

0x80000000 | (bus<16) | (dev<<11) | (func<<8) | (offset<<2);

的意思是对配置信息中的总线号为bus,设备号为dev,功能号为func所指定的配置信息中的第offset个4字节的信息进行操作。

第0个4字节的信息，其实就是配置信息的第一行，Device ID 和Vendor ID.

那么第三行就是class code,第4行就是header type 了。

所以，我们要访问所有的配置信息，只用改变offset的值，使其为分别为0--15，就可以分别读取到所有的配置信息了。

那么地址中的bus,dev,func是什么意思呢？

跟CPU连接的PCI有很多，用bus, dev,func就把不同的PCI区分开了。那么与当前CPU连接的PCI的bus, dev,func分别是多少呢？

也就是说，bus, dev,func到底填多少合适？到底网卡连接的pci对应的bus,dev,func应该是多少呢？

可以写for循环去搜索，当bus,dev,func取到合适的值时，我们读取到的配置信息的class_code应该是02。

因为class_code是02时，表示PCI连接的设备是网卡。

所以，我们在以上代码中写了for循环，去遍历所有的bus,dev,func的值，看看哪些位置有pci,并且这个pci连接的是网卡。

那么如何知道哪些bus,dev,func的值对应的有pci? 只用看其对应的配置信息的第1行，如果第1行的DeviceID 和 Vendor ID不是0xFFFF,就说明有配置信息。

有配置信息，说明PCI连接的有设备，但不一定是网卡，还可能是显卡，硬盘等。

所以，我们还要进一步看其class_code的值，如果是02,就表示是网卡。

另外，遍历总线号bus时，由于bus的数字是存储于adder的23--16位的，一共8个bit位，所以，其取值范围为0--255，

遍历设备号dev时，由于其存储于addr的15--11位，共5位，所以，其取值范围为0--31.

遍历功能号func时，由于其存储于addr的10-8位，共3位，所以，其取值范围为0-7.

那么最终，我们的代码为：

void check_pci(unsigned char *buf_back,struct BOOTINFO *binfo){    char s[200];    unsigned int indata;	  int bus,dev,func;    unsigned int bus_max=0xff;    unsigned int dev_max=0x1f;    unsigned int func_max=0x07;    // 设置打印信息的显示位置    int start_row=250;    int start_col=50;    int row_inc=0;    int i;    sprintf(s, "buf        ,dev        ,func       ,vender_id  ,device_id  ,header_type,class_code ");	  putfonts8_asc(buf_back, binfo->scrnx, start_col, start_row-1*16, COL8_FFFFFF, s);				for(bus=0;bus<=bus_max;++bus)	{		for(dev=0;dev<=dev_max;++dev)		{			for(func=0;func<=func_max;++func)			{	 				  unsigned int addr = 0x80000000L | (bus<<16) | (dev<<11) | (func<<8) | (0<<2);    			io_out32(0xCF8, addr);    			indata = io_in32(0xCFC);        // 查看当前bus,dev,func处有无pci				if( ((indata & 0xffff) != 0xffff)  && (indata !=0))				{          					//如果有，获取当前pci的第4行的header type 					unsigned int addr1 = addr | (3<<2);					io_out32(0xCF8,addr1);					unsigned int header_type = (io_in32(0xCFC)&0x00ff0000)>>16;					//获取当前pci的第3行的class code ,这个可以看到设备是否是网卡					unsigned int addr2 = addr | (2<<2);					io_out32(0xCF8,addr2);					unsigned int class_code = (io_in32(0xCFC)&0xff000000)>>24;          // 显示pci的device id,vendor id,header type, class code 					sprintf(s, "%02d         ,%02d         ,%02d         ,0x%04x     ,0x%04x     ,0x%02x       ,0x%02x       ",bus,dev,func,indata&0xffff,(indata&0xffff0000)>>16,header_type,class_code);					putfonts8_asc(buf_back, binfo->scrnx, start_col, start_row+row_inc*16, COL8_FFFFFF, s);				    row_inc++;				}							}		}	}	return;}

把函数check_pci添加到bootpack.c的for循环之前：

    check_pci(buf_back,binfo);//打印pci信息    // 图层刷新    sheet_refresh(sht_back,  0, 0, sht_back->bxsize,  sht_back->bysize);

显示效果如下

可以看到，在bus=0,dev=0,func=0时，对应的pci所连接的设备的vender_id是0x8086,表示是Inter的，device_id是1237,header_type是0，class_code是0x06,表明不是网卡，0x06具体表示什么？看下表：

表明它是桥设备。

根据这个表，咱们打印出的第3行是0x01, 表示海量存储器

根据这个表，咱们打印出的第4行是0x03, 表示网络控制器，即显卡

根据这个表，咱们打印出的第5行是0x02, 表示显示控制器，即网卡。

那么到这里，我们在bus号为0,dev号为3，func号为0的位置，找到了一张网卡。它的厂商是0x10ech,设备号是8029h

好了，到这里，今天我们通过I/O端口，读取到了网卡对应的PCI.

下一步就可以通过网卡对应的PCI来控制网卡收发信息。

附录：

在30天操作系统上写网卡驱动需要从头开始，是比较琐碎的事，为此，我搜索了一定的源码和资料。

源码就是linux系统的各版本内核的源码，它带有很多网卡的驱动。

资料就是对pci，总线，以及内存映射，网络通信协议等资料。

在后续的驱动编写中，可能要反复的来复习这些资料。

比如：

这里面说了两种方法访问配置信息，第一种就是通过端口的0xCF8,0xCFC；第二种是通过内存映射。

比如直接访问如下的内存区域即可得到：

我还没有试。留着以后参考中。

还有一个细节，汇编对端口的读写，要特别注意。

比如我这里一开始端口的读写程序有bug,所以读取信息一直是错误的。

最后把 端口的读写程序从

_io_out32:	; void io_out32(int port, int data);		MOV		EDX,[ESP+4]		; port		MOV		EAX,[ESP+8]		; data		OUT		EDX,EAX		RET

改为

_io_out32:	; void io_out32(int port, int data);		MOV		DX,[ESP+4]		; port		MOV		EAX,[ESP+8]		; data		OUT		DX,EAX		RET

后，就正常了，

因为端口的地址0xCF8，不需要EDX,用EDX反而不能表示端口了，就无法给实现往端口上输出信息。

关于端口读写，还有用嵌入汇编的方式，比如：

另外，使用端口对PCI配置信息的读取有个例子不错，可以参考：

这里写了一个window上的代码和一个linux上的代码。

比如我用linux上的代码后，输入的结果如下：

运行的时候，需要用sudo。因为这里设计到IO读取，所以需要root权限。

另外运行这个例子的时候，我就有个疑问：问什么这个例子明明是个应用程序，不是操作系统本身的代码，它却可以访问IO端口？

一般应用程序的代码，由于GDT的定义，应该是不能操作I/O端口的。

后来的代码里发现了

   if ( iopl(3) < 0 )    {        printf("iopl set error\n");        return -1;    }

iopl函数用于获取io端口的访问权限，如果这个函数获取返回值大于0，就可以通过操作系统所提供的中断函数来对io端口进行访问了。

总之：应用程序要访问操作系统所占用的哪些资源，都得通过中断函数来访问。通过中断函数，我们就可以设计权限，加以控制，保证操作系统代码本身的安全性。

以下是一些样例：

在30天操作系统的代码上，添加读pci配置的程序check_pci的过程并不顺利，一开始写到屏幕上的信息无法刷新出来，就通过鼠标移动过去，把这些信息“擦”出来。当然后来发现使用刷新函数的时候，刷新错对象向，应该刷新sht_back,就过刷新sht_win了，sht_win表示的是tast_a窗口，如下图。

第一次成功

上图中显示了很多0xffff,这是因为程序什么也没有输出，所以我们调试的时候，就把所有的信息都输出的屏幕上了；我把没有cpi时的信息显示到左边，有cpi时的信息显示到了右边。

更改刷新函数后，可以正常刷新了

用MAC上的qemu打开了30天自制的操作系统，发现多了一个设备0x100e的设备

增加打印PCI所连接设备的header type和class_code信息

在MAC上

增加打印，在mac上的qemu上运行30天操作系统代码

可以看到，这里一共6个设备，比在windows上的qemu多了一个设备，多了一些PCI桥设备。网卡的型号变成100e了。

既然找到网卡了，下一步就是启动网卡，读取网卡的mac地址，命令网卡发送数据等了。

具体怎么实现呢？

1比如重启网卡设备，就是给网卡的某寄存器写入命令，用I/O方法，或者内存映射的方法。具体详细信息可以查看网卡信息的datasheet。

重启网卡设备，则是通过向映射后的网卡的相应寄存器写入命令，其通过映射后的首地址及相应的寄存器偏移量找到该寄存器的位置，然后通过函数writeb()写该寄存器。有关相关寄存器对应的偏移量，一般是通过网卡的相关的datasheet获得。

2.如果要获取网卡的MAC地址，则一般通过函数readb()读取首地址开始的前六位。

后面我们就获取到网卡的MAC地址，然后给网卡的寄存器里写值，来命令网卡收发信息。或者把网卡动作与操作系统的中断绑定起来。