CMSIS-Driver升级lwip的底层驱动，增加多线程信号量保护（2020-04-25）

eric2013

新版lwip软件包镜像下载：
http://www.armbbs.cn/forum.php?mod=viewthread&tid=96992

就是这个ethernetif.c：

后面升级lwip教程，同步升级下这个驱动文件：

1. /*
   
2. * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
   
3. * All rights reserved.
   
4. *
   
5. * Redistribution and use in source and binary forms, with or without modification,
   
6. * are permitted provided that the following conditions are met:
   
7. *
   
8. * 1. Redistributions of source code must retain the above copyright notice,
   
9. *    this list of conditions and the following disclaimer.
   
10. * 2. Redistributions in binary form must reproduce the above copyright notice,
    
11. *    this list of conditions and the following disclaimer in the documentation
    
12. *    and/or other materials provided with the distribution.
    
13. * 3. The name of the author may not be used to endorse or promote products
    
14. *    derived from this software without specific prior written permission.
    
15. *
    
16. * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
    
17. * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
    
18. * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
    
19. * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
    
20. * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
    
21. * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
    
22. * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
    
23. * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
    
24. * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
    
25. * OF SUCH DAMAGE.
    
26. *
    
27. * This file is part of the lwIP TCP/IP stack.
    
28. *
    
29. * Author: Adam Dunkels <adam@sics.se>
    
30. *
    
31. */
    
32. 
    
33. #include "lwip/opt.h"
    
34. 
    
35. #include "lwip/def.h"
    
36. #include "lwip/mem.h"
    
37. #include "lwip/pbuf.h"
    
38. #include "lwip/stats.h"
    
39. #include "lwip/snmp.h"
    
40. #include "lwip/ethip6.h"
    
41. #include "lwip/etharp.h"
    
42. #include "netif/ppp/pppoe.h"
    
43. 
    
44. #include "arch/sys_arch.h"
    
45. #include "lwip/sys.h"
    
46. 
    
47. #include "ethif_config.h"
    
48. #include "ethernetif.h"
    
49. #include "Driver_ETH_MAC.h"
    
50. #include "Driver_ETH_PHY.h"
    
51. 
    
52. /* Ethernet MAC & PHY Driver */
    
53. extern ARM_DRIVER_ETH_MAC ARM_Driver_ETH_MAC_(ETH_DRV_NUM);
    
54. extern ARM_DRIVER_ETH_PHY ARM_Driver_ETH_PHY_(ETH_DRV_NUM);
    
55. 
    
56. /* Define those to better describe your network interface. */
    
57. #define IFNAME0 'e'
    
58. #define IFNAME1 'n'
    
59. 
    
60. /**
    
61. * Helper struct to hold private data used to operate your ethernet interface.
    
62. * Keeping the ethernet address of the MAC in this struct is not necessary
    
63. * as it is already kept in the struct netif.
    
64. */
    
65. struct ethernetif {
    
66.   ARM_DRIVER_ETH_MAC *mac;              // Registered MAC driver
    
67.   ARM_DRIVER_ETH_PHY *phy;              // Registered PHY driver
    
68.   ARM_ETH_LINK_STATE link;              // Ethernet Link State
    
69.   bool               event_rx_frame;    // Callback RX event generated
    
70.   bool               phy_ok;            // PHY initialized successfully
    
71.   bool               rx_event;          // Frame received
    
72.   sys_sem_t          sem;
    
73. };
    
74. 
    
75. static struct ethernetif eth0_status;
    
76. 
    
77. /* Forward declarations. */
    
78. static void  ethernetif_input(struct netif *netif);
    
79. static void  eth0_notify (uint32_t event);
    
80. 
    
81. /**
    
82. * In this function, the hardware should be initialized.
    
83. * Called from ethernetif_init().
    
84. *
    
85. * @param netif the already initialized lwip network interface structure
    
86. *        for this ethernetif
    
87. */
    
88. static void
    
89. low_level_init(struct netif *netif)
    
