lib/efi_loader/efi_net.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  EFI application network access support
   4  *
   5  *  Copyright (c) 2016 Alexander Graf
   6  */
   7
   8 #include <common.h>
   9 #include <efi_loader.h>
  10 #include <malloc.h>
  11
  12 static const efi_guid_t efi_net_guid = EFI_SIMPLE_NETWORK_PROTOCOL_GUID;
  13 static const efi_guid_t efi_pxe_base_code_protocol_guid =
  14                                         EFI_PXE_BASE_CODE_PROTOCOL_GUID;
  15 static struct efi_pxe_packet *dhcp_ack;
  16 static bool new_rx_packet;
  17 static void *new_tx_packet;
  18 static void *transmit_buffer;
  19
  20 /*
  21  * The notification function of this event is called in every timer cycle
  22  * to check if a new network packet has been received.
  23  */
  24 static struct efi_event *network_timer_event;
  25 /*
  26  * This event is signaled when a packet has been received.
  27  */
  28 static struct efi_event *wait_for_packet;
  29
  30 /**
  31  * struct efi_net_obj - EFI object representing a network interface
  32  *
  33  * @header:     EFI object header
  34  * @net:        simple network protocol interface
  35  * @net_mode:   status of the network interface
  36  * @pxe:        PXE base code protocol interface
  37  * @pxe_mode:   status of the PXE base code protocol
  38  */
  39 struct efi_net_obj {
  40         struct efi_object header;
  41         struct efi_simple_network net;
  42         struct efi_simple_network_mode net_mode;
  43         struct efi_pxe_base_code_protocol pxe;
  44         struct efi_pxe_mode pxe_mode;
  45 };
  46
  47 /*
  48  * efi_net_start() - start the network interface
  49  *
  50  * This function implements the Start service of the
  51  * EFI_SIMPLE_NETWORK_PROTOCOL. See the Unified Extensible Firmware Interface
  52  * (UEFI) specification for details.
  53  *
  54  * @this:       pointer to the protocol instance
  55  * Return:      status code
  56  */
  57 static efi_status_t EFIAPI efi_net_start(struct efi_simple_network *this)
  58 {
  59         efi_status_t ret = EFI_SUCCESS;
  60
  61         EFI_ENTRY("%p", this);
  62
  63         /* Check parameters */
  64         if (!this) {
  65                 ret = EFI_INVALID_PARAMETER;
  66                 goto out;
  67         }
  68
  69         if (this->mode->state != EFI_NETWORK_STOPPED) {
  70                 ret = EFI_ALREADY_STARTED;
  71         } else {
  72                 this->int_status = 0;
  73                 wait_for_packet->is_signaled = false;
  74                 this->mode->state = EFI_NETWORK_STARTED;
  75         }
  76 out:
  77         return EFI_EXIT(ret);
  78 }
  79
  80 /*
  81  * efi_net_stop() - stop the network interface
  82  *
  83  * This function implements the Stop service of the
  84  * EFI_SIMPLE_NETWORK_PROTOCOL. See the Unified Extensible Firmware Interface
  85  * (UEFI) specification for details.
  86  *
  87  * @this:       pointer to the protocol instance
  88  * Return:      status code
  89  */
  90 static efi_status_t EFIAPI efi_net_stop(struct efi_simple_network *this)
  91 {
  92         efi_status_t ret = EFI_SUCCESS;
  93
  94         EFI_ENTRY("%p", this);
  95
  96         /* Check parameters */
  97         if (!this) {
  98                 ret = EFI_INVALID_PARAMETER;
  99                 goto out;
 100         }
 101
 102         if (this->mode->state == EFI_NETWORK_STOPPED)
 103                 ret = EFI_NOT_STARTED;
 104         else
 105                 this->mode->state = EFI_NETWORK_STOPPED;
 106 out:
 107         return EFI_EXIT(ret);
 108 }
 109
 110 /*
 111  * efi_net_initialize() - initialize the network interface
 112  *
 113  * This function implements the Initialize service of the
 114  * EFI_SIMPLE_NETWORK_PROTOCOL. See the Unified Extensible Firmware Interface
 115  * (UEFI) specification for details.
 116  *
 117  * @this:       pointer to the protocol instance
 118  * @extra_rx:   extra receive buffer to be allocated
 119  * @extra_tx:   extra transmit buffer to be allocated
 120  * Return:      status code
 121  */
 122 static efi_status_t EFIAPI efi_net_initialize(struct efi_simple_network *this,
 123                                               ulong extra_rx, ulong extra_tx)
 124 {
 125         int ret;
 126         efi_status_t r = EFI_SUCCESS;
 127
 128         EFI_ENTRY("%p, %lx, %lx", this, extra_rx, extra_tx);
 129
 130         /* Check parameters */
 131         if (!this) {
 132                 r = EFI_INVALID_PARAMETER;
 133                 goto out;
 134         }
 135
 136         /* Setup packet buffers */
 137         net_init();
 138         /* Disable hardware and put it into the reset state */
 139         eth_halt();
 140         /* Set current device according to environment variables */
 141         eth_set_current();
 142         /* Get hardware ready for send and receive operations */
 143         ret = eth_init();
 144         if (ret < 0) {
 145                 eth_halt();
 146                 this->mode->state = EFI_NETWORK_STOPPED;
 147                 r = EFI_DEVICE_ERROR;
 148                 goto out;
 149         } else {
 150                 this->int_status = 0;
 151                 wait_for_packet->is_signaled = false;
 152                 this->mode->state = EFI_NETWORK_INITIALIZED;
 153         }
 154 out:
 155         return EFI_EXIT(r);
 156 }
 157
 158 /*
 159  * efi_net_reset() - reinitialize the network interface
 160  *
 161  * This function implements the Reset service of the
 162  * EFI_SIMPLE_NETWORK_PROTOCOL. See the Unified Extensible Firmware Interface
 163  * (UEFI) specification for details.
 164  *
 165  * @this:                       pointer to the protocol instance
 166  * @extended_verification:      execute exhaustive verification
 167  * Return:                      status code
 168  */
 169 static efi_status_t EFIAPI efi_net_reset(struct efi_simple_network *this,
 170                                          int extended_verification)
 171 {
 172         EFI_ENTRY("%p, %x", this, extended_verification);
 173
 174         return EFI_EXIT(EFI_CALL(efi_net_initialize(this, 0, 0)));
 175 }
 176
 177 /*
 178  * efi_net_shutdown() - shut down the network interface
 179  *
 180  * This function implements the Shutdown service of the
 181  * EFI_SIMPLE_NETWORK_PROTOCOL. See the Unified Extensible Firmware Interface
 182  * (UEFI) specification for details.
 183  *
 184  * @this:       pointer to the protocol instance
 185  * Return:      status code
 186  */
 187 static efi_status_t EFIAPI efi_net_shutdown(struct efi_simple_network *this)
 188 {
 189         efi_status_t ret = EFI_SUCCESS;
 190
 191         EFI_ENTRY("%p", this);
 192
 193         /* Check parameters */
 194         if (!this) {
 195                 ret = EFI_INVALID_PARAMETER;
 196                 goto out;
 197         }
 198
 199         eth_halt();
 200         this->int_status = 0;
 201         wait_for_packet->is_signaled = false;
 202         this->mode->state = EFI_NETWORK_STOPPED;
 203
 204 out:
 205         return EFI_EXIT(ret);
 206 }
 207
 208 /*
 209  * efi_net_receive_filters() - mange multicast receive filters
 210  *
 211  * This function implements the ReceiveFilters service of the
 212  * EFI_SIMPLE_NETWORK_PROTOCOL. See the Unified Extensible Firmware Interface
 213  * (UEFI) specification for details.
 214  *
 215  * @this:               pointer to the protocol instance
 216  * @enable:             bit mask of receive filters to enable
 217  * @disable:            bit mask of receive filters to disable
 218  * @reset_mcast_filter: true resets contents of the filters
 219  * @mcast_filter_count: number of hardware MAC addresses in the new filters list
 220  * @mcast_filter:       list of new filters
 221  * Return:              status code
 222  */
 223 static efi_status_t EFIAPI efi_net_receive_filters
 224                 (struct efi_simple_network *this, u32 enable, u32 disable,
 225                  int reset_mcast_filter, ulong mcast_filter_count,
 226                  struct efi_mac_address *mcast_filter)
 227 {
 228         EFI_ENTRY("%p, %x, %x, %x, %lx, %p", this, enable, disable,
 229                   reset_mcast_filter, mcast_filter_count, mcast_filter);
 230
 231         return EFI_EXIT(EFI_UNSUPPORTED);
 232 }
 233
 234 /*
 235  * efi_net_station_address() - set the hardware MAC address
 236  *
 237  * This function implements the StationAddress service of the
 238  * EFI_SIMPLE_NETWORK_PROTOCOL. See the Unified Extensible Firmware Interface
 239  * (UEFI) specification for details.
 240  *
 241  * @this:       pointer to the protocol instance
 242  * @reset:      if true reset the address to default
 243  * @new_mac:    new MAC address
 244  * Return:      status code
 245  */
 246 static efi_status_t EFIAPI efi_net_station_address
 247                 (struct efi_simple_network *this, int reset,
 248                  struct efi_mac_address *new_mac)
 249 {
 250         EFI_ENTRY("%p, %x, %p", this, reset, new_mac);
 251
 252         return EFI_EXIT(EFI_UNSUPPORTED);
 253 }
 254
 255 /*
 256  * efi_net_statistics() - reset or collect statistics of the network interface
 257  *
 258  * This function implements the Statistics service of the
 259  * EFI_SIMPLE_NETWORK_PROTOCOL. See the Unified Extensible Firmware Interface
 260  * (UEFI) specification for details.
 261  *
 262  * @this:       pointer to the protocol instance
 263  * @reset:      if true, the statistics are reset
 264  * @stat_size:  size of the statistics table
 265  * @stat_table: table to receive the statistics
 266  * Return:      status code
 267  */
 268 static efi_status_t EFIAPI efi_net_statistics(struct efi_simple_network *this,
 269                                               int reset, ulong *stat_size,
 270                                               void *stat_table)
 271 {
 272         EFI_ENTRY("%p, %x, %p, %p", this, reset, stat_size, stat_table);
 273
 274         return EFI_EXIT(EFI_UNSUPPORTED);
 275 }
 276
 277 /*
 278  * efi_net_mcastiptomac() - translate multicast IP address to MAC address
 279  *
 280  * This function implements the Statistics service of the
 281  * EFI_SIMPLE_NETWORK_PROTOCOL. See the Unified Extensible Firmware Interface
 282  * (UEFI) specification for details.
 283  *
 284  * @this:       pointer to the protocol instance
 285  * @ipv6:       true if the IP address is an IPv6 address
 286  * @ip:         IP address
 287  * @mac:        MAC address
 288  * Return:      status code
 289  */
 290 static efi_status_t EFIAPI efi_net_mcastiptomac(struct efi_simple_network *this,
 291                                                 int ipv6,
 292                                                 struct efi_ip_address *ip,
 293                                                 struct efi_mac_address *mac)
 294 {
 295         EFI_ENTRY("%p, %x, %p, %p", this, ipv6, ip, mac);
 296
 297         return EFI_EXIT(EFI_INVALID_PARAMETER);
 298 }
 299
 300 /**
 301  * efi_net_nvdata() - read or write NVRAM
 302  *
 303  * This function implements the GetStatus service of the Simple Network
 304  * Protocol. See the UEFI spec for details.
 305  *
 306  * @this:               the instance of the Simple Network Protocol
 307  * @readwrite:          true for read, false for write
 308  * @offset:             offset in NVRAM
 309  * @buffer_size:        size of buffer
 310  * @buffer:             buffer
 311  * Return:              status code
 312  */
 313 static efi_status_t EFIAPI efi_net_nvdata(struct efi_simple_network *this,
 314                                           int read_write, ulong offset,
 315                                           ulong buffer_size, char *buffer)
 316 {
 317         EFI_ENTRY("%p, %x, %lx, %lx, %p", this, read_write, offset, buffer_size,
 318                   buffer);
 319
 320         return EFI_EXIT(EFI_UNSUPPORTED);
 321 }
 322
 323 /**
 324  * efi_net_get_status() - get interrupt status
 325  *
 326  * This function implements the GetStatus service of the Simple Network
 327  * Protocol. See the UEFI spec for details.
 328  *
 329  * @this:               the instance of the Simple Network Protocol
 330  * @int_status:         interface status
 331  * @txbuf:              transmission buffer
 332  */
 333 static efi_status_t EFIAPI efi_net_get_status(struct efi_simple_network *this,
 334                                               u32 *int_status, void **txbuf)
 335 {
 336         efi_status_t ret = EFI_SUCCESS;
 337
 338         EFI_ENTRY("%p, %p, %p", this, int_status, txbuf);
 339
 340         efi_timer_check();
 341
 342         /* Check parameters */
 343         if (!this) {
 344                 ret = EFI_INVALID_PARAMETER;
 345                 goto out;
 346         }
 347
 348         switch (this->mode->state) {
 349         case EFI_NETWORK_STOPPED:
 350                 ret = EFI_NOT_STARTED;
 351                 goto out;
 352         case EFI_NETWORK_STARTED:
 353                 ret = EFI_DEVICE_ERROR;
 354                 goto out;
 355         default:
 356                 break;
 357         }
 358
 359         if (int_status) {
 360                 *int_status = this->int_status;
 361                 this->int_status = 0;
 362         }
 363         if (txbuf)
 364                 *txbuf = new_tx_packet;
 365
 366         new_tx_packet = NULL;
 367 out:
 368         return EFI_EXIT(ret);
 369 }
 370
 371 /**
 372  * efi_net_transmit() - transmit a packet
 373  *
 374  * This function implements the Transmit service of the Simple Network Protocol.
 375  * See the UEFI spec for details.
 376  *
 377  * @this:               the instance of the Simple Network Protocol
 378  * @header_size:        size of the media header
 379  * @buffer_size:        size of the buffer to receive the packet
 380  * @buffer:             buffer to receive the packet
 381  * @src_addr:           source hardware MAC address
 382  * @dest_addr:          destination hardware MAC address
 383  * @protocol:           type of header to build
 384  * Return:              status code
 385  */
 386 static efi_status_t EFIAPI efi_net_transmit
 387                 (struct efi_simple_network *this, size_t header_size,
 388                  size_t buffer_size, void *buffer,
 389                  struct efi_mac_address *src_addr,
 390                  struct efi_mac_address *dest_addr, u16 *protocol)
 391 {
 392         efi_status_t ret = EFI_SUCCESS;
 393
 394         EFI_ENTRY("%p, %lu, %lu, %p, %p, %p, %p", this,
 395                   (unsigned long)header_size, (unsigned long)buffer_size,
 396                   buffer, src_addr, dest_addr, protocol);
 397
 398         efi_timer_check();
 399
 400         /* Check parameters */
 401         if (!this || !buffer) {
 402                 ret = EFI_INVALID_PARAMETER;
 403                 goto out;
 404         }
 405
 406         /* We do not support jumbo packets */
 407         if (buffer_size > PKTSIZE_ALIGN) {
 408                 ret = EFI_INVALID_PARAMETER;
 409                 goto out;
 410         }
 411
 412         /* At least the IP header has to fit into the buffer */
 413         if (buffer_size < this->mode->media_header_size) {
 414                 ret = EFI_BUFFER_TOO_SMALL;
 415                 goto out;
 416         }
 417
 418         /*
 419          * TODO:
 420          * Support VLANs. Use net_set_ether() for copying the header. Use a
 421          * U_BOOT_ENV_CALLBACK to update the media header size.
 422          */
 423         if (header_size) {
 424                 struct ethernet_hdr *header = buffer;
 425
 426                 if (!dest_addr || !protocol ||
 427                     header_size != this->mode->media_header_size) {
 428                         ret = EFI_INVALID_PARAMETER;
 429                         goto out;
 430                 }
 431                 if (!src_addr)
 432                         src_addr = &this->mode->current_address;
 433
 434                 memcpy(header->et_dest, dest_addr, ARP_HLEN);
 435                 memcpy(header->et_src, src_addr, ARP_HLEN);
 436                 header->et_protlen = htons(*protocol);
 437         }
 438
 439         switch (this->mode->state) {
 440         case EFI_NETWORK_STOPPED:
 441                 ret = EFI_NOT_STARTED;
 442                 goto out;
 443         case EFI_NETWORK_STARTED:
 444                 ret = EFI_DEVICE_ERROR;
 445                 goto out;
 446         default:
 447                 break;
 448         }
 449
 450         /* Ethernet packets always fit, just bounce */
 451         memcpy(transmit_buffer, buffer, buffer_size);
 452         net_send_packet(transmit_buffer, buffer_size);
 453
 454         new_tx_packet = buffer;
 455         this->int_status |= EFI_SIMPLE_NETWORK_TRANSMIT_INTERRUPT;
 456 out:
 457         return EFI_EXIT(ret);
 458 }
 459
 460 /**
 461  * efi_net_receive() - receive a packet from a network interface
 462  *
 463  * This function implements the Receive service of the Simple Network Protocol.
 464  * See the UEFI spec for details.
 465  *
 466  * @this:               the instance of the Simple Network Protocol
 467  * @header_size:        size of the media header
 468  * @buffer_size:        size of the buffer to receive the packet
 469  * @buffer:             buffer to receive the packet
 470  * @src_addr:           source MAC address
 471  * @dest_addr:          destination MAC address
 472  * @protocol:           protocol
 473  * Return:              status code
 474  */
 475 static efi_status_t EFIAPI efi_net_receive
 476                 (struct efi_simple_network *this, size_t *header_size,
 477                  size_t *buffer_size, void *buffer,
 478                  struct efi_mac_address *src_addr,
 479                  struct efi_mac_address *dest_addr, u16 *protocol)
 480 {
 481         efi_status_t ret = EFI_SUCCESS;
 482         struct ethernet_hdr *eth_hdr;
 483         size_t hdr_size = sizeof(struct ethernet_hdr);
 484         u16 protlen;
 485
 486         EFI_ENTRY("%p, %p, %p, %p, %p, %p, %p", this, header_size,
 487                   buffer_size, buffer, src_addr, dest_addr, protocol);
 488
 489         /* Execute events */
 490         efi_timer_check();
 491
 492         /* Check parameters */
 493         if (!this || !buffer || !buffer_size) {
 494                 ret = EFI_INVALID_PARAMETER;
 495                 goto out;
 496         }
 497
 498         switch (this->mode->state) {
 499         case EFI_NETWORK_STOPPED:
 500                 ret = EFI_NOT_STARTED;
 501                 goto out;
 502         case EFI_NETWORK_STARTED:
 503                 ret = EFI_DEVICE_ERROR;
 504                 goto out;
 505         default:
 506                 break;
 507         }
 508
 509         if (!new_rx_packet) {
 510                 ret = EFI_NOT_READY;
 511                 goto out;
 512         }
 513         /* Fill export parameters */
 514         eth_hdr = (struct ethernet_hdr *)net_rx_packet;
 515         protlen = ntohs(eth_hdr->et_protlen);
 516         if (protlen == 0x8100) {
 517                 hdr_size += 4;
 518                 protlen = ntohs(*(u16 *)&net_rx_packet[hdr_size - 2]);
 519         }
 520         if (header_size)
 521                 *header_size = hdr_size;
 522         if (dest_addr)
 523                 memcpy(dest_addr, eth_hdr->et_dest, ARP_HLEN);
 524         if (src_addr)
 525                 memcpy(src_addr, eth_hdr->et_src, ARP_HLEN);
 526         if (protocol)
 527                 *protocol = protlen;
 528         if (*buffer_size < net_rx_packet_len) {
 529                 /* Packet doesn't fit, try again with bigger buffer */
 530                 *buffer_size = net_rx_packet_len;
 531                 ret = EFI_BUFFER_TOO_SMALL;
 532                 goto out;
 533         }
 534         /* Copy packet */
 535         memcpy(buffer, net_rx_packet, net_rx_packet_len);
 536         *buffer_size = net_rx_packet_len;
 537         new_rx_packet = 0;
 538         this->int_status &= ~EFI_SIMPLE_NETWORK_RECEIVE_INTERRUPT;
 539 out:
 540         return EFI_EXIT(ret);
 541 }
 542
 543 /**
 544  * efi_net_set_dhcp_ack() - take note of a selected DHCP IP address
 545  *
 546  * This function is called by dhcp_handler().
 547  */
 548 void efi_net_set_dhcp_ack(void *pkt, int len)
 549 {
 550         int maxsize = sizeof(*dhcp_ack);
 551
 552         if (!dhcp_ack)
 553                 dhcp_ack = malloc(maxsize);
 554
 555         memcpy(dhcp_ack, pkt, min(len, maxsize));
 556 }
 557
 558 /**
 559  * efi_net_push() - callback for received network packet
 560  *
 561  * This function is called when a network packet is received by eth_rx().
 562  *
 563  * @pkt:        network packet
 564  * @len:        length
 565  */
 566 static void efi_net_push(void *pkt, int len)
 567 {
 568         new_rx_packet = true;
 569 }
 570
 571 /**
 572  * efi_network_timer_notify() - check if a new network packet has been received
 573  *
 574  * This notification function is called in every timer cycle.
 575  *
 576  * @event       the event for which this notification function is registered
 577  * @context     event context - not used in this function
 578  */
 579 static void EFIAPI efi_network_timer_notify(struct efi_event *event,
 580                                             void *context)
 581 {
 582         struct efi_simple_network *this = (struct efi_simple_network *)context;
 583
 584         EFI_ENTRY("%p, %p", event, context);
 585
 586         /*
 587          * Some network drivers do not support calling eth_rx() before
 588          * initialization.
 589          */
 590         if (!this || this->mode->state != EFI_NETWORK_INITIALIZED)
 591                 goto out;
 592
 593         if (!new_rx_packet) {
 594                 push_packet = efi_net_push;
 595                 eth_rx();
 596                 push_packet = NULL;
 597                 if (new_rx_packet) {
 598                         /* Check that we at least received an Ethernet header */
 599                         if (net_rx_packet_len >=
 600                             sizeof(struct ethernet_hdr)) {
 601                                 this->int_status |=
 602                                         EFI_SIMPLE_NETWORK_RECEIVE_INTERRUPT;
 603                                 wait_for_packet->is_signaled = true;
 604                         } else {
 605                                 new_rx_packet = 0;
 606                         }
 607                 }
 608         }
 609 out:
 610         EFI_EXIT(EFI_SUCCESS);
 611 }
 612
 613 static efi_status_t EFIAPI efi_pxe_base_code_start(
 614                                 struct efi_pxe_base_code_protocol *this,
 615                                 u8 use_ipv6)
 616 {
 617         return EFI_UNSUPPORTED;
 618 }
 619
 620 static efi_status_t EFIAPI efi_pxe_base_code_stop(
 621                                 struct efi_pxe_base_code_protocol *this)
 622 {
 623         return EFI_UNSUPPORTED;
 624 }
 625
 626 static efi_status_t EFIAPI efi_pxe_base_code_dhcp(
 627                                 struct efi_pxe_base_code_protocol *this,
 628                                 u8 sort_offers)
 629 {
 630         return EFI_UNSUPPORTED;
 631 }
 632
 633 static efi_status_t EFIAPI efi_pxe_base_code_discover(
 634                                 struct efi_pxe_base_code_protocol *this,
 635                                 u16 type, u16 *layer, u8 bis,
 636                                 struct efi_pxe_base_code_discover_info *info)
 637 {
 638         return EFI_UNSUPPORTED;
 639 }
 640
 641 static efi_status_t EFIAPI efi_pxe_base_code_mtftp(
 642                                 struct efi_pxe_base_code_protocol *this,
 643                                 u32 operation, void *buffer_ptr,
 644                                 u8 overwrite, efi_uintn_t *buffer_size,
 645                                 struct efi_ip_address server_ip, char *filename,
 646                                 struct efi_pxe_base_code_mtftp_info *info,
 647                                 u8 dont_use_buffer)
 648 {
 649         return EFI_UNSUPPORTED;
 650 }
 651
 652 static efi_status_t EFIAPI efi_pxe_base_code_udp_write(
 653                                 struct efi_pxe_base_code_protocol *this,
 654                                 u16 op_flags, struct efi_ip_address *dest_ip,
 655                                 u16 *dest_port,
 656                                 struct efi_ip_address *gateway_ip,
 657                                 struct efi_ip_address *src_ip, u16 *src_port,
 658                                 efi_uintn_t *header_size, void *header_ptr,
 659                                 efi_uintn_t *buffer_size, void *buffer_ptr)
 660 {
 661         return EFI_UNSUPPORTED;
 662 }
 663
 664 static efi_status_t EFIAPI efi_pxe_base_code_udp_read(
 665                                 struct efi_pxe_base_code_protocol *this,
 666                                 u16 op_flags, struct efi_ip_address *dest_ip,
 667                                 u16 *dest_port, struct efi_ip_address *src_ip,
 668                                 u16 *src_port, efi_uintn_t *header_size,
 669                                 void *header_ptr, efi_uintn_t *buffer_size,
 670                                 void *buffer_ptr)
 671 {
 672         return EFI_UNSUPPORTED;
 673 }
 674
 675 static efi_status_t EFIAPI efi_pxe_base_code_set_ip_filter(
 676                                 struct efi_pxe_base_code_protocol *this,
 677                                 struct efi_pxe_base_code_filter *new_filter)
 678 {
 679         return EFI_UNSUPPORTED;
 680 }
 681
 682 static efi_status_t EFIAPI efi_pxe_base_code_arp(
 683                                 struct efi_pxe_base_code_protocol *this,
 684                                 struct efi_ip_address *ip_addr,
 685                                 struct efi_mac_address *mac_addr)
 686 {
 687         return EFI_UNSUPPORTED;
 688 }
 689
 690 static efi_status_t EFIAPI efi_pxe_base_code_set_parameters(
 691                                 struct efi_pxe_base_code_protocol *this,
 692                                 u8 *new_auto_arp, u8 *new_send_guid,
 693                                 u8 *new_ttl, u8 *new_tos,
 694                                 u8 *new_make_callback)
 695 {
 696         return EFI_UNSUPPORTED;
 697 }
 698
 699 static efi_status_t EFIAPI efi_pxe_base_code_set_station_ip(
 700                                 struct efi_pxe_base_code_protocol *this,
 701                                 struct efi_ip_address *new_station_ip,
 702                                 struct efi_ip_address *new_subnet_mask)
 703 {
 704         return EFI_UNSUPPORTED;
 705 }
 706
 707 static efi_status_t EFIAPI efi_pxe_base_code_set_packets(
 708                                 struct efi_pxe_base_code_protocol *this,
 709                                 u8 *new_dhcp_discover_valid,
 710                                 u8 *new_dhcp_ack_received,
 711                                 u8 *new_proxy_offer_received,
 712                                 u8 *new_pxe_discover_valid,
 713                                 u8 *new_pxe_reply_received,
 714                                 u8 *new_pxe_bis_reply_received,
 715                                 EFI_PXE_BASE_CODE_PACKET *new_dchp_discover,
 716                                 EFI_PXE_BASE_CODE_PACKET *new_dhcp_acc,
 717                                 EFI_PXE_BASE_CODE_PACKET *new_proxy_offer,
 718                                 EFI_PXE_BASE_CODE_PACKET *new_pxe_discover,
 719                                 EFI_PXE_BASE_CODE_PACKET *new_pxe_reply,
 720                                 EFI_PXE_BASE_CODE_PACKET *new_pxe_bis_reply)
 721 {
 722         return EFI_UNSUPPORTED;
 723 }
 724
 725 /**
 726  * efi_net_register() - register the simple network protocol
 727  *
 728  * This gets called from do_bootefi_exec().
 729  */
 730 efi_status_t efi_net_register(void)
 731 {
 732         struct efi_net_obj *netobj = NULL;
 733         efi_status_t r;
 734
 735         if (!eth_get_dev()) {
 736                 /* No network device active, don't expose any */
 737                 return EFI_SUCCESS;
 738         }
 739
 740         /* We only expose the "active" network device, so one is enough */
 741         netobj = calloc(1, sizeof(*netobj));
 742         if (!netobj)
 743                 goto out_of_resources;
 744
 745         /* Allocate an aligned transmit buffer */
 746         transmit_buffer = calloc(1, PKTSIZE_ALIGN + PKTALIGN);
 747         if (!transmit_buffer)
 748                 goto out_of_resources;
 749         transmit_buffer = (void *)ALIGN((uintptr_t)transmit_buffer, PKTALIGN);
 750
 751         /* Hook net up to the device list */
 752         efi_add_handle(&netobj->header);
 753
 754         /* Fill in object data */
 755         r = efi_add_protocol(&netobj->header, &efi_net_guid,
 756                              &netobj->net);
 757         if (r != EFI_SUCCESS)
 758                 goto failure_to_add_protocol;
 759         r = efi_add_protocol(&netobj->header, &efi_guid_device_path,
 760                              efi_dp_from_eth());
 761         if (r != EFI_SUCCESS)
 762                 goto failure_to_add_protocol;
 763         r = efi_add_protocol(&netobj->header, &efi_pxe_base_code_protocol_guid,
 764                              &netobj->pxe);
 765         if (r != EFI_SUCCESS)
 766                 goto failure_to_add_protocol;
 767         netobj->net.revision = EFI_SIMPLE_NETWORK_PROTOCOL_REVISION;
 768         netobj->net.start = efi_net_start;
 769         netobj->net.stop = efi_net_stop;
 770         netobj->net.initialize = efi_net_initialize;
 771         netobj->net.reset = efi_net_reset;
 772         netobj->net.shutdown = efi_net_shutdown;
 773         netobj->net.receive_filters = efi_net_receive_filters;
 774         netobj->net.station_address = efi_net_station_address;
 775         netobj->net.statistics = efi_net_statistics;
 776         netobj->net.mcastiptomac = efi_net_mcastiptomac;
 777         netobj->net.nvdata = efi_net_nvdata;
 778         netobj->net.get_status = efi_net_get_status;
 779         netobj->net.transmit = efi_net_transmit;
 780         netobj->net.receive = efi_net_receive;
 781         netobj->net.mode = &netobj->net_mode;
 782         netobj->net_mode.state = EFI_NETWORK_STARTED;
 783         memcpy(netobj->net_mode.current_address.mac_addr, eth_get_ethaddr(), 6);
 784         netobj->net_mode.hwaddr_size = ARP_HLEN;
 785         netobj->net_mode.media_header_size = ETHER_HDR_SIZE;
 786         netobj->net_mode.max_packet_size = PKTSIZE;
 787         netobj->net_mode.if_type = ARP_ETHER;
 788
 789         netobj->pxe.revision = EFI_PXE_BASE_CODE_PROTOCOL_REVISION;
 790         netobj->pxe.start = efi_pxe_base_code_start;
 791         netobj->pxe.stop = efi_pxe_base_code_stop;
 792         netobj->pxe.dhcp = efi_pxe_base_code_dhcp;
 793         netobj->pxe.discover = efi_pxe_base_code_discover;
 794         netobj->pxe.mtftp = efi_pxe_base_code_mtftp;
 795         netobj->pxe.udp_write = efi_pxe_base_code_udp_write;
 796         netobj->pxe.udp_read = efi_pxe_base_code_udp_read;
 797         netobj->pxe.set_ip_filter = efi_pxe_base_code_set_ip_filter;
 798         netobj->pxe.arp = efi_pxe_base_code_arp;
 799         netobj->pxe.set_parameters = efi_pxe_base_code_set_parameters;
 800         netobj->pxe.set_station_ip = efi_pxe_base_code_set_station_ip;
 801         netobj->pxe.set_packets = efi_pxe_base_code_set_packets;
 802         netobj->pxe.mode = &netobj->pxe_mode;
 803         if (dhcp_ack)
 804                 netobj->pxe_mode.dhcp_ack = *dhcp_ack;
 805
 806         /*
 807          * Create WaitForPacket event.
 808          */
 809         r = efi_create_event(EVT_NOTIFY_WAIT, TPL_CALLBACK,
 810                              efi_network_timer_notify, NULL, NULL,
 811                              &wait_for_packet);
 812         if (r != EFI_SUCCESS) {
 813                 printf("ERROR: Failed to register network event\n");
 814                 return r;
 815         }
 816         netobj->net.wait_for_packet = wait_for_packet;
 817         /*
 818          * Create a timer event.
 819          *
 820          * The notification function is used to check if a new network packet
 821          * has been received.
 822          *
 823          * iPXE is running at TPL_CALLBACK most of the time. Use a higher TPL.
 824          */
 825         r = efi_create_event(EVT_TIMER | EVT_NOTIFY_SIGNAL, TPL_NOTIFY,
 826                              efi_network_timer_notify, &netobj->net, NULL,
 827                              &network_timer_event);
 828         if (r != EFI_SUCCESS) {
 829                 printf("ERROR: Failed to register network event\n");
 830                 return r;
 831         }
 832         /* Network is time critical, create event in every timer cycle */
 833         r = efi_set_timer(network_timer_event, EFI_TIMER_PERIODIC, 0);
 834         if (r != EFI_SUCCESS) {
 835                 printf("ERROR: Failed to set network timer\n");
 836                 return r;
 837         }
 838
 839         return EFI_SUCCESS;
 840 failure_to_add_protocol:
 841         printf("ERROR: Failure to add protocol\n");
 842         return r;
 843 out_of_resources:
 844         free(netobj);
 845         /* free(transmit_buffer) not needed yet */
 846         printf("ERROR: Out of memory\n");
 847         return EFI_OUT_OF_RESOURCES;
 848 }