#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/ethtool.h>
struct net_device_stats mycard_stats;   /* Statistics */
/* Fill ethtool_ops methods from a suitable place in the driver */
struct ethtool_ops mycard_ethtool_ops = {/* ... */.get_eeprom = mycard_get_eeprom,      /* Dump EEPROM contents *//* ... */
};
/* Initialize/probe the card. For PCI cards, this is invokedfrom (or is itself) the probe() method. In that case, thefunction is declared as:static struct net_device *init_mycard(struct pci_dev *pdev, conststruct pci_device_id *id)
*/
static struct net_device *
init_mycard()
{struct net_device *netdev;struct priv_struct mycard_priv;/* ... */netdev = alloc_etherdev(sizeof(struct priv_struct));/* Common methods */netdev->netdev_ops = &my_netdev_ops;dev->ethtool_ops = &my_ethtool_ops;dev->watchdog_timeo = TX_TIMEOUT;netif_napi_add(dev, &tp->napi, my_poll, 64);/* Register the interface */register_netdev(netdev);/* ... *//* Get MAC address from attached EEPROM *//* ... *//* Download microcode if needed *//* ... */
}
/* The interrupt handler */
static irqreturn_t
mycard_interrupt(int irq, void *dev_id)
{struct net_device *netdev = dev_id;struct sk_buff *skb;unsigned int length;/* ... */if (receive_interrupt) {/* We were interrupted due to packet reception. At this point,the NIC has already DMA'ed received data to an sk_buff thatwas pre-allocated and mapped during device open. Obtain theaddress of the sk_buff depending on your data structuredesign and assign it to 'skb'. 'length' is similarly obtainedfrom the NIC by reading the descriptor used to DMA data fromthe card. Now, skb->data contains the receive data. *//* ... *//* For PCI cards, perform a pci_unmap_single() on thereceived buffer in order to allow the CPU to access it *//* ... *//* Allow the data go to the tail of the packet by movingskb->tail down by length bytes and increasingskb->len correspondingly */skb_put(skb, length)/* Pass the packet to the TCP/IP stack */
#if !defined (USE_NAPI)  /* Do it the old way */netif_rx(skb);
#else                    /* Do it the NAPI way */if (napi_schedule_prep(&priv->napi))) {/* Disable NIC interrupt. Implementation not shown. */disable_nic_interrupt();      /* Post the packet to the protocol layer andadd the device to the poll list */__napi_schedule(&priv->napi);}
#endif} else if (tx_complete_interrupt) {/* Transmit Complete Interrupt *//* ... *//* Unmap and free transmit resources such asDMA descriptors and buffers. Free sk_buffs orreclaim them into a free pool *//* ... */
}
}
/* Driver open */
static int
mycard_open(struct net_device *netdev)
{/* ... *//* Request irq */request_irq(irq, mycard_interrupt, IRQF_SHARED,netdev->name, dev);/* Fill transmit and receive rings *//* See the section,"Buffer Management and Concurrency Control" *//* ... *//* Provide free descriptor addresses to the card *//* ... *//* Convey your readiness to accept data from thenetworking stack */netif_start_queue(netdev);/* ... */
}
/* Driver close */
static int
mycard_close(struct net_device *netdev)
{/* ... *//* Ask the networking stack to stop sending down data */netif_stop_queue(netdev);/* ... */
}
/* Called when the device is unplugged or when the module isreleased. For PCI cards, this is invoked from (or is itself)the remove() method. In that case, the function is declared as:static void __devexit mycard_remove(struct pci_dev *pdev)
*/
static void __devexit
mycard_remove(){struct net_device *netdev;/* ... *//* For a PCI card, obtain the associated netdev as follows,assuming that the probe() method performed a correspondingpci_set_drvdata(pdev, netdev) after allocating the netdev */netdev = pci_get_drvdata(pdev); /*unregister_netdev(netdev);  /* Reverse of register_netdev() *//* ... */free_netdev(netdev);       /* Reverse of alloc_netdev() *//* ... */
}
/* Suspend method. For PCI devices, this is part ofthe pci_driver structure discussed in Chapter 10 */
static int
mycard_suspend(struct pci_dev *pdev, pm_message_t state)
{/* ... */netif_device_detach(netdev);/* ... */
}
/* Resume method. For PCI devices, this is part ofthe pci_driver structure discussed in Chapter 10 */
static int
mycard_resume(struct pci_dev *pdev)
{/* ... */netif_device_attach(netdev);/* ... */
}
/* Get statistics */
static struct net_device_stats *
mycard_get_stats(struct net_device *netdev)
{/* House keeping *//* ... */return(&mycard_stats);
}
/* Dump EEPROM contents. This is an ethtool_ops operation */
static int
mycard_get_eeprom(struct net_device *netdev,struct ethtool_eeprom *eeprom, uint8_t *bytes)
{/* Read data from the accompanying EEPROM *//* ... */
}/* Poll method */
static int
mycard_poll(struct net_device *netdev, int *budget)
{/* Post packets to the protocol layer usingnetif_receive_skb() *//* ... */if (no_more_ingress_packets()){/* Remove the device from the polled list */__napi_complete(netdev);/* Fall back to interrupt mode. Implementation not shown */enable_nic_interrupt();return 0;}
}
/* Transmit method */
static int
mycard_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
{/* DMA the transmit packet from the associated sk_buffto card memory *//* ... *//* Manage buffers *//* ... */
}

需要注意的是，网卡驱动使用了new api 机制，硬件对接收到的包是进行中断来通知驱动处理还是通过轮询的方式来处理，该机制进行了简单的判断。接收到的数据与协议栈进行通信才是核心部分，主要工作都在接收函数，需要将接收到的数据存放到sk_buff 结构中，然后对其进行调整填充等操作，然后直接将数据送往上一层。注意：网卡是一个数据链路层设备 ！网卡驱动需要将接收到的数据送往网络层，将要发送的数据送到物理层，当然这个动作都由硬件来完成。