90. {
    
91.   struct ethernetif *eth = netif->state;
    
92.   ARM_ETH_MAC_CAPABILITIES cap;
    
93. 
    
94.   /* set MAC hardware address length */
    
95.   netif->hwaddr_len = ETH_HWADDR_LEN;
    
96. 
    
97.   /* set MAC hardware address */
    
98.   netif->hwaddr[0] =  MAC_ADDR0;
    
99.   netif->hwaddr[1] =  MAC_ADDR1;
    
100.   netif->hwaddr[2] =  MAC_ADDR2;
     
101.   netif->hwaddr[3] =  MAC_ADDR3;
     
102.   netif->hwaddr[4] =  MAC_ADDR4;
     
103.   netif->hwaddr[5] =  MAC_ADDR5;
     
104. 
     
105.   /* maximum transfer unit */
     
106.   netif->mtu = 1500;
     
107. 
     
108.   /* device capabilities */
     
109.   /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */
     
110.   netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET;
     
111. #if LWIP_IPV4 && LWIP_IGMP
     
112.   netif->flags |= NETIF_FLAG_IGMP;
     
113. #endif
     
114. #if LWIP_IPV6 && LWIP_IPV6_MLD
     
115.   netif->flags |= NETIF_FLAG_MLD6;
     
116.   /*
     
117.    * For hardware/netifs that implement MAC filtering.
     
118.    * All-nodes link-local is handled by default, so we must let the hardware know
     
119.    * to allow multicast packets in.
     
120.    * Should set mld_mac_filter previously. */
     
121.   if (netif->mld_mac_filter != NULL) {
     
122.     ip6_addr_t ip6_allnodes_ll;
     
123.     ip6_addr_set_allnodes_linklocal(&ip6_allnodes_ll);
     
124.     netif->mld_mac_filter(netif, &ip6_allnodes_ll, NETIF_ADD_MAC_FILTER);
     
125.   }
     
126. #endif /* LWIP_IPV6 && LWIP_IPV6_MLD */
     
127. 
     
128.   /* Do whatever else is needed to initialize interface. */
     
129.   eth->phy = &ARM_Driver_ETH_PHY_(ETH_DRV_NUM);
     
130.   eth->mac = &ARM_Driver_ETH_MAC_(ETH_DRV_NUM);
     
131. 
     
132.   eth->link   = ARM_ETH_LINK_DOWN;
     
133.   eth->phy_ok = false;
     
134. 
     
135.   sys_sem_new (e->sem, 0);
     
136.   /* Get MAC capabilities */
     
137.   cap = eth->mac->GetCapabilities ();
     
138.   eth->event_rx_frame = (cap.event_rx_frame) ? true : false;
     
139. 
     
140.   eth->mac->Initialize (eth0_notify);
     
141.   eth->mac->PowerControl (ARM_POWER_FULL);
     
142.   eth->mac->SetMacAddress ((ARM_ETH_MAC_ADDR *)netif->hwaddr);
     
143.   eth->mac->Control (ARM_ETH_MAC_CONTROL_TX, 0);
     
144.   eth->mac->Control (ARM_ETH_MAC_CONTROL_RX, 0);
     
145. 
     
146.   /* Initialize Physical Media Interface */
     
147.   if (eth->phy->Initialize (eth->mac->PHY_Read, eth->mac->PHY_Write) == ARM_DRIVER_OK) {
     
148.     eth->phy->PowerControl (ARM_POWER_FULL);
     
149.     eth->phy->SetInterface (cap.media_interface);
     
150.     eth->phy->SetMode (ARM_ETH_PHY_AUTO_NEGOTIATE);
     
151.     eth->phy_ok = true;
     
152.   }
     
153.   sys_sem_signal (e->sem);
     
154. }
     
155. 
     
156. static void eth0_notify (uint32_t event) {
     
157.   /* Send notification on RX event */
     
158.   if (event == ARM_ETH_MAC_EVENT_RX_FRAME) {
     
159.     eth0_status.rx_event = true;
     
160.   }
     
161. }
     
162. 
     
