EmbeddedPkg/Drivers/Lan91xDxe/Lan91xDxe.c

   1 /** @file
   2 *  SMSC LAN91x series Network Controller Driver.
   3 *
   4 *  Copyright (c) 2013-2017 Linaro.org
   5 *
   6 *  Derived from the LAN9118 driver. Original sources
   7 *  Copyright (c) 2012-2013, ARM Limited. All rights reserved.
   8 *
   9 *  This program and the accompanying materials are licensed and
  10 *  made available under the terms and conditions of the BSD License
  11 *  which accompanies this distribution.  The full text of the license
  12 *  may be found at: http://opensource.org/licenses/bsd-license.php
  13 *
  14 *  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  15 *  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  16 *
  17 **/
  18
  19 #include <Uefi.h>
  20 #include <Uefi/UefiSpec.h>
  21 #include <Base.h>
  22
  23 // Protocols used by this driver
  24 #include <Protocol/SimpleNetwork.h>
  25 #include <Protocol/ComponentName2.h>
  26 #include <Protocol/PxeBaseCode.h>
  27 #include <Protocol/DevicePath.h>
  28
  29 // Libraries used by this driver
  30 #include <Library/UefiLib.h>
  31 #include <Library/DebugLib.h>
  32 #include <Library/UefiBootServicesTableLib.h>
  33 #include <Library/MemoryAllocationLib.h>
  34 #include <Library/IoLib.h>
  35 #include <Library/PcdLib.h>
  36 #include <Library/NetLib.h>
  37 #include <Library/DevicePathLib.h>
  38
  39 // Hardware register definitions
  40 #include "Lan91xDxeHw.h"
  41
  42 // Debugging output options
  43 //#define LAN91X_PRINT_REGISTERS 1
  44 //#define LAN91X_PRINT_PACKET_HEADERS 1
  45 //#define LAN91X_PRINT_RECEIVE_FILTERS 1
  46
  47 // Chip power-down option -- UNTESTED
  48 //#define LAN91X_POWER_DOWN 1
  49
  50 /*---------------------------------------------------------------------------------------------------------------------
  51
  52   LAN91x Information Structure
  53
  54 ---------------------------------------------------------------------------------------------------------------------*/
  55 typedef struct _LAN91X_DRIVER {
  56   // Driver signature
  57   UINT32            Signature;
  58   EFI_HANDLE        ControllerHandle;
  59
  60   // EFI SNP protocol instances
  61   EFI_SIMPLE_NETWORK_PROTOCOL Snp;
  62   EFI_SIMPLE_NETWORK_MODE SnpMode;
  63
  64   // EFI Snp statistics instance
  65   EFI_NETWORK_STATISTICS Stats;
  66
  67   // Transmit Buffer recycle queue
  68
  69   LIST_ENTRY TransmitQueueHead;
  70
  71   // Register access variables
  72   UINTN             IoBase;             // I/O Base Address
  73   UINT8             Revision;           // Chip Revision Number
  74   INT8              PhyAd;              // Phy Address
  75   UINT8             BankSel;            // Currently selected register bank
  76
  77 } LAN91X_DRIVER;
  78
  79 #define LAN91X_NO_PHY (-1)              // PhyAd value if PHY not detected
  80
  81 #define LAN91X_SIGNATURE                        SIGNATURE_32('S', 'M', '9', '1')
  82 #define INSTANCE_FROM_SNP_THIS(a)               CR(a, LAN91X_DRIVER, Snp, LAN91X_SIGNATURE)
  83
  84 #define LAN91X_STALL              2
  85 #define LAN91X_MEMORY_ALLOC_POLLS 100   // Max times to poll for memory allocation
  86 #define LAN91X_PKT_OVERHEAD       6     // Overhead bytes in packet buffer
  87
  88 // Synchronization TPLs
  89 #define LAN91X_TPL  TPL_CALLBACK
  90
  91 // Most common CRC32 Polynomial for little endian machines
  92 #define CRC_POLYNOMIAL               0xEDB88320
  93
  94
  95 typedef struct {
  96   MAC_ADDR_DEVICE_PATH      Lan91x;
  97   EFI_DEVICE_PATH_PROTOCOL  End;
  98 } LAN91X_DEVICE_PATH;
  99
 100 LAN91X_DEVICE_PATH Lan91xPathTemplate =  {
 101   {
 102     {
 103       MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP,
 104       { (UINT8) (sizeof(MAC_ADDR_DEVICE_PATH)), (UINT8) ((sizeof(MAC_ADDR_DEVICE_PATH)) >> 8) }
 105     },
 106     { { 0 } },
 107     0
 108   },
 109   {
 110     END_DEVICE_PATH_TYPE,
 111     END_ENTIRE_DEVICE_PATH_SUBTYPE,
 112     { sizeof(EFI_DEVICE_PATH_PROTOCOL), 0 }
 113   }
 114 };
 115
 116 // Chip ID numbers and name strings
 117 #define CHIP_9192       3
 118 #define CHIP_9194       4
 119 #define CHIP_9195       5
 120 #define CHIP_9196       6
 121 #define CHIP_91100      7
 122 #define CHIP_91100FD    8
 123 #define CHIP_91111FD    9
 124
 125 STATIC CHAR16 CONST * CONST ChipIds[ 16 ] =  {
 126   NULL, NULL, NULL,
 127   /* 3 */ L"SMC91C90/91C92",
 128   /* 4 */ L"SMC91C94",
 129   /* 5 */ L"SMC91C95",
 130   /* 6 */ L"SMC91C96",
 131   /* 7 */ L"SMC91C100",
 132   /* 8 */ L"SMC91C100FD",
 133   /* 9 */ L"SMC91C11xFD",
 134   NULL, NULL, NULL,
 135   NULL, NULL, NULL
 136 };
 137
 138 /* ------------------ TxBuffer Queue structures ------------------- */
 139
 140 typedef struct {
 141   VOID            *Buf;
 142   UINTN           Length;
 143 } MSK_SYSTEM_BUF;
 144
 145 typedef struct {
 146   UINTN           Signature;
 147   LIST_ENTRY      Link;
 148   MSK_SYSTEM_BUF  SystemBuf;
 149 } MSK_LINKED_SYSTEM_BUF;
 150
 151 #define TX_MBUF_SIGNATURE  SIGNATURE_32 ('t','x','m','b')
 152
 153 /* ------------------ MAC Address Hash Calculations ------------------- */
 154
 155 /*
 156 **  Generate a hash value from a multicast address
 157 **
 158 **  This uses the Ethernet standard CRC32 algorithm
 159 **
 160 **  INFO USED:
 161 **    1: http://en.wikipedia.org/wiki/Cyclic_redundancy_check
 162 **
 163 **    2: http://www.erg.abdn.ac.uk/~gorry/eg3567/dl-pages/crc.html
 164 **
 165 **    3: http://en.wikipedia.org/wiki/Computation_of_CRC
 166 */
 167 STATIC
 168 UINT32
 169 MulticastHash (
 170   IN    EFI_MAC_ADDRESS *Mac,
 171   IN    UINT32 AddrLen
 172   )
 173 {
 174   UINT32 Iter;
 175   UINT32 Remainder;
 176   UINT32 Crc32;
 177   UINT8 *Addr;
 178
 179   // 0xFFFFFFFF is standard seed for Ethernet
 180   Remainder = 0xFFFFFFFF;
 181
 182   // Generate the remainder byte-by-byte (LSB first)
 183   Addr = &Mac->Addr[0];
 184   while (AddrLen-- > 0) {
 185     Remainder ^= *Addr++;
 186     for (Iter = 0; Iter < 8; ++Iter) {
 187       // Check if exponent is set
 188       if ((Remainder & 1) != 0) {
 189         Remainder = (Remainder >> 1) ^ CRC_POLYNOMIAL;
 190       } else {
 191         Remainder = (Remainder >> 1) ^ 0;
 192       }
 193     }
 194   }
 195
 196   // Reverse the bits of the remainder
 197   Crc32 = 0;
 198   for (Iter = 0; Iter < 32; ++Iter) {
 199     Crc32 <<= 1;
 200     Crc32 |= Remainder & 1;
 201     Remainder >>= 1;
 202   }
 203   return Crc32;
 204 }
 205
 206
 207 /* ---------------- Banked Register Operations ------------------ */
 208
 209 // Select the proper I/O bank
 210 STATIC
 211 VOID
 212 SelectIoBank (
 213   LAN91X_DRIVER   *LanDriver,
 214   UINTN            Register
 215   )
 216 {
 217   UINT8   Bank;
 218
 219   Bank = RegisterToBank (Register);
 220
 221   // Select the proper I/O bank
 222   if (LanDriver->BankSel != Bank) {
 223     MmioWrite16 (LanDriver->IoBase + LAN91X_BANK_OFFSET, Bank);
 224     LanDriver->BankSel = Bank;
 225   }
 226 }
 227
 228 // Read a 16-bit I/O-space register
 229 STATIC
 230 UINT16
 231 ReadIoReg16 (
 232   LAN91X_DRIVER   *LanDriver,
 233   UINTN            Register
 234   )
 235 {
 236   UINT8   Offset;
 237
 238   // Select the proper I/O bank
 239   SelectIoBank (LanDriver, Register);
 240
 241   // Read the requested register
 242   Offset = RegisterToOffset (Register);
 243   return MmioRead16 (LanDriver->IoBase + Offset);
 244 }
 245
 246 // Write a 16-bit I/O-space register
 247 STATIC
 248 UINT16
 249 WriteIoReg16 (
 250   LAN91X_DRIVER   *LanDriver,
 251   UINTN            Register,
 252   UINT16           Value
 253   )
 254 {
 255   UINT8   Offset;
 256
 257   // Select the proper I/O bank
 258   SelectIoBank (LanDriver, Register);
 259
 260   // Write the requested register
 261   Offset = RegisterToOffset (Register);
 262   return MmioWrite16 (LanDriver->IoBase + Offset, Value);
 263 }
 264
 265 // Read an 8-bit I/O-space register
 266 STATIC
 267 UINT8
 268 ReadIoReg8 (
 269   LAN91X_DRIVER   *LanDriver,
 270   UINTN            Register
 271   )
 272 {
 273   UINT8   Offset;
 274
 275   // Select the proper I/O bank
 276   SelectIoBank (LanDriver, Register);
 277
 278   // Read the requested register
 279   Offset = RegisterToOffset (Register);
 280   return MmioRead8 (LanDriver->IoBase + Offset);
 281 }
 282
 283 // Write an 8-bit I/O-space register
 284 STATIC
 285 UINT8
 286 WriteIoReg8 (
 287   LAN91X_DRIVER   *LanDriver,
 288   UINTN            Register,
 289   UINT8            Value
 290   )
 291 {
 292   UINT8   Offset;
 293
 294   // Select the proper I/O bank
 295   SelectIoBank (LanDriver, Register);
 296
 297   // Write the requested register
 298   Offset = RegisterToOffset (Register);
 299   return MmioWrite8 (LanDriver->IoBase + Offset, Value);
 300 }
 301
 302
 303 /* ---------------- MII/PHY Access Operations ------------------ */
 304
 305 #define LAN91X_MDIO_STALL   1
 306
 307 STATIC
 308 VOID
 309 MdioOutput (
 310   LAN91X_DRIVER   *LanDriver,
 311   UINTN            Bits,
 312   UINT32           Value
 313   )
 314 {
 315   UINT16          MgmtReg;
 316   UINT32          Mask;
 317
 318   MgmtReg = ReadIoReg16 (LanDriver, LAN91X_MGMT);
 319   MgmtReg &= ~MGMT_MCLK;
 320   MgmtReg |= MGMT_MDOE;
 321
 322   for (Mask = (1 << (Bits - 1)); Mask != 0; Mask >>= 1) {
 323     if ((Value & Mask) != 0) {
 324       MgmtReg |= MGMT_MDO;
 325     } else {
 326       MgmtReg &= ~MGMT_MDO;
 327     }
 328
 329     WriteIoReg16 (LanDriver, LAN91X_MGMT, MgmtReg);
 330     gBS->Stall (LAN91X_MDIO_STALL);
 331     WriteIoReg16 (LanDriver, LAN91X_MGMT, MgmtReg | MGMT_MCLK);
 332     gBS->Stall (LAN91X_MDIO_STALL);
 333   }
 334 }
 335 #define PHY_OUTPUT_TIME (2 * LAN91X_MDIO_STALL)
 336
 337 STATIC
 338 UINT32
 339 MdioInput (
 340   LAN91X_DRIVER   *LanDriver,
 341   UINTN            Bits
 342   )
 343 {
 344   UINT16          MgmtReg;
 345   UINT32          Mask;
 346   UINT32          Value;
 347
 348   MgmtReg = ReadIoReg16 (LanDriver, LAN91X_MGMT);
 349   MgmtReg &= ~(MGMT_MDOE | MGMT_MCLK | MGMT_MDO);
 350   WriteIoReg16 (LanDriver, LAN91X_MGMT, MgmtReg);
 351
 352   Value = 0;
 353   for (Mask = (1 << (Bits - 1)); Mask != 0; Mask >>= 1) {
 354     if ((ReadIoReg16 (LanDriver, LAN91X_MGMT) & MGMT_MDI) != 0) {
 355        Value |= Mask;
 356     }
 357
 358     WriteIoReg16 (LanDriver, LAN91X_MGMT, MgmtReg);
 359     gBS->Stall (LAN91X_MDIO_STALL);
 360     WriteIoReg16 (LanDriver, LAN91X_MGMT, MgmtReg | MGMT_MCLK);
 361     gBS->Stall (LAN91X_MDIO_STALL);
 362   }
 363
 364   return Value;
 365 }
 366 #define PHY_INPUT_TIME (2 * LAN91X_MDIO_STALL)
 367
 368 STATIC
 369 VOID
 370 MdioIdle (
 371   LAN91X_DRIVER   *LanDriver
 372   )
 373 {
 374   UINT16          MgmtReg;
 375
 376   MgmtReg = ReadIoReg16 (LanDriver, LAN91X_MGMT);
 377   MgmtReg &= ~(MGMT_MDOE | MGMT_MCLK | MGMT_MDO);
 378   WriteIoReg16 (LanDriver, LAN91X_MGMT, MgmtReg);
 379 }
 380
 381 // Write to a PHY register
 382 STATIC
 383 VOID
 384 WritePhyReg16 (
 385   LAN91X_DRIVER   *LanDriver,
 386   UINTN            RegAd,
 387   UINT16           Value
 388   )
 389 {
 390   // Bit-bang the MII Serial Frame write operation
 391   MdioOutput (LanDriver, 32, 0xffffffff);       // Send 32 Ones as a preamble
 392   MdioOutput (LanDriver,  2, 0x01);             // Send Start (01)
 393   MdioOutput (LanDriver,  2, 0x01);             // Send Write (01)
 394   MdioOutput (LanDriver,  5, LanDriver->PhyAd); // Send PHYAD[4:0]
 395   MdioOutput (LanDriver,  5, RegAd);            // Send REGAD[4:0]
 396   MdioOutput (LanDriver,  2, 0x02);             // Send TurnAround (10)
 397   MdioOutput (LanDriver, 16, Value);            // Write 16 data bits
 398
 399   // Idle the MDIO bus
 400   MdioIdle (LanDriver);
 401 }
 402 // Calculate approximate time to write a PHY register in microseconds
 403 #define PHY_WRITE_TIME  ((32 + 2 + 2 + 5 + 5 + 2 + 16) * PHY_OUTPUT_TIME)
 404
 405 // Read from a PHY register
 406 STATIC
 407 UINT16
 408 ReadPhyReg16 (
 409   LAN91X_DRIVER   *LanDriver,
 410   UINTN            RegAd
 411   )
 412 {
 413   UINT32 Value;
 414
 415   // Bit-bang the MII Serial Frame read operation
 416   MdioOutput (LanDriver, 32, 0xffffffff);       // Send 32 Ones as a preamble
 417   MdioOutput (LanDriver,  2, 0x01);             // Send Start (01)
 418   MdioOutput (LanDriver,  2, 0x02);             // Send Read (10)
 419   MdioOutput (LanDriver,  5, LanDriver->PhyAd); // Send PHYAD[4:0]
 420   MdioOutput (LanDriver,  5, RegAd);            // Send REGAD[4:0]
 421
 422   (VOID)  MdioInput (LanDriver, 2);             // Discard TurnAround bits
 423   Value = MdioInput (LanDriver, 16);            // Read 16 data bits
 424
 425   // Idle the MDIO bus
 426   MdioIdle (LanDriver);
 427
 428   return (Value & 0xffff);
 429 }
 430 // Calculate approximate time to read a PHY register in microseconds
 431 #define PHY_READ_TIME  (((32 + 2 + 2 + 5 + 5) * PHY_OUTPUT_TIME) + \
 432                         ((2 + 16) * PHY_INPUT_TIME))
 433
 434
 435 /* ---------------- Debug Functions ------------------ */
 436
 437 #ifdef LAN91X_PRINT_REGISTERS
 438 STATIC
 439 VOID
 440 PrintIoRegisters (
 441   IN  LAN91X_DRIVER   *LanDriver
 442   )
 443 {
 444   UINTN   Bank;
 445   UINTN   Offset;
 446   UINT16  Value;
 447
 448   DEBUG ((DEBUG_ERROR, "\nLAN91x I/O Register Dump:\n"));
 449
 450   // Print currrent bank select register
 451   Value = MmioRead16 (LanDriver->IoBase + LAN91X_BANK_OFFSET);
 452   DEBUG ((DEBUG_ERROR, "  BankSel: %d  Bank Register %04x (%d)\n",
 453       LanDriver->BankSel, Value, Value & 0x0007));
 454
 455   // Print all I/O registers
 456   for (Offset = 0; Offset < 0x0e; Offset += 2) {
 457     DEBUG ((DEBUG_ERROR, "  %02x:", Offset));
 458     for (Bank = 0; Bank <= 3; ++Bank) {
 459       DEBUG ((DEBUG_ERROR, "  %04x", ReadIoReg16 (LanDriver, MakeRegister (Bank, Offset))));
 460     }
 461     DEBUG ((DEBUG_ERROR, "\n"));
 462   }
 463 }
 464
 465 STATIC
 466 VOID
 467 PrintPhyRegisters (
 468   IN  LAN91X_DRIVER   *LanDriver
 469   )
 470 {
 471   UINTN   RegNum;
 472
 473   DEBUG ((DEBUG_ERROR, "\nLAN91x Phy %d Register Dump:\n", LanDriver->PhyAd));
 474
 475   // Print all Phy registers
 476   for (RegNum = 0; RegNum <= 5; ++RegNum) {
 477     DEBUG ((DEBUG_ERROR, "  %2d:  %04x\n",
 478            RegNum,
 479            ReadPhyReg16 (LanDriver, RegNum)
 480     ));
 481   }
 482   for (RegNum = 16; RegNum <= 20; ++RegNum) {
 483     DEBUG ((DEBUG_ERROR, "  %2d:  %04x\n",
 484            RegNum,
 485            ReadPhyReg16 (LanDriver, RegNum)
 486     ));
 487   }
 488 }
 489 #endif
 490
 491 #if LAN91X_PRINT_PACKET_HEADERS
 492 STATIC
 493 VOID
 494 PrintIpDgram (
 495   IN  CONST VOID  *DstMac,
 496   IN  CONST VOID  *SrcMac,
 497   IN  CONST VOID  *Proto,
 498   IN  CONST VOID  *IpDgram
 499   )
 500 {
 501   CONST UINT8   *Ptr;
 502   UINT16         SrcPort;
 503   UINT16         DstPort;
 504
 505   Ptr = DstMac;
 506   DEBUG ((DEBUG_ERROR, "  Dst: %02x-%02x-%02x",
 507          Ptr[0], Ptr[1], Ptr[2]));
 508   DEBUG ((DEBUG_ERROR, "-%02x-%02x-%02x",
 509          Ptr[3], Ptr[4], Ptr[5]));
 510
 511   Ptr = SrcMac;
 512   DEBUG ((DEBUG_ERROR, "  Src: %02x-%02x-%02x",
 513          Ptr[0], Ptr[1], Ptr[2]));
 514   DEBUG ((DEBUG_ERROR, "-%02x-%02x-%02x",
 515          Ptr[3], Ptr[4], Ptr[5]));
 516
 517   Ptr = Proto;
 518   DEBUG ((DEBUG_ERROR, "  Proto: %02x%02x\n",
 519          Ptr[0], Ptr[1]));
 520
 521   Ptr = IpDgram;
 522   switch (Ptr[9]) {
 523   case EFI_IP_PROTO_ICMP:
 524     DEBUG ((DEBUG_ERROR, "  ICMP"));
 525     break;
 526   case EFI_IP_PROTO_TCP:
 527     DEBUG ((DEBUG_ERROR, "  TCP"));
 528     break;
 529   case EFI_IP_PROTO_UDP:
 530     DEBUG ((DEBUG_ERROR, "  UDP"));
 531     break;
 532   default:
 533     DEBUG ((DEBUG_ERROR, "  IpProto %d\n", Ptr[9]));
 534     return;
 535   }
 536
 537   DEBUG ((DEBUG_ERROR, "  SrcIp: %d.%d.%d.%d",
 538          Ptr[12], Ptr[13], Ptr[14], Ptr[15]));
 539   DEBUG ((DEBUG_ERROR, "  DstIp: %d.%d.%d.%d",
 540          Ptr[16], Ptr[17], Ptr[18], Ptr[19]));
 541
 542   SrcPort = (Ptr[20] << 8) | Ptr[21];
 543   DstPort = (Ptr[22] << 8) | Ptr[23];
 544   DEBUG ((DEBUG_ERROR, "  SrcPort: %d  DstPort: %d\n", SrcPort, DstPort));
 545 }
 546 #endif
 547
 548
 549 /* ---------------- PHY Management Operations ----------------- */
 550
 551 STATIC
 552 EFI_STATUS
 553 PhyDetect (
 554   IN  LAN91X_DRIVER *LanDriver
 555   )
 556 {
 557   UINT16  PhyId1;
 558   UINT16  PhyId2;
 559
 560   for (LanDriver->PhyAd = 0x1f; LanDriver->PhyAd >= 0 ; --LanDriver->PhyAd) {
 561     PhyId1 = ReadPhyReg16 (LanDriver, PHY_INDEX_ID1);
 562     PhyId2 = ReadPhyReg16 (LanDriver, PHY_INDEX_ID2);
 563
 564     if ((PhyId1 != 0x0000) && (PhyId1 != 0xffff) &&
 565         (PhyId2 != 0x0000) && (PhyId2 != 0xffff)) {
 566       if ((PhyId1 == 0x0016) && ((PhyId2 & 0xfff0) == 0xf840)) {
 567         DEBUG ((DEBUG_ERROR, "LAN91x: PHY type LAN83C183 (LAN91C111 Internal)\n"));
 568       } else if ((PhyId1 == 0x0282) && ((PhyId2 & 0xfff0) == 0x1c50)) {
 569         DEBUG ((DEBUG_ERROR, "LAN91x: PHY type LAN83C180\n"));
 570       } else {
 571         DEBUG ((DEBUG_ERROR, "LAN91x: PHY id %04x:%04x\n", PhyId1, PhyId2));
 572       }
 573       return EFI_SUCCESS;
 574     }
 575   }
 576
 577   DEBUG ((DEBUG_ERROR, "LAN91x: PHY detection failed\n"));
 578   return EFI_NO_MEDIA;
 579 }
 580
 581
 582 // Check the Link Status and take appropriate action
 583 STATIC
 584 BOOLEAN
 585 CheckLinkStatus (
 586   IN  LAN91X_DRIVER *LanDriver
 587   )
 588 {
 589   UINT16  PhyStatus;
 590
 591   // Get the PHY Status
 592   PhyStatus = ReadPhyReg16 (LanDriver, PHY_INDEX_BASIC_STATUS);
 593
 594   return (PhyStatus & PHYSTS_LINK_STS) != 0;
 595 }
 596
 597
 598 // Do auto-negotiation
 599 STATIC
 600 EFI_STATUS
 601 PhyAutoNegotiate (
 602   IN  LAN91X_DRIVER *LanDriver
 603   )
 604 {
 605   UINTN  Retries;
 606   UINT16 PhyControl;
 607   UINT16 PhyStatus;
 608   UINT16 PhyAdvert;
 609
 610   // If there isn't a PHY, don't try to reset it
 611   if (LanDriver->PhyAd == LAN91X_NO_PHY) {
 612     return EFI_SUCCESS;
 613   }
 614
 615   // Next check that auto-negotiation is supported
 616   PhyStatus = ReadPhyReg16 (LanDriver, PHY_INDEX_BASIC_STATUS);
 617   if ((PhyStatus & PHYSTS_AUTO_CAP) == 0) {
 618     return EFI_SUCCESS;
 619   }
 620
 621   // Translate capabilities to advertise
 622   PhyAdvert = PHYANA_CSMA;
 623
 624   if ((PhyStatus & PHYSTS_10BASET_HDPLX) != 0) {
 625     PhyAdvert |= PHYANA_10BASET;
 626   }
 627   if ((PhyStatus & PHYSTS_10BASET_FDPLX) != 0) {
 628     PhyAdvert |= PHYANA_10BASETFD;
 629   }
 630   if ((PhyStatus & PHYSTS_100BASETX_HDPLX) != 0) {
 631     PhyAdvert |= PHYANA_100BASETX;
 632   }
 633   if ((PhyStatus & PHYSTS_100BASETX_FDPLX) != 0) {
 634     PhyAdvert |= PHYANA_100BASETXFD;
 635   }
 636   if ((PhyStatus & PHYSTS_100BASE_T4) != 0) {
 637     PhyAdvert |= PHYANA_100BASET4;
 638   }
 639
 640   // Set the capabilities to advertise
 641   WritePhyReg16 (LanDriver, PHY_INDEX_AUTO_NEG_ADVERT, PhyAdvert);
 642   (VOID) ReadPhyReg16 (LanDriver, PHY_INDEX_AUTO_NEG_ADVERT);
 643
 644   // Restart Auto-Negotiation
 645   PhyControl = ReadPhyReg16 (LanDriver, PHY_INDEX_BASIC_CTRL);
 646   PhyControl &= ~(PHYCR_SPEED_SEL | PHYCR_DUPLEX_MODE);
 647   PhyControl |= PHYCR_AUTO_EN | PHYCR_RST_AUTO;
 648   WritePhyReg16 (LanDriver, PHY_INDEX_BASIC_CTRL, PhyControl);
 649
 650   // Wait up to 2 seconds for the process to complete
 651   Retries = 2000000 / (PHY_READ_TIME + 100);
 652   while ((ReadPhyReg16 (LanDriver, PHY_INDEX_BASIC_STATUS) & PHYSTS_AUTO_COMP) == 0) {
 653     if (--Retries == 0) {
 654       DEBUG ((DEBUG_ERROR, "LAN91x: PHY auto-negotiation timed-out\n"));
 655       return EFI_TIMEOUT;
 656     }
 657     gBS->Stall (100);
 658   }
 659
 660   return EFI_SUCCESS;
 661 }
 662
 663
 664 // Perform PHY software reset
 665 STATIC
 666 EFI_STATUS
 667 PhySoftReset (
 668   IN  LAN91X_DRIVER *LanDriver
 669   )
 670 {
 671   UINTN     Retries;
 672
 673   // If there isn't a PHY, don't try to reset it
 674   if (LanDriver->PhyAd == LAN91X_NO_PHY) {
 675     return EFI_SUCCESS;
 676   }
 677
 678   // Request a PHY reset
 679   WritePhyReg16 (LanDriver, PHY_INDEX_BASIC_CTRL, PHYCR_RESET);
 680
 681   // The internal PHY will reset within 50ms. Allow 100ms.
 682   Retries = 100000 / (PHY_READ_TIME + 100);
 683   while (ReadPhyReg16 (LanDriver, PHY_INDEX_BASIC_CTRL) & PHYCR_RESET) {
 684     if (--Retries == 0) {
 685       DEBUG ((DEBUG_ERROR, "LAN91x: PHY reset timed-out\n"));
 686       return EFI_TIMEOUT;
 687     }
 688     gBS->Stall (100);
 689   }
 690
 691   return EFI_SUCCESS;
 692 }
 693
 694
 695 /* ---------------- General Operations ----------------- */
 696
 697 STATIC
 698 EFI_MAC_ADDRESS
 699 GetCurrentMacAddress (
 700   IN  LAN91X_DRIVER *LanDriver
 701   )
 702 {
 703   UINTN            RegNum;
 704   UINT8           *Addr;
 705   EFI_MAC_ADDRESS  MacAddress;
 706
 707   SetMem (&MacAddress, sizeof(MacAddress), 0);
 708
 709   Addr = &MacAddress.Addr[0];
 710   for (RegNum = LAN91X_IAR0; RegNum <= LAN91X_IAR5; ++RegNum) {
 711     *Addr = ReadIoReg8 (LanDriver, RegNum);
 712     ++Addr;
 713   }
 714
 715   return MacAddress;
 716 }
 717
 718 STATIC
 719 EFI_STATUS
 720 SetCurrentMacAddress (
 721   IN  LAN91X_DRIVER   *LanDriver,
 722   IN  EFI_MAC_ADDRESS *MacAddress
 723   )
 724 {
 725   UINTN            RegNum;
 726   UINT8           *Addr;
 727
 728   Addr = &MacAddress->Addr[0];
 729   for (RegNum = LAN91X_IAR0; RegNum <= LAN91X_IAR5; ++RegNum) {
 730     WriteIoReg8 (LanDriver, RegNum, *Addr);
 731     ++Addr;
 732   }
 733
 734   return EFI_SUCCESS;
 735 }
 736
 737 STATIC
 738 EFI_STATUS
 739 MmuOperation (
 740   IN  LAN91X_DRIVER *LanDriver,
 741   IN  UINTN          MmuOp
 742   )
 743 {
 744   UINTN   Polls;
 745
 746   WriteIoReg16 (LanDriver, LAN91X_MMUCR, MmuOp);
 747   Polls = 100;
 748   while ((ReadIoReg16 (LanDriver, LAN91X_MMUCR) & MMUCR_BUSY) != 0) {
 749     if (--Polls == 0) {
 750       DEBUG ((DEBUG_ERROR, "LAN91x: MMU operation %04x timed-out\n", MmuOp));
 751       return EFI_TIMEOUT;
 752     }
 753     gBS->Stall (LAN91X_STALL);
 754   }
 755
 756   return EFI_SUCCESS;
 757 }
 758
 759 // Read bytes from the DATA register
 760 STATIC
 761 EFI_STATUS
 762 ReadIoData (
 763   IN  LAN91X_DRIVER *LanDriver,
 764   IN  VOID          *Buffer,
 765   IN  UINTN          BufLen
 766   )
 767 {
 768   UINT8     *Ptr;
 769
 770   Ptr = Buffer;
 771   for (; BufLen > 0; --BufLen) {
 772     *Ptr = ReadIoReg8 (LanDriver, LAN91X_DATA0);
 773     ++Ptr;
 774   }
 775
 776   return EFI_SUCCESS;
 777 }
 778
 779 // Write bytes to the DATA register
 780 STATIC
 781 EFI_STATUS
 782 WriteIoData (
 783   IN  LAN91X_DRIVER *LanDriver,
 784   IN  VOID          *Buffer,
 785   IN  UINTN          BufLen
 786   )
 787 {
 788   UINT8     *Ptr;
 789
 790   Ptr = Buffer;
 791   for (; BufLen > 0; --BufLen) {
 792     WriteIoReg8 (LanDriver, LAN91X_DATA0, *Ptr);
 793     ++Ptr;
 794   }
 795
 796   return EFI_SUCCESS;
 797 }
 798
 799 // Disable the interface
 800 STATIC
 801 EFI_STATUS
 802 ChipDisable (
 803   IN  LAN91X_DRIVER *LanDriver
 804   )
 805 {
 806 #ifdef LAN91X_POWER_DOWN
 807   UINT16  Val16;
 808 #endif
 809
 810   // Stop Rx and Tx operations
 811   WriteIoReg16 (LanDriver, LAN91X_RCR, RCR_CLEAR);
 812   WriteIoReg16 (LanDriver, LAN91X_TCR, TCR_CLEAR);
 813
 814 #ifdef LAN91X_POWER_DOWN
 815   // Power-down the chip
 816   Val16 = ReadIoReg16 (LanDriver, LAN91X_CR);
 817   Val16 &= ~CR_EPH_POWER_EN;
 818   WriteIoReg16 (LanDriver, LAN91X_CR, Val16);
 819 #endif
 820
 821   return EFI_SUCCESS;
 822 }
 823
 824 // Enable the interface
 825 STATIC
 826 EFI_STATUS
 827 ChipEnable (
 828   IN  LAN91X_DRIVER *LanDriver
 829   )
 830 {
 831 #ifdef LAN91X_POWER_DOWN
 832   UINT16  Val16;
 833
 834   // Power-up the chip
 835   Val16 = ReadIoReg16 (LanDriver, LAN91X_CR);
 836   Val16 |= CR_EPH_POWER_EN;
 837   WriteIoReg16 (LanDriver, LAN91X_CR, Val16);
 838   gBS->Stall (LAN91X_STALL);
 839 #endif
 840
 841   // Start Rx and Tx operations
 842   WriteIoReg16 (LanDriver, LAN91X_TCR, TCR_DEFAULT);
 843   WriteIoReg16 (LanDriver, LAN91X_RCR, RCR_DEFAULT);
 844
 845   return EFI_SUCCESS;
 846 }
 847
 848
 849 // Perform software reset on the LAN91x
 850 STATIC
 851 EFI_STATUS
 852 SoftReset (
 853   IN  LAN91X_DRIVER   *LanDriver
 854   )
 855 {
 856   UINT16  Val16;
 857
 858   // Issue the reset
 859   WriteIoReg16 (LanDriver, LAN91X_RCR, RCR_SOFT_RST);
 860   gBS->Stall (LAN91X_STALL);
 861   WriteIoReg16 (LanDriver, LAN91X_RCR, RCR_CLEAR);
 862
 863   // Set the configuration register
 864   WriteIoReg16 (LanDriver, LAN91X_CR, CR_DEFAULT);
 865   gBS->Stall (LAN91X_STALL);
 866
 867   // Stop Rx and Tx
 868   WriteIoReg16 (LanDriver, LAN91X_RCR, RCR_CLEAR);
 869   WriteIoReg16 (LanDriver, LAN91X_TCR, TCR_CLEAR);
 870
 871   // Initialize the Control Register
 872   Val16 = ReadIoReg16 (LanDriver, LAN91X_CTR);
 873   Val16 |= CTR_AUTO_REL;
 874   WriteIoReg16 (LanDriver, LAN91X_CTR, Val16);
 875
 876   // Reset the MMU
 877   MmuOperation (LanDriver, MMUCR_OP_RESET_MMU);
 878
 879   return EFI_SUCCESS;
 880 }
 881
 882 /*
 883 **  Probe()
 884 **
 885 **  Validate that there is a LAN91x device.
 886 **
 887 */
 888 STATIC
 889 EFI_STATUS
 890 Probe (
 891   IN  LAN91X_DRIVER   *LanDriver
 892   )
 893 {
 894   UINT16        Bank;
 895   UINT16        Val16;
 896   CHAR16 CONST *ChipId;
 897   UINTN         ResetTime;
 898
 899   // First check that the Bank Select register is valid
 900   Bank = MmioRead16 (LanDriver->IoBase + LAN91X_BANK_OFFSET);
 901   if ((Bank & 0xff00) != 0x3300) {
 902     DEBUG ((DEBUG_ERROR, "LAN91x: signature error: expecting 33xx, read %04x\n", Bank));
 903     return EFI_DEVICE_ERROR;
 904   }
 905
 906   // Try reading the revision register next
 907   LanDriver->BankSel = 0xff;
 908   Val16 = ReadIoReg16 (LanDriver, LAN91X_REV);
 909
 910   Bank = MmioRead16 (LanDriver->IoBase + LAN91X_BANK_OFFSET);
 911   if ((Bank & 0xff03) != 0x3303) {
 912     DEBUG ((DEBUG_ERROR, "LAN91x: signature error: expecting 33x3, read %04x\n", Bank));
 913     return EFI_DEVICE_ERROR;
 914   }
 915
 916   // Validate the revision register
 917   if ((Val16 & 0xff00) != 0x3300) {
 918     DEBUG ((DEBUG_ERROR, "LAN91x: revision error: expecting 33xx, read %04x\n", Val16));
 919     return EFI_DEVICE_ERROR;
 920   }
 921
 922   ChipId = ChipIds[(Val16 >> 4) & 0x0f];
 923   if (ChipId == NULL) {
 924     DEBUG ((DEBUG_ERROR, "LAN91x: unrecognized revision: %04x\n", Val16));
 925     return EFI_DEVICE_ERROR;
 926   }
 927   DEBUG ((DEBUG_ERROR, "LAN91x: detected chip %s rev %d\n", ChipId, Val16 & 0xf));
 928   LanDriver->Revision = Val16 & 0xff;
 929
 930   // Reload from EEPROM to get the hardware MAC address
 931   WriteIoReg16 (LanDriver, LAN91X_CTR, CTR_RESERVED | CTR_RELOAD);
 932   ResetTime = 1000;
 933   while ((ReadIoReg16 (LanDriver, LAN91X_CTR) & CTR_RELOAD) != 0) {
 934     if (--ResetTime == 0) {
 935       DEBUG ((DEBUG_ERROR, "LAN91x: reload from EEPROM timed-out\n"));
 936       WriteIoReg16 (LanDriver, LAN91X_CTR, CTR_RESERVED);
 937       return EFI_DEVICE_ERROR;
 938     }
 939     gBS->Stall (LAN91X_STALL);
 940   }
 941
 942   // Read and save the Permanent MAC Address
 943   LanDriver->SnpMode.PermanentAddress = GetCurrentMacAddress (LanDriver);
 944   LanDriver->SnpMode.CurrentAddress = LanDriver->SnpMode.PermanentAddress;
 945   DEBUG ((DEBUG_ERROR, //DEBUG_NET | DEBUG_INFO,
 946          "LAN91x: HW MAC Address: %02x-%02x-%02x-%02x-%02x-%02x\n",
 947          LanDriver->SnpMode.PermanentAddress.Addr[0],
 948          LanDriver->SnpMode.PermanentAddress.Addr[1],
 949          LanDriver->SnpMode.PermanentAddress.Addr[2],
 950          LanDriver->SnpMode.PermanentAddress.Addr[3],
 951          LanDriver->SnpMode.PermanentAddress.Addr[4],
 952          LanDriver->SnpMode.PermanentAddress.Addr[5]
 953          ));
 954
 955   // Reset the device
 956   SoftReset (LanDriver);
 957
 958   // Try to detect a PHY
 959   if (LanDriver->Revision > (CHIP_91100 << 4)) {
 960     PhyDetect (LanDriver);
 961   } else {
 962     LanDriver->PhyAd = LAN91X_NO_PHY;
 963   }
 964
 965   return EFI_SUCCESS;
 966 }
 967
 968
 969
 970
 971 /*------------------ Simple Network Driver entry point functions ------------------*/
 972
 973 // Refer to the Simple Network Protocol section (21.1)
 974 // in the UEFI 2.3.1 Specification for documentation.
 975
 976 #define ReturnUnlock(s) do { Status = (s); goto exit_unlock; } while(0)
 977
 978
 979 /*
 980 **  UEFI Start() function
 981 **
 982 */
 983 EFI_STATUS
 984 EFIAPI
 985 SnpStart (
 986   IN        EFI_SIMPLE_NETWORK_PROTOCOL* Snp
 987  )
 988 {
 989   EFI_SIMPLE_NETWORK_MODE *Mode;
 990   EFI_TPL                  SavedTpl;
 991   EFI_STATUS               Status;
 992
 993   // Check Snp instance
 994   if (Snp == NULL) {
 995     return EFI_INVALID_PARAMETER;
 996   }
 997
 998   // Serialize access to data and registers
 999   SavedTpl = gBS->RaiseTPL (LAN91X_TPL);
1000   Mode = Snp->Mode;
1001
1002   // Check state of the driver
1003   switch (Mode->State) {
1004   case EfiSimpleNetworkStopped:
1005     break;
1006   case EfiSimpleNetworkStarted:
1007   case EfiSimpleNetworkInitialized:
1008     DEBUG ((DEBUG_WARN, "LAN91x: Driver already started\n"));
1009     ReturnUnlock (EFI_ALREADY_STARTED);
1010   default:
1011     DEBUG ((DEBUG_ERROR, "LAN91x: Driver in an invalid state: %u\n",
1012           (UINTN)Snp->Mode->State));
1013     ReturnUnlock (EFI_DEVICE_ERROR);
1014   }
1015
1016
1017   // Change state
1018   Mode->State = EfiSimpleNetworkStarted;
1019   Status = EFI_SUCCESS;
1020
1021   // Restore TPL and return
1022 exit_unlock:
1023   gBS->RestoreTPL (SavedTpl);
1024   return Status;
1025 }
1026
1027 /*
1028 **  UEFI Stop() function
1029 **
1030 */
1031 EFI_STATUS
1032 EFIAPI
1033 SnpStop (
1034   IN        EFI_SIMPLE_NETWORK_PROTOCOL* Snp
1035   )
1036 {
1037   LAN91X_DRIVER *LanDriver;
1038   EFI_TPL        SavedTpl;
1039   EFI_STATUS     Status;
1040
1041   // Check Snp Instance
1042   if (Snp == NULL) {
1043     return EFI_INVALID_PARAMETER;
1044   }
1045
1046   // Serialize access to data and registers
1047   SavedTpl = gBS->RaiseTPL (LAN91X_TPL);
1048
1049   // Check state of the driver
1050   switch (Snp->Mode->State) {
1051   case EfiSimpleNetworkStarted:
1052   case EfiSimpleNetworkInitialized:
1053     break;
1054   case EfiSimpleNetworkStopped:
1055     DEBUG ((DEBUG_WARN, "LAN91x: Driver not started\n"));
1056     ReturnUnlock (EFI_NOT_STARTED);
1057   default:
1058     DEBUG ((DEBUG_ERROR, "LAN91x: Driver in an invalid state: %u\n",
1059           (UINTN)Snp->Mode->State));
1060     ReturnUnlock (EFI_DEVICE_ERROR);
1061   }
1062
1063   // Find the LanDriver structure
1064   LanDriver = INSTANCE_FROM_SNP_THIS(Snp);
1065
1066   // Stop the Tx and Rx
1067   ChipDisable (LanDriver);
1068
1069   // Change the state
1070   Snp->Mode->State = EfiSimpleNetworkStopped;
1071   Status = EFI_SUCCESS;
1072
1073   // Restore TPL and return
1074 exit_unlock:
1075   gBS->RestoreTPL (SavedTpl);
1076   return Status;
1077 }
1078
1079 /*
1080 **  UEFI Initialize() function
1081 **
1082 */
1083 EFI_STATUS
1084 EFIAPI
1085 SnpInitialize (
1086   IN  EFI_SIMPLE_NETWORK_PROTOCOL* Snp,
1087   IN  UINTN                        RxBufferSize    OPTIONAL,
1088   IN  UINTN                        TxBufferSize    OPTIONAL
1089   )
1090 {
1091   LAN91X_DRIVER *LanDriver;
1092   EFI_TPL        SavedTpl;
1093   EFI_STATUS     Status;
1094
1095   // Check Snp Instance
1096   if (Snp == NULL) {
1097     return EFI_INVALID_PARAMETER;
1098   }
1099
1100   // Serialize access to data and registers
1101   SavedTpl = gBS->RaiseTPL (LAN91X_TPL);
1102
1103   // Check that driver was started but not initialised
1104   switch (Snp->Mode->State) {
1105   case EfiSimpleNetworkStarted:
1106     break;
1107   case EfiSimpleNetworkInitialized:
1108     DEBUG ((DEBUG_WARN, "LAN91x: Driver already initialized\n"));
1109     ReturnUnlock (EFI_SUCCESS);
1110   case EfiSimpleNetworkStopped:
1111     DEBUG ((DEBUG_WARN, "LAN91x: Driver not started\n"));
1112     ReturnUnlock (EFI_NOT_STARTED);
1113   default:
1114     DEBUG ((DEBUG_ERROR, "LAN91x: Driver in an invalid state: %u\n",
1115           (UINTN)Snp->Mode->State));
1116     ReturnUnlock (EFI_DEVICE_ERROR);
1117   }
1118
1119   // Find the LanDriver structure
1120   LanDriver = INSTANCE_FROM_SNP_THIS(Snp);
1121
1122   // Initiate a software reset
1123   Status = SoftReset (LanDriver);
1124   if (EFI_ERROR(Status)) {
1125     DEBUG ((DEBUG_WARN, "LAN91x: Soft reset failed\n"));
1126     ReturnUnlock (EFI_DEVICE_ERROR);
1127   }
1128
1129   // Initiate a PHY reset
1130   if (PhySoftReset (LanDriver) < 0) {
1131     Snp->Mode->State = EfiSimpleNetworkStopped;
1132     DEBUG ((DEBUG_WARN, "LAN91x: PHY soft reset timeout\n"));
1133     ReturnUnlock (EFI_NOT_STARTED);
1134   }
1135
1136   // Do auto-negotiation
1137   Status = PhyAutoNegotiate (LanDriver);
1138   if (EFI_ERROR(Status)) {
1139     DEBUG ((DEBUG_WARN, "LAN91x: PHY auto-negotiation failed\n"));
1140   }
1141
1142   // Enable the receiver and transmitter
1143   ChipEnable (LanDriver);
1144
1145   // Now acknowledge all interrupts
1146   WriteIoReg8 (LanDriver, LAN91X_IST, 0xFF);
1147
1148   // Declare the driver as initialized
1149   Snp->Mode->State = EfiSimpleNetworkInitialized;
1150   Status = EFI_SUCCESS;
1151
1152   // Restore TPL and return
1153 exit_unlock:
1154   gBS->RestoreTPL (SavedTpl);
1155   return Status;
1156 }
1157
1158 /*
1159 **  UEFI Reset () function
1160 **
1161 */
1162 EFI_STATUS
1163 EFIAPI
1164 SnpReset (
1165   IN        EFI_SIMPLE_NETWORK_PROTOCOL* Snp,
1166   IN        BOOLEAN Verification
1167   )
1168 {
1169   LAN91X_DRIVER *LanDriver;
1170   EFI_TPL        SavedTpl;
1171   EFI_STATUS     Status;
1172
1173   // Check Snp Instance
1174   if (Snp == NULL) {
1175     return EFI_INVALID_PARAMETER;
1176   }
1177
1178   // Serialize access to data and registers
1179   SavedTpl = gBS->RaiseTPL (LAN91X_TPL);
1180
1181   // Check that driver was started and initialised
1182   switch (Snp->Mode->State) {
1183   case EfiSimpleNetworkInitialized:
1184     break;
1185   case EfiSimpleNetworkStarted:
1186     DEBUG ((DEBUG_WARN, "LAN91x: Driver not yet initialized\n"));
1187     ReturnUnlock (EFI_DEVICE_ERROR);
1188   case EfiSimpleNetworkStopped:
1189     DEBUG ((DEBUG_WARN, "LAN91x: Driver not started\n"));
1190     ReturnUnlock (EFI_NOT_STARTED);
1191   default:
1192     DEBUG ((DEBUG_ERROR, "LAN91x: Driver in an invalid state: %u\n",
1193           (UINTN)Snp->Mode->State));
1194     ReturnUnlock (EFI_DEVICE_ERROR);
1195   }
1196
1197   // Find the LanDriver structure
1198   LanDriver = INSTANCE_FROM_SNP_THIS(Snp);
1199
1200   // Initiate a software reset
1201   if (EFI_ERROR (SoftReset (LanDriver))) {
1202     DEBUG ((DEBUG_WARN, "LAN91x: Soft reset failed\n"));
1203     ReturnUnlock (EFI_DEVICE_ERROR);
1204   }
1205
1206   // Initiate a PHY reset
1207   if (EFI_ERROR (PhySoftReset (LanDriver))) {
1208     DEBUG ((DEBUG_WARN, "LAN91x: PHY soft reset failed\n"));
1209     ReturnUnlock (EFI_DEVICE_ERROR);
1210   }
1211
1212   // Enable the receiver and transmitter
1213   Status = ChipEnable (LanDriver);
1214
1215   // Restore TPL and return
1216 exit_unlock:
1217   gBS->RestoreTPL (SavedTpl);
1218   return Status;
1219 }
1220
1221 /*
1222 **  UEFI Shutdown () function
1223 **
1224 */
1225 EFI_STATUS
1226 EFIAPI
1227 SnpShutdown (
1228   IN        EFI_SIMPLE_NETWORK_PROTOCOL* Snp
1229   )
1230 {
1231   LAN91X_DRIVER *LanDriver;
1232   EFI_TPL        SavedTpl;
1233   EFI_STATUS     Status;
1234
1235   // Check Snp Instance
1236   if (Snp == NULL) {
1237     return EFI_INVALID_PARAMETER;
1238   }
1239
1240   // Serialize access to data and registers
1241   SavedTpl = gBS->RaiseTPL (LAN91X_TPL);
1242
1243   // First check that driver has already been initialized
1244   switch (Snp->Mode->State) {
1245   case EfiSimpleNetworkInitialized:
1246     break;
1247   case EfiSimpleNetworkStarted:
1248     DEBUG ((DEBUG_WARN, "LAN91x: Driver not yet initialized\n"));
1249     ReturnUnlock (EFI_DEVICE_ERROR);
1250   case EfiSimpleNetworkStopped:
1251     DEBUG ((DEBUG_WARN, "LAN91x: Driver in stopped state\n"));
1252     ReturnUnlock (EFI_NOT_STARTED);
1253   default:
1254     DEBUG ((DEBUG_ERROR, "LAN91x: Driver in an invalid state: %u\n",
1255           (UINTN)Snp->Mode->State));
1256     ReturnUnlock (EFI_DEVICE_ERROR);
1257   }
1258
1259   // Find the LanDriver structure
1260   LanDriver = INSTANCE_FROM_SNP_THIS(Snp);
1261
1262   // Disable the interface
1263   Status = ChipDisable (LanDriver);
1264
1265   // Restore TPL and return
1266 exit_unlock:
1267   gBS->RestoreTPL (SavedTpl);
1268   return Status;
1269 }
1270
1271
1272 /*
1273 **  UEFI ReceiveFilters() function
1274 **
1275 */
1276 EFI_STATUS
1277 EFIAPI
1278 SnpReceiveFilters (
1279   IN        EFI_SIMPLE_NETWORK_PROTOCOL* Snp,
1280   IN        UINT32 Enable,
1281   IN        UINT32 Disable,
1282   IN        BOOLEAN Reset,
1283   IN        UINTN NumMfilter          OPTIONAL,
1284   IN        EFI_MAC_ADDRESS *Mfilter  OPTIONAL
1285   )
1286 {
1287 #define MCAST_HASH_BYTES  8
1288
1289   LAN91X_DRIVER           *LanDriver;
1290   EFI_SIMPLE_NETWORK_MODE *SnpMode;
1291   EFI_TPL        SavedTpl;
1292   EFI_STATUS     Status;
1293   UINTN          i;
1294   UINT32         Crc;
1295   UINT16         RcvCtrl;
1296   UINT8          McastHash[MCAST_HASH_BYTES];
1297
1298   // Check Snp Instance
1299   if (Snp == NULL) {
1300     return EFI_INVALID_PARAMETER;
1301   }
1302
1303   // Serialize access to data and registers
1304   SavedTpl = gBS->RaiseTPL (LAN91X_TPL);
1305
1306   // First check that driver has already been initialized
1307   switch (Snp->Mode->State) {
1308   case EfiSimpleNetworkInitialized:
1309     break;
1310   case EfiSimpleNetworkStarted:
1311     DEBUG ((DEBUG_WARN, "LAN91x: Driver not yet initialized\n"));
1312     ReturnUnlock (EFI_DEVICE_ERROR);
1313   case EfiSimpleNetworkStopped:
1314     DEBUG ((DEBUG_WARN, "LAN91x: Driver not started\n"));
1315     ReturnUnlock (EFI_NOT_STARTED);
1316   default:
1317     DEBUG ((DEBUG_ERROR, "LAN91x: Driver in an invalid state: %u\n",
1318           (UINTN)Snp->Mode->State));
1319     ReturnUnlock (EFI_DEVICE_ERROR);
1320   }
1321
1322   // Find the LanDriver structure
1323   LanDriver = INSTANCE_FROM_SNP_THIS(Snp);
1324   SnpMode = Snp->Mode;
1325
1326 #ifdef LAN91X_PRINT_RECEIVE_FILTERS
1327   DEBUG ((DEBUG_ERROR, "LAN91x:SnpReceiveFilters()\n"));
1328   DEBUG ((DEBUG_ERROR, "  Enable     = %08x\n", Enable));
1329   DEBUG ((DEBUG_ERROR, "  Disable    = %08x\n", Disable));
1330   DEBUG ((DEBUG_ERROR, "  Reset      = %d\n",  Reset));
1331   DEBUG ((DEBUG_ERROR, "  NumMfilter = %d\n",  NumMfilter));
1332   for (i = 0; i < NumMfilter; ++i) {
1333     DEBUG ((DEBUG_ERROR,
1334            "    [%2d] = %02x-%02x-%02x-%02x-%02x-%02x\n",
1335            i,
1336            Mfilter[i].Addr[0],
1337            Mfilter[i].Addr[1],
1338            Mfilter[i].Addr[2],
1339            Mfilter[i].Addr[3],
1340            Mfilter[i].Addr[4],
1341            Mfilter[i].Addr[5]));
1342   }
1343 #endif
1344
1345   // Update the Multicast Hash registers
1346   if (Reset) {
1347     // Clear the hash table
1348     SetMem (McastHash, MCAST_HASH_BYTES, 0);
1349     SnpMode->MCastFilterCount = 0;
1350   } else {
1351     // Read the current hash table
1352     for (i = 0; i < MCAST_HASH_BYTES; ++i) {
1353       McastHash[i] = ReadIoReg8 (LanDriver, LAN91X_MT0 + i);
1354     }
1355     // Set the new additions
1356     for (i = 0; i < NumMfilter; ++i) {
1357       Crc = MulticastHash (&Mfilter[i], NET_ETHER_ADDR_LEN);
1358       McastHash[(Crc >> 29) & 0x3] |= 1 << ((Crc >> 26) & 0x3);
1359     }
1360     SnpMode->MCastFilterCount = NumMfilter;
1361   }
1362   // If the hash registers need updating, write them
1363   if (Reset || NumMfilter > 0) {
1364     for (i = 0; i < MCAST_HASH_BYTES; ++i) {
1365       WriteIoReg8 (LanDriver, LAN91X_MT0 + i, McastHash[i]);
1366     }
1367   }
1368
1369   RcvCtrl = ReadIoReg16 (LanDriver, LAN91X_RCR);
1370   if ((Enable & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS) != 0) {
1371     RcvCtrl |= RCR_PRMS;
1372     SnpMode->ReceiveFilterSetting |= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS;
1373   }
1374   if ((Disable & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS) != 0) {
1375     RcvCtrl &= ~RCR_PRMS;
1376     SnpMode->ReceiveFilterSetting &= ~EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS;
1377   }
1378
1379   if ((Enable & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST) != 0) {
1380     RcvCtrl |= RCR_ALMUL;
1381     SnpMode->ReceiveFilterSetting |= EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST;
1382   }
1383   if ((Disable & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST) != 0) {
1384     RcvCtrl &= ~RCR_ALMUL;
1385     SnpMode->ReceiveFilterSetting &= ~EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST;
1386   }
1387   WriteIoReg16 (LanDriver, LAN91X_RCR, RcvCtrl);
1388
1389   Status = SetCurrentMacAddress (LanDriver, &SnpMode->CurrentAddress);
1390
1391   // Restore TPL and return
1392 exit_unlock:
1393   gBS->RestoreTPL (SavedTpl);
1394   return Status;
1395 }
1396
1397 /*
1398 **  UEFI StationAddress() function
1399 **
1400 */
1401 EFI_STATUS
1402 EFIAPI
1403 SnpStationAddress (
1404   IN        EFI_SIMPLE_NETWORK_PROTOCOL *Snp,
1405   IN        BOOLEAN Reset,
1406   IN        EFI_MAC_ADDRESS *NewMac
1407 )
1408 {
1409   LAN91X_DRIVER *LanDriver;
1410   EFI_TPL        SavedTpl;
1411   EFI_STATUS     Status;
1412
1413   // Check Snp instance
1414   if (Snp == NULL) {
1415     return EFI_INVALID_PARAMETER;
1416   }
1417
1418   // Serialize access to data and registers
1419   SavedTpl = gBS->RaiseTPL (LAN91X_TPL);
1420
1421   // Check that driver was started and initialised
1422   switch (Snp->Mode->State) {
1423   case EfiSimpleNetworkInitialized:
1424     break;
1425   case EfiSimpleNetworkStarted:
1426     DEBUG ((DEBUG_WARN, "LAN91x: Driver not yet initialized\n"));
1427     ReturnUnlock (EFI_DEVICE_ERROR);
1428   case EfiSimpleNetworkStopped:
1429     DEBUG ((DEBUG_WARN, "LAN91x: Driver not started\n"));
1430     ReturnUnlock (EFI_NOT_STARTED);
1431   default:
1432     DEBUG ((DEBUG_ERROR, "LAN91x: Driver in an invalid state: %u\n",
1433           (UINTN)Snp->Mode->State));
1434     ReturnUnlock (EFI_DEVICE_ERROR);
1435   }
1436
1437   // Find the LanDriver structure
1438   LanDriver = INSTANCE_FROM_SNP_THIS(Snp);
1439
1440   if (Reset) {
1441     Snp->Mode->CurrentAddress = Snp->Mode->PermanentAddress;
1442   } else {
1443     if (NewMac == NULL) {
1444       ReturnUnlock (EFI_INVALID_PARAMETER);
1445     }
1446     Snp->Mode->CurrentAddress = *NewMac;
1447   }
1448
1449   Status = SetCurrentMacAddress (LanDriver, &Snp->Mode->CurrentAddress);
1450
1451   // Restore TPL and return
1452 exit_unlock:
1453   gBS->RestoreTPL (SavedTpl);
1454   return Status;
1455 }
1456
1457 /*
1458 **  UEFI Statistics() function
1459 **
1460 */
1461 EFI_STATUS
1462 EFIAPI
1463 SnpStatistics (
1464   IN        EFI_SIMPLE_NETWORK_PROTOCOL* Snp,
1465   IN        BOOLEAN Reset,
1466   IN  OUT   UINTN *StatSize,
1467       OUT   EFI_NETWORK_STATISTICS *Statistics
1468   )
1469 {
1470   LAN91X_DRIVER *LanDriver;
1471   EFI_TPL        SavedTpl;
1472   EFI_STATUS     Status;
1473
1474   // Check Snp instance
1475   if (Snp == NULL) {
1476     return EFI_INVALID_PARAMETER;
1477   }
1478
1479   // Check pointless condition
1480   if ((!Reset) && (StatSize == NULL) && (Statistics == NULL)) {
1481     return EFI_SUCCESS;
1482   }
1483
1484   // Check the parameters
1485   if ((StatSize == NULL) && (Statistics != NULL)) {
1486     return EFI_INVALID_PARAMETER;
1487   }
1488
1489   // Serialize access to data and registers
1490   SavedTpl = gBS->RaiseTPL (LAN91X_TPL);
1491
1492   // Check that driver was started and initialised
1493   switch (Snp->Mode->State) {
1494   case EfiSimpleNetworkInitialized:
1495     break;
1496   case EfiSimpleNetworkStarted:
1497     DEBUG ((DEBUG_WARN, "LAN91x: Driver not yet initialized\n"));
1498     ReturnUnlock (EFI_DEVICE_ERROR);
1499   case EfiSimpleNetworkStopped:
1500     DEBUG ((DEBUG_WARN, "LAN91x: Driver not started\n"));
1501     ReturnUnlock (EFI_NOT_STARTED);
1502   default:
1503     DEBUG ((DEBUG_ERROR, "LAN91x: Driver in an invalid state: %u\n",
1504           (UINTN)Snp->Mode->State));
1505     ReturnUnlock (EFI_DEVICE_ERROR);
1506   }
1507
1508   // Find the LanDriver structure
1509   LanDriver = INSTANCE_FROM_SNP_THIS(Snp);
1510
1511   // Do a reset if required
1512   if (Reset) {
1513     ZeroMem (&LanDriver->Stats, sizeof(EFI_NETWORK_STATISTICS));
1514   }
1515
1516   // Check buffer size
1517   if (*StatSize < sizeof(EFI_NETWORK_STATISTICS)) {
1518     *StatSize = sizeof(EFI_NETWORK_STATISTICS);
1519     ReturnUnlock (EFI_BUFFER_TOO_SMALL);
1520     goto exit_unlock;
1521   }
1522
1523   // Fill in the statistics
1524   CopyMem(&Statistics, &LanDriver->Stats, sizeof(EFI_NETWORK_STATISTICS));
1525   Status = EFI_SUCCESS;
1526
1527   // Restore TPL and return
1528 exit_unlock:
1529   gBS->RestoreTPL (SavedTpl);
1530   return Status;
1531 }
1532
1533 /*
1534 **  UEFI MCastIPtoMAC() function
1535 **
1536 */
1537 EFI_STATUS
1538 EFIAPI
1539 SnpMcastIptoMac (
1540   IN        EFI_SIMPLE_NETWORK_PROTOCOL* Snp,
1541   IN        BOOLEAN IsIpv6,
1542   IN        EFI_IP_ADDRESS *Ip,
1543       OUT   EFI_MAC_ADDRESS *McastMac
1544   )
1545 {
1546   // Check Snp instance
1547   if (Snp == NULL) {
1548     return EFI_INVALID_PARAMETER;
1549   }
1550
1551   // Check parameters
1552   if ((McastMac == NULL) || (Ip == NULL)) {
1553     return EFI_INVALID_PARAMETER;
1554   }
1555
1556   // Make sure MAC address is empty
1557   ZeroMem (McastMac, sizeof(EFI_MAC_ADDRESS));
1558
1559   // If we need ipv4 address
1560   if (!IsIpv6) {
1561     // Most significant 25 bits of a multicast HW address are set
1562     McastMac->Addr[0] = 0x01;
1563     McastMac->Addr[1] = 0x00;
1564     McastMac->Addr[2] = 0x5E;
1565
1566     // Lower 23 bits from ipv4 address
1567     McastMac->Addr[3] = (Ip->v4.Addr[1] & 0x7F); // Clear the ms bit (25th bit of MAC must be 0)
1568     McastMac->Addr[4] = Ip->v4.Addr[2];
1569     McastMac->Addr[5] = Ip->v4.Addr[3];
1570   } else {
1571     // Most significant 16 bits of multicast v6 HW address are set
1572     McastMac->Addr[0] = 0x33;
1573     McastMac->Addr[1] = 0x33;
1574
1575     // lower four octets are taken from ipv6 address
1576     McastMac->Addr[2] = Ip->v6.Addr[8];
1577     McastMac->Addr[3] = Ip->v6.Addr[9];
1578     McastMac->Addr[4] = Ip->v6.Addr[10];
1579     McastMac->Addr[5] = Ip->v6.Addr[11];
1580   }
1581
1582   return EFI_SUCCESS;
1583 }
1584
1585 /*
1586 **  UEFI NvData() function
1587 **
1588 */
1589 EFI_STATUS
1590 EFIAPI
1591 SnpNvData (
1592   IN        EFI_SIMPLE_NETWORK_PROTOCOL* pobj,
1593   IN        BOOLEAN read_write,
1594   IN        UINTN offset,
1595   IN        UINTN buff_size,
1596   IN  OUT   VOID *data
1597   )
1598 {
1599   DEBUG ((DEBUG_ERROR, "LAN91x: Non-volatile storage not supported\n"));
1600
1601   return EFI_UNSUPPORTED;
1602 }
1603
1604
1605 /*
1606 **  UEFI GetStatus () function
1607 **
1608 */
1609 EFI_STATUS
1610 EFIAPI
1611 SnpGetStatus (
1612   IN        EFI_SIMPLE_NETWORK_PROTOCOL *Snp,
1613       OUT   UINT32   *IrqStat   OPTIONAL,
1614       OUT   VOID    **TxBuff    OPTIONAL
1615   )
1616 {
1617   LAN91X_DRIVER         *LanDriver;
1618   EFI_TPL               SavedTpl;
1619   EFI_STATUS            Status;
1620   BOOLEAN               MediaPresent;
1621   UINT8                 IstReg;
1622   MSK_LINKED_SYSTEM_BUF *LinkedTXRecycleBuff;
1623
1624   // Check preliminaries
1625   if (Snp == NULL) {
1626     return EFI_INVALID_PARAMETER;
1627   }
1628
1629   // Serialize access to data and registers
1630   SavedTpl = gBS->RaiseTPL (LAN91X_TPL);
1631
1632   // Check that driver was started and initialised
1633   switch (Snp->Mode->State) {
1634   case EfiSimpleNetworkInitialized:
1635     break;
1636   case EfiSimpleNetworkStarted:
1637     DEBUG ((DEBUG_WARN, "LAN91x: Driver not yet initialized\n"));
1638     ReturnUnlock (EFI_DEVICE_ERROR);
1639   case EfiSimpleNetworkStopped:
1640     DEBUG ((DEBUG_WARN, "LAN91x: Driver not started\n"));
1641     ReturnUnlock (EFI_NOT_STARTED);
1642   default:
1643     DEBUG ((DEBUG_ERROR, "LAN91x: Driver in an invalid state: %u\n",
1644           (UINTN)Snp->Mode->State));
1645     ReturnUnlock (EFI_DEVICE_ERROR);
1646   }
1647
1648   // Find the LanDriver structure
1649   LanDriver = INSTANCE_FROM_SNP_THIS(Snp);
1650
1651   // Arbitrarily set the interrupt status to 0
1652   if (IrqStat != NULL) {
1653     *IrqStat = 0;
1654     IstReg = ReadIoReg8 (LanDriver, LAN91X_IST);
1655     if ((IstReg & IST_RCV) != 0) {
1656       *IrqStat |= EFI_SIMPLE_NETWORK_RECEIVE_INTERRUPT;
1657     }
1658     if ((IstReg & IST_TX) != 0) {
1659       *IrqStat |= EFI_SIMPLE_NETWORK_TRANSMIT_INTERRUPT;
1660     }
1661   }
1662
1663   // Pass back the completed buffer address
1664   // The transmit buffer status is not read when TxBuf is NULL
1665   if (TxBuff != NULL) {
1666     *((UINT8 **) TxBuff) = (UINT8 *) 0;
1667     if( !IsListEmpty (&LanDriver->TransmitQueueHead))
1668     {
1669       LinkedTXRecycleBuff = CR (GetFirstNode (&LanDriver->TransmitQueueHead), MSK_LINKED_SYSTEM_BUF, Link, TX_MBUF_SIGNATURE);
1670       if(LinkedTXRecycleBuff != NULL) {
1671         *TxBuff = LinkedTXRecycleBuff->SystemBuf.Buf;
1672         RemoveEntryList (&LinkedTXRecycleBuff->Link);
1673         FreePool (LinkedTXRecycleBuff);
1674       }
1675     }
1676   }
1677
1678   // Update the media status
1679   MediaPresent = CheckLinkStatus (LanDriver);
1680   if (MediaPresent != Snp->Mode->MediaPresent) {
1681     DEBUG ((DEBUG_WARN, "LAN91x: Link %s\n", MediaPresent ? L"up" : L"down"));
1682   }
1683   Snp->Mode->MediaPresent = MediaPresent;
1684   Status = EFI_SUCCESS;
1685
1686   // Restore TPL and return
1687 exit_unlock:
1688   gBS->RestoreTPL (SavedTpl);
1689   return Status;
1690 }
1691
1692
1693 /*
1694 **  UEFI Transmit() function
1695 **
1696 */
1697 EFI_STATUS
1698 EFIAPI
1699 SnpTransmit (
1700   IN        EFI_SIMPLE_NETWORK_PROTOCOL *Snp,
1701   IN        UINTN            HdrSize,
1702   IN        UINTN            BufSize,
1703   IN        VOID            *BufAddr,
1704   IN        EFI_MAC_ADDRESS *SrcAddr    OPTIONAL,
1705   IN        EFI_MAC_ADDRESS *DstAddr    OPTIONAL,
1706   IN        UINT16          *Protocol   OPTIONAL
1707   )
1708 {
1709   LAN91X_DRIVER   *LanDriver;
1710   EFI_TPL          SavedTpl;
1711   EFI_STATUS       Status;
1712   UINT8           *Ptr;
1713   UINTN            Len;
1714   UINTN            MmuPages;
1715   UINTN            Retries;
1716   UINT16           Proto;
1717   UINT8            PktNum;
1718   MSK_LINKED_SYSTEM_BUF   *LinkedTXRecycleBuff;
1719
1720
1721   // Check preliminaries
1722   if ((Snp == NULL) || (BufAddr == NULL)) {
1723     DEBUG ((DEBUG_ERROR, "LAN91x: SnpTransmit(): NULL Snp (%p) or BufAddr (%p)\n",
1724         Snp, BufAddr));
1725     return EFI_INVALID_PARAMETER;
1726   }
1727
1728   // Serialize access to data and registers
1729   SavedTpl = gBS->RaiseTPL (LAN91X_TPL);
1730
1731   // Check that driver was started and initialised
1732   switch (Snp->Mode->State) {
1733   case EfiSimpleNetworkInitialized:
1734     break;
1735   case EfiSimpleNetworkStarted:
1736     DEBUG ((DEBUG_WARN, "LAN91x: Driver not yet initialized\n"));
1737     ReturnUnlock (EFI_DEVICE_ERROR);
1738   case EfiSimpleNetworkStopped:
1739     DEBUG ((DEBUG_WARN, "LAN91x: Driver not started\n"));
1740     ReturnUnlock (EFI_NOT_STARTED);
1741   default:
1742     DEBUG ((DEBUG_ERROR, "LAN91x: Driver in an invalid state: %u\n",
1743           (UINTN)Snp->Mode->State));
1744     ReturnUnlock (EFI_DEVICE_ERROR);
1745   }
1746
1747   // Find the LanDriver structure
1748   LanDriver = INSTANCE_FROM_SNP_THIS(Snp);
1749
1750   // Ensure header is correct size if non-zero
1751   if (HdrSize != 0) {
1752     if (HdrSize != Snp->Mode->MediaHeaderSize) {
1753       DEBUG ((DEBUG_ERROR, "LAN91x: SnpTransmit(): Invalid HdrSize %d\n", HdrSize));
1754       ReturnUnlock (EFI_INVALID_PARAMETER);
1755     }
1756
1757     if ((DstAddr == NULL) || (Protocol == NULL)) {
1758       DEBUG ((DEBUG_ERROR, "LAN91x: SnpTransmit(): NULL DstAddr %p or Protocol %p\n",
1759           DstAddr, Protocol));
1760       ReturnUnlock (EFI_INVALID_PARAMETER);
1761     }
1762   }
1763
1764   // Before transmitting check the link status
1765   if (!Snp->Mode->MediaPresent) {
1766     DEBUG ((DEBUG_WARN, "LAN91x: SnpTransmit(): Link not ready\n"));
1767     ReturnUnlock (EFI_NOT_READY);
1768   }
1769
1770   // Calculate the request size in 256-byte "pages" minus 1
1771   // The 91C111 ignores this, but some older devices need it.
1772   MmuPages = ((BufSize & ~1) + LAN91X_PKT_OVERHEAD - 1) >> 8;
1773   if (MmuPages > 7) {
1774     DEBUG ((DEBUG_WARN, "LAN91x: Tx buffer too large (%d bytes)\n", BufSize));
1775     LanDriver->Stats.TxOversizeFrames += 1;
1776     LanDriver->Stats.TxDroppedFrames += 1;
1777     ReturnUnlock (EFI_BAD_BUFFER_SIZE);
1778   }
1779
1780   // Request allocation of a transmit buffer
1781   Status = MmuOperation (LanDriver, MMUCR_OP_TX_ALLOC | MmuPages);
1782   if (EFI_ERROR (Status)) {
1783     DEBUG ((DEBUG_ERROR, "LAN91x: Tx buffer request failure: %d\n", Status));
1784     ReturnUnlock (EFI_DEVICE_ERROR);
1785   }
1786
1787   // Wait for allocation request completion
1788   Retries = LAN91X_MEMORY_ALLOC_POLLS;
1789   while ((ReadIoReg8 (LanDriver, LAN91X_IST) & IST_ALLOC) == 0) {
1790     if (--Retries == 0) {
1791       DEBUG ((DEBUG_ERROR, "LAN91x: Tx buffer allocation timeout\n"));
1792       ReturnUnlock (EFI_TIMEOUT);
1793     }
1794   }
1795
1796   // Check for successful allocation
1797   PktNum = ReadIoReg8 (LanDriver, LAN91X_ARR);
1798   if ((PktNum & ARR_FAILED) != 0) {
1799     DEBUG ((DEBUG_ERROR, "LAN91x: Tx buffer allocation failure: %02x\n", PktNum));
1800     ReturnUnlock (EFI_NOT_READY);
1801   }
1802   PktNum &= ARR_PACKET;
1803
1804   // Check for the nature of the frame
1805   // If no destination address, it's ARP broadcast
1806   if(DstAddr != NULL)
1807   {
1808     if (DstAddr->Addr[0] == 0xFF) {
1809       LanDriver->Stats.TxBroadcastFrames += 1;
1810     } else if ((DstAddr->Addr[0] & 0x1) == 1) {
1811       LanDriver->Stats.TxMulticastFrames += 1;
1812     } else {
1813       LanDriver->Stats.TxUnicastFrames += 1;
1814     }
1815   } else {
1816     LanDriver->Stats.TxBroadcastFrames += 1;
1817   }
1818
1819   // Set the Packet Number and Pointer registers
1820   WriteIoReg8 (LanDriver, LAN91X_PNR, PktNum);
1821   WriteIoReg16 (LanDriver, LAN91X_PTR, PTR_AUTO_INCR);
1822
1823   // Set up mutable buffer information variables
1824   Ptr = BufAddr;
1825   Len = BufSize;
1826
1827   // Write Status and Byte Count first
1828   WriteIoReg16 (LanDriver, LAN91X_DATA0, 0);
1829   WriteIoReg16 (LanDriver, LAN91X_DATA0, (Len + LAN91X_PKT_OVERHEAD) & BCW_COUNT);
1830
1831   // This packet may come with a preconfigured Ethernet header.
1832   // If not, we need to construct one from optional parameters.
1833   if (HdrSize) {
1834
1835     // Write the destination address
1836     WriteIoData (LanDriver, DstAddr, NET_ETHER_ADDR_LEN);
1837
1838     // Write the Source Address
1839     if (SrcAddr != NULL) {
1840       WriteIoData (LanDriver, SrcAddr, NET_ETHER_ADDR_LEN);
1841     } else {
1842       WriteIoData (LanDriver, &LanDriver->SnpMode.CurrentAddress, NET_ETHER_ADDR_LEN);
1843     }
1844
1845     // Write the Protocol word
1846     Proto = HTONS (*Protocol);
1847     WriteIoReg16 (LanDriver, LAN91X_DATA0, Proto);
1848
1849     // Adjust the data start and length
1850     Ptr += sizeof(ETHER_HEAD);
1851     Len -= sizeof(ETHER_HEAD);
1852   }
1853
1854   // Copy the remainder data buffer, except the odd byte
1855   WriteIoData (LanDriver, Ptr, Len & ~1);
1856   Ptr += Len & ~1;
1857   Len &= 1;
1858
1859   // Write the Packet Control Word and odd byte
1860   WriteIoReg16 (LanDriver, LAN91X_DATA0,
1861       (Len != 0) ? (PCW_ODD | PCW_CRC | *Ptr) : PCW_CRC);
1862
1863   // Release the packet for transmission
1864   Status = MmuOperation (LanDriver, MMUCR_OP_TX_PUSH);
1865   if (EFI_ERROR (Status)) {
1866     DEBUG ((DEBUG_ERROR, "LAN91x: Tx buffer release failure: %d\n", Status));
1867     ReturnUnlock (EFI_DEVICE_ERROR);
1868   }
1869
1870   // Update the Tx statistics
1871   LanDriver->Stats.TxTotalBytes += BufSize;
1872   LanDriver->Stats.TxGoodFrames += 1;
1873
1874   // Update the Tx Buffer cache
1875   LinkedTXRecycleBuff = AllocateZeroPool (sizeof (MSK_LINKED_SYSTEM_BUF));
1876   if (LinkedTXRecycleBuff == NULL) {
1877     return EFI_OUT_OF_RESOURCES;
1878   }
1879   LinkedTXRecycleBuff->Signature = TX_MBUF_SIGNATURE;
1880   //
1881   // Add the passed Buffer to the transmit queue. Don't copy.
1882   //
1883   LinkedTXRecycleBuff->SystemBuf.Buf = BufAddr;
1884   LinkedTXRecycleBuff->SystemBuf.Length = BufSize;
1885   InsertTailList (&LanDriver->TransmitQueueHead, &LinkedTXRecycleBuff->Link);
1886
1887   Status = EFI_SUCCESS;
1888
1889   // Dump the packet header
1890 #if LAN91X_PRINT_PACKET_HEADERS
1891   Ptr = BufAddr;
1892   DEBUG ((DEBUG_ERROR, "LAN91X:SnpTransmit()\n"));
1893   DEBUG ((DEBUG_ERROR, "  HdrSize: %d, SrcAddr: %p, Length: %d, Last byte: %02x\n",
1894          HdrSize, SrcAddr, BufSize, Ptr[BufSize - 1]));
1895   PrintIpDgram (
1896       (HdrSize == 0) ? (EFI_MAC_ADDRESS *)&Ptr[0] : DstAddr,
1897       (HdrSize == 0) ? (EFI_MAC_ADDRESS *)&Ptr[6] : (SrcAddr != NULL) ? SrcAddr : &LanDriver->SnpMode.CurrentAddress,
1898       (HdrSize == 0) ? (UINT16 *)&Ptr[12] : &Proto,
1899       &Ptr[14]
1900       );
1901 #endif
1902
1903   // Restore TPL and return
1904 exit_unlock:
1905   gBS->RestoreTPL (SavedTpl);
1906   return Status;
1907 }
1908
1909
1910 /*
1911 **  UEFI Receive() function
1912 **
1913 */
1914 EFI_STATUS
1915 EFIAPI
1916 SnpReceive (
1917   IN        EFI_SIMPLE_NETWORK_PROTOCOL *Snp,
1918       OUT   UINTN           *HdrSize      OPTIONAL,
1919   IN  OUT   UINTN           *BuffSize,
1920       OUT   VOID            *Data,
1921       OUT   EFI_MAC_ADDRESS *SrcAddr      OPTIONAL,
1922       OUT   EFI_MAC_ADDRESS *DstAddr      OPTIONAL,
1923       OUT   UINT16 *Protocol              OPTIONAL
1924   )
1925 {
1926   EFI_TPL        SavedTpl;
1927   EFI_STATUS     Status;
1928   LAN91X_DRIVER *LanDriver;
1929   UINT8         *DataPtr;
1930   UINT16         PktStatus;
1931   UINT16         PktLength;
1932   UINT16         PktControl;
1933   UINT8          IstReg;
1934
1935   // Check preliminaries
1936   if ((Snp == NULL) || (Data == NULL)) {
1937     return EFI_INVALID_PARAMETER;
1938   }
1939
1940   // Serialize access to data and registers
1941   SavedTpl = gBS->RaiseTPL (LAN91X_TPL);
1942
1943   // Check that driver was started and initialised
1944   switch (Snp->Mode->State) {
1945   case EfiSimpleNetworkInitialized:
1946     break;
1947   case EfiSimpleNetworkStarted:
1948     DEBUG ((DEBUG_WARN, "LAN91x: Driver not yet initialized\n"));
1949     ReturnUnlock (EFI_DEVICE_ERROR);
1950   case EfiSimpleNetworkStopped:
1951     DEBUG ((DEBUG_WARN, "LAN91x: Driver not started\n"));
1952     ReturnUnlock (EFI_NOT_STARTED);
1953   default:
1954     DEBUG ((DEBUG_ERROR, "LAN91x: Driver in an invalid state: %u\n",
1955           (UINTN)Snp->Mode->State));
1956     ReturnUnlock (EFI_DEVICE_ERROR);
1957   }
1958
1959   // Find the LanDriver structure
1960   LanDriver = INSTANCE_FROM_SNP_THIS(Snp);
1961
1962   // Check for Rx Overrun
1963   IstReg = ReadIoReg8 (LanDriver, LAN91X_IST);
1964   if ((IstReg & IST_RX_OVRN) != 0) {
1965     LanDriver->Stats.RxTotalFrames += 1;
1966     LanDriver->Stats.RxDroppedFrames += 1;
1967     WriteIoReg8 (LanDriver, LAN91X_IST, IST_RX_OVRN);
1968     DEBUG ((DEBUG_WARN, "LAN91x: Receiver overrun\n"));
1969   }
1970
1971   // Check for Rx data available
1972   if ((IstReg & IST_RCV) == 0) {
1973     ReturnUnlock (EFI_NOT_READY);
1974   }
1975
1976   // Configure the PTR register for reading
1977   WriteIoReg16 (LanDriver, LAN91X_PTR, PTR_RCV | PTR_AUTO_INCR | PTR_READ);
1978
1979   // Read the Packet Status and Packet Length words
1980   PktStatus = ReadIoReg16 (LanDriver, LAN91X_DATA0);
1981   PktLength = ReadIoReg16 (LanDriver, LAN91X_DATA0) & BCW_COUNT;
1982
1983   // Check for valid received packet
1984   if ((PktStatus == 0) && (PktLength == 0)) {
1985     DEBUG ((DEBUG_WARN, "LAN91x: Received zero-length packet. IST=%04x\n", IstReg));
1986     ReturnUnlock (EFI_NOT_READY);
1987   }
1988   LanDriver->Stats.RxTotalFrames += 1;
1989
1990   // Check if we got a CRC error
1991   if ((PktStatus & RX_BAD_CRC) != 0) {
1992     DEBUG ((DEBUG_WARN, "LAN91x: Received frame CRC error\n"));
1993     LanDriver->Stats.RxCrcErrorFrames += 1;
1994     LanDriver->Stats.RxDroppedFrames += 1;
1995     Status = EFI_DEVICE_ERROR;
1996     goto exit_release;
1997   }
1998
1999   // Check if we got a too-short frame
2000   if ((PktStatus & RX_TOO_SHORT) != 0) {
2001     DEBUG ((DEBUG_WARN, "LAN91x: Received frame too short (%d bytes)\n", PktLength));
2002     LanDriver->Stats.RxUndersizeFrames += 1;
2003     LanDriver->Stats.RxDroppedFrames += 1;
2004     Status = EFI_DEVICE_ERROR;
2005     goto exit_release;
2006   }
2007
2008    // Check if we got a too-long frame
2009   if ((PktStatus & RX_TOO_LONG) != 0) {
2010     DEBUG ((DEBUG_WARN, "LAN91x: Received frame too long (%d bytes)\n", PktLength));
2011     LanDriver->Stats.RxOversizeFrames += 1;
2012     LanDriver->Stats.RxDroppedFrames += 1;
2013     Status = EFI_DEVICE_ERROR;
2014     goto exit_release;
2015   }
2016
2017    // Check if we got an alignment error
2018   if ((PktStatus & RX_ALGN_ERR) != 0) {
2019     DEBUG ((DEBUG_WARN, "LAN91x: Received frame alignment error\n"));
2020     // Don't seem to keep track of these specifically
2021     LanDriver->Stats.RxDroppedFrames += 1;
2022     Status = EFI_DEVICE_ERROR;
2023     goto exit_release;
2024   }
2025
2026   // Classify the received fram
2027   if ((PktStatus & RX_MULTICAST) != 0) {
2028     LanDriver->Stats.RxMulticastFrames += 1;
2029   } else if ((PktStatus & RX_BROADCAST) != 0) {
2030     LanDriver->Stats.RxBroadcastFrames += 1;
2031   } else {
2032     LanDriver->Stats.RxUnicastFrames += 1;
2033   }
2034
2035   // Calculate the received packet data length
2036   PktLength -= LAN91X_PKT_OVERHEAD;
2037   if ((PktStatus & RX_ODD_FRAME) != 0) {
2038     PktLength += 1;
2039   }
2040
2041   // Check buffer size
2042   if (*BuffSize < PktLength) {
2043     DEBUG ((DEBUG_WARN, "LAN91x: Receive buffer too small for packet (%d < %d)\n",
2044         *BuffSize, PktLength));
2045     *BuffSize = PktLength;
2046     Status = EFI_BUFFER_TOO_SMALL;
2047     goto exit_release;
2048   }
2049
2050   // Transfer the data bytes
2051   DataPtr = Data;
2052   ReadIoData (LanDriver, DataPtr, PktLength & ~0x0001);
2053
2054   // Read the PktControl and Odd Byte from the FIFO
2055   PktControl = ReadIoReg16 (LanDriver, LAN91X_DATA0);
2056   if ((PktControl & PCW_ODD) != 0) {
2057     DataPtr[PktLength - 1] = PktControl & PCW_ODD_BYTE;
2058   }
2059
2060   // Update buffer size
2061   *BuffSize = PktLength;
2062
2063   if (HdrSize != NULL) {
2064     *HdrSize = LanDriver->SnpMode.MediaHeaderSize;
2065   }
2066
2067   // Extract the destination address
2068   if (DstAddr != NULL) {
2069     CopyMem (DstAddr, &DataPtr[0], NET_ETHER_ADDR_LEN);
2070   }
2071
2072   // Get the source address
2073   if (SrcAddr != NULL) {
2074     CopyMem (SrcAddr, &DataPtr[6], NET_ETHER_ADDR_LEN);
2075   }
2076
2077   // Get the protocol
2078   if (Protocol != NULL) {
2079     *Protocol = NTOHS (*(UINT16*)(&DataPtr[12]));
2080   }
2081
2082   // Update the Rx statistics
2083   LanDriver->Stats.RxTotalBytes += PktLength;
2084   LanDriver->Stats.RxGoodFrames += 1;
2085   Status = EFI_SUCCESS;
2086
2087 #if LAN91X_PRINT_PACKET_HEADERS
2088   // Dump the packet header
2089   DEBUG ((DEBUG_ERROR, "LAN91X:SnpReceive()\n"));
2090   DEBUG ((DEBUG_ERROR, "  HdrSize: %p, SrcAddr: %p, DstAddr: %p, Protocol: %p\n",
2091          HdrSize, SrcAddr, DstAddr, Protocol));
2092   DEBUG ((DEBUG_ERROR, "  Length: %d, Last byte: %02x\n", PktLength, DataPtr[PktLength - 1]));
2093   PrintIpDgram (&DataPtr[0], &DataPtr[6], &DataPtr[12], &DataPtr[14]);
2094 #endif
2095
2096   // Release the FIFO buffer
2097 exit_release:
2098   MmuOperation (LanDriver, MMUCR_OP_RX_POP_REL);
2099
2100   // Restore TPL and return
2101 exit_unlock:
2102   gBS->RestoreTPL (SavedTpl);
2103   return Status;
2104 }
2105
2106
2107 /*------------------ Driver Execution Environment main entry point ------------------*/
2108
2109 /*
2110 **  Entry point for the LAN91x driver
2111 **
2112 */
2113 EFI_STATUS
2114 Lan91xDxeEntry (
2115   IN EFI_HANDLE Handle,
2116   IN EFI_SYSTEM_TABLE *SystemTable
2117   )
2118 {
2119   EFI_STATUS Status;
2120   LAN91X_DRIVER *LanDriver;
2121   EFI_SIMPLE_NETWORK_PROTOCOL *Snp;
2122   EFI_SIMPLE_NETWORK_MODE *SnpMode;
2123   LAN91X_DEVICE_PATH *Lan91xPath;
2124
2125   // The PcdLan91xDxeBaseAddress PCD must be defined
2126   ASSERT(PcdGet32 (PcdLan91xDxeBaseAddress) != 0);
2127
2128   // Allocate Resources
2129   LanDriver = AllocateZeroPool (sizeof(LAN91X_DRIVER));
2130   Lan91xPath = AllocateCopyPool (sizeof(LAN91X_DEVICE_PATH), &Lan91xPathTemplate);
2131
2132   // Initialize I/O Space access info
2133   LanDriver->IoBase = PcdGet32 (PcdLan91xDxeBaseAddress);
2134   LanDriver->PhyAd = LAN91X_NO_PHY;
2135   LanDriver->BankSel = 0xff;
2136
2137   // Initialize pointers
2138   Snp = &(LanDriver->Snp);
2139   SnpMode = &(LanDriver->SnpMode);
2140   Snp->Mode = SnpMode;
2141
2142   // Set the signature of the LAN Driver structure
2143   LanDriver->Signature = LAN91X_SIGNATURE;
2144
2145   // Probe the device
2146   Status = Probe (LanDriver);
2147   if (EFI_ERROR(Status)) {
2148     DEBUG ((DEBUG_ERROR, "LAN91x:Lan91xDxeEntry(): Probe failed with status %d\n", Status));
2149     return Status;
2150   }
2151
2152 #ifdef LAN91X_PRINT_REGISTERS
2153   PrintIoRegisters (LanDriver);
2154   PrintPhyRegisters (LanDriver);
2155 #endif
2156
2157   // Initialize transmit queue
2158   InitializeListHead (&LanDriver->TransmitQueueHead);
2159
2160   // Assign fields and func pointers
2161   Snp->Revision = EFI_SIMPLE_NETWORK_PROTOCOL_REVISION;
2162   Snp->WaitForPacket = NULL;
2163   Snp->Initialize = SnpInitialize;
2164   Snp->Start = SnpStart;
2165   Snp->Stop = SnpStop;
2166   Snp->Reset = SnpReset;
2167   Snp->Shutdown = SnpShutdown;
2168   Snp->ReceiveFilters = SnpReceiveFilters;
2169   Snp->StationAddress = SnpStationAddress;
2170   Snp->Statistics = SnpStatistics;
2171   Snp->MCastIpToMac = SnpMcastIptoMac;
2172   Snp->NvData = SnpNvData;
2173   Snp->GetStatus = SnpGetStatus;
2174   Snp->Transmit = SnpTransmit;
2175   Snp->Receive = SnpReceive;
2176
2177   // Fill in simple network mode structure
2178   SnpMode->State = EfiSimpleNetworkStopped;
2179   SnpMode->HwAddressSize = NET_ETHER_ADDR_LEN;    // HW address is 6 bytes
2180   SnpMode->MediaHeaderSize = sizeof(ETHER_HEAD);  // Size of an Ethernet header
2181   SnpMode->MaxPacketSize = EFI_PAGE_SIZE;         // Ethernet Frame (with VLAN tag +4 bytes)
2182
2183   // Supported receive filters
2184   SnpMode->ReceiveFilterMask = EFI_SIMPLE_NETWORK_RECEIVE_UNICAST |
2185                                EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST |
2186                                EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST |
2187                                EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS |
2188                                EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST;
2189
2190   // Initially-enabled receive filters
2191   SnpMode->ReceiveFilterSetting = EFI_SIMPLE_NETWORK_RECEIVE_UNICAST |
2192                                   EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST |
2193                                   EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST;
2194
2195   // LAN91x has 64bit hash table. We can filter an infinite MACs, but
2196   // higher-level software must filter out any hash collisions.
2197   SnpMode->MaxMCastFilterCount = MAX_MCAST_FILTER_CNT;
2198   SnpMode->MCastFilterCount = 0;
2199   ZeroMem (&SnpMode->MCastFilter, MAX_MCAST_FILTER_CNT * sizeof(EFI_MAC_ADDRESS));
2200
2201   // Set the interface type (1: Ethernet or 6: IEEE 802 Networks)
2202   SnpMode->IfType = NET_IFTYPE_ETHERNET;
2203
2204   // Mac address is changeable
2205   SnpMode->MacAddressChangeable = TRUE;
2206
2207   // We can only transmit one packet at a time
2208   SnpMode->MultipleTxSupported = FALSE;
2209
2210   // MediaPresent checks for cable connection and partner link
2211   SnpMode->MediaPresentSupported = TRUE;
2212   SnpMode->MediaPresent = FALSE;
2213
2214   //  Set broadcast address
2215   SetMem (&SnpMode->BroadcastAddress, sizeof (EFI_MAC_ADDRESS), 0xFF);
2216
2217   // Assign fields for device path
2218   Lan91xPath->Lan91x.MacAddress = SnpMode->PermanentAddress;
2219   Lan91xPath->Lan91x.IfType = SnpMode->IfType;
2220
2221   // Initialise the protocol
2222   Status = gBS->InstallMultipleProtocolInterfaces (
2223                   &LanDriver->ControllerHandle,
2224                   &gEfiSimpleNetworkProtocolGuid, Snp,
2225                   &gEfiDevicePathProtocolGuid, Lan91xPath,
2226                   NULL
2227                   );
2228
2229   // Say what the status of loading the protocol structure is
2230   if (EFI_ERROR(Status)) {
2231     FreePool (LanDriver);
2232   }
2233
2234   return Status;
2235 }