wilc1000_driver.c
Go to the documentation of this file.
1 /**
2  * @file wilc1000_driver.c
3  * @brief WILC1000 Wi-Fi controller
4  *
5  * @section License
6  *
7  * SPDX-License-Identifier: GPL-2.0-or-later
8  *
9  * Copyright (C) 2010-2019 Oryx Embedded SARL. All rights reserved.
10  *
11  * This file is part of CycloneTCP Open.
12  *
13  * This program is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU General Public License
15  * as published by the Free Software Foundation; either version 2
16  * of the License, or (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software Foundation,
25  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
26  *
27  * @author Oryx Embedded SARL (www.oryx-embedded.com)
28  * @version 1.9.6
29  **/
30 
31 //Switch to the appropriate trace level
32 #define TRACE_LEVEL NIC_TRACE_LEVEL
33 
34 //Dependencies
35 #include "driver/include/m2m_wifi.h"
36 #include "core/net.h"
38 #include "wilc1000_config.h"
39 #include "debug.h"
40 
41 //Underlying network interface
42 static NetInterface *wilc1000StaInterface = NULL;
43 static NetInterface *wilc1000ApInterface = NULL;
44 
45 //Transmit buffer
46 static uint8_t txBuffer[WILC1000_TX_BUFFER_SIZE];
47 //Receive buffer
48 static uint8_t rxBuffer[WILC1000_RX_BUFFER_SIZE];
49 
50 
51 /**
52  * @brief WILC1000 driver (STA mode)
53  **/
54 
56 {
58  ETH_MTU,
66  NULL,
67  NULL,
68  NULL,
69  TRUE,
70  TRUE,
71  TRUE,
72  TRUE
73 };
74 
75 
76 /**
77  * @brief WILC1000 driver (AP mode)
78  **/
79 
81 {
83  ETH_MTU,
91  NULL,
92  NULL,
93  NULL,
94  TRUE,
95  TRUE,
96  TRUE,
97  TRUE
98 };
99 
100 
101 /**
102  * @brief WILC1000 initialization
103  * @param[in] interface Underlying network interface
104  * @return Error code
105  **/
106 
108 {
109  int8_t status;
110  tstrWifiInitParam param;
111 #if (M2M_FIRMWARE_VERSION_MAJOR_NO == 4)
112  MacAddr staMacAddr;
113  MacAddr apMacAddr;
114 #endif
115 
116  //STA or AP mode?
117  if(interface->nicDriver == &wilc1000StaDriver)
118  {
119  //Debug message
120  TRACE_INFO("Initializing WILC1000 (STA mode)...\r\n");
121  //Save underlying network interface
122  wilc1000StaInterface = interface;
123  }
124  else
125  {
126  //Debug message
127  TRACE_INFO("Initializing WILC1000 (AP mode)...\r\n");
128  //Save underlying network interface
129  wilc1000ApInterface = interface;
130  }
131 
132  //Start of exception handling block
133  do
134  {
135  //Initialization sequence is performed once
136  if(wilc1000StaInterface == NULL || wilc1000ApInterface == NULL)
137  {
138  //Low-level initialization
139  status = nm_bsp_init();
140  //Check status code
141  if(status != M2M_SUCCESS)
142  break;
143 
144  //Set default parameters
145  memset(&param, 0, sizeof(param));
146 
147  //Register callback functions
148  param.pfAppWifiCb = wilc1000AppWifiEvent;
149  param.pfAppMonCb = NULL;
150 #if (M2M_FIRMWARE_VERSION_MAJOR_NO == 3)
151  param.strEthInitParam.pfAppWifiCb = NULL;
152 #endif
153  param.strEthInitParam.pfAppEthCb = wilc1000AppEthEvent;
154 
155  //Set receive buffer
156  param.strEthInitParam.au8ethRcvBuf = rxBuffer;
157  param.strEthInitParam.u16ethRcvBufSize = WILC1000_RX_BUFFER_SIZE;
158 
159  //Initialize WILC1000 controller
160  status = m2m_wifi_init(&param);
161  //Check status code
162  if(status != M2M_SUCCESS)
163  break;
164 
165 #if (M2M_FIRMWARE_VERSION_MAJOR_NO == 3)
166  //Optionally set the station MAC address
167  if(macCompAddr(&interface->macAddr, &MAC_UNSPECIFIED_ADDR))
168  {
169  //Use the factory preprogrammed station address
170  status = m2m_wifi_get_mac_address(interface->macAddr.b);
171  //Check status code
172  if(status != M2M_SUCCESS)
173  break;
174 
175  //Generate the 64-bit interface identifier
176  macAddrToEui64(&interface->macAddr, &interface->eui64);
177  }
178  else
179  {
180  //Override the factory preprogrammed address
181  status = m2m_wifi_set_mac_address(interface->macAddr.b);
182  //Check status code
183  if(status != M2M_SUCCESS)
184  break;
185  }
186 #endif
187  }
188  else
189  {
190  //Initialization was already done
191  status = M2M_SUCCESS;
192  }
193 
194 #if (M2M_FIRMWARE_VERSION_MAJOR_NO == 3)
195  //STA or AP mode?
196  if(interface->nicDriver == &wilc1000StaDriver)
197  {
198  //Check whether the AP interface has been initialized first
199  if(wilc1000ApInterface != NULL)
200  {
201  //Copy MAC address
202  interface->macAddr = wilc1000ApInterface->macAddr;
203  interface->eui64 = wilc1000ApInterface->eui64;
204  }
205  }
206  else
207  {
208  //Check whether the STA interface has been initialized first
209  if(wilc1000StaInterface != NULL)
210  {
211  //Copy MAC
212  interface->macAddr = wilc1000StaInterface->macAddr;
213  interface->eui64 = wilc1000StaInterface->eui64;
214  }
215  }
216 
217 #elif (M2M_FIRMWARE_VERSION_MAJOR_NO == 4)
218  //Retrieve current MAC addresses
219  status = m2m_wifi_get_mac_address(apMacAddr.b, staMacAddr.b);
220  //Check status code
221  if(status != M2M_SUCCESS)
222  break;
223 
224  //Optionally set the MAC address
225  if(macCompAddr(&interface->macAddr, &MAC_UNSPECIFIED_ADDR))
226  {
227  //Use the factory preprogrammed MAC address
228  if(interface == wilc1000StaInterface)
229  interface->macAddr = staMacAddr;
230  else
231  interface->macAddr = apMacAddr;
232 
233  //Generate the 64-bit interface identifier
234  macAddrToEui64(&interface->macAddr, &interface->eui64);
235  }
236  else
237  {
238  //Override the factory preprogrammed address
239  if(interface == wilc1000StaInterface)
240  staMacAddr = interface->macAddr;
241  else
242  apMacAddr = interface->macAddr;
243 
244  //Assign MAC addresses
245  status = m2m_wifi_set_mac_address(staMacAddr.b, apMacAddr.b);
246  //Check status code
247  if(status != M2M_SUCCESS)
248  break;
249  }
250 #endif
251 
252  //End of exception handling block
253  } while(0);
254 
255  //WILC1000 is now ready to send
256  osSetEvent(&interface->nicTxEvent);
257 
258  //Return status code
259  if(status == M2M_SUCCESS)
260  return NO_ERROR;
261  else
262  return ERROR_FAILURE;
263 }
264 
265 
266 /**
267  * @brief WILC1000 timer handler
268  *
269  * This routine is periodically called by the TCP/IP stack to
270  * handle periodic operations such as polling the link state
271  *
272  * @param[in] interface Underlying network interface
273  **/
274 
275 void wilc1000Tick(NetInterface *interface)
276 {
277 }
278 
279 
280 /**
281  * @brief Enable interrupts
282  * @param[in] interface Underlying network interface
283  **/
284 
286 {
287 }
288 
289 
290 /**
291  * @brief Disable interrupts
292  * @param[in] interface Underlying network interface
293  **/
294 
296 {
297 }
298 
299 
300 /**
301  * @brief WILC1000 interrupt service routine
302  * @return TRUE if a higher priority task must be woken. Else FALSE is returned
303  **/
304 
306 {
307  bool_t flag;
308 
309  //This flag will be set if a higher priority task must be woken
310  flag = FALSE;
311 
312  //STA and/or AP mode?
313  if(wilc1000StaInterface != NULL)
314  wilc1000StaInterface->nicEvent = TRUE;
315  else if(wilc1000ApInterface != NULL)
316  wilc1000ApInterface->nicEvent = TRUE;
317 
318  //Notify the TCP/IP stack of the event
319  flag = osSetEventFromIsr(&netEvent);
320 
321  //A higher priority task must be woken?
322  return flag;
323 }
324 
325 
326 /**
327  * @brief WILC1000 event handler
328  * @param[in] interface Underlying network interface
329  **/
330 
332 {
333  //Process Wi-Fi events
334  m2m_wifi_handle_events(NULL);
335 }
336 
337 
338 /**
339  * @brief Send a packet
340  * @param[in] interface Underlying network interface
341  * @param[in] buffer Multi-part buffer containing the data to send
342  * @param[in] offset Offset to the first data byte
343  * @return Error code
344  **/
345 
347  const NetBuffer *buffer, size_t offset)
348 {
349  int8_t status;
350  size_t length;
351 
352  //Retrieve the length of the packet
353  length = netBufferGetLength(buffer) - offset;
354 
355  //Check the frame length
357  {
358  //The transmitter can accept another packet
359  osSetEvent(&interface->nicTxEvent);
360  //Report an error
361  return ERROR_INVALID_LENGTH;
362  }
363 
364  //Make sure the link is up before transmitting the frame
365  if(!interface->linkState)
366  {
367  //The transmitter can accept another packet
368  osSetEvent(&interface->nicTxEvent);
369  //Drop current packet
370  return NO_ERROR;
371  }
372 
373 #if (M2M_FIRMWARE_VERSION_MAJOR_NO == 3)
374  //Copy user data to the transmit buffer
375  netBufferRead(txBuffer, buffer, offset, length);
376 #elif (M2M_FIRMWARE_VERSION_MAJOR_NO == 4)
377  //Copy user data to the transmit buffer
378  netBufferRead(txBuffer + M2M_ETHERNET_HDR_OFFSET + M2M_ETH_PAD_SIZE,
379  buffer, offset, length);
380 #endif
381 
382  //STA or AP mode?
383  if(interface == wilc1000StaInterface)
384  {
385  //Send packet
386 #if (M2M_FIRMWARE_VERSION_MAJOR_NO == 4 && M2M_FIRMWARE_VERSION_MINOR_NO >= 2)
387  status = m2m_wifi_send_ethernet_pkt(txBuffer, length, STATION_INTERFACE);
388 #else
389  status = m2m_wifi_send_ethernet_pkt(txBuffer, length);
390 #endif
391  }
392  else
393  {
394  //Send packet
395 #if (M2M_FIRMWARE_VERSION_MAJOR_NO == 4 && M2M_FIRMWARE_VERSION_MINOR_NO >= 2)
396  status = m2m_wifi_send_ethernet_pkt(txBuffer, length, AP_INTERFACE);
397 #else
398  status = m2m_wifi_send_ethernet_pkt_ifc1(txBuffer, length);
399 #endif
400  }
401 
402  //The transmitter can accept another packet
403  osSetEvent(&interface->nicTxEvent);
404 
405  //Return status code
406  if(status == M2M_SUCCESS)
407  return NO_ERROR;
408  else
409  return ERROR_FAILURE;
410 }
411 
412 
413 /**
414  * @brief Configure MAC address filtering
415  * @param[in] interface Underlying network interface
416  * @return Error code
417  **/
418 
420 {
421  uint_t i;
422  uint_t refCount;
423  MacFilterEntry *entry;
424 
425  //Debug message
426  TRACE_INFO("Updating WILC1000 multicast filter...\r\n");
427 
428  //The MAC address filter contains the list of MAC addresses to accept
429  //when receiving an Ethernet frame
430  for(i = 0; i < MAC_ADDR_FILTER_SIZE; i++)
431  {
432  //Point to the current entry
433  entry = &interface->macAddrFilter[i];
434 
435  //Valid entry?
436  if(!macCompAddr(&entry->addr, &MAC_UNSPECIFIED_ADDR))
437  {
438  //Check whether the multicast MAC address has already been registered
439  //on the alternate interface
440  if(interface == wilc1000StaInterface)
441  refCount = wilc1000GetAddrRefCount(wilc1000ApInterface, &entry->addr);
442  else
443  refCount = wilc1000GetAddrRefCount(wilc1000StaInterface, &entry->addr);
444 
445  //Ensure that there are not duplicate address entries in the table
446  if(refCount == 0)
447  {
448  //Update MAC filter table only if necessary
449  if(entry->addFlag)
450  {
451  //Add a new entry to the MAC filter table
452  m2m_wifi_enable_mac_mcast(entry->addr.b, TRUE);
453  }
454  else if(entry->deleteFlag)
455  {
456  //Remove the current entry from the MAC filter table
457  m2m_wifi_enable_mac_mcast(entry->addr.b, FALSE);
458  }
459  }
460  }
461  }
462 
463  //Successful processing
464  return NO_ERROR;
465 }
466 
467 
468 /**
469  * @brief Get reference count for the specified multicast MAC address
470  * @param[in] interface Underlying network interface
471  * @param[in] macAddr MAC address
472  * @return Reference count
473  **/
474 
476 {
477  uint_t i;
478  uint_t refCount;
479  MacFilterEntry *entry;
480 
481  //Clear reference count
482  refCount = 0;
483 
484  //Valid network interface?
485  if(interface != NULL)
486  {
487  //Go through the multicast filter table
488  for(i = 0; i < MAC_ADDR_FILTER_SIZE; i++)
489  {
490  //Point to the current entry
491  entry = &interface->macAddrFilter[i];
492 
493  //Valid entry?
494  if(entry->refCount > 0)
495  {
496  //Check whether the specified MAC address matches
497  //a multicast address in the table
498  if(macCompAddr(&entry->addr, macAddr))
499  {
500  //Get reference count
501  refCount = entry->refCount;
502  //We are done
503  break;
504  }
505  }
506  }
507  }
508 
509  //Return reference count
510  return refCount;
511 }
512 
513 
514 /**
515  * @brief Callback function that handles Wi-Fi events
516  * @param[in] msgType Type of notification
517  * @param[in] msg Pointer to the buffer containing the notification parameters
518  **/
519 
520 void wilc1000AppWifiEvent(uint8_t msgType, void *msg)
521 {
522  tstrM2mWifiStateChanged *stateChangedMsg;
523 
524  //Debug message
525  TRACE_INFO("WILC1000 Wi-Fi event callback\r\n");
526 
527  //Check message type
528  if(msgType == M2M_WIFI_RESP_FIRMWARE_STRTED)
529  {
530  //Debug message
531  TRACE_INFO(" M2M_WIFI_RESP_FIRMWARE_STRTED\r\n");
532  }
533  else if(msgType == M2M_WIFI_RESP_CON_STATE_CHANGED)
534  {
535  //Debug message
536  TRACE_INFO(" M2M_WIFI_RESP_CON_STATE_CHANGED\r\n");
537 
538  //Connection state
539  stateChangedMsg = (tstrM2mWifiStateChanged*) msg;
540 
541  //Check interface identifier
542 #if (M2M_FIRMWARE_VERSION_MAJOR_NO == 4 && M2M_FIRMWARE_VERSION_MINOR_NO >= 2)
543  if(stateChangedMsg->u8IfcId == STATION_INTERFACE)
544 #else
545  if(stateChangedMsg->u8IfcId == INTERFACE_1)
546 #endif
547  {
548  //Check whether STA mode is enabled
549  if(wilc1000StaInterface != NULL)
550  {
551  //Check link state
552  if(stateChangedMsg->u8CurrState == M2M_WIFI_CONNECTED)
553  {
554  //Link is up
555  wilc1000StaInterface->linkState = TRUE;
556  }
557  else
558  {
559  //Link is down
560  wilc1000StaInterface->linkState = FALSE;
561  }
562 
563  //Process link state change event
564  nicNotifyLinkChange(wilc1000StaInterface);
565  }
566  }
567 #if (M2M_FIRMWARE_VERSION_MAJOR_NO == 4 && M2M_FIRMWARE_VERSION_MINOR_NO >= 2)
568  else if(stateChangedMsg->u8IfcId == AP_INTERFACE)
569 #else
570  else if(stateChangedMsg->u8IfcId == INTERFACE_2)
571 #endif
572  {
573  //Check whether AP mode is enabled
574  if(wilc1000ApInterface != NULL)
575  {
576  //Check link state
577  if(stateChangedMsg->u8CurrState == M2M_WIFI_CONNECTED)
578  {
579  //Link is up
580  wilc1000ApInterface->linkState = TRUE;
581  }
582  else
583  {
584  //Link is down
585  wilc1000ApInterface->linkState = FALSE;
586  }
587 
588  //Process link state change event
589  nicNotifyLinkChange(wilc1000ApInterface);
590  }
591  }
592  }
593 
594 #if defined(CONF_WILC_EVENT_HOOK)
595  //Release exclusive access
597  //Invoke user callback function
598  CONF_WILC_EVENT_HOOK(msgType, msg);
599  //Get exclusive access
601 #endif
602 }
603 
604 
605 /**
606  * @brief Callback function that handles events in bypass mode
607  * @param[in] msgType Type of notification
608  * @param[in] msg Pointer to the buffer containing the notification parameters
609  * @param[in] ctrlBuf Pointer to the control buffer
610  **/
611 
612 void wilc1000AppEthEvent(uint8_t msgType, void *msg, void *ctrlBuf)
613 {
614  size_t length;
615  uint8_t *packet;
616 #if (M2M_FIRMWARE_VERSION_MAJOR_NO == 4 && M2M_FIRMWARE_VERSION_MINOR_NO >= 2)
617  tstrM2MDataBufCtrl *ctrl;
618 #else
619  tstrM2mIpCtrlBuf *ctrl;
620 #endif
621 
622  //Debug message
623  TRACE_DEBUG("WILC1000 RX event callback\r\n");
624 
625  //Point to the control buffer
626 #if (M2M_FIRMWARE_VERSION_MAJOR_NO == 4 && M2M_FIRMWARE_VERSION_MINOR_NO >= 2)
627  ctrl = (tstrM2MDataBufCtrl *) ctrlBuf;
628 #else
629  ctrl = (tstrM2mIpCtrlBuf *) ctrlBuf;
630 #endif
631 
632  //Check message type
633  if(msgType == M2M_WIFI_RESP_ETHERNET_RX_PACKET)
634  {
635  //Debug message
636  TRACE_DEBUG(" M2M_WIFI_RESP_ETHERNET_RX_PACKET\r\n");
637 
638 #if (M2M_FIRMWARE_VERSION_MAJOR_NO == 3)
639  //Point to the beginning of the packet
640  packet = rxBuffer;
641 #elif (M2M_FIRMWARE_VERSION_MAJOR_NO == 4)
642  //Point to the beginning of the packet
643  packet = rxBuffer + ctrl->u8DataOffset;
644 #endif
645 
646  //Retrieve the length of the packet
647  length = ctrl->u16DataSize;
648 
649  //Check interface identifier
650 #if (M2M_FIRMWARE_VERSION_MAJOR_NO == 4 && M2M_FIRMWARE_VERSION_MINOR_NO >= 2)
651  if(ctrl->u8IfcId == STATION_INTERFACE)
652 #else
653  if(ctrl->u8IfcId == INTERFACE_1)
654 #endif
655  {
656  //Valid interface?
657  if(wilc1000StaInterface != NULL)
658  {
659  //Check destination MAC address
660  if(wilc1000ApInterface != NULL)
661  {
662  if(macCompAddr(packet, wilc1000ApInterface->macAddr.b))
663  macCopyAddr(packet, wilc1000StaInterface->macAddr.b);
664  }
665 
666  //Pass the packet to the upper layer (STA mode)
667  nicProcessPacket(wilc1000StaInterface, packet, length);
668  }
669  }
670 #if (M2M_FIRMWARE_VERSION_MAJOR_NO == 4 && M2M_FIRMWARE_VERSION_MINOR_NO >= 2)
671  else if(ctrl->u8IfcId == AP_INTERFACE)
672 #else
673  else if(ctrl->u8IfcId == INTERFACE_2)
674 #endif
675  {
676  //Valid interface?
677  if(wilc1000ApInterface != NULL)
678  {
679  //Check destination MAC address
680  if(wilc1000StaInterface != NULL)
681  {
682  if(macCompAddr(packet, wilc1000StaInterface->macAddr.b))
683  macCopyAddr(packet, wilc1000ApInterface->macAddr.b);
684  }
685 
686  //Pass the packet to the upper layer (AP mode)
687  nicProcessPacket(wilc1000ApInterface, packet, length);
688  }
689  }
690  }
691 }
bool_t osSetEventFromIsr(OsEvent *event)
Set an event object to the signaled state from an interrupt service routine.
void nicNotifyLinkChange(NetInterface *interface)
Process link state change notification.
Definition: nic.c:525
error_t wilc1000Init(NetInterface *interface)
WILC1000 initialization.
uint8_t length
Definition: dtls_misc.h:149
int bool_t
Definition: compiler_port.h:49
void macAddrToEui64(const MacAddr *macAddr, Eui64 *interfaceId)
Map a MAC address to the IPv6 modified EUI-64 identifier.
Definition: ethernet.c:800
size_t netBufferRead(void *dest, const NetBuffer *src, size_t srcOffset, size_t length)
Read data from a multi-part buffer.
Definition: net_mem.c:672
bool_t wilc1000GetAddrRefCount(NetInterface *interface, const MacAddr *macAddr)
Get reference count for the specified multicast MAC address.
void nicProcessPacket(NetInterface *interface, uint8_t *packet, size_t length)
Handle a packet received by the network controller.
Definition: nic.c:383
Structure describing a buffer that spans multiple chunks.
Definition: net_mem.h:88
#define MAC_ADDR_FILTER_SIZE
Definition: ethernet.h:74
#define TRUE
Definition: os_port.h:50
const NicDriver wilc1000StaDriver
WILC1000 driver (STA mode)
bool_t addFlag
Definition: ethernet.h:224
uint_t refCount
Reference count for the current entry.
Definition: ethernet.h:223
void wilc1000AppWifiEvent(uint8_t msgType, void *msg)
Callback function that handles Wi-Fi events.
#define macCopyAddr(destMacAddr, srcMacAddr)
Definition: ethernet.h:104
#define WILC1000_RX_BUFFER_SIZE
#define FALSE
Definition: os_port.h:46
void wilc1000DisableIrq(NetInterface *interface)
Disable interrupts.
error_t
Error codes.
Definition: error.h:42
@ ERROR_FAILURE
Generic error code.
Definition: error.h:45
#define txBuffer
#define NetInterface
Definition: net.h:36
MacAddr addr
MAC address.
Definition: ethernet.h:222
@ ERROR_INVALID_LENGTH
Definition: error.h:109
OsMutex netMutex
Definition: net.c:75
error_t wilc1000UpdateMacAddrFilter(NetInterface *interface)
Configure MAC address filtering.
OsEvent netEvent
Definition: net.c:77
#define TRACE_INFO(...)
Definition: debug.h:94
size_t netBufferGetLength(const NetBuffer *buffer)
Get the actual length of a multi-part buffer.
Definition: net_mem.c:297
WILC1000 Wi-Fi controller.
bool_t wilc1000IrqHandler(void)
WILC1000 interrupt service routine.
#define rxBuffer
error_t wilc1000SendPacket(NetInterface *interface, const NetBuffer *buffer, size_t offset)
Send a packet.
#define TRACE_DEBUG(...)
Definition: debug.h:106
void wilc1000Tick(NetInterface *interface)
WILC1000 timer handler.
#define ETH_MTU
Definition: ethernet.h:91
MAC filter table entry.
Definition: ethernet.h:220
void osAcquireMutex(OsMutex *mutex)
Acquire ownership of the specified mutex object.
void osReleaseMutex(OsMutex *mutex)
Release ownership of the specified mutex object.
const NicDriver wilc1000ApDriver
WILC1000 driver (AP mode)
void wilc1000EnableIrq(NetInterface *interface)
Enable interrupts.
uint8_t msgType
Definition: dtls_misc.h:186
#define macCompAddr(macAddr1, macAddr2)
Definition: ethernet.h:107
void wilc1000AppEthEvent(uint8_t msgType, void *msg, void *ctrlBuf)
Callback function that handles events in bypass mode.
void osSetEvent(OsEvent *event)
Set the specified event object to the signaled state.
bool_t deleteFlag
Definition: ethernet.h:225
unsigned int uint_t
Definition: compiler_port.h:45
TCP/IP stack core.
void wilc1000EventHandler(NetInterface *interface)
WILC1000 event handler.
NIC driver.
Definition: nic.h:179
#define WILC1000_TX_BUFFER_SIZE
const MacAddr MAC_UNSPECIFIED_ADDR
Definition: ethernet.c:56
@ NO_ERROR
Success.
Definition: error.h:44
Debugging facilities.
__start_packed struct @108 MacAddr
MAC address.
@ NIC_TYPE_ETHERNET
Ethernet interface.
Definition: nic.h:79