163. /**
     
164. * This function should do the actual transmission of the packet. The packet is
     
165. * contained in the pbuf that is passed to the function. This pbuf
     
166. * might be chained.
     
167. *
     
168. * @param netif the lwip network interface structure for this ethernetif
     
169. * @param p the MAC packet to send (e.g. IP packet including MAC addresses and type)
     
170. * @return ERR_OK if the packet could be sent
     
171. *         an err_t value if the packet couldn't be sent
     
172. *
     
173. * @note Returning ERR_MEM here if a DMA queue of your MAC is full can lead to
     
174. *       strange results. You might consider waiting for space in the DMA queue
     
175. *       to become available since the stack doesn't retry to send a packet
     
176. *       dropped because of memory failure (except for the TCP timers).
     
177. */
     
178. 
     
179. static err_t
     
180. low_level_output(struct netif *netif, struct pbuf *p)
     
181. {
     
182.   struct ethernetif *eth = netif->state;
     
183.   struct pbuf *q;
     
184. 
     
185. #if ETH_PAD_SIZE
     
186.   pbuf_remove_header(p, ETH_PAD_SIZE); /* drop the padding word */
     
187. #endif
     
188. 
     
189.   sys_sem_wait (e->sem);
     
190.   for (q = p; q != NULL; q = q->next) {
     
191.     /* Send the data from the pbuf to the interface, one pbuf at a
     
192.        time. The size of the data in each pbuf is kept in the ->len
     
193.        variable. */
     
194.     u32_t flags = (q->next) ? ARM_ETH_MAC_TX_FRAME_FRAGMENT : 0;
     
195.     eth->mac->SendFrame (q->payload, q->len, flags);
     
196.   }
     
197.   sys_sem_signal (e->sem);
     
198. 
     
199.   MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p->tot_len);
     
200.   if (((u8_t *)p->payload)[0] & 1) {
     
201.     /* broadcast or multicast packet*/
     
202.     MIB2_STATS_NETIF_INC(netif, ifoutnucastpkts);
     
203.   } else {
     
204.     /* unicast packet */
     
205.     MIB2_STATS_NETIF_INC(netif, ifoutucastpkts);
     
206.   }
     
207.   /* increase ifoutdiscards or ifouterrors on error */
     
208. 
     
209. #if ETH_PAD_SIZE
     
210.   pbuf_add_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
     
211. #endif
     
212. 
     
213.   LINK_STATS_INC(link.xmit);
     
214. 
     
215.   return ERR_OK;
     
216. }
     
217. 
     
218. /**
     
219. * Should allocate a pbuf and transfer the bytes of the incoming
     
220. * packet from the interface into the pbuf.
     
221. *
     
222. * @param netif the lwip network interface structure for this ethernetif
     
223. * @return a pbuf filled with the received packet (including MAC header)
     
224. *         NULL on memory error
     
225. */
     
226. static struct pbuf *
     
227. low_level_input(struct netif *netif)
     
228. {
     
229.   struct ethernetif *eth = netif->state;
     
230.   struct pbuf *p;
     
231.   u16_t len;
     
232. 
     
233.   /* Obtain the size of the packet and put it into the "len"
     
234.      variable. */
     
235.   len = eth->mac->GetRxFrameSize ();
     
236.   if (len == 0) {
     
237.     /* No packet available */
     
238.     return NULL;
     
239.   }
     
240.   if (len > 1514) {
     
241.     /* Drop oversized packet */
     
242.     eth->mac->ReadFrame (NULL, 0);
     
243.     return NULL;
     
244.   }
     
245. 
     
246. #if ETH_PAD_SIZE
     
247.   len += ETH_PAD_SIZE; /* allow room for Ethernet padding */
     
248. #endif
     
249. 
     
250.   /* We allocate a pbuf chain of pbufs from the pool. */
     
251.   p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL);
     
252. 
     
