ARM-Linux驱动--DM9000网卡驱动分析（四）

 

1、接下来接着分析DM9000网卡驱动的数据接收函数

view plain copy to clipboard print ?

1. /* 
2.  *  Received a packet and pass to upper layer 
3.  *  接收数据包，将数据包传递给上层 
4.  */  
5. static void  
6. dm9000_rx(struct net_device *dev)  
7. {  
8.     board_info_t *db = netdev_priv(dev);/* 得到网卡私有信息数据结构的首地址 */  
9.     struct dm9000_rxhdr rxhdr;/* 该结构体封装了dm9000接收的数据包信息 */  
10.     struct sk_buff *skb;  
11.     u8 rxbyte, *rdptr;  
12.     bool GoodPacket;  
13.     int RxLen;  
14.   
15.     /* Check packet ready or not */  
16.     do {  
17.         /* MRCMDX是内存数据预取读命令 */  
18.         ior(db, DM9000_MRCMDX); /* Dummy read */  
19.         /* Get most updated data */  
20.         rxbyte = readb(db->io_data);  
21.   
22.         /* Status check: this byte must be 0 or 1 */  
23.         /* DM9000_PKT_ERR          0x02 ,表示接收出错 */  
24.         if (rxbyte & DM9000_PKT_ERR) {  
25.             dev_warn(db->dev, "status check fail: %d\n", rxbyte);/* 输出提示信息 */  
26.             iow(db, DM9000_RCR, 0x00);  /* Stop Device 关闭设备 */  
27.             iow(db, DM9000_ISR, IMR_PAR);   /* Stop INT request 停止中断请求*/  
28.             return;  
29.         }  
30.           
31.         /* DM9000_PKT_RDY          0x01 没有准备好，直接返回*/  
32.         if (!(rxbyte & DM9000_PKT_RDY))  
33.             return;  
34.   
35.         /* A packet ready now  & Get status/length */  
36.         GoodPacket = true;  
37.         writeb(DM9000_MRCMD, db->io_addr);/* MRCMD是地址增加的数据读取命令 */  
38.   
39.         (db->inblk)(db->io_data, &rxhdr, sizeof(rxhdr));/* 读取数据，从RX_SRAM到 rxhdr结构体中*/  
40.   
41.         RxLen = le16_to_cpu(rxhdr.RxLen);  
42.   
43.         if (netif_msg_rx_status(db))  
44.             dev_dbg(db->dev, "RX: status %02x, length %04x\n",  
45.                 rxhdr.RxStatus, RxLen);  
46.   
47.         /* Packet Status check ，检查包的完整性*/  
48.         if (RxLen < 0x40) {  
49.             GoodPacket = false;  
50.             if (netif_msg_rx_err(db))  
51.                 dev_dbg(db->dev, "RX: Bad Packet (runt)\n");  
52.         }  
53.         /* 如果数据长度大于DM9000_PKT_MAX ，即 1536 */  
54.         if (RxLen > DM9000_PKT_MAX) {  
55.             dev_dbg(db->dev, "RST: RX Len:%x\n", RxLen);  
56.         }  
57.   
58.         /* rxhdr.RxStatus is identical to RSR register. */  
59.         /* 这里也是包的检查 */  
60.         if (rxhdr.RxStatus & (RSR_FOE | RSR_CE | RSR_AE |  
61.                       RSR_PLE | RSR_RWTO |  
62.                       RSR_LCS | RSR_RF)) {  
63.             GoodPacket = false;  
64.             if (rxhdr.RxStatus & RSR_FOE) {  
65.                 if (netif_msg_rx_err(db))  
66.                     dev_dbg(db->dev, "fifo error\n");  
67.                 dev->stats.rx_fifo_errors++;  
68.             }  
69.             if (rxhdr.RxStatus & RSR_CE) {  
70.                 if (netif_msg_rx_err(db))  
71.                     dev_dbg(db->dev, "crc error\n");  
72.                 dev->stats.rx_crc_errors++;  
73.             }  
74.             if (rxhdr.RxStatus & RSR_RF) {  
75.                 if (netif_msg_rx_err(db))  
76.                     dev_dbg(db->dev, "length error\n");  
77.                 dev->stats.rx_length_errors++;  
78.             }  
79.         }  
80.   
81.         /* Move data from DM9000 ，从DM9000获取数据*/  
82.         if (GoodPacket &&  
83.             ((skb = dev_alloc_skb(RxLen + 4)) != NULL)) {  
84.             skb_reserve(skb, 2);  
85.             rdptr = (u8 *) skb_put(skb, RxLen - 4);  
86.   
87.             /* Read received packet from RX SRAM */  
88.             /* 将RX SRAM中的数据读取到skbuff结构体 */  
89.             (db->inblk)(db->io_data, rdptr, RxLen);  
90.             dev->stats.rx_bytes += RxLen;  
91.   
92.             /* Pass to upper layer */  
93.             skb->protocol = eth_type_trans(skb, dev);  
94.             if (db->rx_csum) {  
95.                 if ((((rxbyte & 0x1c) << 3) & rxbyte) == 0)  
96.                     skb->ip_summed = CHECKSUM_UNNECESSARY;  
97.                 else  
98.                     skb->ip_summed = CHECKSUM_NONE;  
99.             }  
100.             netif_rx(skb);/* 将skbuff结构体发送给上层 */  
101.             dev->stats.rx_packets++;/* 计数增1 */  
102.   
103.         } else {  
104.             /* need to dump the packet's data */  
105.             /* 坏包，丢弃 */  
106.             (db->dumpblk)(db->io_data, RxLen);  
107.         }  
108.     } while (rxbyte & DM9000_PKT_RDY);  
109. }  

2、下面是完整的DM9000驱动代码，可以完整的查看

view plain copy to clipboard print ?

