1.Linux网络子系统

系统调用接口层

为应用程序提供访问网络子系统的统一方法。

协议无关层

提供通用的方法来使用传输层协议。

协议栈的实现

实现具体的网络协议

设备无关层

协议与设备驱动之前通信的通用接口

设备驱动程序

2.重要数据结构

2.1 网卡描述结构

在Linux内核中，每个网卡都由一个net_device结构来 描述，其中的一些重要成员有：

char name[IFNAMSIZ]

设备名,如：eth%d

unsigned long base_addr

I/O 基地址

const struct net_device_ops *netdev_ops;
记录了网卡所支持的操作

2.2 网卡操作集合

类似于字符设备驱动中的file_operations结构， net_device_ops结构记录了网卡所支持的操作。

static const struct net_device_ops dm9000_netdev_ops =

{

.ndo_open = dm9000_open,

.ndo_stop = dm9000_stop,

.ndo_start_xmit = dm9000_start_xmit,

.ndo_do_ioctl = dm9000_ioctl,

.ndo_validate_addr = eth_validate_addr,

.ndo_set_mac_address = eth_mac_addr,

};

2.3 网络数据包

Linux内核中的每个网络数据包都由一个套接字 缓冲区结构 struct sk_buff 描述，即一个 sk_buff结构就是一个网络包,指向sk_buff的指 针通常被称做skb。

3.网卡驱动架构分析
cs89x0.c:

1. /* cs89x0.c: A Crystal Semiconductor (Now Cirrus Logic) CS89[02]0

2. * driver for linux.

3. */

6. static const struct net_device_ops net_ops = {                                                                     //net_device_ops结构，各种网卡操作函数接口

7. .ndo_open = net_open,

8. .ndo_stop = net_close,

9. .ndo_tx_timeout = net_timeout,

10. .ndo_start_xmit = net_send_packet,

11. .ndo_get_stats = net_get_stats,

12. .ndo_set_multicast_list = set_multicast_list,

13. .ndo_set_mac_address = set_mac_address,

14. #ifdef CONFIG_NET_POLL_CONTROLLER

15. .ndo_poll_controller = net_poll_controller,

16. #endif

17. .ndo_change_mtu = eth_change_mtu,

18. .ndo_validate_addr = eth_validate_addr,

19. };

21. static netdev_tx_t net_send_packet(struct sk_buff *skb,struct net_device *dev)                                     //网卡的发送函数

