1 #ifndef _IPXE_NETDEVICE_H
2 #define _IPXE_NETDEVICE_H
3
4 /** @file
5 *
6 * Network device management
7 *
8 */
9
10 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
11
12 #include <stdint.h>
13 #include <ipxe/list.h>
14 #include <ipxe/tables.h>
15 #include <ipxe/refcnt.h>
16 #include <ipxe/settings.h>
17 #include <ipxe/interface.h>
18 #include <ipxe/retry.h>
19
20 struct io_buffer;
21 struct net_device;
22 struct net_protocol;
23 struct ll_protocol;
24 struct device;
25
26 /** Maximum length of a hardware address
27 *
28 * The longest currently-supported link-layer address is for IPoIB.
29 */
30 #define MAX_HW_ADDR_LEN 8
31
32 /** Maximum length of a link-layer address
33 *
34 * The longest currently-supported link-layer address is for IPoIB.
35 */
36 #define MAX_LL_ADDR_LEN 20
37
38 /** Maximum length of a link-layer header
39 *
40 * The longest currently-supported link-layer header is for RNDIS: an
41 * 8-byte RNDIS header, a 32-byte RNDIS packet message header, a
42 * 14-byte Ethernet header and a possible 4-byte VLAN header. Round
43 * up to 64 bytes.
44 */
45 #define MAX_LL_HEADER_LEN 64
46
47 /** Maximum length of a network-layer address */
48 #define MAX_NET_ADDR_LEN 16
49
50 /** Maximum length of a network-layer header
51 *
52 * The longest currently-supported network-layer header is for IPv6 at
53 * 40 bytes.
54 */
55 #define MAX_NET_HEADER_LEN 40
56
57 /** Maximum combined length of a link-layer and network-layer header */
58 #define MAX_LL_NET_HEADER_LEN ( MAX_LL_HEADER_LEN + MAX_NET_HEADER_LEN )
59
60 /**
61 * A network-layer protocol
62 *
63 */
64 struct net_protocol {
65 /** Protocol name */
66 const char *name;
67 /**
68 * Process received packet
69 *
70 * @v iobuf I/O buffer
71 * @v netdev Network device
72 * @v ll_dest Link-layer destination address
73 * @v ll_source Link-layer source address
74 * @v flags Packet flags
75 * @ret rc Return status code
76 *
77 * This method takes ownership of the I/O buffer.
78 */
79 int ( * rx ) ( struct io_buffer *iobuf, struct net_device *netdev,
80 const void *ll_dest, const void *ll_source,
81 unsigned int flags );
82 /**
83 * Transcribe network-layer address
84 *
85 * @v net_addr Network-layer address
86 * @ret string Human-readable transcription of address
87 *
88 * This method should convert the network-layer address into a
89 * human-readable format (e.g. dotted quad notation for IPv4).
90 *
91 * The buffer used to hold the transcription is statically
92 * allocated.
93 */
94 const char * ( *ntoa ) ( const void * net_addr );
95 /** Network-layer protocol
96 *
97 * This is an ETH_P_XXX constant, in network-byte order
98 */
99 uint16_t net_proto;
100 /** Network-layer address length */
101 uint8_t net_addr_len;
102 };
103
104 /** Packet is a multicast (including broadcast) packet */
105 #define LL_MULTICAST 0x0001
106
107 /** Packet is a broadcast packet */
108 #define LL_BROADCAST 0x0002
109
110 /**
111 * A link-layer protocol
112 *
113 */
114 struct ll_protocol {
115 /** Protocol name */
116 const char *name;
117 /**
118 * Add link-layer header
119 *
120 * @v netdev Network device
121 * @v iobuf I/O buffer
122 * @v ll_dest Link-layer destination address
123 * @v ll_source Source link-layer address
124 * @v net_proto Network-layer protocol, in network-byte order
125 * @ret rc Return status code
126 */
127 int ( * push ) ( struct net_device *netdev, struct io_buffer *iobuf,
128 const void *ll_dest, const void *ll_source,
129 uint16_t net_proto );
130 /**
131 * Remove link-layer header
132 *
133 * @v netdev Network device
134 * @v iobuf I/O buffer
135 * @ret ll_dest Link-layer destination address
136 * @ret ll_source Source link-layer address
137 * @ret net_proto Network-layer protocol, in network-byte order
138 * @ret flags Packet flags
139 * @ret rc Return status code
140 */
141 int ( * pull ) ( struct net_device *netdev, struct io_buffer *iobuf,
142 const void **ll_dest, const void **ll_source,
143 uint16_t *net_proto, unsigned int *flags );
144 /**
145 * Initialise link-layer address
146 *
147 * @v hw_addr Hardware address
148 * @v ll_addr Link-layer address to fill in
149 */
150 void ( * init_addr ) ( const void *hw_addr, void *ll_addr );
151 /**
152 * Transcribe link-layer address
153 *
154 * @v ll_addr Link-layer address
155 * @ret string Human-readable transcription of address
156 *
157 * This method should convert the link-layer address into a
158 * human-readable format.
159 *
160 * The buffer used to hold the transcription is statically
161 * allocated.
162 */
163 const char * ( * ntoa ) ( const void *ll_addr );
164 /**
165 * Hash multicast address
166 *
167 * @v af Address family
168 * @v net_addr Network-layer address
169 * @v ll_addr Link-layer address to fill in
170 * @ret rc Return status code
171 */
172 int ( * mc_hash ) ( unsigned int af, const void *net_addr,
173 void *ll_addr );
174 /**
175 * Generate Ethernet-compatible compressed link-layer address
176 *
177 * @v ll_addr Link-layer address
178 * @v eth_addr Ethernet-compatible address to fill in
179 * @ret rc Return status code
180 */
181 int ( * eth_addr ) ( const void *ll_addr, void *eth_addr );
182 /**
183 * Generate EUI-64 address
184 *
185 * @v ll_addr Link-layer address
186 * @v eui64 EUI-64 address to fill in
187 * @ret rc Return status code
188 */
189 int ( * eui64 ) ( const void *ll_addr, void *eui64 );
190 /** Link-layer protocol
191 *
192 * This is an ARPHRD_XXX constant, in network byte order.
193 */
194 uint16_t ll_proto;
195 /** Hardware address length */
196 uint8_t hw_addr_len;
197 /** Link-layer address length */
198 uint8_t ll_addr_len;
199 /** Link-layer header length */
200 uint8_t ll_header_len;
201 /** Flags */
202 unsigned int flags;
203 };
204
205 /** Local link-layer address functions only as a name
206 *
207 * This flag indicates that the local link-layer address cannot
208 * directly be used as a destination address by a remote node.
209 */
210 #define LL_NAME_ONLY 0x0001
211
212 /** Network device operations */
213 struct net_device_operations {
214 /** Open network device
215 *
216 * @v netdev Network device
217 * @ret rc Return status code
218 *
219 * This method should allocate RX I/O buffers and enable
220 * the hardware to start transmitting and receiving packets.
221 */
222 int ( * open ) ( struct net_device *netdev );
223 /** Close network device
224 *
225 * @v netdev Network device
226 *
227 * This method should stop the flow of packets, and free up
228 * any packets that are currently in the device's TX queue.
229 */
230 void ( * close ) ( struct net_device *netdev );
231 /** Transmit packet
232 *
233 * @v netdev Network device
234 * @v iobuf I/O buffer
235 * @ret rc Return status code
236 *
237 * This method should cause the hardware to initiate
238 * transmission of the I/O buffer.
239 *
240 * If this method returns success, the I/O buffer remains
241 * owned by the net device's TX queue, and the net device must
242 * eventually call netdev_tx_complete() to free the buffer.
243 * If this method returns failure, the I/O buffer is
244 * immediately released; the failure is interpreted as
245 * "failure to enqueue buffer".
246 *
247 * This method is guaranteed to be called only when the device
248 * is open.
249 */
250 int ( * transmit ) ( struct net_device *netdev,
251 struct io_buffer *iobuf );
252 /** Poll for completed and received packets
253 *
254 * @v netdev Network device
255 *
256 * This method should cause the hardware to check for
257 * completed transmissions and received packets. Any received
258 * packets should be delivered via netdev_rx().
259 *
260 * This method is guaranteed to be called only when the device
261 * is open.
262 */
263 void ( * poll ) ( struct net_device *netdev );
264 /** Enable or disable interrupts
265 *
266 * @v netdev Network device
267 * @v enable Interrupts should be enabled
268 *
269 * This method may be NULL to indicate that interrupts are not
270 * supported.
271 */
272 void ( * irq ) ( struct net_device *netdev, int enable );
273 };
274
275 /** Network device error */
276 struct net_device_error {
277 /** Error status code */
278 int rc;
279 /** Error count */
280 unsigned int count;
281 };
282
283 /** Maximum number of unique errors that we will keep track of */
284 #define NETDEV_MAX_UNIQUE_ERRORS 4
285
286 /** Network device statistics */
287 struct net_device_stats {
288 /** Count of successful completions */
289 unsigned int good;
290 /** Count of error completions */
291 unsigned int bad;
292 /** Error breakdowns */
293 struct net_device_error errors[NETDEV_MAX_UNIQUE_ERRORS];
294 };
295
296 /** A network device configuration */
297 struct net_device_configuration {
298 /** Network device */
299 struct net_device *netdev;
300 /** Network device configurator */
301 struct net_device_configurator *configurator;
302 /** Configuration status */
303 int rc;
304 /** Job control interface */
305 struct interface job;
306 };
307
308 /** A network device configurator */
309 struct net_device_configurator {
310 /** Name */
311 const char *name;
312 /** Check applicability of configurator
313 *
314 * @v netdev Network device
315 * @ret applies Configurator applies to this network device
316 */
317 int ( * applies ) ( struct net_device *netdev );
318 /** Start configuring network device
319 *
320 * @v job Job control interface
321 * @v netdev Network device
322 * @ret rc Return status code
323 */
324 int ( * start ) ( struct interface *job, struct net_device *netdev );
325 };
326
327 /** Network device configurator table */
328 #define NET_DEVICE_CONFIGURATORS \
329 __table ( struct net_device_configurator, "net_device_configurators" )
330
331 /** Declare a network device configurator */
332 #define __net_device_configurator \
333 __table_entry ( NET_DEVICE_CONFIGURATORS, 01 )
334
335 /** Maximum length of a network device name */
336 #define NETDEV_NAME_LEN 12
337
338 /**
339 * A network device
340 *
341 * This structure represents a piece of networking hardware. It has
342 * properties such as a link-layer address and methods for
343 * transmitting and receiving raw packets.
344 *
345 * Note that this structure must represent a generic network device,
346 * not just an Ethernet device.
347 */
348 struct net_device {
349 /** Reference counter */
350 struct refcnt refcnt;
351 /** List of network devices */
352 struct list_head list;
353 /** List of open network devices */
354 struct list_head open_list;
355 /** Index of this network device */
356 unsigned int index;
357 /** Name of this network device */
358 char name[NETDEV_NAME_LEN];
359 /** Underlying hardware device */
360 struct device *dev;
361
362 /** Network device operations */
363 struct net_device_operations *op;
364
365 /** Link-layer protocol */
366 struct ll_protocol *ll_protocol;
367 /** Hardware address
368 *
369 * This is an address which is an intrinsic property of the
370 * hardware, e.g. an address held in EEPROM.
371 *
372 * Note that the hardware address may not be the same length
373 * as the link-layer address.
374 */
375 uint8_t hw_addr[MAX_HW_ADDR_LEN];
376 /** Link-layer address
377 *
378 * This is the current link-layer address assigned to the
379 * device. It can be changed at runtime.
380 */
381 uint8_t ll_addr[MAX_LL_ADDR_LEN];
382 /** Link-layer broadcast address */
383 const uint8_t *ll_broadcast;
384
385 /** Current device state
386 *
387 * This is the bitwise-OR of zero or more NETDEV_XXX constants.
388 */
389 unsigned int state;
390 /** Link status code
391 *
392 * Zero indicates that the link is up; any other value
393 * indicates the error preventing link-up.
394 */
395 int link_rc;
396 /** Link block timer */
397 struct retry_timer link_block;
398 /** Maximum packet length
399 *
400 * This is the maximum packet length (including any link-layer
401 * headers) supported by the hardware.
402 */
403 size_t max_pkt_len;
404 /** Maximum transmission unit length
405 *
406 * This is the maximum transmission unit length (excluding any
407 * link-layer headers) configured for the link.
408 */
409 size_t mtu;
410 /** TX packet queue */
411 struct list_head tx_queue;
412 /** Deferred TX packet queue */
413 struct list_head tx_deferred;
414 /** RX packet queue */
415 struct list_head rx_queue;
416 /** TX statistics */
417 struct net_device_stats tx_stats;
418 /** RX statistics */
419 struct net_device_stats rx_stats;
420
421 /** Configuration settings applicable to this device */
422 struct generic_settings settings;
423
424 /** Driver private data */
425 void *priv;
426
427 /** Network device configurations (variable length) */
428 struct net_device_configuration configs[0];
429 };
430
431 /** Network device is open */
432 #define NETDEV_OPEN 0x0001
433
434 /** Network device interrupts are enabled */
435 #define NETDEV_IRQ_ENABLED 0x0002
436
437 /** Network device receive queue processing is frozen */
438 #define NETDEV_RX_FROZEN 0x0004
439
440 /** Network device interrupts are unsupported
441 *
442 * This flag can be used by a network device to indicate that
443 * interrupts are not supported despite the presence of an irq()
444 * method.
445 */
446 #define NETDEV_IRQ_UNSUPPORTED 0x0008
447
448 /** Link-layer protocol table */
449 #define LL_PROTOCOLS __table ( struct ll_protocol, "ll_protocols" )
450
451 /** Declare a link-layer protocol */
452 #define __ll_protocol __table_entry ( LL_PROTOCOLS, 01 )
453
454 /** Network-layer protocol table */
455 #define NET_PROTOCOLS __table ( struct net_protocol, "net_protocols" )
456
457 /** Declare a network-layer protocol */
458 #define __net_protocol __table_entry ( NET_PROTOCOLS, 01 )
459
460 /** A network upper-layer driver */
461 struct net_driver {
462 /** Name */
463 const char *name;
464 /** Probe device
465 *
466 * @v netdev Network device
467 * @ret rc Return status code
468 */
469 int ( * probe ) ( struct net_device *netdev );
470 /** Notify of device or link state change
471 *
472 * @v netdev Network device
473 */
474 void ( * notify ) ( struct net_device *netdev );
475 /** Remove device
476 *
477 * @v netdev Network device
478 */
479 void ( * remove ) ( struct net_device *netdev );
480 };
481
482 /** Network driver table */
483 #define NET_DRIVERS __table ( struct net_driver, "net_drivers" )
484
485 /** Declare a network driver */
486 #define __net_driver __table_entry ( NET_DRIVERS, 01 )
487
488 extern struct list_head net_devices;
489 extern struct net_device_operations null_netdev_operations;
490 extern struct settings_operations netdev_settings_operations;
491
492 /**
493 * Initialise a network device
494 *
495 * @v netdev Network device
496 * @v op Network device operations
497 */
netdev_init(struct net_device * netdev,struct net_device_operations * op)498 static inline void netdev_init ( struct net_device *netdev,
499 struct net_device_operations *op ) {
500 netdev->op = op;
501 }
502
503 /**
504 * Stop using a network device
505 *
506 * @v netdev Network device
507 *
508 * Drivers should call this method immediately before the final call
509 * to netdev_put().
510 */
netdev_nullify(struct net_device * netdev)511 static inline void netdev_nullify ( struct net_device *netdev ) {
512 netdev->op = &null_netdev_operations;
513 }
514
515 /**
516 * Get printable network device link-layer address
517 *
518 * @v netdev Network device
519 * @ret name Link-layer address
520 */
netdev_addr(struct net_device * netdev)521 static inline const char * netdev_addr ( struct net_device *netdev ) {
522 return netdev->ll_protocol->ntoa ( netdev->ll_addr );
523 }
524
525 /** Iterate over all network devices */
526 #define for_each_netdev( netdev ) \
527 list_for_each_entry ( (netdev), &net_devices, list )
528
529 /** There exist some network devices
530 *
531 * @ret existence Existence of network devices
532 */
have_netdevs(void)533 static inline int have_netdevs ( void ) {
534 return ( ! list_empty ( &net_devices ) );
535 }
536
537 /**
538 * Get reference to network device
539 *
540 * @v netdev Network device
541 * @ret netdev Network device
542 */
543 static inline __attribute__ (( always_inline )) struct net_device *
netdev_get(struct net_device * netdev)544 netdev_get ( struct net_device *netdev ) {
545 ref_get ( &netdev->refcnt );
546 return netdev;
547 }
548
549 /**
550 * Drop reference to network device
551 *
552 * @v netdev Network device
553 */
554 static inline __attribute__ (( always_inline )) void
netdev_put(struct net_device * netdev)555 netdev_put ( struct net_device *netdev ) {
556 ref_put ( &netdev->refcnt );
557 }
558
559 /**
560 * Get driver private area for this network device
561 *
562 * @v netdev Network device
563 * @ret priv Driver private area for this network device
564 */
565 static inline __attribute__ (( always_inline )) void *
netdev_priv(struct net_device * netdev)566 netdev_priv ( struct net_device *netdev ) {
567 return netdev->priv;
568 }
569
570 /**
571 * Get per-netdevice configuration settings block
572 *
573 * @v netdev Network device
574 * @ret settings Settings block
575 */
576 static inline __attribute__ (( always_inline )) struct settings *
netdev_settings(struct net_device * netdev)577 netdev_settings ( struct net_device *netdev ) {
578 return &netdev->settings.settings;
579 }
580
581 /**
582 * Initialise a per-netdevice configuration settings block
583 *
584 * @v generics Generic settings block
585 * @v refcnt Containing object reference counter, or NULL
586 * @v name Settings block name
587 */
588 static inline __attribute__ (( always_inline )) void
netdev_settings_init(struct net_device * netdev)589 netdev_settings_init ( struct net_device *netdev ) {
590 generic_settings_init ( &netdev->settings, &netdev->refcnt );
591 netdev->settings.settings.op = &netdev_settings_operations;
592 }
593
594 /**
595 * Get network device configuration
596 *
597 * @v netdev Network device
598 * @v configurator Network device configurator
599 * @ret config Network device configuration
600 */
601 static inline struct net_device_configuration *
netdev_configuration(struct net_device * netdev,struct net_device_configurator * configurator)602 netdev_configuration ( struct net_device *netdev,
603 struct net_device_configurator *configurator ) {
604
605 return &netdev->configs[ table_index ( NET_DEVICE_CONFIGURATORS,
606 configurator ) ];
607 }
608
609 /**
610 * Check if configurator applies to network device
611 *
612 * @v netdev Network device
613 * @v configurator Network device configurator
614 * @ret applies Configurator applies to network device
615 */
616 static inline int
netdev_configurator_applies(struct net_device * netdev,struct net_device_configurator * configurator)617 netdev_configurator_applies ( struct net_device *netdev,
618 struct net_device_configurator *configurator ) {
619 return ( ( configurator->applies == NULL ) ||
620 configurator->applies ( netdev ) );
621 }
622
623 /**
624 * Check link state of network device
625 *
626 * @v netdev Network device
627 * @ret link_up Link is up
628 */
629 static inline __attribute__ (( always_inline )) int
netdev_link_ok(struct net_device * netdev)630 netdev_link_ok ( struct net_device *netdev ) {
631 return ( netdev->link_rc == 0 );
632 }
633
634 /**
635 * Check link block state of network device
636 *
637 * @v netdev Network device
638 * @ret link_blocked Link is blocked
639 */
640 static inline __attribute__ (( always_inline )) int
netdev_link_blocked(struct net_device * netdev)641 netdev_link_blocked ( struct net_device *netdev ) {
642 return ( timer_running ( &netdev->link_block ) );
643 }
644
645 /**
646 * Check whether or not network device is open
647 *
648 * @v netdev Network device
649 * @ret is_open Network device is open
650 */
651 static inline __attribute__ (( always_inline )) int
netdev_is_open(struct net_device * netdev)652 netdev_is_open ( struct net_device *netdev ) {
653 return ( netdev->state & NETDEV_OPEN );
654 }
655
656 /**
657 * Check whether or not network device supports interrupts
658 *
659 * @v netdev Network device
660 * @ret irq_supported Network device supports interrupts
661 */
662 static inline __attribute__ (( always_inline )) int
netdev_irq_supported(struct net_device * netdev)663 netdev_irq_supported ( struct net_device *netdev ) {
664 return ( ( netdev->op->irq != NULL ) &&
665 ! ( netdev->state & NETDEV_IRQ_UNSUPPORTED ) );
666 }
667
668 /**
669 * Check whether or not network device interrupts are currently enabled
670 *
671 * @v netdev Network device
672 * @ret irq_enabled Network device interrupts are enabled
673 */
674 static inline __attribute__ (( always_inline )) int
netdev_irq_enabled(struct net_device * netdev)675 netdev_irq_enabled ( struct net_device *netdev ) {
676 return ( netdev->state & NETDEV_IRQ_ENABLED );
677 }
678
679 /**
680 * Check whether or not network device receive queue processing is frozen
681 *
682 * @v netdev Network device
683 * @ret rx_frozen Network device receive queue processing is frozen
684 */
685 static inline __attribute__ (( always_inline )) int
netdev_rx_frozen(struct net_device * netdev)686 netdev_rx_frozen ( struct net_device *netdev ) {
687 return ( netdev->state & NETDEV_RX_FROZEN );
688 }
689
690 extern void netdev_rx_freeze ( struct net_device *netdev );
691 extern void netdev_rx_unfreeze ( struct net_device *netdev );
692 extern void netdev_link_err ( struct net_device *netdev, int rc );
693 extern void netdev_link_down ( struct net_device *netdev );
694 extern void netdev_link_block ( struct net_device *netdev,
695 unsigned long timeout );
696 extern void netdev_link_unblock ( struct net_device *netdev );
697 extern int netdev_tx ( struct net_device *netdev, struct io_buffer *iobuf );
698 extern void netdev_tx_defer ( struct net_device *netdev,
699 struct io_buffer *iobuf );
700 extern void netdev_tx_err ( struct net_device *netdev,
701 struct io_buffer *iobuf, int rc );
702 extern void netdev_tx_complete_err ( struct net_device *netdev,
703 struct io_buffer *iobuf, int rc );
704 extern void netdev_tx_complete_next_err ( struct net_device *netdev, int rc );
705 extern void netdev_rx ( struct net_device *netdev, struct io_buffer *iobuf );
706 extern void netdev_rx_err ( struct net_device *netdev,
707 struct io_buffer *iobuf, int rc );
708 extern void netdev_poll ( struct net_device *netdev );
709 extern struct io_buffer * netdev_rx_dequeue ( struct net_device *netdev );
710 extern struct net_device * alloc_netdev ( size_t priv_size );
711 extern int register_netdev ( struct net_device *netdev );
712 extern int netdev_open ( struct net_device *netdev );
713 extern void netdev_close ( struct net_device *netdev );
714 extern void unregister_netdev ( struct net_device *netdev );
715 extern void netdev_irq ( struct net_device *netdev, int enable );
716 extern struct net_device * find_netdev ( const char *name );
717 extern struct net_device * find_netdev_by_index ( unsigned int index );
718 extern struct net_device * find_netdev_by_location ( unsigned int bus_type,
719 unsigned int location );
720 extern struct net_device *
721 find_netdev_by_ll_addr ( struct ll_protocol *ll_protocol, const void *ll_addr );
722 extern struct net_device * last_opened_netdev ( void );
723 extern int net_tx ( struct io_buffer *iobuf, struct net_device *netdev,
724 struct net_protocol *net_protocol, const void *ll_dest,
725 const void *ll_source );
726 extern int net_rx ( struct io_buffer *iobuf, struct net_device *netdev,
727 uint16_t net_proto, const void *ll_dest,
728 const void *ll_source, unsigned int flags );
729 extern void net_poll ( void );
730 extern struct net_device_configurator *
731 find_netdev_configurator ( const char *name );
732 extern int netdev_configure ( struct net_device *netdev,
733 struct net_device_configurator *configurator );
734 extern int netdev_configure_all ( struct net_device *netdev );
735 extern int netdev_configuration_in_progress ( struct net_device *netdev );
736 extern int netdev_configuration_ok ( struct net_device *netdev );
737
738 /**
739 * Complete network transmission
740 *
741 * @v netdev Network device
742 * @v iobuf I/O buffer
743 *
744 * The packet must currently be in the network device's TX queue.
745 */
netdev_tx_complete(struct net_device * netdev,struct io_buffer * iobuf)746 static inline void netdev_tx_complete ( struct net_device *netdev,
747 struct io_buffer *iobuf ) {
748 netdev_tx_complete_err ( netdev, iobuf, 0 );
749 }
750
751 /**
752 * Complete network transmission
753 *
754 * @v netdev Network device
755 *
756 * Completes the oldest outstanding packet in the TX queue.
757 */
netdev_tx_complete_next(struct net_device * netdev)758 static inline void netdev_tx_complete_next ( struct net_device *netdev ) {
759 netdev_tx_complete_next_err ( netdev, 0 );
760 }
761
762 /**
763 * Mark network device as having link up
764 *
765 * @v netdev Network device
766 */
767 static inline __attribute__ (( always_inline )) void
netdev_link_up(struct net_device * netdev)768 netdev_link_up ( struct net_device *netdev ) {
769 netdev_link_err ( netdev, 0 );
770 }
771
772 #endif /* _IPXE_NETDEVICE_H */
773