qemu/roms/ipxe/src/include/ipxe/netdevice.h

   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 length includes any link-layer headers.
 401          */
 402         size_t max_pkt_len;
 403         /** TX packet queue */
 404         struct list_head tx_queue;
 405         /** Deferred TX packet queue */
 406         struct list_head tx_deferred;
 407         /** RX packet queue */
 408         struct list_head rx_queue;
 409         /** TX statistics */
 410         struct net_device_stats tx_stats;
 411         /** RX statistics */
 412         struct net_device_stats rx_stats;
 413
 414         /** Configuration settings applicable to this device */
 415         struct generic_settings settings;
 416
 417         /** Driver private data */
 418         void *priv;
 419
 420         /** Network device configurations (variable length) */
 421         struct net_device_configuration configs[0];
 422 };
 423
 424 /** Network device is open */
 425 #define NETDEV_OPEN 0x0001
 426
 427 /** Network device interrupts are enabled */
 428 #define NETDEV_IRQ_ENABLED 0x0002
 429
 430 /** Network device receive queue processing is frozen */
 431 #define NETDEV_RX_FROZEN 0x0004
 432
 433 /** Network device interrupts are unsupported
 434  *
 435  * This flag can be used by a network device to indicate that
 436  * interrupts are not supported despite the presence of an irq()
 437  * method.
 438  */
 439 #define NETDEV_IRQ_UNSUPPORTED 0x0008
 440
 441 /** Link-layer protocol table */
 442 #define LL_PROTOCOLS __table ( struct ll_protocol, "ll_protocols" )
 443
 444 /** Declare a link-layer protocol */
 445 #define __ll_protocol  __table_entry ( LL_PROTOCOLS, 01 )
 446
 447 /** Network-layer protocol table */
 448 #define NET_PROTOCOLS __table ( struct net_protocol, "net_protocols" )
 449
 450 /** Declare a network-layer protocol */
 451 #define __net_protocol __table_entry ( NET_PROTOCOLS, 01 )
 452
 453 /** A network upper-layer driver */
 454 struct net_driver {
 455         /** Name */
 456         const char *name;
 457         /** Probe device
 458          *
 459          * @v netdev            Network device
 460          * @ret rc              Return status code
 461          */
 462         int ( * probe ) ( struct net_device *netdev );
 463         /** Notify of device or link state change
 464          *
 465          * @v netdev            Network device
 466          */
 467         void ( * notify ) ( struct net_device *netdev );
 468         /** Remove device
 469          *
 470          * @v netdev            Network device
 471          */
 472         void ( * remove ) ( struct net_device *netdev );
 473 };
 474
 475 /** Network driver table */
 476 #define NET_DRIVERS __table ( struct net_driver, "net_drivers" )
 477
 478 /** Declare a network driver */
 479 #define __net_driver __table_entry ( NET_DRIVERS, 01 )
 480
 481 extern struct list_head net_devices;
 482 extern struct net_device_operations null_netdev_operations;
 483 extern struct settings_operations netdev_settings_operations;
 484
 485 /**
 486  * Initialise a network device
 487  *
 488  * @v netdev            Network device
 489  * @v op                Network device operations
 490  */
 491 static inline void netdev_init ( struct net_device *netdev,
 492                                  struct net_device_operations *op ) {
 493         netdev->op = op;
 494 }
 495
 496 /**
 497  * Stop using a network device
 498  *
 499  * @v netdev            Network device
 500  *
 501  * Drivers should call this method immediately before the final call
 502  * to netdev_put().
 503  */
 504 static inline void netdev_nullify ( struct net_device *netdev ) {
 505         netdev->op = &null_netdev_operations;
 506 }
 507
 508 /**
 509  * Get printable network device link-layer address
 510  *
 511  * @v netdev            Network device
 512  * @ret name            Link-layer address
 513  */
 514 static inline const char * netdev_addr ( struct net_device *netdev ) {
 515         return netdev->ll_protocol->ntoa ( netdev->ll_addr );
 516 }
 517
 518 /** Iterate over all network devices */
 519 #define for_each_netdev( netdev ) \
 520         list_for_each_entry ( (netdev), &net_devices, list )
 521
 522 /** There exist some network devices
 523  *
 524  * @ret existence       Existence of network devices
 525  */
 526 static inline int have_netdevs ( void ) {
 527         return ( ! list_empty ( &net_devices ) );
 528 }
 529
 530 /**
 531  * Get reference to network device
 532  *
 533  * @v netdev            Network device
 534  * @ret netdev          Network device
 535  */
 536 static inline __attribute__ (( always_inline )) struct net_device *
 537 netdev_get ( struct net_device *netdev ) {
 538         ref_get ( &netdev->refcnt );
 539         return netdev;
 540 }
 541
 542 /**
 543  * Drop reference to network device
 544  *
 545  * @v netdev            Network device
 546  */
 547 static inline __attribute__ (( always_inline )) void
 548 netdev_put ( struct net_device *netdev ) {
 549         ref_put ( &netdev->refcnt );
 550 }
 551
 552 /**
 553  * Get driver private area for this network device
 554  *
 555  * @v netdev            Network device
 556  * @ret priv            Driver private area for this network device
 557  */
 558 static inline __attribute__ (( always_inline )) void *
 559 netdev_priv ( struct net_device *netdev ) {
 560         return netdev->priv;
 561 }
 562
 563 /**
 564  * Get per-netdevice configuration settings block
 565  *
 566  * @v netdev            Network device
 567  * @ret settings        Settings block
 568  */
 569 static inline __attribute__ (( always_inline )) struct settings *
 570 netdev_settings ( struct net_device *netdev ) {
 571         return &netdev->settings.settings;
 572 }
 573
 574 /**
 575  * Initialise a per-netdevice configuration settings block
 576  *
 577  * @v generics          Generic settings block
 578  * @v refcnt            Containing object reference counter, or NULL
 579  * @v name              Settings block name
 580  */
 581 static inline __attribute__ (( always_inline )) void
 582 netdev_settings_init ( struct net_device *netdev ) {
 583         generic_settings_init ( &netdev->settings, &netdev->refcnt );
 584         netdev->settings.settings.op = &netdev_settings_operations;
 585 }
 586
 587 /**
 588  * Get network device configuration
 589  *
 590  * @v netdev            Network device
 591  * @v configurator      Network device configurator
 592  * @ret config          Network device configuration
 593  */
 594 static inline struct net_device_configuration *
 595 netdev_configuration ( struct net_device *netdev,
 596                        struct net_device_configurator *configurator ) {
 597
 598         return &netdev->configs[ table_index ( NET_DEVICE_CONFIGURATORS,
 599                                                configurator ) ];
 600 }
 601
 602 /**
 603  * Check if configurator applies to network device
 604  *
 605  * @v netdev            Network device
 606  * @v configurator      Network device configurator
 607  * @ret applies         Configurator applies to network device
 608  */
 609 static inline int
 610 netdev_configurator_applies ( struct net_device *netdev,
 611                               struct net_device_configurator *configurator ) {
 612         return ( ( configurator->applies == NULL ) ||
 613                  configurator->applies ( netdev ) );
 614 }
 615
 616 /**
 617  * Check link state of network device
 618  *
 619  * @v netdev            Network device
 620  * @ret link_up         Link is up
 621  */
 622 static inline __attribute__ (( always_inline )) int
 623 netdev_link_ok ( struct net_device *netdev ) {
 624         return ( netdev->link_rc == 0 );
 625 }
 626
 627 /**
 628  * Check link block state of network device
 629  *
 630  * @v netdev            Network device
 631  * @ret link_blocked    Link is blocked
 632  */
 633 static inline __attribute__ (( always_inline )) int
 634 netdev_link_blocked ( struct net_device *netdev ) {
 635         return ( timer_running ( &netdev->link_block ) );
 636 }
 637
 638 /**
 639  * Check whether or not network device is open
 640  *
 641  * @v netdev            Network device
 642  * @ret is_open         Network device is open
 643  */
 644 static inline __attribute__ (( always_inline )) int
 645 netdev_is_open ( struct net_device *netdev ) {
 646         return ( netdev->state & NETDEV_OPEN );
 647 }
 648
 649 /**
 650  * Check whether or not network device supports interrupts
 651  *
 652  * @v netdev            Network device
 653  * @ret irq_supported   Network device supports interrupts
 654  */
 655 static inline __attribute__ (( always_inline )) int
 656 netdev_irq_supported ( struct net_device *netdev ) {
 657         return ( ( netdev->op->irq != NULL ) &&
 658                  ! ( netdev->state & NETDEV_IRQ_UNSUPPORTED ) );
 659 }
 660
 661 /**
 662  * Check whether or not network device interrupts are currently enabled
 663  *
 664  * @v netdev            Network device
 665  * @ret irq_enabled     Network device interrupts are enabled
 666  */
 667 static inline __attribute__ (( always_inline )) int
 668 netdev_irq_enabled ( struct net_device *netdev ) {
 669         return ( netdev->state & NETDEV_IRQ_ENABLED );
 670 }
 671
 672 /**
 673  * Check whether or not network device receive queue processing is frozen
 674  *
 675  * @v netdev            Network device
 676  * @ret rx_frozen       Network device receive queue processing is frozen
 677  */
 678 static inline __attribute__ (( always_inline )) int
 679 netdev_rx_frozen ( struct net_device *netdev ) {
 680         return ( netdev->state & NETDEV_RX_FROZEN );
 681 }
 682
 683 extern void netdev_rx_freeze ( struct net_device *netdev );
 684 extern void netdev_rx_unfreeze ( struct net_device *netdev );
 685 extern void netdev_link_err ( struct net_device *netdev, int rc );
 686 extern void netdev_link_down ( struct net_device *netdev );
 687 extern void netdev_link_block ( struct net_device *netdev,
 688                                 unsigned long timeout );
 689 extern void netdev_link_unblock ( struct net_device *netdev );
 690 extern int netdev_tx ( struct net_device *netdev, struct io_buffer *iobuf );
 691 extern void netdev_tx_defer ( struct net_device *netdev,
 692                               struct io_buffer *iobuf );
 693 extern void netdev_tx_err ( struct net_device *netdev,
 694                             struct io_buffer *iobuf, int rc );
 695 extern void netdev_tx_complete_err ( struct net_device *netdev,
 696                                  struct io_buffer *iobuf, int rc );
 697 extern void netdev_tx_complete_next_err ( struct net_device *netdev, int rc );
 698 extern void netdev_rx ( struct net_device *netdev, struct io_buffer *iobuf );
 699 extern void netdev_rx_err ( struct net_device *netdev,
 700                             struct io_buffer *iobuf, int rc );
 701 extern void netdev_poll ( struct net_device *netdev );
 702 extern struct io_buffer * netdev_rx_dequeue ( struct net_device *netdev );
 703 extern struct net_device * alloc_netdev ( size_t priv_size );
 704 extern int register_netdev ( struct net_device *netdev );
 705 extern int netdev_open ( struct net_device *netdev );
 706 extern void netdev_close ( struct net_device *netdev );
 707 extern void unregister_netdev ( struct net_device *netdev );
 708 extern void netdev_irq ( struct net_device *netdev, int enable );
 709 extern struct net_device * find_netdev ( const char *name );
 710 extern struct net_device * find_netdev_by_index ( unsigned int index );
 711 extern struct net_device * find_netdev_by_location ( unsigned int bus_type,
 712                                                      unsigned int location );
 713 extern struct net_device *
 714 find_netdev_by_ll_addr ( struct ll_protocol *ll_protocol, const void *ll_addr );
 715 extern struct net_device * last_opened_netdev ( void );
 716 extern int net_tx ( struct io_buffer *iobuf, struct net_device *netdev,
 717                     struct net_protocol *net_protocol, const void *ll_dest,
 718                     const void *ll_source );
 719 extern int net_rx ( struct io_buffer *iobuf, struct net_device *netdev,
 720                     uint16_t net_proto, const void *ll_dest,
 721                     const void *ll_source, unsigned int flags );
 722 extern void net_poll ( void );
 723 extern struct net_device_configurator *
 724 find_netdev_configurator ( const char *name );
 725 extern int netdev_configure ( struct net_device *netdev,
 726                               struct net_device_configurator *configurator );
 727 extern int netdev_configure_all ( struct net_device *netdev );
 728 extern int netdev_configuration_in_progress ( struct net_device *netdev );
 729 extern int netdev_configuration_ok ( struct net_device *netdev );
 730
 731 /**
 732  * Complete network transmission
 733  *
 734  * @v netdev            Network device
 735  * @v iobuf             I/O buffer
 736  *
 737  * The packet must currently be in the network device's TX queue.
 738  */
 739 static inline void netdev_tx_complete ( struct net_device *netdev,
 740                                         struct io_buffer *iobuf ) {
 741         netdev_tx_complete_err ( netdev, iobuf, 0 );
 742 }
 743
 744 /**
 745  * Complete network transmission
 746  *
 747  * @v netdev            Network device
 748  *
 749  * Completes the oldest outstanding packet in the TX queue.
 750  */
 751 static inline void netdev_tx_complete_next ( struct net_device *netdev ) {
 752         netdev_tx_complete_next_err ( netdev, 0 );
 753 }
 754
 755 /**
 756  * Mark network device as having link up
 757  *
 758  * @v netdev            Network device
 759  */
 760 static inline __attribute__ (( always_inline )) void
 761 netdev_link_up ( struct net_device *netdev ) {
 762         netdev_link_err ( netdev, 0 );
 763 }
 764
 765 #endif /* _IPXE_NETDEVICE_H */