22. {

23. struct net_local *lp = netdev_priv(dev);

24. unsigned long flags;

26. if (net_debug > 3) {

27. printk("%s: sent %d byte packet of type %x\n",

28. dev->name, skb->len,

29. (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);

30. }

32. /* keep the upload from being interrupted, since we

33. ask the chip to start transmitting before the

34. whole packet has been completely uploaded. */

36. spin_lock_irqsave(&lp->lock, flags);

37. netif_stop_queue(dev);                                                                                         //驱动程序通知网络子系统暂停数据包传输，从来进行实现流量控制。

39. /* initiate a transmit sequence */

40. writeword(dev->base_addr, TX_CMD_PORT, lp->send_cmd);

41. writeword(dev->base_addr, TX_LEN_PORT, skb->len);

43. /* Test to see if the chip has allocated memory for the packet */

44. if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {

45. /*

46. * It hasn't. But that shouldn't happen since

47. * we're waiting for TxOk, so return 1 and requeue this packet.

48. */

50. spin_unlock_irqrestore(&lp->lock, flags);

51. if (net_debug) printk("cs89x0: Tx buffer not free!\n");

52. return NETDEV_TX_BUSY;

53. }

54. /* Write the contents of the packet */

55. writewords(dev->base_addr, TX_FRAME_PORT,skb->data,(skb->len+1) >>1);                                         //将skb的内容写入寄存器，发送

56. spin_unlock_irqrestore(&lp->lock, flags);

57. dev->stats.tx_bytes += skb->len;

58. dev_kfree_skb (skb);                                                                                          //释放skb

60. /*

61. * We DO NOT call netif_wake_queue() here.

62. * We also DO NOT call netif_start_queue().

63. *

64. * Either of these would cause another bottom half run through

65. * net_send_packet() before this packet has fully gone out. That causes

66. * us to hit the "Gasp!" above and the send is rescheduled. it runs like

67. * a dog. We just return and wait for the Tx completion interrupt handler

68. * to restart the netdevice layer

69. */

71. return NETDEV_TX_OK;

72. }

74. /* The typical workload of the driver:

75. Handle the network interface interrupts. */

77. static irqreturn_t net_interrupt(int irq, void *dev_id)                                                                   //网卡中断处理函数

78. {

79. struct net_device *dev = dev_id;

80. struct net_local *lp;

81. int ioaddr, status;

82. int handled = 0;

84. ioaddr = dev->base_addr;

85. lp = netdev_priv(dev);

87. /* we MUST read all the events out of the ISQ, otherwise we'll never

88. get interrupted again. As a consequence, we can't have any limit

89. on the number of times we loop in the interrupt handler. The

90. hardware guarantees that eventually we'll run out of events. Of

91. course, if you're on a slow machine, and packets are arriving

92. faster than you can read them off, you're screwed. Hasta la

93. vista, */

94. while ((status = readword(dev->base_addr, ISQ_PORT))) {

95. if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);

96. handled = 1;

97. switch(status & ISQ_EVENT_MASK) {

98. case ISQ_RECEIVER_EVENT:

99. /* Got a packet(s). */

100. net_rx(dev);

101. break;

102. case ISQ_TRANSMITTER_EVENT:

103. dev->stats.tx_packets++;

104. netif_wake_queue(dev); /* Inform upper layers. */                                                         //发送中停止设备，在这里被唤醒

105. if ((status & ( TX_OK |

106. TX_LOST_CRS |

107. TX_SQE_ERROR |

108. TX_LATE_COL |

109. TX_16_COL)) != TX_OK) {

110. if ((status & TX_OK) == 0)

111. dev->stats.tx_errors++;

112. if (status & TX_LOST_CRS)

113. dev->stats.tx_carrier_errors++;

114. if (status & TX_SQE_ERROR)

115. dev->stats.tx_heartbeat_errors++;

116. if (status & TX_LATE_COL)

117. dev->stats.tx_window_errors++;

118. if (status & TX_16_COL)

119. dev->stats.tx_aborted_errors++;

120. }

121. break;

122. case ISQ_BUFFER_EVENT:

123. if (status & READY_FOR_TX) {

124. /* we tried to transmit a packet earlier,

125. but inexplicably ran out of buffers.

126. That shouldn't happen since we only ever

127. load one packet. Shrug. Do the right

128. thing anyway. */

129. netif_wake_queue(dev); /* Inform upper layers. */

130. }

131. if (status & TX_UNDERRUN) {

132. if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);

133. lp->send_underrun++;

134. if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;

135. else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;

136. /* transmit cycle is done, although

137. frame wasn't transmitted - this

138. avoids having to wait for the upper

139. layers to timeout on us, in the

140. event of a tx underrun */

141. netif_wake_queue(dev); /* Inform upper layers. */

142. }

143. #if ALLOW_DMA

144. if (lp->use_dma && (status & RX_DMA)) {

145. int count = readreg(dev, PP_DmaFrameCnt);

146. while(count) {

147. if (net_debug > 5)

148. printk("%s: receiving %d DMA frames\n", dev->name, count);

149. if (net_debug > 2 && count >1)

150. printk("%s: receiving %d DMA frames\n", dev->name, count);

151. dma_rx(dev);

152. if (--count == 0)

153. count = readreg(dev, PP_DmaFrameCnt);

154. if (net_debug > 2 && count > 0)

155. printk("%s: continuing with %d DMA frames\n", dev->name, count);

156. }

157. }

158. #endif

159. break;

160. case ISQ_RX_MISS_EVENT:

161. dev->stats.rx_missed_errors += (status >> 6);

162. break;

163. case ISQ_TX_COL_EVENT:

164. dev->stats.collisions += (status >> 6);

165. break;

166. }

167. }

168. return IRQ_RETVAL(handled);

169. }

170. ………..

172. /* We have a good packet(s), get it/them out of the buffers. */

173. static void

174. net_rx(struct net_device *dev)                                                                                             //网卡的接收函数

175. {

176. struct sk_buff *skb;

177. int status, length;

179. int ioaddr = dev->base_addr;

180. status = readword(ioaddr, RX_FRAME_PORT);                                                                              //读取待接收的数据状态

181. length = readword(ioaddr, RX_FRAME_PORT);                                                                              //读取接收数据的长度

183. if ((status & RX_OK) == 0) {

184. count_rx_errors(status, dev);

185. return;

186. }

188. /* Malloc up new buffer. */

189. skb = dev_alloc_skb(length + 2);                                                                                       //分配skb长度+2的结构

190. if (skb == NULL) {

191. #if 0 /* Again, this seems a cruel thing to do */

192. printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);

193. #endif

194. dev->stats.rx_dropped++;

195. return;

196. }

197. skb_reserve(skb, 2); /* longword align L3 header */

199. readwords(ioaddr, RX_FRAME_PORT, skb_put(skb, length), length >> 1);                                                    //从网卡寄存器中读出数据，存入skb

200. if (length & 1)