253.   if (p != NULL) {
     
254. 
     
255. #if ETH_PAD_SIZE
     
256.     pbuf_remove_header(p, ETH_PAD_SIZE); /* drop the padding word */
     
257. #endif
     
258. 
     
259.     /* pbuf payload should be allocated in one piece of contiguous memory. */
     
260.     if (p->len < len) {
     
261.       len = p->len;
     
262.     }
     
263.     /* we are assuming the data will fit into this payload.
     
264.      * this is documented in pbuf.h
     
265.      */
     
266.     eth->mac->ReadFrame (p->payload, len);
     
267. 
     
268.     MIB2_STATS_NETIF_ADD(netif, ifinoctets, p->tot_len);
     
269.     if (((u8_t *)p->payload)[0] & 1) {
     
270.       /* broadcast or multicast packet*/
     
271.       MIB2_STATS_NETIF_INC(netif, ifinnucastpkts);
     
272.     } else {
     
273.       /* unicast packet*/
     
274.       MIB2_STATS_NETIF_INC(netif, ifinucastpkts);
     
275.     }
     
276. #if ETH_PAD_SIZE
     
277.     pbuf_add_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
     
278. #endif
     
279. 
     
280.     LINK_STATS_INC(link.recv);
     
281.   } else {
     
282.     /* Drop packet */
     
283.     eth->mac->ReadFrame (NULL, 0);
     
284.     LINK_STATS_INC(link.memerr);
     
285.     LINK_STATS_INC(link.drop);
     
286.     MIB2_STATS_NETIF_INC(netif, ifindiscards);
     
287.   }
     
288. 
     
289.   return p;
     
290. }
     
291. 
     
292. /**
     
293. * This function should be called when a packet is ready to be read
     
294. * from the interface. It uses the function low_level_input() that
     
295. * should handle the actual reception of bytes from the network
     
296. * interface. Then the type of the received packet is determined and
     
297. * the appropriate input function is called.
     
298. *
     
299. * @param netif the lwip network interface structure for this ethernetif
     
300. */
     
301. static void
     
302. ethernetif_input(struct netif *netif)
     
303. {
     
304.   struct ethernetif *eth = netif->state;
     
305.   struct pbuf *p;
     
306. 
     
307.   /* move received packet into a new pbuf */
     
308.   sys_sem_wait (e->sem);
     
309.   p = low_level_input(netif);
     
310.   sys_sem_signal (e->sem);
     
311.   /* if no packet could be read, silently ignore this */
     
312.   if (p != NULL) {
     
313.     /* pass all packets to ethernet_input, which decides what packets it supports */
     
314.     if (netif->input(p, netif) != ERR_OK) {
     
315.       LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: IP input error\n"));
     
316.       pbuf_free(p);
     
317.       p = NULL;
     
318.     }
     
319.     return;
     
320.   }
     
321.   eth->rx_event = false;
     
322. }
     
323. 
     
324. /**
     
325. * Should be called at the beginning of the program to set up the
     
326. * network interface. It calls the function low_level_init() to do the
     
327. * actual setup of the hardware.
     
328. *
     
329. * This function should be passed as a parameter to netif_add().
     
330. *
     
331. * @param netif the lwip network interface structure for this ethernetif
     
332. * @return ERR_OK if the loopif is initialized
     
333. *         ERR_MEM if private data couldn't be allocated
     
334. *         any other err_t on error
     
335. */
     
336. err_t
     
337. ethernetif_init(struct netif *netif)
     
338. {
     
339.   LWIP_ASSERT("netif != NULL", (netif != NULL));
     
340. 
     
341. #if LWIP_NETIF_HOSTNAME
     
342.   /* Initialize interface hostname */
     
343.   netif->hostname = "lwip";
     
344. #endif /* LWIP_NETIF_HOSTNAME */
     
345. 
     
346.   /*
     
347.    * Initialize the snmp variables and counters inside the struct netif.
     
348.    * The last argument should be replaced with your link speed, in units
     
349.    * of bits per second.
     
350.    */
     
351.   MIB2_INIT_NETIF(netif, snmp_ifType_ethernet_csmacd, 100000000);
     
352. 
     
353.   netif->state = e0_status;
     
354.   netif->name[0] = IFNAME0;
     
355.   netif->name[1] = IFNAME1;
     
356.   /* We directly use etharp_output() here to save a function call.
     
357.    * You can instead declare your own function an call etharp_output()
     
358.    * from it if you have to do some checks before sending (e.g. if link
     
359.    * is available...) */
     
360. #if LWIP_IPV4
     
361.   netif->output = etharp_output;
     
362. #endif /* LWIP_IPV4 */
     
363. #if LWIP_IPV6
     
364.   netif->output_ip6 = ethip6_output;
     
365. #endif /* LWIP_IPV6 */
     
366.   netif->linkoutput = low_level_output;
     
367. 
     
368.   /* initialize the hardware */
     
369.   low_level_init(netif);
     
370. 
     
371.   return ERR_OK;
     
372. }
     