1. #include <linux/module.h>   
2. #include <linux/ioport.h>   
3. #include <linux/netdevice.h>   
4. #include <linux/etherdevice.h>   
5. #include <linux/init.h>   
6. #include <linux/skbuff.h>   
7. #include <linux/spinlock.h>   
8. #include <linux/crc32.h>   
9. #include <linux/mii.h>   
10. #include <linux/ethtool.h>   
11. #include <linux/dm9000.h>   
12. #include <linux/delay.h>   
13. #include <linux/platform_device.h>   
14. #include <linux/irq.h>   
15. #include <linux/slab.h>   
16.   
17. #include <asm/delay.h>   
18. #include <asm/irq.h>   
19. #include <asm/io.h>   
20.   
21. #include "dm9000.h"   
22.   
23. #include <mach/regs-gpio.h>    
24. #include <mach/irqs.h>   
25. #include <mach/hardware.h>   
26.   
27. /* Board/System/Debug information/definition ---------------- */  
28.   
29. #define DM9000_PHY      0x40    /* PHY address 0x01 */   
30.   
31. #define CARDNAME    "dm9000"   
32. #define DRV_VERSION "1.31"   
33.   
34. /* 
35.  * Transmit timeout, default 5 seconds. 
36.  */  
37. static int watchdog = 5000;  
38. module_param(watchdog, int, 0400);  
39. MODULE_PARM_DESC(watchdog, "transmit timeout in milliseconds");  
40.   
41. /* DM9000 register address locking. 
42.  * 
43.  * The DM9000 uses an address register to control where data written 
44.  * to the data register goes. This means that the address register 
45.  * must be preserved over interrupts or similar calls. 
46.  * 
47.  * During interrupt and other critical calls, a spinlock is used to 
48.  * protect the system, but the calls themselves save the address 
49.  * in the address register in case they are interrupting another 
50.  * access to the device. 
51.  * 
52.  * For general accesses a lock is provided so that calls which are 
53.  * allowed to sleep are serialised so that the address register does 
54.  * not need to be saved. This lock also serves to serialise access 
55.  * to the EEPROM and PHY access registers which are shared between 
56.  * these two devices. 
57.  */  
58.   
59. /* The driver supports the original DM9000E, and now the two newer 
60.  * devices, DM9000A and DM9000B. 
61.  */  
62.   
63. enum dm9000_type {  
64.     TYPE_DM9000E,   /* original DM9000 */  
65.     TYPE_DM9000A,  
66.     TYPE_DM9000B  
67. };  
68.   
69. /* Structure/enum declaration ------------------------------- */  
70. typedef struct board_info {  
71.   
72.     void __iomem    *io_addr;   /* Register I/O base address */  
73.     void __iomem    *io_data;   /* Data I/O address */  
74.     u16      irq;       /* IRQ */  
75.   
76.     u16     tx_pkt_cnt;  
77.     u16     queue_pkt_len;  
78.     u16     queue_start_addr;  
79.     u16     queue_ip_summed;  
80.     u16     dbug_cnt;  
81.     u8      io_mode;        /* 0:word, 2:byte */  
82.     u8      phy_addr;  
83.     u8      imr_all;  
84.   
85.     unsigned int    flags;  
86.     unsigned int    in_suspend :1;  
87.     unsigned int    wake_supported :1;  
88.     int     debug_level;  
89.   
90.     enum dm9000_type type;  
91.   
92.     void (*inblk)(void __iomem *port, void *data, int length);  
93.     void (*outblk)(void __iomem *port, void *data, int length);  
94.     void (*dumpblk)(void __iomem *port, int length);  
95.   
96.     struct device   *dev;        /* parent device */  
97.   
98.     struct resource *addr_res;   /* resources found */  
99.     struct resource *data_res;  
100.     struct resource *addr_req;   /* resources requested */  
101.     struct resource *data_req;  
102.     struct resource *irq_res;  
103.   
104.     int      irq_wake;  
105.   
106.     struct mutex     addr_lock; /* phy and eeprom access lock */  
107.   
108.     struct delayed_work phy_poll;  
109.     struct net_device  *ndev;  
110.   
111.     spinlock_t  lock;  
112.   
113.     struct mii_if_info mii;  
114.     u32     msg_enable;  
115.     u32     wake_state;  
116.   
117.     int     rx_csum;  
118.     int     can_csum;  
119.     int     ip_summed;  
120. } board_info_t;  
121.   
122. /* debug code */  
123.   
124. #define dm9000_dbg(db, lev, msg...) do {        \   
125.     if ((lev) < CONFIG_DM9000_DEBUGLEVEL &&      \  
126.         (lev) < db->debug_level) {            \  
127.         dev_dbg(db->dev, msg);           \  
128.     }                       \  
129. } while (0)  
130.   
131. static inline board_info_t *to_dm9000_board(struct net_device *dev)  
132. {  
133.     return netdev_priv(dev);  
134. }  
135.   
136. /* DM9000 network board routine ---------------------------- */  
137.   
138. static void  
139. dm9000_reset(board_info_t * db)  
140. {  
141.     dev_dbg(db->dev, "resetting device\n");  
142.   
143.     /* RESET device */  
144.     writeb(DM9000_NCR, db->io_addr);  
145.     udelay(200);  
146.     writeb(NCR_RST, db->io_data);  
147.     udelay(200);  
148. }  
149.   
150. /* 
151.  *   Read a byte from I/O port 
152.  */  
153. static u8  
154. ior(board_info_t * db, int reg)  
155. {  
156.     writeb(reg, db->io_addr);  
157.     return readb(db->io_data);  
158. }  
159.   
160. /* 
161.  *   Write a byte to I/O port 
162.  */  
163.   
164. static void  
165. iow(board_info_t * db, int reg, int value)  
166. {  
167.     writeb(reg, db->io_addr);  
168.     writeb(value, db->io_data);  
169. }  
170.   
171. /* routines for sending block to chip */  
172.   
173. static void dm9000_outblk_8bit(void __iomem *reg, void *data, int count)  
174. {  
175.     writesb(reg, data, count);  
176. }  
177.   
178. static void dm9000_outblk_16bit(void __iomem *reg, void *data, int count)  
179. {  
180.     writesw(reg, data, (count+1) >> 1);  
181. }  
182.   
183. static void dm9000_outblk_32bit(void __iomem *reg, void *data, int count)  
184. {  
185.     writesl(reg, data, (count+3) >> 2);  
186. }  
187.   
188. /* input block from chip to memory */  
189.   
190. static void dm9000_inblk_8bit(void __iomem *reg, void *data, int count)  
191. {  
192.     readsb(reg, data, count);  
193. }  
194.   
195.   
196. static void dm9000_inblk_16bit(void __iomem *reg, void *data, int count)  
197. {  
198.     readsw(reg, data, (count+1) >> 1);  
199. }  
200.   
201. static void dm9000_inblk_32bit(void __iomem *reg, void *data, int count)  
202. {  
203.     readsl(reg, data, (count+3) >> 2);  
204. }  
205.   
206. /* dump block from chip to null */  
207.   
208. static void dm9000_dumpblk_8bit(void __iomem *reg, int count)  
209. {  
210.     int i;  
211.     int tmp;  
212.   
213.     for (i = 0; i < count; i++)  
214.         tmp = readb(reg);  
215. }  
216.   
217. static void dm9000_dumpblk_16bit(void __iomem *reg, int count)  
218. {  
219.     int i;  
220.     int tmp;  
221.   
222.     count = (count + 1) >> 1;  
223.   
224.     for (i = 0; i < count; i++)  
225.         tmp = readw(reg);  
226. }  
227.   
228. static void dm9000_dumpblk_32bit(void __iomem *reg, int count)  
229. {  
230.     int i;  
231.     int tmp;  
232.   
233.     count = (count + 3) >> 2;  
234.   
235.     for (i = 0; i < count; i++)  
236.         tmp = readl(reg);  
237. }  
238.   
239. /* dm9000_set_io 
240.  * 
241.  * select the specified set of io routines to use with the 
242.  * device 
243.  */  
244.   
245. static void dm9000_set_io(struct board_info *db, int byte_width)  
246. {  
247.     /* use the size of the data resource to work out what IO 
248.      * routines we want to use 
249.      */  
250.   
251.     switch (byte_width) {  
252.     case 1:  
253.         db->dumpblk = dm9000_dumpblk_8bit;  
254.         db->outblk  = dm9000_outblk_8bit;  
255.         db->inblk   = dm9000_inblk_8bit;  
256.         break;  
257.   
258.   
259.     case 3:  
260.         dev_dbg(db->dev, ": 3 byte IO, falling back to 16bit\n");  
261.     case 2:  
262.         db->dumpblk = dm9000_dumpblk_16bit;  
263.         db->outblk  = dm9000_outblk_16bit;  
264.         db->inblk   = dm9000_inblk_16bit;  
265.         break;  
266.   
267.     case 4:  
268.     default:  
269.         db->dumpblk = dm9000_dumpblk_32bit;  
270.         db->outblk  = dm9000_outblk_32bit;  
271.         db->inblk   = dm9000_inblk_32bit;  
272.         break;  
273.     }  
274. }  
275.   
276. static void dm9000_schedule_poll(board_info_t *db)  
277. {  
278.     if (db->type == TYPE_DM9000E)  
279.         schedule_delayed_work(&db->phy_poll, HZ * 2);  
280. }  
281.   
282. static int dm9000_ioctl(struct net_device *dev, struct ifreq *req, int cmd)  
283. {  
284.     board_info_t *dm = to_dm9000_board(dev);  
285.   
286.     if (!netif_running(dev))  
287.         return -EINVAL;  
288.   
289.     return generic_mii_ioctl(&dm->mii, if_mii(req), cmd, NULL);  
290. }  
291.   
292. static unsigned int  
293. dm9000_read_locked(board_info_t *db, int reg)  
294. {  
295.     unsigned long flags;  
296.     unsigned int ret;  
297.   
298.     spin_lock_irqsave(&db->lock, flags);  
299.     ret = ior(db, reg);  
300.     spin_unlock_irqrestore(&db->lock, flags);  
301.   
302.     return ret;  
303. }  
304.   
305. static int dm9000_wait_eeprom(board_info_t *db)  
306. {  
307.     unsigned int status;  
308.     int timeout = 8;    /* wait max 8msec */  
309.   
310.     /* The DM9000 data sheets say we should be able to 
311.      * poll the ERRE bit in EPCR to wait for the EEPROM 
312.      * operation. From testing several chips, this bit 
313.      * does not seem to work. 
314.      * 
315.      * We attempt to use the bit, but fall back to the 
316.      * timeout (which is why we do not return an error 
317.      * on expiry) to say that the EEPROM operation has 
318.      * completed. 
319.      */  
320.   
321.     while (1) {  
322.         status = dm9000_read_locked(db, DM9000_EPCR);  
323.   
324.         if ((status & EPCR_ERRE) == 0)  
325.             break;  
326.   
327.         msleep(1);  
328.   
329.         if (timeout-- < 0) {  
330.             dev_dbg(db->dev, "timeout waiting EEPROM\n");  
331.             break;  
332.         }  
333.     }  
334.   
335.     return 0;  
336. }  
337.   
338. /* 
339.  *  Read a word data from EEPROM 
340.  */  
341. static void  
342. dm9000_read_eeprom(board_info_t *db, int offset, u8 *to)  
343. {  
344.     unsigned long flags;  
345.   
346.     if (db->flags & DM9000_PLATF_NO_EEPROM) {  
347.         to[0] = 0xff;  
348.         to[1] = 0xff;  
349.         return;  
350.     }  
351.   
352.     mutex_lock(&db->addr_lock);  
353.   
354.     spin_lock_irqsave(&db->lock, flags);  
355.   
356.     iow(db, DM9000_EPAR, offset);  
357.     iow(db, DM9000_EPCR, EPCR_ERPRR);  
358.   
359.     spin_unlock_irqrestore(&db->lock, flags);  
360.   
361.     dm9000_wait_eeprom(db);  
362.   
363.     /* delay for at-least 150uS */  
364.     msleep(1);  
365.   
366.     spin_lock_irqsave(&db->lock, flags);  
367.   
368.     iow(db, DM9000_EPCR, 0x0);  
369.   
370.     to[0] = ior(db, DM9000_EPDRL);  
371.     to[1] = ior(db, DM9000_EPDRH);  
372.   
373.     spin_unlock_irqrestore(&db->lock, flags);  
374.   
375.     mutex_unlock(&db->addr_lock);  
376. }  
377.   
378. /* 
379.  * Write a word data to SROM 
380.  */  
381. static void  
382. dm9000_write_eeprom(board_info_t *db, int offset, u8 *data)  
383. {  
384.     unsigned long flags;  
385.   
386.     if (db->flags & DM9000_PLATF_NO_EEPROM)  
387.         return;  
388.   
389.     mutex_lock(&db->addr_lock);  
390.   
391.     spin_lock_irqsave(&db->lock, flags);  
392.     iow(db, DM9000_EPAR, offset);  
393.     iow(db, DM9000_EPDRH, data[1]);  
394.     iow(db, DM9000_EPDRL, data[0]);  
395.     iow(db, DM9000_EPCR, EPCR_WEP | EPCR_ERPRW);  
396.     spin_unlock_irqrestore(&db->lock, flags);  
397.   
398.     dm9000_wait_eeprom(db);  
399.   
400.     mdelay(1);  /* wait at least 150uS to clear */  
401.   
402.     spin_lock_irqsave(&db->lock, flags);  
403.     iow(db, DM9000_EPCR, 0);  
404.     spin_unlock_irqrestore(&db->lock, flags);  
405.   
406.     mutex_unlock(&db->addr_lock);  
407. }  
408.   
409. /* ethtool ops */  
410.   
411. static void dm9000_get_drvinfo(struct net_device *dev,  
412.                    struct ethtool_drvinfo *info)  
413. {  
414.     board_info_t *dm = to_dm9000_board(dev);  
415.   
416.     strcpy(info->driver, CARDNAME);  
417.     strcpy(info->version, DRV_VERSION);  
418.     strcpy(info->bus_info, to_platform_device(dm->dev)->name);  
419. }  
420.   
421. static u32 dm9000_get_msglevel(struct net_device *dev)  
422. {  
423.     board_info_t *dm = to_dm9000_board(dev);  
424.   
425.     return dm->msg_enable;  
426. }  
427.   
428. static void dm9000_set_msglevel(struct net_device *dev, u32 value)  
429. {  
430.     board_info_t *dm = to_dm9000_board(dev);  
431.   
432.     dm->msg_enable = value;  
433. }  
434.   
435. static int dm9000_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)  
436. {  
437.     board_info_t *dm = to_dm9000_board(dev);  
438.   
439.     mii_ethtool_gset(&dm->mii, cmd);  
440.     return 0;  
441. }  
442.   
443. static int dm9000_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)  
444. {  
445.     board_info_t *dm = to_dm9000_board(dev);  
446.   
447.     return mii_ethtool_sset(&dm->mii, cmd);  
448. }  
449.   
450. static int dm9000_nway_reset(struct net_device *dev)  
451. {  
452.     board_info_t *dm = to_dm9000_board(dev);  
453.     return mii_nway_restart(&dm->mii);  
454. }  
455.   
456. static uint32_t dm9000_get_rx_csum(struct net_device *dev)  
457. {  
458.     board_info_t *dm = to_dm9000_board(dev);  
459.     return dm->rx_csum;  
460. }  
461.   
462. static int dm9000_set_rx_csum_unlocked(struct net_device *dev, uint32_t data)  
463. {  
464.     board_info_t *dm = to_dm9000_board(dev);  
465.   
466.     if (dm->can_csum) {  
467.         dm->rx_csum = data;  
468.         iow(dm, DM9000_RCSR, dm->rx_csum ? RCSR_CSUM : 0);  
469.   
470.         return 0;  
471.     }  
472.   
473.     return -EOPNOTSUPP;  
474. }  
475.   
476. static int dm9000_set_rx_csum(struct net_device *dev, uint32_t data)  
477. {  
478.     board_info_t *dm = to_dm9000_board(dev);  
479.     unsigned long flags;  
480.     int ret;  
481.   
482.     spin_lock_irqsave(&dm->lock, flags);  
483.     ret = dm9000_set_rx_csum_unlocked(dev, data);  
484.     spin_unlock_irqrestore(&dm->lock, flags);  
485.   
486.     return ret;  
487. }  
488.   
489. static int dm9000_set_tx_csum(struct net_device *dev, uint32_t data)  
490. {  
491.     board_info_t *dm = to_dm9000_board(dev);  
492.     int ret = -EOPNOTSUPP;  
493.   
494.     if (dm->can_csum)  
495.         ret = ethtool_op_set_tx_csum(dev, data);  
496.     return ret;  
497. }  
498.   
499. static u32 dm9000_get_link(struct net_device *dev)  
500. {  
501.     board_info_t *dm = to_dm9000_board(dev);  
502.     u32 ret;  
503.   
504.     if (dm->flags & DM9000_PLATF_EXT_PHY)  
505.         ret = mii_link_ok(&dm->mii);  
506.     else  
507.         ret = dm9000_read_locked(dm, DM9000_NSR) & NSR_LINKST ? 1 : 0;  
508.   
509.     return ret;  
510. }  
511.   
512. #define DM_EEPROM_MAGIC     (0x444D394B)   
513.   
514. static int dm9000_get_eeprom_len(struct net_device *dev)  
515. {  
516.     return 128;  
517. }  
518.   
519. static int dm9000_get_eeprom(struct net_device *dev,  
520.                  struct ethtool_eeprom *ee, u8 *data)  
521. {  
522.     board_info_t *dm = to_dm9000_board(dev);  
523.     int offset = ee->offset;  
524.     int len = ee->len;  
525.     int i;  
526.   
527.     /* EEPROM access is aligned to two bytes */  
528.   
529.     if ((len & 1) != 0 || (offset & 1) != 0)  
530.         return -EINVAL;  
531.   
532.     if (dm->flags & DM9000_PLATF_NO_EEPROM)  
533.         return -ENOENT;  
534.   
535.     ee->magic = DM_EEPROM_MAGIC;  
536.   
537.     for (i = 0; i < len; i += 2)  
538.         dm9000_read_eeprom(dm, (offset + i) / 2, data + i);  
539.   
540.     return 0;  
541. }  
542.   
543. static int dm9000_set_eeprom(struct net_device *dev,  
544.                  struct ethtool_eeprom *ee, u8 *data)  
545. {  
546.     board_info_t *dm = to_dm9000_board(dev);  
547.     int offset = ee->offset;  
548.     int len = ee->len;  
549.     int i;  
550.   
551.     /* EEPROM access is aligned to two bytes */  
552.   
553.     if ((len & 1) != 0 || (offset & 1) != 0)  
554.         return -EINVAL;  
555.   
556.     if (dm->flags & DM9000_PLATF_NO_EEPROM)  
557.         return -ENOENT;  
558.   
559.     if (ee->magic != DM_EEPROM_MAGIC)  
560.         return -EINVAL;  
561.   
562.     for (i = 0; i < len; i += 2)  
563.         dm9000_write_eeprom(dm, (offset + i) / 2, data + i);  
564.   
565.     return 0;  
566. }  
567.   
568. static void dm9000_get_wol(struct net_device *dev, struct ethtool_wolinfo *w)  
569. {  
570.     board_info_t *dm = to_dm9000_board(dev);  
571.   
572.     memset(w, 0, sizeof(struct ethtool_wolinfo));  
573.   
574.     /* note, we could probably support wake-phy too */  
575.     w->supported = dm->wake_supported ? WAKE_MAGIC : 0;  
576.     w->wolopts = dm->wake_state;  
577. }  
578.   
579. static int dm9000_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)  
580. {  
581.     board_info_t *dm = to_dm9000_board(dev);  
582.     unsigned long flags;  
583.     u32 opts = w->wolopts;  
584.     u32 wcr = 0;  
585.   
586.     if (!dm->wake_supported)  
587.         return -EOPNOTSUPP;  
588.   
589.     if (opts & ~WAKE_MAGIC)  
590.         return -EINVAL;  
591.   
592.     if (opts & WAKE_MAGIC)  
593.         wcr |= WCR_MAGICEN;  
594.   
595.     mutex_lock(&dm->addr_lock);  
596.   
597.     spin_lock_irqsave(&dm->lock, flags);  
598.     iow(dm, DM9000_WCR, wcr);  
599.     spin_unlock_irqrestore(&dm->lock, flags);  
600.   
601.     mutex_unlock(&dm->addr_lock);  
602.   
603.     if (dm->wake_state != opts) {  
604.         /* change in wol state, update IRQ state */  
605.   
606.         if (!dm->wake_state)  
607.             set_irq_wake(dm->irq_wake, 1);  
608.         else if (dm->wake_state & !opts)  
609.             set_irq_wake(dm->irq_wake, 0);  
610.     }  
611.   
612.     dm->wake_state = opts;  
613.     return 0;  
614. }  
615.   
616. static const struct ethtool_ops dm9000_ethtool_ops = {  
617.     .get_drvinfo        = dm9000_get_drvinfo,  
618.     .get_settings       = dm9000_get_settings,  
619.     .set_settings       = dm9000_set_settings,  
620.     .get_msglevel       = dm9000_get_msglevel,  
621.     .set_msglevel       = dm9000_set_msglevel,  
622.     .nway_reset     = dm9000_nway_reset,  
623.     .get_link       = dm9000_get_link,  
624.     .get_wol        = dm9000_get_wol,  
625.     .set_wol        = dm9000_set_wol,  
626.     .get_eeprom_len     = dm9000_get_eeprom_len,  
627.     .get_eeprom     = dm9000_get_eeprom,  
628.     .set_eeprom     = dm9000_set_eeprom,  
629.     .get_rx_csum        = dm9000_get_rx_csum,  
630.     .set_rx_csum        = dm9000_set_rx_csum,  
631.     .get_tx_csum        = ethtool_op_get_tx_csum,  
632.     .set_tx_csum        = dm9000_set_tx_csum,  
633. };  
634.   
635. static void dm9000_show_carrier(board_info_t *db,  
636.                 unsigned carrier, unsigned nsr)  
637. {  
638.     struct net_device *ndev = db->ndev;  
639.     unsigned ncr = dm9000_read_locked(db, DM9000_NCR);  
640.   
641.     if (carrier)  
642.         dev_info(db->dev, "%s: link up, %dMbps, %s-duplex, no LPA\n",  
643.              ndev->name, (nsr & NSR_SPEED) ? 10 : 100,  
644.              (ncr & NCR_FDX) ? "full" : "half");  
645.     else  
646.         dev_info(db->dev, "%s: link down\n", ndev->name);  
647. }  
648.   
649. static void  
650. dm9000_poll_work(struct work_struct *w)  
651. {  
652.     struct delayed_work *dw = to_delayed_work(w);  
653.     board_info_t *db = container_of(dw, board_info_t, phy_poll);  
654.     struct net_device *ndev = db->ndev;  
655.   
656.     if (db->flags & DM9000_PLATF_SIMPLE_PHY &&  
657.         !(db->flags & DM9000_PLATF_EXT_PHY)) {  
658.         unsigned nsr = dm9000_read_locked(db, DM9000_NSR);  
659.         unsigned old_carrier = netif_carrier_ok(ndev) ? 1 : 0;  
660.         unsigned new_carrier;  
661.   
662.         new_carrier = (nsr & NSR_LINKST) ? 1 : 0;  
663.   
664.         if (old_carrier != new_carrier) {  
665.             if (netif_msg_link(db))  
666.                 dm9000_show_carrier(db, new_carrier, nsr);  
667.   
668.             if (!new_carrier)  
669.                 netif_carrier_off(ndev);  
670.             else  
671.                 netif_carrier_on(ndev);  
672.         }  
673.     } else  
674.         mii_check_media(&db->mii, netif_msg_link(db), 0);  
675.       
676.     if (netif_running(ndev))  
677.         dm9000_schedule_poll(db);  
678. }  
679.   
680. /* dm9000_release_board 
681.  * 
682.  * release a board, and any mapped resources 
683.  */  
684.   
685. static void  
686. dm9000_release_board(struct platform_device *pdev, struct board_info *db)  
687. {  
688.     /* unmap our resources */  
689.   
690.     iounmap(db->io_addr);  
691.     iounmap(db->io_data);  
692.   
693.     /* release the resources */  
694.   
695.     release_resource(db->data_req);  
696.     kfree(db->data_req);  
697.   
698.     release_resource(db->addr_req);  
699.     kfree(db->addr_req);  
700. }  
701.   
702. static unsigned char dm9000_type_to_char(enum dm9000_type type)  
703. {  
704.     switch (type) {  
705.     case TYPE_DM9000E: return 'e';  
706.     case TYPE_DM9000A: return 'a';  
707.     case TYPE_DM9000B: return 'b';  
708.     }  
709.   
710.     return '?';  
711. }  
712.   
713. /* 
714.  *  Set DM9000 multicast address 
715.  */  
716. static void  
717. dm9000_hash_table_unlocked(struct net_device *dev)  
718. {  
719.     board_info_t *db = netdev_priv(dev);  
720.     struct netdev_hw_addr *ha;  
721.     int i, oft;  
722.     u32 hash_val;  
723.     u16 hash_table[4];  
724.     u8 rcr = RCR_DIS_LONG | RCR_DIS_CRC | RCR_RXEN;  
725.   
726.     dm9000_dbg(db, 1, "entering %s\n", __func__);  
727.   
728.     for (i = 0, oft = DM9000_PAR; i < 6; i++, oft++)  
729.         iow(db, oft, dev->dev_addr[i]);  
730.   
731.     /* Clear Hash Table */  
732.     for (i = 0; i < 4; i++)  
733.         hash_table[i] = 0x0;  
734.   
735.     /* broadcast address */  
736.     hash_table[3] = 0x8000;  
737.   
738.     if (dev->flags & IFF_PROMISC)  
739.         rcr |= RCR_PRMSC;  
740.   
741.     if (dev->flags & IFF_ALLMULTI)  
742.         rcr |= RCR_ALL;  
743.   
744.     /* the multicast address in Hash Table : 64 bits */  
745.     netdev_for_each_mc_addr(ha, dev) {  
746.         hash_val = ether_crc_le(6, ha->addr) & 0x3f;  
747.         hash_table[hash_val / 16] |= (u16) 1 << (hash_val % 16);  
748.     }  
749.   
750.     /* Write the hash table to MAC MD table */  
751.     for (i = 0, oft = DM9000_MAR; i < 4; i++) {  
752.         iow(db, oft++, hash_table[i]);  
753.         iow(db, oft++, hash_table[i] >> 8);  
754.     }  
755.   
756.     iow(db, DM9000_RCR, rcr);  
757. }  
758.   
759. static void  
760. dm9000_hash_table(struct net_device *dev)  
761. {  
762.     board_info_t *db = netdev_priv(dev);  
763.     unsigned long flags;  
764.   
765.     spin_lock_irqsave(&db->lock, flags);  
766.     dm9000_hash_table_unlocked(dev);  
767.     spin_unlock_irqrestore(&db->lock, flags);  
768. }  
769.   
770. /* 
771.  * Initialize dm9000 board 
772.  */  
773. static void  
774. dm9000_init_dm9000(struct net_device *dev)  
775. {  
776.     board_info_t *db = netdev_priv(dev);  
777.     unsigned int imr;  
778.     unsigned int ncr;  
779.   
780.     dm9000_dbg(db, 1, "entering %s\n", __func__);  
781.   
782.     /* I/O mode */  
783.     db->io_mode = ior(db, DM9000_ISR) >> 6;    /* ISR bit7:6 keeps I/O mode */  
784.   
785.     /* Checksum mode */  
786.     dm9000_set_rx_csum_unlocked(dev, db->rx_csum);  
787.   
788.     /* GPIO0 on pre-activate PHY */  
789.     iow(db, DM9000_GPR, 0); /* REG_1F bit0 activate phyxcer */  
790.     iow(db, DM9000_GPCR, GPCR_GEP_CNTL);    /* Let GPIO0 output */  
791.     iow(db, DM9000_GPR, 0); /* Enable PHY */  
792.   
793.     ncr = (db->flags & DM9000_PLATF_EXT_PHY) ? NCR_EXT_PHY : 0;  
794.   
795.     /* if wol is needed, then always set NCR_WAKEEN otherwise we end 
796.      * up dumping the wake events if we disable this. There is already 
797.      * a wake-mask in DM9000_WCR */  
798.     if (db->wake_supported)  
799.         ncr |= NCR_WAKEEN;  
800.   
801.     iow(db, DM9000_NCR, ncr);  
802.   
803.     /* Program operating register */  
804.     iow(db, DM9000_TCR, 0);         /* TX Polling clear */  
805.     iow(db, DM9000_BPTR, 0x3f); /* Less 3Kb, 200us */  
806.     iow(db, DM9000_FCR, 0xff);  /* Flow Control */  
807.     iow(db, DM9000_SMCR, 0);        /* Special Mode */  
808.     /* clear TX status */  
809.     iow(db, DM9000_NSR, NSR_WAKEST | NSR_TX2END | NSR_TX1END);  
810.     iow(db, DM9000_ISR, ISR_CLR_STATUS); /* Clear interrupt status */  
811.   
812.     /* Set address filter table */  
813.     dm9000_hash_table_unlocked(dev);  
814.   
815.     imr = IMR_PAR | IMR_PTM | IMR_PRM;  
816.     if (db->type != TYPE_DM9000E)  
817.         imr |= IMR_LNKCHNG;  
818.   
819.     db->imr_all = imr;  
820.   
821.     /* Enable TX/RX interrupt mask */  
822.     iow(db, DM9000_IMR, imr);  
823.   
824.     /* Init Driver variable */  
825.     db->tx_pkt_cnt = 0;  
826.     db->queue_pkt_len = 0;  
827.     dev->trans_start = jiffies;  
828. }  
829.   
830. /* Our watchdog timed out. Called by the networking layer */  
831. static void dm9000_timeout(struct net_device *dev)  
832. {  
833.     board_info_t *db = netdev_priv(dev);  
834.     u8 reg_save;  
835.     unsigned long flags;  
836.   
837.     /* Save previous register address */  
838.     reg_save = readb(db->io_addr);  
839.     spin_lock_irqsave(&db->lock, flags);  
840.   
841.     netif_stop_queue(dev);  
842.     dm9000_reset(db);  
843.     dm9000_init_dm9000(dev);  
844.     /* We can accept TX packets again */  
845.     dev->trans_start = jiffies; /* prevent tx timeout */  
846.     netif_wake_queue(dev);  
847.   
848.     /* Restore previous register address */  
849.     writeb(reg_save, db->io_addr);  
850.     spin_unlock_irqrestore(&db->lock, flags);  
851. }  
852.   
853. static void dm9000_send_packet(struct net_device *dev,  
854.                    int ip_summed,  
855.                    u16 pkt_len)  
856. {  
857.     board_info_t *dm = to_dm9000_board(dev);  
858.   
859.     /* The DM9000 is not smart enough to leave fragmented packets alone. */  
860.     if (dm->ip_summed != ip_summed) {  
861.         if (ip_summed == CHECKSUM_NONE)  
862.             iow(dm, DM9000_TCCR, 0);  
863.         else  
864.             iow(dm, DM9000_TCCR, TCCR_IP | TCCR_UDP | TCCR_TCP);  
865.         dm->ip_summed = ip_summed;  
866.     }  
867.   
868.     /* Set TX length to DM9000 */  
869.     /* 设置TX数据的长度到寄存器TXPLL和TXPLH */  
870.     iow(dm, DM9000_TXPLL, pkt_len);  
871.     iow(dm, DM9000_TXPLH, pkt_len >> 8);  
872.   
873.     /* Issue TX polling command */  
874.     /* 设置发送控制寄存器的发送请求位 */  
875.     iow(dm, DM9000_TCR, TCR_TXREQ); /* Cleared after TX complete */  
876. }  
877.   
878. /* 
879.  *  Hardware start transmission. 
880.  *  Send a packet to media from the upper layer. 
881.  */  
882. static int  
883. dm9000_start_xmit(struct sk_buff *skb, struct net_device *dev)  
884. {  
885.     unsigned long flags;  
886.     board_info_t *db = netdev_priv(dev);/* 获取网卡虽有信息的存储结构信息的地址 */  
887.   
888.     dm9000_dbg(db, 3, "%s:\n", __func__);  
889.   
890.     if (db->tx_pkt_cnt > 1)  
891.         return NETDEV_TX_BUSY;  
892.   
893.     spin_lock_irqsave(&db->lock, flags);/* 获得自旋锁 */  
894.   
895.     /* Move data to DM9000 TX RAM */  
896.     /*MWCMD 即 Memory data write command with address increment Register(F8H) 
897.     * 根据 IO 操作模式(8-bit or 16-bit)来增加写指针 1 或 2 
898.     */  
899.     writeb(DM9000_MWCMD, db->io_addr);  
900.   
901.     (db->outblk)(db->io_data, skb->data, skb->len);/* 将数据从sk_buff中copy到网卡的TX SRAM中 */  
902.       
903.     dev->stats.tx_bytes += skb->len;/* 统计发送的字节数 */  
904.       
905.     db->tx_pkt_cnt++;/* 待发送计数 */  
906.     /* TX control: First packet immediately send, second packet queue */  
907.     if (db->tx_pkt_cnt == 1) {  
908.         dm9000_send_packet(dev, skb->ip_summed, skb->len);/* 如果计数为1，直接发送 */  
909.     } else {/* 如果是第2个，则 */  
910.         /* Second packet */  
911.         db->queue_pkt_len = skb->len;  
912.         db->queue_ip_summed = skb->ip_summed;  
913.         netif_stop_queue(dev);/* 告诉上层停止发送 */  
914.     }  
915.   
916.     spin_unlock_irqrestore(&db->lock, flags);/* 解锁 */  
917.   
918.     /* free this SKB ，释放SKB*/  
919.     dev_kfree_skb(skb);  
920.   
921.     return NETDEV_TX_OK;  
922. }  
923.   
924. /* 
925.  * DM9000 interrupt handler 
926.  * receive the packet to upper layer, free the transmitted packet 
927.  */  
928.   
929. static void dm9000_tx_done(struct net_device *dev, board_info_t *db)  
930. {  
931.     int tx_status = ior(db, DM9000_NSR);    /* Got TX status */  
932.   
933.     if (tx_status & (NSR_TX2END | NSR_TX1END)) {/* 第一个或第二个数据包发送完毕 */  
934.         /* One packet sent complete */  
935.         db->tx_pkt_cnt--;/* 待发送的数据包个数减1 */  
936.         dev->stats.tx_packets++;/* 发送的数据包加1 */  
937.   
938.         if (netif_msg_tx_done(db))  
939.             dev_dbg(db->dev, "tx done, NSR %02x\n", tx_status);  
940.   
941.         /* Queue packet check & send */  
942.         if (db->tx_pkt_cnt > 0)/* 如果还有数据包 */  
943.             dm9000_send_packet(dev, db->queue_ip_summed,  
944.                        db->queue_pkt_len);  
945.         netif_wake_queue(dev);/* 告诉内核，将数据包放入发生那个队列 */  
946.     }  
947. }  
948.   
949. /* DM9000接收数据后的封装结构体，表示数据包的头4个字节 */  
950. struct dm9000_rxhdr {  
951.     u8  RxPktReady;  
952.     u8  RxStatus;  
953.     __le16  RxLen;  
954. } __attribute__((__packed__));  
955.   
956. /* 
957.  *  Received a packet and pass to upper layer 
958.  *  接收数据包，将数据包传递给上层 
959.  */  
960. static void  
961. dm9000_rx(struct net_device *dev)  
962. {  
963.     board_info_t *db = netdev_priv(dev);/* 得到网卡私有信息数据结构的首地址 */  
964.     struct dm9000_rxhdr rxhdr;/* 该结构体封装了dm9000接收的数据包信息 */  
965.     struct sk_buff *skb;  
966.     u8 rxbyte, *rdptr;  
967.     bool GoodPacket;  
968.     int RxLen;  
969.   
970.     /* Check packet ready or not */  
971.     do {  
972.         /* MRCMDX是内存数据预取读命令 */  
973.         ior(db, DM9000_MRCMDX); /* Dummy read */  
974.         /* Get most updated data */  
975.         rxbyte = readb(db->io_data);  
976.   
977.         /* Status check: this byte must be 0 or 1 */  
978.         /* DM9000_PKT_ERR          0x02 ,表示接收出错 */  
979.         if (rxbyte & DM9000_PKT_ERR) {  
980.             dev_warn(db->dev, "status check fail: %d\n", rxbyte);/* 输出提示信息 */  
981.             iow(db, DM9000_RCR, 0x00);  /* Stop Device 关闭设备 */  
982.             iow(db, DM9000_ISR, IMR_PAR);   /* Stop INT request 停止中断请求*/  
983.             return;  
984.         }  
985.           
986.         /* DM9000_PKT_RDY          0x01 没有准备好，直接返回*/  
987.         if (!(rxbyte & DM9000_PKT_RDY))  
988.             return;  
989.   
990.         /* A packet ready now  & Get status/length */  
991.         GoodPacket = true;  
992.         writeb(DM9000_MRCMD, db->io_addr);/* MRCMD是地址增加的数据读取命令 */  
993.   
994.         (db->inblk)(db->io_data, &rxhdr, sizeof(rxhdr));/* 读取数据，从RX_SRAM到 rxhdr结构体中*/  
995.   
996.         RxLen = le16_to_cpu(rxhdr.RxLen);  
997.   
998.         if (netif_msg_rx_status(db))  
999.             dev_dbg(db->dev, "RX: status %02x, length %04x\n",  
1000.                 rxhdr.RxStatus, RxLen);  
1001.   
1002.         /* Packet Status check ，检查包的完整性*/  
1003.         if (RxLen < 0x40) {  
1004.             GoodPacket = false;  
1005.             if (netif_msg_rx_err(db))  
1006.                 dev_dbg(db->dev, "RX: Bad Packet (runt)\n");  
1007.         }  
1008.         /* 如果数据长度大于DM9000_PKT_MAX ，即 1536 */  
1009.         if (RxLen > DM9000_PKT_MAX) {  
1010.             dev_dbg(db->dev, "RST: RX Len:%x\n", RxLen);  
1011.         }  
1012.   
1013.         /* rxhdr.RxStatus is identical to RSR register. */  
1014.         /* 这里也是包的检查 */  
1015.         if (rxhdr.RxStatus & (RSR_FOE | RSR_CE | RSR_AE |  
1016.                       RSR_PLE | RSR_RWTO |  
1017.                       RSR_LCS | RSR_RF)) {  
1018.             GoodPacket = false;  
1019.             if (rxhdr.RxStatus & RSR_FOE) {  
1020.                 if (netif_msg_rx_err(db))  
1021.                     dev_dbg(db->dev, "fifo error\n");  
1022.                 dev->stats.rx_fifo_errors++;  
1023.             }  
1024.             if (rxhdr.RxStatus & RSR_CE) {  
1025.                 if (netif_msg_rx_err(db))  
1026.                     dev_dbg(db->dev, "crc error\n");  
1027.                 dev->stats.rx_crc_errors++;  
1028.             }  
1029.             if (rxhdr.RxStatus & RSR_RF) {  
1030.                 if (netif_msg_rx_err(db))  
1031.                     dev_dbg(db->dev, "length error\n");  
1032.                 dev->stats.rx_length_errors++;  
1033.             }  
1034.         }  
1035.   
1036.         /* Move data from DM9000 ，从DM9000获取数据*/  
1037.         if (GoodPacket &&  
1038.             ((skb = dev_alloc_skb(RxLen + 4)) != NULL)) {  
1039.             skb_reserve(skb, 2);  
1040.             rdptr = (u8 *) skb_put(skb, RxLen - 4);  
1041.   
1042.             /* Read received packet from RX SRAM */  
1043.             /* 将RX SRAM中的数据读取到skbuff结构体 */  
1044.             (db->inblk)(db->io_data, rdptr, RxLen);  
1045.             dev->stats.rx_bytes += RxLen;  
1046.   
1047.             /* Pass to upper layer */  
1048.             skb->protocol = eth_type_trans(skb, dev);  
1049.             if (db->rx_csum) {  
1050.                 if ((((rxbyte & 0x1c) << 3) & rxbyte) == 0)  
1051.                     skb->ip_summed = CHECKSUM_UNNECESSARY;  
1052.                 else  
1053.                     skb->ip_summed = CHECKSUM_NONE;  
1054.             }  
1055.             netif_rx(skb);/* 将skbuff结构体发送给上层 */  
1056.             dev->stats.rx_packets++;/* 计数增1 */  
1057.   
1058.         } else {  
1059.             /* need to dump the packet's data */  
1060.             /* 坏包，丢弃 */  
1061.             (db->dumpblk)(db->io_data, RxLen);  
1062.         }  
1063.     } while (rxbyte & DM9000_PKT_RDY);  
1064. }  
1065.   
1066. static irqreturn_t dm9000_interrupt(int irq, void *dev_id)  
1067. {  
1068.     struct net_device *dev = dev_id;  
1069.     board_info_t *db = netdev_priv(dev);  
1070.     int int_status;  
1071.     unsigned long flags;  
1072.     u8 reg_save;  
1073.   
1074.     dm9000_dbg(db, 3, "entering %s\n", __func__);  
1075.   
1076.     /* A real interrupt coming */  
1077.   
1078.     /* holders of db->lock must always block IRQs */  
1079.     spin_lock_irqsave(&db->lock, flags);  
1080.   
1081.     /* Save previous register address */  
1082.     reg_save = readb(db->io_addr);  
1083.   
1084.     /* Disable all interrupts */  
1085.     iow(db, DM9000_IMR, IMR_PAR);  
1086.   
1087.     /* Got DM9000 interrupt status */  
1088.     int_status = ior(db, DM9000_ISR);   /* Got ISR */  
1089.     iow(db, DM9000_ISR, int_status);    /* Clear ISR status */  
1090.   
1091.     if (netif_msg_intr(db))  
1092.         dev_dbg(db->dev, "interrupt status %02x\n", int_status);  
1093.   
1094.     /* Received the coming packet */  
1095.     if (int_status & ISR_PRS)  
1096.         dm9000_rx(dev);  
1097.   
1098.     /* Trnasmit Interrupt check */  
1099.     if (int_status & ISR_PTS)  
1100.         dm9000_tx_done(dev, db);  
1101.   
1102.     if (db->type != TYPE_DM9000E) {  
1103.         if (int_status & ISR_LNKCHNG) {  
1104.             /* fire a link-change request */  
1105.             schedule_delayed_work(&db->phy_poll, 1);  
1106.         }  
1107.     }  
1108.   
1109.     /* Re-enable interrupt mask */  
1110.     iow(db, DM9000_IMR, db->imr_all);  
1111.   
1112.     /* Restore previous register address */  
1113.     writeb(reg_save, db->io_addr);  
1114.   
1115.     spin_unlock_irqrestore(&db->lock, flags);  
1116.   
1117.     return IRQ_HANDLED;  
1118. }  
1119.   
1120. static irqreturn_t dm9000_wol_interrupt(int irq, void *dev_id)  
1121. {  
1122.     struct net_device *dev = dev_id;  
1123.     board_info_t *db = netdev_priv(dev);  
1124.     unsigned long flags;  
1125.     unsigned nsr, wcr;  
1126.   
1127.     spin_lock_irqsave(&db->lock, flags);  
1128.   
1129.     nsr = ior(db, DM9000_NSR);  
1130.     wcr = ior(db, DM9000_WCR);  
1131.   
1132.     dev_dbg(db->dev, "%s: NSR=0x%02x, WCR=0x%02x\n", __func__, nsr, wcr);  
1133.   
1134.     if (nsr & NSR_WAKEST) {  
1135.         /* clear, so we can avoid */  
1136.         iow(db, DM9000_NSR, NSR_WAKEST);  
1137.   
1138.         if (wcr & WCR_LINKST)  
1139.             dev_info(db->dev, "wake by link status change\n");  
1140.         if (wcr & WCR_SAMPLEST)  
1141.             dev_info(db->dev, "wake by sample packet\n");  
1142.         if (wcr & WCR_MAGICST )  
1143.             dev_info(db->dev, "wake by magic packet\n");  
1144.         if (!(wcr & (WCR_LINKST | WCR_SAMPLEST | WCR_MAGICST)))  
1145.             dev_err(db->dev, "wake signalled with no reason? "  
1146.                 "NSR=0x%02x, WSR=0x%02x\n", nsr, wcr);  
1147.   
1148.     }  
1149.   
1150.     spin_unlock_irqrestore(&db->lock, flags);  
1151.   
1152.     return (nsr & NSR_WAKEST) ? IRQ_HANDLED : IRQ_NONE;  
1153. }  
1154.   
1155. #ifdef CONFIG_NET_POLL_CONTROLLER   
1156. /* 
1157.  *Used by netconsole 
1158.  */  
1159. static void dm9000_poll_controller(struct net_device *dev)  
1160. {  
1161.     disable_irq(dev->irq);  
1162.     dm9000_interrupt(dev->irq, dev);  
1163.     enable_irq(dev->irq);  
1164. }  
1165. #endif   
1166.   
1167. /* 
1168.  *  Open the interface. 
1169.  *  The interface is opened whenever "ifconfig" actives it. 
1170.  */  
1171. static int  
1172. dm9000_open(struct net_device *dev)  
1173. {  
1174.     board_info_t *db = netdev_priv(dev);/* 返回board_info_t的地址 */  
1175.     unsigned long irqflags = db->irq_res->flags & IRQF_TRIGGER_MASK;  
1176.   
1177.     if (netif_msg_ifup(db))  
1178.         dev_dbg(db->dev, "enabling %s\n", dev->name);  
1179.   
1180.     /* If there is no IRQ type specified, default to something that 
1181.      * may work, and tell the user that this is a problem */  
1182.   
1183.     if (irqflags == IRQF_TRIGGER_NONE)  
1184.         dev_warn(db->dev, "WARNING: no IRQ resource flags set.\n");  
1185.   
1186.     irqflags |= IRQF_SHARED;  
1187.       
1188.     /* 注册中断 */  
1189.     if (request_irq(dev->irq, dm9000_interrupt, irqflags, dev->name, dev))  
1190.         return -EAGAIN;  
1191.   
1192.     /* Initialize DM9000 board */  
1193.     dm9000_reset(db);/* 复位DM9000 */  
1194.     dm9000_init_dm9000(dev);/* 根据net_device的数据初始化DM9000 */  
1195.   
1196.     /* Init driver variable */  
1197.     db->dbug_cnt = 0;  
1198.   
1199.     mii_check_media(&db->mii, netif_msg_link(db), 1);/* 检测mii接口的状态 */  
1200.     netif_start_queue(dev);/* 用来告诉上层网络协定这个驱动程序还有空的缓冲区可用，请把下 一个封包送进来。*/  
1201.       
1202.     /*在probe函数中初始化的等待队列 INIT_DELAYED_WORK(&db->phy_poll, dm9000_poll_work);    
1203.     ＊初始化定时器，调用等待队列*/  
1204.     dm9000_schedule_poll(db);  
1205.   
1206.     return 0;  
1207. }  
1208.   
1209. /* 
1210.  * Sleep, either by using msleep() or if we are suspending, then 
1211.  * use mdelay() to sleep. 
1212.  */  
1213. static void dm9000_msleep(board_info_t *db, unsigned int ms)  
1214. {  
1215.     if (db->in_suspend)  
1216.         mdelay(ms);  
1217.     else  
1218.         msleep(ms);  
1219. }  
1220.   
1221. /* 
1222.  *   Read a word from phyxcer 
1223.  */  
1224. static int  
1225. dm9000_phy_read(struct net_device *dev, int phy_reg_unused, int reg)  
1226. {  
1227.     board_info_t *db = netdev_priv(dev);  
1228.     unsigned long flags;  
1229.     unsigned int reg_save;  
1230.     int ret;  
1231.   
1232.     mutex_lock(&db->addr_lock);  
1233.   
1234.     spin_lock_irqsave(&db->lock,flags);  
1235.   
1236.     /* Save previous register address */  
1237.     reg_save = readb(db->io_addr);  
1238.   
1239.     /* Fill the phyxcer register into REG_0C */  
1240.     iow(db, DM9000_EPAR, DM9000_PHY | reg);  
1241.   
1242.     iow(db, DM9000_EPCR, EPCR_ERPRR | EPCR_EPOS);   /* Issue phyxcer read command */  
1243.   
1244.     writeb(reg_save, db->io_addr);  
1245.     spin_unlock_irqrestore(&db->lock,flags);  
1246.   
1247.     dm9000_msleep(db, 1);       /* Wait read complete */  
1248.   
1249.     spin_lock_irqsave(&db->lock,flags);  
1250.     reg_save = readb(db->io_addr);  
1251.   
1252.     iow(db, DM9000_EPCR, 0x0);  /* Clear phyxcer read command */  
1253.   
1254.     /* The read data keeps on REG_0D & REG_0E */  
1255.     ret = (ior(db, DM9000_EPDRH) << 8) | ior(db, DM9000_EPDRL);  
1256.   
1257.     /* restore the previous address */  
1258.     writeb(reg_save, db->io_addr);  
1259.     spin_unlock_irqrestore(&db->lock,flags);  
1260.   
1261.     mutex_unlock(&db->addr_lock);  
1262.   
1263.     dm9000_dbg(db, 5, "phy_read[%02x] -> %04x\n", reg, ret);  
1264.     return ret;  
1265. }  
1266.   
1267. /* 
1268.  *   Write a word to phyxcer 
1269.  */  
1270. static void  
1271. dm9000_phy_write(struct net_device *dev,  
1272.          int phyaddr_unused, int reg, int value)  
1273. {  
1274.     board_info_t *db = netdev_priv(dev);  
1275.     unsigned long flags;  
1276.     unsigned long reg_save;  
1277.   
1278.     dm9000_dbg(db, 5, "phy_write[%02x] = %04x\n", reg, value);  
1279.     mutex_lock(&db->addr_lock);  
1280.   
1281.     spin_lock_irqsave(&db->lock,flags);  
1282.   
1283.     /* Save previous register address */  
1284.     reg_save = readb(db->io_addr);  
1285.   
1286.     /* Fill the phyxcer register into REG_0C */  
1287.     iow(db, DM9000_EPAR, DM9000_PHY | reg);  
1288.   
1289.     /* Fill the written data into REG_0D & REG_0E */  
1290.     iow(db, DM9000_EPDRL, value);  
1291.     iow(db, DM9000_EPDRH, value >> 8);  
1292.   
1293.     iow(db, DM9000_EPCR, EPCR_EPOS | EPCR_ERPRW);   /* Issue phyxcer write command */  
1294.   
1295.     writeb(reg_save, db->io_addr);  
1296.     spin_unlock_irqrestore(&db->lock, flags);  
1297.   
1298.     dm9000_msleep(db, 1);       /* Wait write complete */  
1299.   
1300.     spin_lock_irqsave(&db->lock,flags);  
1301.     reg_save = readb(db->io_addr);  
1302.   
1303.     iow(db, DM9000_EPCR, 0x0);  /* Clear phyxcer write command */  
1304.   
1305.     /* restore the previous address */  
1306.     writeb(reg_save, db->io_addr);  
1307.   
1308.     spin_unlock_irqrestore(&db->lock, flags);  
1309.     mutex_unlock(&db->addr_lock);  
1310. }  
1311.   
1312. /* 复位 phy，配置寄存器GPR位0为1，关闭dm9000电源，配置寄存器IMR位7为1，disable中断，配置寄存器RCR，disable接收 */  
1313. static void  
1314. dm9000_shutdown(struct net_device *dev)  
1315. {  
1316.     board_info_t *db = netdev_priv(dev);/* 获取网卡私有信息的地址 */  
1317.   
1318.     /* RESET device */  
1319.     dm9000_phy_write(dev, 0, MII_BMCR, BMCR_RESET); /* PHY RESET ,复位PHY*/  
1320.     iow(db, DM9000_GPR, 0x01);  /* Power-Down PHY ，关闭PHY*/  
1321.     iow(db, DM9000_IMR, IMR_PAR);   /* Disable all interrupt ，关闭所有的中断*/  
1322.     iow(db, DM9000_RCR, 0x00);  /* Disable RX ,不再接受数据*/  
1323. }  
1324.   
1325. /* 
1326.  * Stop the interface. 
1327.  * The interface is stopped when it is brought. 
1328.  */  
1329. static int  
1330. dm9000_stop(struct net_device *ndev)  
1331. {  
1332.     board_info_t *db = netdev_priv(ndev);/* 同上，获取网卡的私有结构信息的地址 */  
1333.   
1334.     if (netif_msg_ifdown(db))  
1335.         dev_dbg(db->dev, "shutting down %s\n", ndev->name);  
1336.   
1337.     cancel_delayed_work_sync(&db->phy_poll);/* 终止phy_poll队列中被延迟的任务 */  
1338.   
1339.     netif_stop_queue(ndev);/* 关闭发送队列 */  
1340.     netif_carrier_off(ndev);/*通知该内核设备载波丢失,大部分涉及实际的物理连接的网络技术提供有一个载波状态,载波存在说明硬件存在并准备好*/  
1341.   
1342.     /* free interrupt */  
1343.     free_irq(ndev->irq, ndev);/* 释放中断 */  
1344.   
1345.     dm9000_shutdown(ndev);/* 关闭DM9000网卡 */  
1346.   
1347.     return 0;  
1348. }  
1349.   
1350. static const struct net_device_ops dm9000_netdev_ops = {  
1351.     .ndo_open       = dm9000_open,/* 打开设备函数 */  
1352.     .ndo_stop       = dm9000_stop,/* 关闭设备函数 */  
1353.     .ndo_start_xmit     = dm9000_start_xmit,/* 开始发送数据 */  
1354.     .ndo_tx_timeout     = dm9000_timeout,/* 发送超时 */  
1355.     .ndo_set_multicast_list = dm9000_hash_table,/* 设定多播列表 */  
1356.     .ndo_do_ioctl       = dm9000_ioctl,/* io操作函数 */  
1357.     .ndo_change_mtu     = eth_change_mtu,/* 改变MTU */  
1358.     .ndo_validate_addr  = eth_validate_addr,  
1359.     .ndo_set_mac_address    = eth_mac_addr,  
1360. #ifdef CONFIG_NET_POLL_CONTROLLER   
1361.     .ndo_poll_controller    = dm9000_poll_controller,  
1362. #endif   
1363. };  
1364.   
1365. /* 
1366.  * Search DM9000 board, allocate space and register it 
1367.  */  
1368. static int __devinit  
1369. dm9000_probe(struct platform_device *pdev)  
1370. {  
1371.     struct dm9000_plat_data *pdata = pdev->dev.platform_data;  
1372.     struct board_info *db;  /* Point a board information structure */  
1373.     struct net_device *ndev;/* 网络设备 */  
1374.     const unsigned char *mac_src;  
1375.     int ret = 0;  
1376.     int iosize;  
1377.     int i;  
1378.     u32 id_val;  
1379.   
1380.     unsigned char ne_def_eth_mac_addr[]={0x00,0x12,0x34,0x56,0x80,0x49};/* 设定默认的mac地址 */  
1381.     static void *bwscon;/* 保存ioremap返回的寄存器的虚拟地址，下同 */  
1382.     static void *gpfcon;  
1383.     static void *extint0;  
1384.     static void *intmsk;  
1385.     /*Added by yan*/  
1386.     #define BWSCON           (0x48000000)   
1387.     #define GPFCON           (0x56000050)   
1388.     #define EXTINT0           (0x56000088)   
1389.     #define INTMSK           (0x4A000008)   
1390.   
1391.     bwscon=ioremap_nocache(BWSCON,0x0000004);  
1392.     gpfcon=ioremap_nocache(GPFCON,0x0000004);  
1393.     extint0=ioremap_nocache(EXTINT0,0x0000004);  
1394.     intmsk=ioremap_nocache(INTMSK,0x0000004);  
1395.   
1396.     writel( readl(bwscon)|0xc0000,bwscon);/* 将BWSCON寄存器[19:18]设置为11 */  
1397.     writel( (readl(gpfcon) & ~(0x3 << 14)) | (0x2 << 14), gpfcon); /* 设置GPF寄存器 */  
1398.     writel( readl(gpfcon) | (0x1 << 7), gpfcon); // Disable pull-up，不使能上拉   
1399.     writel( (readl(extint0) & ~(0xf << 28)) | (0x4 << 28), extint0); //rising edge，设置上升沿触发中断   
1400.     writel( (readl(intmsk))  & ~0x80, intmsk);/* 设置中断屏蔽寄存器 */  
1401.           
1402.     /*End of add*/  
1403.     /* Init network device */  
1404.     /* 使用alloc_etherdev()函数分配一个网络设备的结构体，原型在include/linux/etherdevice.h */  
1405.     ndev = alloc_etherdev(sizeof(struct board_info));  
1406.     if (!ndev) {  
1407.         dev_err(&pdev->dev, "could not allocate device.\n");  
1408.         return -ENOMEM;  
1409.     }  
1410.   
1411. /*通过SET_NETDEV_DEV(netdev, &pdev->dev)宏设置net_device.device->parent为当前的pci_device->device 
1412. *(这儿net_device包含的是device结构，而不是指针）。这样，就建立起了net_device到device的联系。 
1413. */  
1414.     SET_NETDEV_DEV(ndev, &pdev->dev);  
1415.   
1416.     dev_dbg(&pdev->dev, "dm9000_probe()\n");  
1417.   
1418.     /* setup board info structure */  
1419.     /* 下面都是设置board_info结构体 */  
1420.     db = netdev_priv(ndev);/* 返回dev->priv的地址 */  
1421.   
1422.     db->dev = &pdev->dev;  
1423.     db->ndev = ndev;  
1424.   
1425.     spin_lock_init(&db->lock);  
1426.     mutex_init(&db->addr_lock);  
1427.   
1428.     INIT_DELAYED_WORK(&db->phy_poll, dm9000_poll_work);  
1429.   
1430.     db->addr_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);  
1431.     db->data_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);  
1432.     db->irq_res  = platform_get_resource(pdev, IORESOURCE_IRQ, 0);  
1433.   
1434.     if (db->addr_res == NULL || db->data_res == NULL ||  
1435.         db->irq_res == NULL) {  
1436.         dev_err(db->dev, "insufficient resources\n");  
1437.         ret = -ENOENT;  
1438.         goto out;  
1439.     }  
1440.   
1441.     db->irq_wake = platform_get_irq(pdev, 1);  
1442.     if (db->irq_wake >= 0) {  
1443.         dev_dbg(db->dev, "wakeup irq %d\n", db->irq_wake);  
1444.   
1445.         ret = request_irq(db->irq_wake, dm9000_wol_interrupt,  
1446.                   IRQF_SHARED, dev_name(db->dev), ndev);  
1447.         if (ret) {  
1448.             dev_err(db->dev, "cannot get wakeup irq (%d)\n", ret);  
1449.         } else {  
1450.   
1451.             /* test to see if irq is really wakeup capable */  
1452.             ret = set_irq_wake(db->irq_wake, 1);  
1453.             if (ret) {  
1454.                 dev_err(db->dev, "irq %d cannot set wakeup (%d)\n",  
1455.                     db->irq_wake, ret);  
1456.                 ret = 0;  
1457.             } else {  
1458.                 set_irq_wake(db->irq_wake, 0);  
1459.                 db->wake_supported = 1;  
1460.             }  
1461.         }  
1462.     }  
1463.   
1464.     iosize = resource_size(db->addr_res);  
1465.     db->addr_req = request_mem_region(db->addr_res->start, iosize,  
1466.                       pdev->name);  
1467.   
1468.     if (db->addr_req == NULL) {  
1469.         dev_err(db->dev, "cannot claim address reg area\n");  
1470.         ret = -EIO;  
1471.         goto out;  
1472.     }  
1473.   
1474.     db->io_addr = ioremap(db->addr_res->start, iosize);  
1475.   
1476.     if (db->io_addr == NULL) {  
1477.         dev_err(db->dev, "failed to ioremap address reg\n");  
1478.         ret = -EINVAL;  
1479.         goto out;  
1480.     }  
1481.   
1482.     iosize = resource_size(db->data_res);  
1483.     db->data_req = request_mem_region(db->data_res->start, iosize,  
1484.                       pdev->name);  
1485.   
1486.     if (db->data_req == NULL) {  
1487.         dev_err(db->dev, "cannot claim data reg area\n");  
1488.         ret = -EIO;  
1489.         goto out;  
1490.     }  
1491.   
1492.     db->io_data = ioremap(db->data_res->start, iosize);  
1493.   
1494.     if (db->io_data == NULL) {  
1495.         dev_err(db->dev, "failed to ioremap data reg\n");  
1496.         ret = -EINVAL;  
1497.         goto out;  
1498.     }  
1499.     /* 设置结构体board_info结束 */  
1500.       
1501.     /* fill in parameters for net-dev structure */  
1502.     ndev->base_addr = (unsigned long)db->io_addr;/* 设置网络设备的地址 */  
1503.     ndev->irq    = db->irq_res->start;/* 设置网络设备的中断资源地址 */  
1504.   
1505.     /* ensure at least we have a default set of IO routines */  
1506.     dm9000_set_io(db, iosize);  
1507.   
1508.     /* check to see if anything is being over-ridden */  
1509.       
1510.     /*根据pdev->dev.platform_data的信息判断IO的宽度并设置相应的宽度*/  
1511.     if (pdata != NULL) {  
1512.         /* check to see if the driver wants to over-ride the 
1513.          * default IO width */  
1514.   
1515.         if (pdata->flags & DM9000_PLATF_8BITONLY)  
1516.             dm9000_set_io(db, 1);  
1517.   
1518.         if (pdata->flags & DM9000_PLATF_16BITONLY)  
1519.             dm9000_set_io(db, 2);  
1520.   
1521.         if (pdata->flags & DM9000_PLATF_32BITONLY)  
1522.             dm9000_set_io(db, 4);  
1523.   
1524.         /* check to see if there are any IO routine 
1525.          * over-rides */  
1526.   
1527.         if (pdata->inblk != NULL)  
1528.             db->inblk = pdata->inblk;  
1529.   
1530.         if (pdata->outblk != NULL)  
1531.             db->outblk = pdata->outblk;  
1532.   
1533.         if (pdata->dumpblk != NULL)  
1534.             db->dumpblk = pdata->dumpblk;  
1535.   
1536.         db->flags = pdata->flags;  
1537.     }  
1538.   
1539. #ifdef CONFIG_DM9000_FORCE_SIMPLE_PHY_POLL   
1540.     db->flags |= DM9000_PLATF_SIMPLE_PHY;  
1541. #endif   
1542.   
1543.     dm9000_reset(db);/* 复位 */  
1544.   
1545.     /* try multiple times, DM9000 sometimes gets the read wrong */  
1546.     for (i = 0; i < 8; i++) {  
1547.         id_val  = ior(db, DM9000_VIDL);  
1548.         id_val |= (u32)ior(db, DM9000_VIDH) << 8;  
1549.         id_val |= (u32)ior(db, DM9000_PIDL) << 16;  
1550.         id_val |= (u32)ior(db, DM9000_PIDH) << 24;  
1551.   
1552.         if (id_val == DM9000_ID)  
1553.             break;  
1554.         dev_err(db->dev, "read wrong id 0x%08x\n", id_val);  
1555.     }  
1556.   
1557.     if (id_val != DM9000_ID) {  
1558.         dev_err(db->dev, "wrong id: 0x%08x\n", id_val);  
1559.         ret = -ENODEV;  
1560.         goto out;  
1561.     }  
1562.   
1563.     /* Identify what type of DM9000 we are working on */  
1564.   
1565.     id_val = ior(db, DM9000_CHIPR);  
1566.     dev_dbg(db->dev, "dm9000 revision 0x%02x\n", id_val);  
1567.   
1568.     switch (id_val) {  
1569.     case CHIPR_DM9000A:  
1570.         db->type = TYPE_DM9000A;  
1571.         break;  
1572.     case CHIPR_DM9000B:  
1573.         db->type = TYPE_DM9000B;  
1574.         break;  
1575.     default:  
1576.         dev_dbg(db->dev, "ID %02x => defaulting to DM9000E\n", id_val);  
1577.         db->type = TYPE_DM9000E;  
1578.     }  
1579.   
1580.     /* dm9000a/b are capable of hardware checksum offload */  
1581.     if (db->type == TYPE_DM9000A || db->type == TYPE_DM9000B) {  
1582.         db->can_csum = 1;  
1583.         db->rx_csum = 1;  
1584.         ndev->features |= NETIF_F_IP_CSUM;  
1585.     }  
1586.   
1587.     /* from this point we assume that we have found a DM9000 */  
1588.   
1589.     /* driver system function */  
1590.     ether_setup(ndev);  
1591.   
1592.     ndev->netdev_ops = &dm9000_netdev_ops;  
1593.     ndev->watchdog_timeo = msecs_to_jiffies(watchdog);  
1594.     ndev->ethtool_ops    = &dm9000_ethtool_ops;  
1595.   
1596.     db->msg_enable       = NETIF_MSG_LINK;  
1597.     db->mii.phy_id_mask  = 0x1f;  
1598.     db->mii.reg_num_mask = 0x1f;  
1599.     db->mii.force_media  = 0;  
1600.     db->mii.full_duplex  = 0;  
1601.     db->mii.dev       = ndev;  
1602.     db->mii.mdio_read    = dm9000_phy_read;  
1603.     db->mii.mdio_write   = dm9000_phy_write;  
1604.   
1605.     mac_src = "eeprom";  
1606.   
1607.     /* try reading the node address from the attached EEPROM */  
1608.     for (i = 0; i < 6; i += 2)  
1609.         dm9000_read_eeprom(db, i / 2, ndev->dev_addr+i);  
1610.   
1611.     if (!is_valid_ether_addr(ndev->dev_addr) && pdata != NULL) {  
1612.         mac_src = "platform data";  
1613.         memcpy(ndev->dev_addr, pdata->dev_addr, 6);  
1614.     }  
1615.   
1616.     if (!is_valid_ether_addr(ndev->dev_addr)) {  
1617.         /* try reading from mac */  
1618.           
1619.         mac_src = "chip";  
1620.         for (i = 0; i < 6; i++)  
1621.             ndev->dev_addr[i] = ne_def_eth_mac_addr[i];  
1622.     }  
1623.   
1624.     if (!is_valid_ether_addr(ndev->dev_addr))  
1625.         dev_warn(db->dev, "%s: Invalid ethernet MAC address. Please "  
1626.              "set using ifconfig\n", ndev->name);  
1627.   
1628.     /* 设置pdev->dev->driver_data为ndev，保存成平台设备总线上的数据，以后使用只需platform_get_drvdata()即可*/  
1629.     platform_set_drvdata(pdev, ndev);  
1630.       
1631.     /* 注册该网络设备 */  
1632.     ret = register_netdev(ndev);  
1633.   
1634.     if (ret == 0)  
1635.         printk(KERN_INFO "%s: dm9000%c at %p,%p IRQ %d MAC: %pM (%s)\n",  
1636.                ndev->name, dm9000_type_to_char(db->type),  
1637.                db->io_addr, db->io_data, ndev->irq,  
1638.                ndev->dev_addr, mac_src);  
1639.     return 0;  
1640.       
1641. /* 异常处理 */  
1642. out:  
1643.     dev_err(db->dev, "not found (%d).\n", ret);  
1644.   
1645.     dm9000_release_board(pdev, db);  
1646.     free_netdev(ndev);  
1647.   
1648.     return ret;  
1649. }  
1650.   
1651. /* 该函数是将设备从内核中移除，释放资源，在移除设备驱动时执行 */  
1652. static int __devexit  
1653. dm9000_drv_remove(struct platform_device *pdev)  
1654. {  
1655.     struct net_device *ndev = platform_get_drvdata(pdev);/* 从总线获取probe函数保存到总线的设备信息 */  
1656.   
1657.     platform_set_drvdata(pdev, NULL);/* 释放pdev资源 */  
1658.   
1659.     unregister_netdev(ndev);/* 解除网络设备 */  
1660.     dm9000_release_board(pdev, (board_info_t *) netdev_priv(ndev));/* 释放该设备申请的IO资源 */  
1661.     free_netdev(ndev);      /* free device structure */  
1662.   
1663.     dev_dbg(&pdev->dev, "released and freed device\n");  
1664.     return 0;  
1665. }  
1666.   
1667. /*平台设备驱动的结构体定义 
1668. *在该结构体中可以定义有关Power Management的管理函数 
1669. *该驱动中将其省略，侧重分析dm9000的基本原理 
1670. */  
1671. static struct platform_driver dm9000_driver = {  
1672.     .driver = {  
1673.         .name    = "dm9000",/* 该名称和系统初始化中，平台设备的名称一致 */  
1674.         .owner   = THIS_MODULE,  
1675.     },  
1676.     .probe   = dm9000_probe,/* 资源探测函数 */  
1677.     .remove  = __devexit_p(dm9000_drv_remove),/* 设备移除函数 */  
1678. };  
1679.   
1680. static int __init  
1681. dm9000_init(void)  
1682. {  
1683.     printk(KERN_INFO "%s Ethernet Driver, V%s\n", CARDNAME, DRV_VERSION);  
1684.   
1685.     return platform_driver_register(&dm9000_driver);  
1686. }  
1687.   
1688. static void __exit  
1689. dm9000_cleanup(void)  
1690. {  
1691.     platform_driver_unregister(&dm9000_driver);  
1692. }  
1693.   
1694. module_init(dm9000_init);  
1695. module_exit(dm9000_cleanup);  
1696.   
1697. MODULE_AUTHOR("Modified by yan");  
1698. MODULE_DESCRIPTION("Davicom DM9000 network driver");  
1699. MODULE_LICENSE("GPL");  
1700. MODULE_ALIAS("platform:dm9000");