201. skb->data[length-1] = readword(ioaddr, RX_FRAME_PORT);

203. if (net_debug > 3) {

204. printk( "%s: received %d byte packet of type %x\n",

205. dev->name, length,

206. (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);

207. }

209. skb->protocol=eth_type_trans(skb,dev);

210. netif_rx(skb);                                                                                                          //将接收到的数据包skb交给协议栈-netif_rx

211. dev->stats.rx_packets++;

212. dev->stats.rx_bytes += length;

213. }

215. #if ALLOW_DMA

216. static void release_dma_buff(struct net_local *lp)

217. {

218. if (lp->dma_buff) {

219. free_pages((unsigned long)(lp->dma_buff), get_order(lp->dmasize * 1024));

220. lp->dma_buff = NULL;

221. }

222. }

223. #endif

225. /* The inverse routine to net_open(). */

226. static int

227. net_close(struct net_device *dev)

228. {

229. #if ALLOW_DMA

230. struct net_local *lp = netdev_priv(dev);

231. #endif

233. netif_stop_queue(dev);

235. writereg(dev, PP_RxCFG, 0);

236. writereg(dev, PP_TxCFG, 0);

237. writereg(dev, PP_BufCFG, 0);

238. writereg(dev, PP_BusCTL, 0);

240. free_irq(dev->irq, dev);

242. #if ALLOW_DMA

243. if (lp->use_dma && lp->dma) {

244. free_dma(dev->dma);

245. release_dma_buff(lp);

246. }

247. #endif

249. /* Update the statistics here. */

250. return 0;

251. }

253. ……..

255. int __init init_module(void)                                                                               //网卡初始化

256. {

257. struct net_device *dev = alloc_etherdev(sizeof(struct net_local));                                     //分配net_device结构空间

258. struct net_local *lp;

259. int ret = 0;

261. #if DEBUGGING

262. net_debug = debug;

263. #else

264. debug = 0;

265. #endif

266. if (!dev)

267. return -ENOMEM;

269. dev->irq = irq;                                                                                        //初始化分配的dev

270. dev->base_addr = io;

271. lp = netdev_priv(dev);

273. #if ALLOW_DMA

274. if (use_dma) {

275. lp->use_dma = use_dma;

276. lp->dma = dma;

277. lp->dmasize = dmasize;

278. }

279. #endif

281. spin_lock_init(&lp->lock);

283. /* boy, they'd better get these right */

284. if (!strcmp(media, "rj45"))

285. lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;

286. else if (!strcmp(media, "aui"))

287. lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI;

288. else if (!strcmp(media, "bnc"))

289. lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;

290. else

291. lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;

293. if (duplex==-1)

294. lp->auto_neg_cnf = AUTO_NEG_ENABLE;

296. if (io == 0) {

297. printk(KERN_ERR "cs89x0.c: Module autoprobing not allowed.\n");

298. printk(KERN_ERR "cs89x0.c: Append io=0xNNN\n");

299. ret = -EPERM;

300. goto out;

301. } else if (io <= 0x1ff) {

302. ret = -ENXIO;

303. goto out;

304. }

306. #if ALLOW_DMA

307. if (use_dma && dmasize != 16 && dmasize != 64) {

308. printk(KERN_ERR "cs89x0.c: dma size must be either 16K or 64K, not %dK\n", dmasize);

309. ret = -EPERM;

310. goto out;

311. }

312. #endif

313. ret = cs89x0_probe1(dev, io, 1);                                                                                //这里依然在初始化：硬件初始化、MAC地址、注册网卡驱动(register_netdev）

314. if (ret)

315. goto out;

317. dev_cs89x0 = dev;

318. return 0;

319. out:

320. free_netdev(dev);

321. return ret;

322. }

324. void __exit

325. cleanup_module(void)

326. {

327. unregister_netdev(dev_cs89x0);

328. writeword(dev_cs89x0->base_addr, ADD_PORT, PP_ChipID);

329. release_region(dev_cs89x0->base_addr, NETCARD_IO_EXTENT);

330. free_netdev(dev_cs89x0);

331. }

332. #endif /* MODULE */

334. /*

335. * Local variables:

336. * version-control: t

337. * kept-new-versions: 5

338. * c-indent-level: 8

339. * tab-width: 8

340. * End:

341. *

342. */

阅读(69) | 评论(0) | 转发(0) |

0

上一篇：串口驱动编程实现

下一篇：linux shell 数组建立及使用技巧

相关热门文章

• SHTML是什么_SSI有什么用…
• 查看linux中某个端口（port）…
• 卡尔曼滤波的原理说明…
• shell中字符串操作
• 关于java中的“错误：找不到或…

给主人留下些什么吧！~~

评论热议