373. 
     
374. void ethernetif_check_link (struct netif *netif) {
     
375.   struct ethernetif *eth = netif->state;
     
376.   ARM_ETH_LINK_STATE link;
     
377. 
     
378.   if (!eth->phy_ok) {
     
379.     return;
     
380.   }
     
381.   /* Check link status */
     
382.   sys_sem_wait (e->sem);
     
383.   link = eth->phy->GetLinkState ();
     
384.   if (link == eth->link) {
     
385.     /* No change */
     
386.     sys_sem_signal (e->sem);
     
387.     return;
     
388.   }
     
389.   eth->link = link;
     
390.   if (eth->link == ARM_ETH_LINK_UP) {
     
391.     /* Start EMAC DMA */
     
392.     ARM_ETH_LINK_INFO info = eth->phy->GetLinkInfo ();
     
393.     eth->mac->Control (ARM_ETH_MAC_CONFIGURE,
     
394.                        info.speed  << ARM_ETH_MAC_SPEED_Pos  |
     
395.                        info.duplex << ARM_ETH_MAC_DUPLEX_Pos |
     
396.                        ARM_ETH_MAC_ADDRESS_BROADCAST         );
     
397.     eth->mac->Control(ARM_ETH_MAC_CONTROL_TX,1);
     
398.     eth->mac->Control(ARM_ETH_MAC_CONTROL_RX,1);
     
399.     sys_sem_signal (e->sem);
     
400.     netif_set_link_up (netif);
     
401.   }
     
402.   else {
     
403.     /* Stop EMAC DMA */
     
404.     eth->mac->Control(ARM_ETH_MAC_CONTROL_TX,0);
     
405.     eth->mac->Control(ARM_ETH_MAC_CONTROL_RX,0);
     
406.     sys_sem_signal (e->sem);
     
407.     netif_set_link_down (netif);
     
408.   }
     
409. }
     
410. 
     
411. void ethernetif_poll (struct netif *netif) {
     
412.   struct ethernetif *eth = netif->state;
     
413. 
     
414.   if (!eth->phy_ok || eth->link == ARM_ETH_LINK_DOWN) {
     
415.     return;
     
416.   }
     
417.   if ((eth->rx_event) || (!eth->event_rx_frame)) {
     
418.     /* process received ethernet packet */
     
419.     ethernetif_input (netif);
     
420.   }
     
421. }
     

复制代码

czc1987

用在哪里，有啥区别呢？不是很明白

dyhfaily

硬汉兄用信号量来保护不会造成优先级反转吗？

eric2013

dyhfaily 发表于 2020-4-26 14:44
硬汉兄用信号量来保护不会造成优先级反转吗？

翻转了也没有关系的。

相比互斥，使用信号好量效率还高点。

想避免的话，可以在lwip这几个任务优先级之间不分配其它优先级可，简单省事些。

nextstation

void ethernetif_poll (struct netif *netif) {
  struct ethernetif *eth = netif->state;

  if (!eth->phy_ok || eth->link == ARM_ETH_LINK_DOWN) {
    return;
  }
  if ((eth->rx_event) || (!eth->event_rx_frame)) {
    /* process received ethernet packet */
    ethernetif_input (netif);
  }
}
如果没有eth中断，这块岂不是要无限循环了，CPU利用率立马就飙上去了，您觉得呢？我感觉需要定义两个信号量，一个触发中断，一个用来保护输入输出。

eric2013

nextstation 发表于 2020-4-28 20:23
void ethernetif_poll (struct netif *netif) {
  struct ethernetif *eth = netif->state;

那必须的，去年发布的时候就支持了。

LwIP网络教程开始更新，使用MDK的RTE环境开发，配套RTX5和FreeRTOS两个版本，更新至第7章（2019-12-12）
http://www.armbbs.cn/forum.php?m ... id=95874&fromuid=58
(出处: 硬汉嵌入式论坛)