EmbeddedPkg: Fix typos in comments
[mirror_edk2.git] / EmbeddedPkg / Drivers / Lan9118Dxe / Lan9118Dxe.c
1 /** @file
2 *
3 * Copyright (c) 2012-2014, ARM Limited. All rights reserved.
4 *
5 * This program and the accompanying materials
6 * are licensed and made available under the terms and conditions of the BSD License
7 * which accompanies this distribution. The full text of the license may be found at
8 * http://opensource.org/licenses/bsd-license.php
9 *
10 * THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12 *
13 **/
14
15 #include "Lan9118Dxe.h"
16
17 typedef struct {
18 MAC_ADDR_DEVICE_PATH Lan9118;
19 EFI_DEVICE_PATH_PROTOCOL End;
20 } LAN9118_DEVICE_PATH;
21
22 LAN9118_DEVICE_PATH Lan9118PathTemplate = {
23 {
24 {
25 MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP,
26 { (UINT8) (sizeof(MAC_ADDR_DEVICE_PATH)), (UINT8) ((sizeof(MAC_ADDR_DEVICE_PATH)) >> 8) }
27 },
28 { { 0 } },
29 0
30 },
31 {
32 END_DEVICE_PATH_TYPE,
33 END_ENTIRE_DEVICE_PATH_SUBTYPE,
34 { sizeof(EFI_DEVICE_PATH_PROTOCOL), 0 }
35 }
36 };
37
38 /*
39 ** Entry point for the LAN9118 driver
40 **
41 */
42 EFI_STATUS
43 Lan9118DxeEntry (
44 IN EFI_HANDLE Handle,
45 IN EFI_SYSTEM_TABLE *SystemTable
46 )
47 {
48 EFI_STATUS Status;
49 LAN9118_DRIVER *LanDriver;
50 EFI_SIMPLE_NETWORK_PROTOCOL *Snp;
51 EFI_SIMPLE_NETWORK_MODE *SnpMode;
52 LAN9118_DEVICE_PATH *Lan9118Path;
53 EFI_HANDLE ControllerHandle;
54
55 // The PcdLan9118DxeBaseAddress PCD must be defined
56 ASSERT (PcdGet32 (PcdLan9118DxeBaseAddress) != 0);
57
58 // Allocate Resources
59 LanDriver = AllocateZeroPool (sizeof (LAN9118_DRIVER));
60 if (LanDriver == NULL) {
61 return EFI_OUT_OF_RESOURCES;
62 }
63 Lan9118Path = (LAN9118_DEVICE_PATH*)AllocateCopyPool (sizeof (LAN9118_DEVICE_PATH), &Lan9118PathTemplate);
64 if (Lan9118Path == NULL) {
65 return EFI_OUT_OF_RESOURCES;
66 }
67
68 // Initialize pointers
69 Snp = &(LanDriver->Snp);
70 SnpMode = &(LanDriver->SnpMode);
71 Snp->Mode = SnpMode;
72
73 // Set the signature of the LAN Driver structure
74 LanDriver->Signature = LAN9118_SIGNATURE;
75
76 // Assign fields and func pointers
77 Snp->Revision = EFI_SIMPLE_NETWORK_PROTOCOL_REVISION;
78 Snp->WaitForPacket = NULL;
79 Snp->Initialize = SnpInitialize;
80 Snp->Start = SnpStart;
81 Snp->Stop = SnpStop;
82 Snp->Reset = SnpReset;
83 Snp->Shutdown = SnpShutdown;
84 Snp->ReceiveFilters = SnpReceiveFilters;
85 Snp->StationAddress = SnpStationAddress;
86 Snp->Statistics = SnpStatistics;
87 Snp->MCastIpToMac = SnpMcastIptoMac;
88 Snp->NvData = SnpNvData;
89 Snp->GetStatus = SnpGetStatus;
90 Snp->Transmit = SnpTransmit;
91 Snp->Receive = SnpReceive;
92
93 // Start completing simple network mode structure
94 SnpMode->State = EfiSimpleNetworkStopped;
95 SnpMode->HwAddressSize = NET_ETHER_ADDR_LEN; // HW address is 6 bytes
96 SnpMode->MediaHeaderSize = sizeof(ETHER_HEAD); // Not sure of this
97 SnpMode->MaxPacketSize = EFI_PAGE_SIZE; // Preamble + SOF + Ether Frame (with VLAN tag +4bytes)
98 SnpMode->NvRamSize = 0; // No NVRAM with this device
99 SnpMode->NvRamAccessSize = 0; // No NVRAM with this device
100
101 //
102 // Claim that all receive filter settings are supported, though the MULTICAST mode
103 // is not completely supported. The LAN9118 Ethernet controller is only able to
104 // do a "hash filtering" and not a perfect filtering on multicast addresses. The
105 // controller does not filter the multicast addresses directly but a hash value
106 // of them. The hash value of a multicast address is derived from its CRC and
107 // ranges from 0 to 63 included.
108 // We claim that the perfect MULTICAST filtering mode is supported because
109 // we do not want the user to switch directly to the PROMISCOUS_MULTICAST mode
110 // and thus not being able to take advantage of the hash filtering.
111 //
112 SnpMode->ReceiveFilterMask = EFI_SIMPLE_NETWORK_RECEIVE_UNICAST |
113 EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST |
114 EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST |
115 EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS |
116 EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST;
117
118 // We do not intend to receive anything for the time being.
119 SnpMode->ReceiveFilterSetting = 0;
120
121 // LAN9118 has 64bit hash table, can filter 64 MCast MAC Addresses
122 SnpMode->MaxMCastFilterCount = MAX_MCAST_FILTER_CNT;
123 SnpMode->MCastFilterCount = 0;
124 ZeroMem (&SnpMode->MCastFilter, MAX_MCAST_FILTER_CNT * sizeof(EFI_MAC_ADDRESS));
125
126 // Set the interface type (1: Ethernet or 6: IEEE 802 Networks)
127 SnpMode->IfType = NET_IFTYPE_ETHERNET;
128
129 // Mac address is changeable as it is loaded from erasable memory
130 SnpMode->MacAddressChangeable = TRUE;
131
132 // Can only transmit one packet at a time
133 SnpMode->MultipleTxSupported = FALSE;
134
135 // MediaPresent checks for cable connection and partner link
136 SnpMode->MediaPresentSupported = TRUE;
137 SnpMode->MediaPresent = FALSE;
138
139 // Set broadcast address
140 SetMem (&SnpMode->BroadcastAddress, sizeof (EFI_MAC_ADDRESS), 0xFF);
141
142 // Power up the device so we can find the MAC address
143 Status = Lan9118Initialize (Snp);
144 if (EFI_ERROR (Status)) {
145 DEBUG ((EFI_D_ERROR, "LAN9118: Error initialising hardware\n"));
146 return EFI_DEVICE_ERROR;
147 }
148
149 // Assign fields for device path
150 CopyMem (&Lan9118Path->Lan9118.MacAddress, &Snp->Mode->CurrentAddress, NET_ETHER_ADDR_LEN);
151 Lan9118Path->Lan9118.IfType = Snp->Mode->IfType;
152
153 // Initialise the protocol
154 ControllerHandle = NULL;
155 Status = gBS->InstallMultipleProtocolInterfaces (
156 &ControllerHandle,
157 &gEfiSimpleNetworkProtocolGuid, Snp,
158 &gEfiDevicePathProtocolGuid, Lan9118Path,
159 NULL
160 );
161 // Say what the status of loading the protocol structure is
162 if (EFI_ERROR(Status)) {
163 FreePool (LanDriver);
164 } else {
165 LanDriver->ControllerHandle = ControllerHandle;
166 }
167
168 return Status;
169 }
170
171 /*
172 * UEFI Start() function
173 *
174 * Parameters:
175 *
176 * @param Snp: A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL instance.
177 *
178 * Description:
179 *
180 * This function starts a network interface. If the network interface successfully starts, then
181 * EFI_SUCCESS will be returned.
182 */
183 EFI_STATUS
184 EFIAPI
185 SnpStart (
186 IN EFI_SIMPLE_NETWORK_PROTOCOL *Snp
187 )
188 {
189 // Check Snp instance
190 if (Snp == NULL) {
191 return EFI_INVALID_PARAMETER;
192 }
193
194 // Check state
195 if ((Snp->Mode->State == EfiSimpleNetworkStarted) ||
196 (Snp->Mode->State == EfiSimpleNetworkInitialized) ) {
197 return EFI_ALREADY_STARTED;
198 }
199
200 // Change state
201 Snp->Mode->State = EfiSimpleNetworkStarted;
202 return EFI_SUCCESS;
203 }
204
205 /*
206 * UEFI Stop() function
207 *
208 */
209 EFI_STATUS
210 EFIAPI
211 SnpStop (
212 IN EFI_SIMPLE_NETWORK_PROTOCOL* Snp
213 )
214 {
215 // Check Snp Instance
216 if (Snp == NULL) {
217 return EFI_INVALID_PARAMETER;
218 }
219
220 // Check state of the driver
221 if (Snp->Mode->State == EfiSimpleNetworkStopped) {
222 return EFI_NOT_STARTED;
223 }
224
225 // Stop the Tx and Rx
226 StopTx (STOP_TX_CFG | STOP_TX_MAC, Snp);
227 StopRx (0, Snp);
228
229 // Change the state
230 switch (Snp->Mode->State) {
231 case EfiSimpleNetworkStarted:
232 case EfiSimpleNetworkInitialized:
233 Snp->Mode->State = EfiSimpleNetworkStopped;
234 break;
235 default:
236 return EFI_DEVICE_ERROR;
237 }
238
239 // Put the device into a power saving mode ?
240 return EFI_SUCCESS;
241 }
242
243
244 // Allocated receive and transmit buffers
245 STATIC UINT32 gTxBuffer = 0;
246
247 /*
248 * UEFI Initialize() function
249 *
250 */
251 EFI_STATUS
252 EFIAPI
253 SnpInitialize (
254 IN EFI_SIMPLE_NETWORK_PROTOCOL* Snp,
255 IN UINTN RxBufferSize OPTIONAL,
256 IN UINTN TxBufferSize OPTIONAL
257 )
258 {
259 EFI_STATUS Status;
260 UINT32 PmConf;
261 INT32 AllocResult;
262 UINT32 RxStatusSize;
263 UINT32 TxStatusSize;
264
265 // Initialize variables
266 // Global variables to hold tx and rx FIFO allocation
267 gTxBuffer = 0;
268
269 // Check Snp Instance
270 if (Snp == NULL) {
271 return EFI_INVALID_PARAMETER;
272 }
273
274 // First check that driver has not already been initialized
275 if (Snp->Mode->State == EfiSimpleNetworkInitialized) {
276 DEBUG ((EFI_D_WARN, "LAN9118 Driver already initialized\n"));
277 return EFI_SUCCESS;
278 } else
279 if (Snp->Mode->State == EfiSimpleNetworkStopped) {
280 DEBUG ((EFI_D_WARN, "LAN9118 Driver not started\n"));
281 return EFI_NOT_STARTED;
282 }
283
284 // Initiate a PHY reset
285 Status = PhySoftReset (PHY_RESET_PMT, Snp);
286 if (EFI_ERROR (Status)) {
287 Snp->Mode->State = EfiSimpleNetworkStopped;
288 DEBUG ((EFI_D_WARN, "Warning: Link not ready after TimeOut. Check ethernet cable\n"));
289 return EFI_NOT_STARTED;
290 }
291
292 // Initiate a software reset
293 Status = SoftReset (0, Snp);
294 if (EFI_ERROR(Status)) {
295 DEBUG ((EFI_D_WARN, "Soft Reset Failed: Hardware Error\n"));
296 return EFI_DEVICE_ERROR;
297 }
298
299 // Read the PM register
300 PmConf = Lan9118MmioRead32 (LAN9118_PMT_CTRL);
301
302 // MPTCTRL_WOL_EN: Allow Wake-On-Lan to detect wake up frames or magic packets
303 // MPTCTRL_ED_EN: Allow energy detection to allow lowest power consumption mode
304 // MPTCTRL_PME_EN: Allow Power Management Events
305 PmConf = 0;
306 PmConf |= (MPTCTRL_WOL_EN | MPTCTRL_ED_EN | MPTCTRL_PME_EN);
307
308 // Write the current configuration to the register
309 Lan9118MmioWrite32 (LAN9118_PMT_CTRL, PmConf);
310
311 // Configure GPIO and HW
312 Status = ConfigureHardware (HW_CONF_USE_LEDS, Snp);
313 if (EFI_ERROR(Status)) {
314 return Status;
315 }
316
317 // Assign the transmitter buffer size (default values)
318 TxStatusSize = LAN9118_TX_STATUS_SIZE;
319 RxStatusSize = LAN9118_RX_STATUS_SIZE;
320
321 // Check that a buff size was specified
322 if (TxBufferSize > 0) {
323 if (RxBufferSize == 0) {
324 RxBufferSize = LAN9118_RX_DATA_SIZE;
325 }
326
327 AllocResult = ChangeFifoAllocation (
328 ALLOC_USE_FIFOS,
329 &TxBufferSize,
330 &RxBufferSize,
331 &TxStatusSize,
332 &RxStatusSize,
333 Snp
334 );
335
336 if (AllocResult < 0) {
337 return EFI_OUT_OF_RESOURCES;
338 }
339 }
340
341 // Do auto-negotiation if supported
342 Status = AutoNegotiate (AUTO_NEGOTIATE_ADVERTISE_ALL, Snp);
343 if (EFI_ERROR(Status)) {
344 DEBUG ((EFI_D_WARN, "LAN9118: Auto Negotiation failed.\n"));
345 }
346
347 // Configure flow control depending on speed capabilities
348 Status = ConfigureFlow (0, 0, 0, 0, Snp);
349 if (EFI_ERROR(Status)) {
350 return Status;
351 }
352
353 // Enable the transmitter
354 Status = StartTx (START_TX_MAC | START_TX_CFG, Snp);
355 if (EFI_ERROR(Status)) {
356 return Status;
357 }
358
359 // Now acknowledge all interrupts
360 Lan9118MmioWrite32 (LAN9118_INT_STS, ~0);
361
362 // Declare the driver as initialized
363 Snp->Mode->State = EfiSimpleNetworkInitialized;
364
365 return Status;
366 }
367
368 /*
369 * UEFI Reset () function
370 *
371 */
372 EFI_STATUS
373 EFIAPI
374 SnpReset (
375 IN EFI_SIMPLE_NETWORK_PROTOCOL* Snp,
376 IN BOOLEAN Verification
377 )
378 {
379 UINT32 PmConf;
380 UINT32 HwConf;
381 UINT32 ResetFlags;
382 EFI_STATUS Status;
383
384 PmConf = 0;
385 HwConf = 0;
386 ResetFlags = 0;
387
388 // Check Snp Instance
389 if (Snp == NULL) {
390 return EFI_INVALID_PARAMETER;
391 }
392
393 // First check that driver has not already been initialized
394 if (Snp->Mode->State == EfiSimpleNetworkStarted) {
395 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver not yet initialized\n"));
396 return EFI_DEVICE_ERROR;
397 } else if (Snp->Mode->State == EfiSimpleNetworkStopped) {
398 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver not started\n"));
399 return EFI_NOT_STARTED;
400 }
401
402 // Initiate a PHY reset
403 Status = PhySoftReset (PHY_RESET_PMT, Snp);
404 if (EFI_ERROR (Status)) {
405 Snp->Mode->State = EfiSimpleNetworkStopped;
406 return EFI_NOT_STARTED;
407 }
408
409 // Initiate a software reset
410 ResetFlags |= SOFT_RESET_CHECK_MAC_ADDR_LOAD | SOFT_RESET_CLEAR_INT;
411
412 if (Verification) {
413 ResetFlags |= SOFT_RESET_SELF_TEST;
414 }
415
416 Status = SoftReset (ResetFlags, Snp);
417 if (EFI_ERROR (Status)) {
418 DEBUG ((EFI_D_WARN, "Warning: Soft Reset Failed: Hardware Error\n"));
419 return EFI_DEVICE_ERROR;
420 }
421
422 // Read the PM register
423 PmConf = Lan9118MmioRead32 (LAN9118_PMT_CTRL);
424
425 // MPTCTRL_WOL_EN: Allow Wake-On-Lan to detect wake up frames or magic packets
426 // MPTCTRL_ED_EN: Allow energy detection to allow lowest power consumption mode
427 // MPTCTRL_PME_EN: Allow Power Management Events
428 PmConf |= (MPTCTRL_WOL_EN | MPTCTRL_ED_EN | MPTCTRL_PME_EN);
429
430 // Write the current configuration to the register
431 Lan9118MmioWrite32 (LAN9118_PMT_CTRL, PmConf);
432
433 // Reactivate the LEDs
434 Status = ConfigureHardware (HW_CONF_USE_LEDS, Snp);
435 if (EFI_ERROR (Status)) {
436 return Status;
437 }
438
439 // Check that a buffer size was specified in SnpInitialize
440 if (gTxBuffer != 0) {
441 HwConf = Lan9118MmioRead32 (LAN9118_HW_CFG); // Read the HW register
442 HwConf &= ~HW_CFG_TX_FIFO_SIZE_MASK; // Clear buffer bits first
443 HwConf |= HW_CFG_TX_FIFO_SIZE(gTxBuffer); // assign size chosen in SnpInitialize
444
445 Lan9118MmioWrite32 (LAN9118_HW_CFG, HwConf); // Write the conf
446 }
447
448 // Enable the receiver and transmitter and clear their contents
449 StartRx (START_RX_CLEAR, Snp);
450 StartTx (START_TX_MAC | START_TX_CFG | START_TX_CLEAR, Snp);
451
452 // Now acknowledge all interrupts
453 Lan9118MmioWrite32 (LAN9118_INT_STS, ~0);
454
455 return EFI_SUCCESS;
456 }
457
458 /*
459 * UEFI Shutdown () function
460 *
461 */
462 EFI_STATUS
463 EFIAPI
464 SnpShutdown (
465 IN EFI_SIMPLE_NETWORK_PROTOCOL* Snp
466 )
467 {
468 EFI_STATUS Status;
469
470 // Check Snp Instance
471 if (Snp == NULL) {
472 return EFI_INVALID_PARAMETER;
473 }
474
475 // First check that driver has not already been initialized
476 if (Snp->Mode->State == EfiSimpleNetworkStarted) {
477 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver not yet initialized\n"));
478 return EFI_DEVICE_ERROR;
479 } else if (Snp->Mode->State == EfiSimpleNetworkStopped) {
480 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver not started\n"));
481 return EFI_NOT_STARTED;
482 }
483
484 // Initiate a PHY reset
485 Status = PhySoftReset (PHY_RESET_PMT, Snp);
486 if (EFI_ERROR (Status)) {
487 return Status;
488 }
489
490 // Initiate a software reset
491 Status = SoftReset (0, Snp);
492 if (EFI_ERROR (Status)) {
493 DEBUG ((EFI_D_WARN, "Warning: Soft Reset Failed: Hardware Error\n"));
494 return Status;
495 }
496
497 // Back to the started and thus not initialized state
498 Snp->Mode->State = EfiSimpleNetworkStarted;
499
500 return EFI_SUCCESS;
501 }
502
503 /**
504 Enable and/or disable the receive filters of the LAN9118
505
506 Please refer to the UEFI specification for the precedence rules among the
507 Enable, Disable and ResetMCastFilter parameters.
508
509 @param[in] Snp A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL
510 instance.
511 @param[in] Enable A bit mask of receive filters to enable.
512 @param[in] Disable A bit mask of receive filters to disable.
513 @param[in] ResetMCastFilter Set to TRUE to reset the contents of the multicast
514 receive filters on the network interface to
515 their default values.
516 @param[in] MCastFilterCnt Number of multicast HW MAC addresses in the new
517 MCastFilter list. This value must be less than or
518 equal to the MCastFilterCnt field of
519 EFI_SIMPLE_NETWORK_MODE. This field is optional if
520 ResetMCastFilter is TRUE.
521 @param[in] MCastFilter A pointer to a list of new multicast receive
522 filter HW MAC addresses. This list will replace
523 any existing multicast HW MAC address list. This
524 field is optional if ResetMCastFilter is TRUE.
525
526 @retval EFI_SUCCESS The receive filters of the LAN9118 were updated.
527 @retval EFI_NOT_STARTED The LAN9118 has not been started.
528 @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE :
529 . This is NULL
530 . Multicast is being enabled (the
531 EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST bit is set in
532 Enable, it is not set in Disable, and ResetMCastFilter
533 is FALSE) and MCastFilterCount is zero.
534 . Multicast is being enabled and MCastFilterCount is
535 greater than Snp->Mode->MaxMCastFilterCount.
536 . Multicast is being enabled and MCastFilter is NULL
537 . Multicast is being enabled and one or more of the
538 addresses in the MCastFilter list are not valid
539 multicast MAC addresses.
540 @retval EFI_DEVICE_ERROR The LAN9118 has been started but not initialized.
541
542 **/
543 EFI_STATUS
544 EFIAPI
545 SnpReceiveFilters (
546 IN EFI_SIMPLE_NETWORK_PROTOCOL *Snp,
547 IN UINT32 Enable,
548 IN UINT32 Disable,
549 IN BOOLEAN ResetMCastFilter,
550 IN UINTN MCastFilterCnt OPTIONAL,
551 IN EFI_MAC_ADDRESS *MCastFilter OPTIONAL
552 )
553 {
554 EFI_SIMPLE_NETWORK_MODE *Mode;
555 UINT32 MultHashTableHigh;
556 UINT32 MultHashTableLow;
557 UINT32 Count;
558 UINT32 Crc;
559 UINT8 HashValue;
560 UINT32 MacCSRValue;
561 UINT32 ReceiveFilterSetting;
562 EFI_MAC_ADDRESS *Mac;
563 EFI_MAC_ADDRESS ZeroMac;
564
565 // Check Snp Instance
566 if (Snp == NULL) {
567 return EFI_INVALID_PARAMETER;
568 }
569 Mode = Snp->Mode;
570
571 // Check that driver was started and initialised
572 if (Mode->State == EfiSimpleNetworkStarted) {
573 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver not initialized\n"));
574 return EFI_DEVICE_ERROR;
575 } else if (Mode->State == EfiSimpleNetworkStopped) {
576 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver in stopped state\n"));
577 return EFI_NOT_STARTED;
578 }
579
580 if ((Enable & (~Mode->ReceiveFilterMask)) ||
581 (Disable & (~Mode->ReceiveFilterMask)) ) {
582 return EFI_INVALID_PARAMETER;
583 }
584
585 //
586 // Check the validity of the multicast setting and compute the
587 // hash values of the multicast mac addresses to listen to.
588 //
589
590 MultHashTableHigh = 0;
591 MultHashTableLow = 0;
592 if ((!ResetMCastFilter) &&
593 ((Disable & EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST) == 0) &&
594 ((Enable & EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST) != 0) ) {
595 if ((MCastFilterCnt == 0) ||
596 (MCastFilterCnt > Mode->MaxMCastFilterCount) ||
597 (MCastFilter == NULL) ) {
598 return EFI_INVALID_PARAMETER;
599 }
600 //
601 // Check the validity of all multicast addresses before to change
602 // anything.
603 //
604 for (Count = 0; Count < MCastFilterCnt; Count++) {
605 if ((MCastFilter[Count].Addr[0] & 1) == 0) {
606 return EFI_INVALID_PARAMETER;
607 }
608 }
609
610 //
611 // Go through each filter address and set appropriate bits on hash table
612 //
613 for (Count = 0; Count < MCastFilterCnt; Count++) {
614 Mac = &(MCastFilter[Count]);
615 CopyMem (&Mode->MCastFilter[Count], Mac, sizeof(EFI_MAC_ADDRESS));
616
617 Crc = GenEtherCrc32 (Mac, NET_ETHER_ADDR_LEN);
618 //gBS->CalculateCrc32 ((VOID*)&Mfilter[Count],6,&Crc); <-- doesn't work as desired
619
620 //
621 // The most significant 6 bits of the MAC address CRC constitute the hash
622 // value of the MAC address.
623 //
624 HashValue = (Crc >> 26) & 0x3F;
625
626 // Select hashlow register if MSB is not set
627 if ((HashValue & 0x20) == 0) {
628 MultHashTableLow |= (1 << HashValue);
629 } else {
630 MultHashTableHigh |= (1 << (HashValue & 0x1F));
631 }
632 }
633 Mode->MCastFilterCount = MCastFilterCnt;
634 } else if (ResetMCastFilter) {
635 Mode->MCastFilterCount = 0;
636 } else {
637 MultHashTableLow = IndirectMACRead32 (INDIRECT_MAC_INDEX_HASHL);
638 MultHashTableHigh = IndirectMACRead32 (INDIRECT_MAC_INDEX_HASHH);
639 }
640
641 //
642 // Before to change anything, stop and reset the reception of
643 // packets.
644 //
645 StopRx (STOP_RX_CLEAR, Snp);
646
647 //
648 // Write the mask of the selected hash values for the multicast filtering.
649 // The two masks are set to zero if the multicast filtering is not enabled.
650 //
651 IndirectMACWrite32 (INDIRECT_MAC_INDEX_HASHL, MultHashTableLow);
652 IndirectMACWrite32 (INDIRECT_MAC_INDEX_HASHH, MultHashTableHigh);
653
654 ReceiveFilterSetting = (Mode->ReceiveFilterSetting | Enable) & (~Disable);
655
656 //
657 // Read MAC controller
658 //
659 MacCSRValue = IndirectMACRead32 (INDIRECT_MAC_INDEX_CR);
660 MacCSRValue &= ~(MACCR_HPFILT | MACCR_BCAST | MACCR_PRMS | MACCR_MCPAS);
661
662 if (ReceiveFilterSetting & EFI_SIMPLE_NETWORK_RECEIVE_UNICAST) {
663 Lan9118SetMacAddress (&Mode->CurrentAddress, Snp);
664 DEBUG ((DEBUG_NET, "Allowing Unicast Frame Reception\n"));
665 } else {
666 //
667 // The Unicast packets do not have to be listen to, set the MAC
668 // address of the LAN9118 to be the "not configured" all zeroes
669 // ethernet MAC address.
670 //
671 ZeroMem (&ZeroMac, NET_ETHER_ADDR_LEN);
672 Lan9118SetMacAddress (&ZeroMac, Snp);
673 }
674
675 if (ReceiveFilterSetting & EFI_SIMPLE_NETWORK_RECEIVE_MULTICAST) {
676 MacCSRValue |= MACCR_HPFILT;
677 DEBUG ((DEBUG_NET, "Allowing Multicast Frame Reception\n"));
678 }
679
680 if (ReceiveFilterSetting & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS_MULTICAST) {
681 MacCSRValue |= MACCR_MCPAS;
682 DEBUG ((DEBUG_NET, "Enabling Promiscuous Multicast Mode\n"));
683 }
684
685 if ((ReceiveFilterSetting & EFI_SIMPLE_NETWORK_RECEIVE_BROADCAST) == 0) {
686 MacCSRValue |= MACCR_BCAST;
687 } else {
688 DEBUG ((DEBUG_NET, "Allowing Broadcast Frame Reception\n"));
689 }
690
691 if (ReceiveFilterSetting & EFI_SIMPLE_NETWORK_RECEIVE_PROMISCUOUS) {
692 MacCSRValue |= MACCR_PRMS;
693 DEBUG ((DEBUG_NET, "Enabling Promiscuous Mode\n"));
694 }
695
696 //
697 // Write the options to the MAC_CSR
698 //
699 IndirectMACWrite32 (INDIRECT_MAC_INDEX_CR, MacCSRValue);
700
701 //
702 // If we have to retrieve something, start packet reception.
703 //
704 Mode->ReceiveFilterSetting = ReceiveFilterSetting;
705 if (ReceiveFilterSetting != 0) {
706 StartRx (0, Snp);
707 }
708
709 return EFI_SUCCESS;
710 }
711
712 /**
713 Modify of reset the current station address
714
715 @param[in] Snp A pointer to the EFI_SIMPLE_NETWORK_PROTOCOL
716 instance.
717 @param[in] Reset Flag used to reset the station address to the
718 LAN9118's permanent address.
719 @param[in] New New station address to be used for the network interface.
720
721 @retval EFI_SUCCESS The LAN9118's station address was updated.
722 @retval EFI_NOT_STARTED The LAN9118 has not been started.
723 @retval EFI_INVALID_PARAMETER One or more of the following conditions is TRUE :
724 . The "New" station address is invalid.
725 . "Reset" is FALSE and "New" is NULL.
726 @retval EFI_DEVICE_ERROR The LAN9118 has been started but not initialized.
727
728 **/
729 EFI_STATUS
730 EFIAPI
731 SnpStationAddress (
732 IN EFI_SIMPLE_NETWORK_PROTOCOL *Snp,
733 IN BOOLEAN Reset,
734 IN EFI_MAC_ADDRESS *New
735 )
736 {
737 UINT32 Count;
738 UINT8 PermAddr[NET_ETHER_ADDR_LEN];
739
740 DEBUG ((DEBUG_NET, "SnpStationAddress()\n"));
741
742 // Check Snp instance
743 if (Snp == NULL) {
744 return EFI_INVALID_PARAMETER;
745 }
746
747 // Check that driver was started and initialised
748 if (Snp->Mode->State == EfiSimpleNetworkStarted) {
749 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver not initialized\n"));
750 return EFI_DEVICE_ERROR;
751 } else if (Snp->Mode->State == EfiSimpleNetworkStopped) {
752 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver in stopped state\n"));
753 return EFI_NOT_STARTED;
754 }
755
756 // Get the Permanent MAC address if need reset
757 if (Reset) {
758 // Try using EEPROM first. Read the first byte of data from EEPROM at the address 0x0
759 if ((IndirectEEPROMRead32 (0) & 0xFF) == EEPROM_EXTERNAL_SERIAL_EEPROM) {
760 for (Count = 0; Count < NET_ETHER_ADDR_LEN; Count++) {
761 PermAddr[Count] = IndirectEEPROMRead32 (Count + 1);
762 }
763 New = (EFI_MAC_ADDRESS *) PermAddr;
764 Lan9118SetMacAddress ((EFI_MAC_ADDRESS *) PermAddr, Snp);
765 } else {
766 DEBUG ((EFI_D_ERROR, "LAN9118: Warning: No valid MAC address in EEPROM, using fallback\n"));
767 New = (EFI_MAC_ADDRESS*) (FixedPcdGet64 (PcdLan9118DefaultMacAddress));
768 }
769 } else {
770 // Otherwise use the specified new MAC address
771 if (New == NULL) {
772 return EFI_INVALID_PARAMETER;
773 }
774 //
775 // If it is a multicast address, it is not valid.
776 //
777 if (New->Addr[0] & 0x01) {
778 return EFI_INVALID_PARAMETER;
779 }
780 }
781
782 CopyMem (&Snp->Mode->CurrentAddress, New, NET_ETHER_ADDR_LEN);
783
784 //
785 // If packet reception is currently activated, stop and reset it,
786 // set the new ethernet address and restart the packet reception.
787 // Otherwise, nothing to do, the MAC address will be updated in
788 // SnpReceiveFilters() when the UNICAST packet reception will be
789 // activated.
790 //
791 if (Snp->Mode->ReceiveFilterSetting != 0) {
792 StopRx (STOP_RX_CLEAR, Snp);
793 Lan9118SetMacAddress (New, Snp);
794 StartRx (0, Snp);
795 }
796
797 return EFI_SUCCESS;
798 }
799
800 /*
801 * UEFI Statistics() function
802 *
803 */
804 EFI_STATUS
805 EFIAPI
806 SnpStatistics (
807 IN EFI_SIMPLE_NETWORK_PROTOCOL* Snp,
808 IN BOOLEAN Reset,
809 IN OUT UINTN *StatSize,
810 OUT EFI_NETWORK_STATISTICS *Statistics
811 )
812 {
813 LAN9118_DRIVER *LanDriver;
814 EFI_STATUS Status;
815
816 LanDriver = INSTANCE_FROM_SNP_THIS (Snp);
817
818 DEBUG ((DEBUG_NET, "SnpStatistics()\n"));
819
820 // Check Snp instance
821 if (Snp == NULL) {
822 return EFI_INVALID_PARAMETER;
823 }
824
825 // Check that driver was started and initialised
826 if (Snp->Mode->State == EfiSimpleNetworkStarted) {
827 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver not initialized\n"));
828 return EFI_DEVICE_ERROR;
829 } else if (Snp->Mode->State == EfiSimpleNetworkStopped) {
830 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver in stopped state\n"));
831 return EFI_NOT_STARTED;
832 }
833
834 //
835 // Do a reset if required. It is not clearly stated in the UEFI specification
836 // whether the reset has to be done before to copy the statistics in "Statictics"
837 // or after. It is a bit strange to do it before but that is what is expected by
838 // the SCT test on Statistics() with reset : "0x3de76704,0x4bf5,0x42cd,0x8c,0x89,
839 // 0x54,0x7e,0x4f,0xad,0x4f,0x24".
840 //
841 if (Reset) {
842 ZeroMem (&LanDriver->Stats, sizeof(EFI_NETWORK_STATISTICS));
843 }
844
845 Status = EFI_SUCCESS;
846 if (StatSize == NULL) {
847 if (Statistics != NULL) {
848 return EFI_INVALID_PARAMETER;
849 }
850 } else {
851 if (Statistics == NULL) {
852 Status = EFI_BUFFER_TOO_SMALL;
853 } else {
854 // Fill in the statistics
855 CopyMem (
856 Statistics, &LanDriver->Stats,
857 MIN (*StatSize, sizeof (EFI_NETWORK_STATISTICS))
858 );
859 if (*StatSize < sizeof (EFI_NETWORK_STATISTICS)) {
860 Status = EFI_BUFFER_TOO_SMALL;
861 }
862 }
863 *StatSize = sizeof (EFI_NETWORK_STATISTICS);
864 }
865
866 return Status;
867 }
868
869 /*
870 * UEFI MCastIPtoMAC() function
871 *
872 */
873 EFI_STATUS
874 EFIAPI
875 SnpMcastIptoMac (
876 IN EFI_SIMPLE_NETWORK_PROTOCOL* Snp,
877 IN BOOLEAN IsIpv6,
878 IN EFI_IP_ADDRESS *Ip,
879 OUT EFI_MAC_ADDRESS *McastMac
880 )
881 {
882 DEBUG ((DEBUG_NET, "SnpMcastIptoMac()\n"));
883
884 // Check Snp instance
885 if (Snp == NULL) {
886 return EFI_INVALID_PARAMETER;
887 }
888
889 // Check that driver was started and initialised
890 if (Snp->Mode->State == EfiSimpleNetworkStarted) {
891 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver not initialized\n"));
892 return EFI_DEVICE_ERROR;
893 } else if (Snp->Mode->State == EfiSimpleNetworkStopped) {
894 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver in stopped state\n"));
895 return EFI_NOT_STARTED;
896 }
897
898 // Check parameters
899 if ((McastMac == NULL) || (Ip == NULL)) {
900 return EFI_INVALID_PARAMETER;
901 }
902
903 // Make sure MAC address is empty
904 ZeroMem (McastMac, sizeof(EFI_MAC_ADDRESS));
905
906 // If we need ipv4 address
907 if (!IsIpv6) {
908 // Most significant 25 bits of a multicast HW address are set.
909 // 01-00-5E is the IPv4 Ethernet Multicast Address (see RFC 1112)
910 McastMac->Addr[0] = 0x01;
911 McastMac->Addr[1] = 0x00;
912 McastMac->Addr[2] = 0x5E;
913
914 // Lower 23 bits from ipv4 address
915 McastMac->Addr[3] = (Ip->v4.Addr[1] & 0x7F); // Clear the most significant bit (25th bit of MAC must be 0)
916 McastMac->Addr[4] = Ip->v4.Addr[2];
917 McastMac->Addr[5] = Ip->v4.Addr[3];
918 } else {
919 // Most significant 16 bits of multicast v6 HW address are set
920 // 33-33 is the IPv6 Ethernet Multicast Address (see RFC 2464)
921 McastMac->Addr[0] = 0x33;
922 McastMac->Addr[1] = 0x33;
923
924 // lower four octets are taken from ipv6 address
925 McastMac->Addr[2] = Ip->v6.Addr[8];
926 McastMac->Addr[3] = Ip->v6.Addr[9];
927 McastMac->Addr[4] = Ip->v6.Addr[10];
928 McastMac->Addr[5] = Ip->v6.Addr[11];
929 }
930
931 return EFI_SUCCESS;
932 }
933
934 /*
935 * UEFI NvData() function
936 *
937 */
938 EFI_STATUS
939 EFIAPI
940 SnpNvData (
941 IN EFI_SIMPLE_NETWORK_PROTOCOL* pobj,
942 IN BOOLEAN read_write,
943 IN UINTN offset,
944 IN UINTN buff_size,
945 IN OUT VOID *data
946 )
947 {
948 DEBUG ((DEBUG_NET, "SnpNvData()\n"));
949
950 return EFI_UNSUPPORTED;
951 }
952
953
954 /*
955 * UEFI GetStatus () function
956 *
957 */
958 EFI_STATUS
959 EFIAPI
960 SnpGetStatus (
961 IN EFI_SIMPLE_NETWORK_PROTOCOL *Snp,
962 OUT UINT32 *IrqStat OPTIONAL,
963 OUT VOID **TxBuff OPTIONAL
964 )
965 {
966 UINT32 FifoInt;
967 EFI_STATUS Status;
968 UINTN NumTxStatusEntries;
969 UINT32 TxStatus;
970 UINT16 PacketTag;
971 UINT32 Interrupts;
972 LAN9118_DRIVER *LanDriver;
973
974 LanDriver = INSTANCE_FROM_SNP_THIS (Snp);
975
976 // Check preliminaries
977 if (Snp == NULL) {
978 return EFI_INVALID_PARAMETER;
979 }
980
981 // Check that driver was started and initialised
982 if (Snp->Mode->State == EfiSimpleNetworkStarted) {
983 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver not initialized\n"));
984 return EFI_DEVICE_ERROR;
985 } else if (Snp->Mode->State == EfiSimpleNetworkStopped) {
986 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver in stopped state\n"));
987 return EFI_NOT_STARTED;
988 }
989
990 // Check and acknowledge TX Status interrupt (this will happen if the
991 // consumer of SNP does not call GetStatus.)
992 // TODO will we lose TxStatuses if this happens? Maybe in SnpTransmit we
993 // should check for it and dump the TX Status FIFO.
994 FifoInt = Lan9118MmioRead32 (LAN9118_FIFO_INT);
995
996 // Clear the TX Status FIFO Overflow
997 if ((FifoInt & INSTS_TXSO) == 0) {
998 FifoInt |= INSTS_TXSO;
999 Lan9118MmioWrite32 (LAN9118_FIFO_INT, FifoInt);
1000 }
1001
1002 // Read interrupt status if IrqStat is not NULL
1003 if (IrqStat != NULL) {
1004 *IrqStat = 0;
1005
1006 // Check for receive interrupt
1007 if (Lan9118MmioRead32 (LAN9118_INT_STS) & INSTS_RSFL) { // Data moved from rx FIFO
1008 *IrqStat |= EFI_SIMPLE_NETWORK_RECEIVE_INTERRUPT;
1009 Lan9118MmioWrite32 (LAN9118_INT_STS,INSTS_RSFL);
1010 }
1011
1012 // Check for transmit interrupt
1013 if (Lan9118MmioRead32 (LAN9118_INT_STS) & INSTS_TSFL) {
1014 *IrqStat |= EFI_SIMPLE_NETWORK_TRANSMIT_INTERRUPT;
1015 Lan9118MmioWrite32 (LAN9118_INT_STS,INSTS_TSFL);
1016 }
1017
1018 // Check for software interrupt
1019 if (Lan9118MmioRead32 (LAN9118_INT_STS) & INSTS_SW_INT) {
1020 *IrqStat |= EFI_SIMPLE_NETWORK_SOFTWARE_INTERRUPT;
1021 Lan9118MmioWrite32 (LAN9118_INT_STS,INSTS_SW_INT);
1022 }
1023 }
1024
1025 // Check Status of transmitted packets
1026 // (We ignore TXSTATUS_NO_CA has it might happen in Full Duplex)
1027
1028 NumTxStatusEntries = Lan9118MmioRead32(LAN9118_TX_FIFO_INF) & TXFIFOINF_TXSUSED_MASK;
1029 if (NumTxStatusEntries > 0) {
1030 TxStatus = Lan9118MmioRead32 (LAN9118_TX_STATUS);
1031 PacketTag = TxStatus >> 16;
1032 TxStatus = TxStatus & 0xFFFF;
1033 if ((TxStatus & TXSTATUS_ES) && (TxStatus != (TXSTATUS_ES | TXSTATUS_NO_CA))) {
1034 DEBUG ((EFI_D_ERROR, "LAN9118: There was an error transmitting. TxStatus=0x%08x:", TxStatus));
1035 if (TxStatus & TXSTATUS_NO_CA) {
1036 DEBUG ((EFI_D_ERROR, "- No carrier\n"));
1037 }
1038 if (TxStatus & TXSTATUS_DEF) {
1039 DEBUG ((EFI_D_ERROR, "- Packet tx was deferred\n"));
1040 }
1041 if (TxStatus & TXSTATUS_EDEF) {
1042 DEBUG ((EFI_D_ERROR, "- Tx ended because of excessive deferral\n"));
1043 }
1044 if (TxStatus & TXSTATUS_ECOLL) {
1045 DEBUG ((EFI_D_ERROR, "- Tx ended because of Excessive Collisions\n"));
1046 }
1047 if (TxStatus & TXSTATUS_LCOLL) {
1048 DEBUG ((EFI_D_ERROR, "- Packet Tx aborted after coll window of 64 bytes\n"));
1049 }
1050 if (TxStatus & TXSTATUS_LOST_CA) {
1051 DEBUG ((EFI_D_ERROR, "- Lost carrier during Tx\n"));
1052 }
1053 return EFI_DEVICE_ERROR;
1054 } else if (TxBuff != NULL) {
1055 LanDriver->Stats.TxTotalFrames += 1;
1056 *TxBuff = LanDriver->TxRing[PacketTag % LAN9118_TX_RING_NUM_ENTRIES];
1057 }
1058 } else if (TxBuff != NULL) {
1059 *TxBuff = NULL;
1060 }
1061
1062 // Check for a TX Error interrupt
1063 Interrupts = Lan9118MmioRead32 (LAN9118_INT_STS);
1064 if (Interrupts & INSTS_TXE) {
1065 DEBUG ((EFI_D_ERROR, "LAN9118: Transmitter error. Restarting..."));
1066
1067 // Software reset, the TXE interrupt is cleared by the reset.
1068 Status = SoftReset (0, Snp);
1069 if (EFI_ERROR (Status)) {
1070 DEBUG ((EFI_D_ERROR, "\n\tSoft Reset Failed: Hardware Error\n"));
1071 return EFI_DEVICE_ERROR;
1072 }
1073
1074 // Reactivate the LEDs
1075 Status = ConfigureHardware (HW_CONF_USE_LEDS, Snp);
1076 if (EFI_ERROR (Status)) {
1077 return Status;
1078 }
1079
1080 //
1081 // Restart the transmitter and if necessary the receiver.
1082 // Do not ask for FIFO reset as it has already been done
1083 // by SoftReset().
1084 //
1085 StartTx (START_TX_MAC | START_TX_CFG, Snp);
1086 if (Snp->Mode->ReceiveFilterSetting != 0) {
1087 StartRx (0, Snp);
1088 }
1089 }
1090
1091 // Update the media status
1092 Status = CheckLinkStatus (0, Snp);
1093 if (EFI_ERROR(Status)) {
1094 Snp->Mode->MediaPresent = FALSE;
1095 } else {
1096 Snp->Mode->MediaPresent = TRUE;
1097 }
1098
1099 return EFI_SUCCESS;
1100 }
1101
1102
1103 /*
1104 * UEFI Transmit() function
1105 *
1106 */
1107 EFI_STATUS
1108 EFIAPI
1109 SnpTransmit (
1110 IN EFI_SIMPLE_NETWORK_PROTOCOL *Snp,
1111 IN UINTN HdrSize,
1112 IN UINTN BuffSize,
1113 IN VOID* Data,
1114 IN EFI_MAC_ADDRESS *SrcAddr OPTIONAL,
1115 IN EFI_MAC_ADDRESS *DstAddr OPTIONAL,
1116 IN UINT16 *Protocol OPTIONAL
1117 )
1118 {
1119 LAN9118_DRIVER *LanDriver;
1120 UINT32 TxFreeSpace;
1121 UINT32 TxStatusSpace;
1122 INT32 Count;
1123 UINT32 CommandA;
1124 UINT32 CommandB;
1125 UINT16 LocalProtocol;
1126 UINT32 *LocalData;
1127 UINT16 PacketTag;
1128
1129 #if defined(EVAL_PERFORMANCE)
1130 UINT64 Perf;
1131 UINT64 StartClock;
1132 UINT64 EndClock;
1133
1134 Perf = GetPerformanceCounterProperties (NULL, NULL);
1135 StartClock = GetPerformanceCounter ();
1136 #endif
1137
1138 LanDriver = INSTANCE_FROM_SNP_THIS (Snp);
1139
1140 // Check preliminaries
1141 if ((Snp == NULL) || (Data == NULL)) {
1142 return EFI_INVALID_PARAMETER;
1143 }
1144
1145 // Check that driver was started and initialised
1146 if (Snp->Mode->State == EfiSimpleNetworkStarted) {
1147 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver not initialized\n"));
1148 return EFI_DEVICE_ERROR;
1149 } else if (Snp->Mode->State == EfiSimpleNetworkStopped) {
1150 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver in stopped state\n"));
1151 return EFI_NOT_STARTED;
1152 }
1153
1154 // Ensure header is correct size if non-zero
1155 if (HdrSize) {
1156 if (HdrSize != Snp->Mode->MediaHeaderSize) {
1157 return EFI_INVALID_PARAMETER;
1158 }
1159
1160 if ((DstAddr == NULL) || (Protocol == NULL)) {
1161 return EFI_INVALID_PARAMETER;
1162 }
1163 }
1164
1165 //
1166 // Check validity of BufferSize
1167 //
1168 if (BuffSize < Snp->Mode->MediaHeaderSize) {
1169 return EFI_BUFFER_TOO_SMALL;
1170 }
1171
1172 // Before transmitting check the link status
1173 /*if (CheckLinkStatus (0, Snp) < 0) {
1174 return EFI_NOT_READY;
1175 }*/
1176
1177 // Get DATA FIFO free space in bytes
1178 TxFreeSpace = TxDataFreeSpace (0, Snp);
1179 if (TxFreeSpace < BuffSize) {
1180 return EFI_NOT_READY;
1181 }
1182
1183 // Get STATUS FIFO used space in bytes
1184 TxStatusSpace = TxStatusUsedSpace (0, Snp);
1185 if (TxStatusSpace > 500) {
1186 return EFI_NOT_READY;
1187 }
1188
1189 // If DstAddr is not provided, get it from Buffer (we trust that the caller
1190 // has provided a well-formed frame).
1191 if (DstAddr == NULL) {
1192 DstAddr = (EFI_MAC_ADDRESS *) Data;
1193 }
1194
1195 // Check for the nature of the frame
1196 if ((DstAddr->Addr[0] & 0x1) == 1) {
1197 LanDriver->Stats.TxMulticastFrames += 1;
1198 } else {
1199 LanDriver->Stats.TxUnicastFrames += 1;
1200 }
1201
1202 // Check if broadcast
1203 if (DstAddr->Addr[0] == 0xFF) {
1204 LanDriver->Stats.TxBroadcastFrames += 1;
1205 }
1206
1207 PacketTag = LanDriver->NextPacketTag;
1208 LanDriver->NextPacketTag++;
1209
1210 if (HdrSize) {
1211
1212 // Format pointer
1213 LocalData = (UINT32*) Data;
1214 LocalProtocol = *Protocol;
1215
1216 // Create first buffer to pass to controller (for the header)
1217 CommandA = TX_CMD_A_FIRST_SEGMENT | TX_CMD_A_BUFF_SIZE (HdrSize);
1218 CommandB = TX_CMD_B_PACKET_TAG (PacketTag) | TX_CMD_B_PACKET_LENGTH (BuffSize);
1219
1220 // Write the commands first
1221 Lan9118MmioWrite32 (LAN9118_TX_DATA, CommandA);
1222 Lan9118MmioWrite32 (LAN9118_TX_DATA, CommandB);
1223
1224 // Write the destination address
1225 Lan9118MmioWrite32 (LAN9118_TX_DATA,
1226 (DstAddr->Addr[0]) |
1227 (DstAddr->Addr[1] << 8) |
1228 (DstAddr->Addr[2] << 16) |
1229 (DstAddr->Addr[3] << 24)
1230 );
1231
1232 Lan9118MmioWrite32 (LAN9118_TX_DATA,
1233 (DstAddr->Addr[4]) |
1234 (DstAddr->Addr[5] << 8) |
1235 (SrcAddr->Addr[0] << 16) | // Write the Source Address
1236 (SrcAddr->Addr[1] << 24)
1237 );
1238
1239 Lan9118MmioWrite32 (LAN9118_TX_DATA,
1240 (SrcAddr->Addr[2]) |
1241 (SrcAddr->Addr[3] << 8) |
1242 (SrcAddr->Addr[4] << 16) |
1243 (SrcAddr->Addr[5] << 24)
1244 );
1245
1246 // Write the Protocol
1247 Lan9118MmioWrite32 (LAN9118_TX_DATA, (UINT32)(HTONS (LocalProtocol)));
1248
1249 // Next buffer is the payload
1250 CommandA = TX_CMD_A_LAST_SEGMENT | TX_CMD_A_BUFF_SIZE (BuffSize - HdrSize) | TX_CMD_A_COMPLETION_INT | TX_CMD_A_DATA_START_OFFSET (2); // 2 bytes beginning offset
1251
1252 // Write the commands
1253 Lan9118MmioWrite32 (LAN9118_TX_DATA, CommandA);
1254 Lan9118MmioWrite32 (LAN9118_TX_DATA, CommandB);
1255
1256 // Write the payload
1257 for (Count = 0; Count < ((BuffSize + 3) >> 2) - 3; Count++) {
1258 Lan9118MmioWrite32 (LAN9118_TX_DATA, LocalData[Count + 3]);
1259 }
1260 } else {
1261 // Format pointer
1262 LocalData = (UINT32*) Data;
1263
1264 // Create a buffer to pass to controller
1265 CommandA = TX_CMD_A_FIRST_SEGMENT | TX_CMD_A_LAST_SEGMENT | TX_CMD_A_BUFF_SIZE (BuffSize) | TX_CMD_A_COMPLETION_INT;
1266 CommandB = TX_CMD_B_PACKET_TAG (PacketTag) | TX_CMD_B_PACKET_LENGTH (BuffSize);
1267
1268 // Write the commands first
1269 Lan9118MmioWrite32 (LAN9118_TX_DATA, CommandA);
1270 Lan9118MmioWrite32 (LAN9118_TX_DATA, CommandB);
1271
1272 // Write all the data
1273 for (Count = 0; Count < ((BuffSize + 3) >> 2); Count++) {
1274 Lan9118MmioWrite32 (LAN9118_TX_DATA, LocalData[Count]);
1275 }
1276 }
1277
1278 // Save the address of the submitted packet so we can notify the consumer that
1279 // it has been sent in GetStatus. When the packet tag appears in the Tx Status
1280 // Fifo, we will return Buffer in the TxBuff parameter of GetStatus.
1281 LanDriver->TxRing[PacketTag % LAN9118_TX_RING_NUM_ENTRIES] = Data;
1282
1283 #if defined(EVAL_PERFORMANCE)
1284 EndClock = GetPerformanceCounter ();
1285 DEBUG ((EFI_D_ERROR, "Time processing: %d counts @ %d Hz\n", StartClock - EndClock,Perf));
1286 #endif
1287
1288 LanDriver->Stats.TxGoodFrames += 1;
1289
1290 return EFI_SUCCESS;
1291 }
1292
1293
1294 /*
1295 * UEFI Receive() function
1296 *
1297 */
1298 EFI_STATUS
1299 EFIAPI
1300 SnpReceive (
1301 IN EFI_SIMPLE_NETWORK_PROTOCOL* Snp,
1302 OUT UINTN *HdrSize OPTIONAL,
1303 IN OUT UINTN *BuffSize,
1304 OUT VOID *Data,
1305 OUT EFI_MAC_ADDRESS *SrcAddr OPTIONAL,
1306 OUT EFI_MAC_ADDRESS *DstAddr OPTIONAL,
1307 OUT UINT16 *Protocol OPTIONAL
1308 )
1309 {
1310 LAN9118_DRIVER *LanDriver;
1311 UINT32 IntSts;
1312 UINT32 RxFifoStatus;
1313 UINT32 NumPackets;
1314 UINT32 RxCfgValue;
1315 UINT32 PLength; // Packet length
1316 UINT32 ReadLimit;
1317 UINT32 Count;
1318 UINT32 Padding;
1319 UINT32 *RawData;
1320 EFI_MAC_ADDRESS Dst;
1321 EFI_MAC_ADDRESS Src;
1322 UINTN DroppedFrames;
1323 EFI_STATUS Status;
1324
1325 LanDriver = INSTANCE_FROM_SNP_THIS (Snp);
1326
1327 #if defined(EVAL_PERFORMANCE)
1328 UINT64 Perf = GetPerformanceCounterProperties (NULL, NULL);
1329 UINT64 StartClock = GetPerformanceCounter ();
1330 #endif
1331
1332 // Check preliminaries
1333 if ((Snp == NULL) || (Data == NULL) || (BuffSize == NULL)) {
1334 return EFI_INVALID_PARAMETER;
1335 }
1336
1337 // Check that driver was started and initialised
1338 if (Snp->Mode->State == EfiSimpleNetworkStarted) {
1339 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver not initialized\n"));
1340 return EFI_DEVICE_ERROR;
1341 } else if (Snp->Mode->State == EfiSimpleNetworkStopped) {
1342 DEBUG ((EFI_D_WARN, "Warning: LAN9118 Driver in stopped state\n"));
1343 return EFI_NOT_STARTED;
1344 }
1345
1346 //
1347 // If the receiver raised the RXE error bit, check if the receiver status
1348 // FIFO is full and if not just acknowledge the error. The two other
1349 // conditions to get a RXE error are :
1350 // . the RX data FIFO is read whereas being empty.
1351 // . the RX status FIFO is read whereas being empty.
1352 // The RX data and status FIFO are read by this driver only in the following
1353 // code of this function. After the readings, the RXE error bit is checked
1354 // and if raised, the controller is reset. Thus, at this point, we consider
1355 // that the only valid reason to get an RXE error is the receiver status
1356 // FIFO being full. And if this is not the case, we consider that this is
1357 // a spurious error and we just get rid of it. We experienced such 'spurious'
1358 // errors when running the driver on an A57 on Juno. No valid reason to
1359 // explain those errors has been found so far and everything seems to
1360 // work perfectly when they are just ignored.
1361 //
1362 IntSts = Lan9118MmioRead32 (LAN9118_INT_STS);
1363 if ((IntSts & INSTS_RXE) && (!(IntSts & INSTS_RSFF))) {
1364 Lan9118MmioWrite32 (LAN9118_INT_STS, INSTS_RXE);
1365 }
1366
1367 // Count dropped frames
1368 DroppedFrames = Lan9118MmioRead32 (LAN9118_RX_DROP);
1369 LanDriver->Stats.RxDroppedFrames += DroppedFrames;
1370
1371 NumPackets = RxStatusUsedSpace (0, Snp) / 4;
1372 if (!NumPackets) {
1373 return EFI_NOT_READY;
1374 }
1375
1376 // Read Rx Status (only if not empty)
1377 RxFifoStatus = Lan9118MmioRead32 (LAN9118_RX_STATUS);
1378 LanDriver->Stats.RxTotalFrames += 1;
1379
1380 // First check for errors
1381 if ((RxFifoStatus & RXSTATUS_MII_ERROR) ||
1382 (RxFifoStatus & RXSTATUS_RXW_TO) ||
1383 (RxFifoStatus & RXSTATUS_FTL) ||
1384 (RxFifoStatus & RXSTATUS_LCOLL) ||
1385 (RxFifoStatus & RXSTATUS_LE) ||
1386 (RxFifoStatus & RXSTATUS_DB))
1387 {
1388 DEBUG ((EFI_D_WARN, "Warning: There was an error on frame reception.\n"));
1389 return EFI_DEVICE_ERROR;
1390 }
1391
1392 // Check if we got a CRC error
1393 if (RxFifoStatus & RXSTATUS_CRC_ERROR) {
1394 DEBUG ((EFI_D_WARN, "Warning: Crc Error\n"));
1395 LanDriver->Stats.RxCrcErrorFrames += 1;
1396 LanDriver->Stats.RxDroppedFrames += 1;
1397 return EFI_DEVICE_ERROR;
1398 }
1399
1400 // Check if we got a runt frame
1401 if (RxFifoStatus & RXSTATUS_RUNT) {
1402 DEBUG ((EFI_D_WARN, "Warning: Runt Frame\n"));
1403 LanDriver->Stats.RxUndersizeFrames += 1;
1404 LanDriver->Stats.RxDroppedFrames += 1;
1405 return EFI_DEVICE_ERROR;
1406 }
1407
1408 // Check filtering status for this packet
1409 if (RxFifoStatus & RXSTATUS_FILT_FAIL) {
1410 DEBUG ((EFI_D_WARN, "Warning: Frame Failed Filtering\n"));
1411 // fast forward?
1412 }
1413
1414 // Check if we got a broadcast frame
1415 if (RxFifoStatus & RXSTATUS_BCF) {
1416 LanDriver->Stats.RxBroadcastFrames += 1;
1417 }
1418
1419 // Check if we got a multicast frame
1420 if (RxFifoStatus & RXSTATUS_MCF) {
1421 LanDriver->Stats.RxMulticastFrames += 1;
1422 }
1423
1424 // Check if we got a unicast frame
1425 if ((RxFifoStatus & RXSTATUS_BCF) && ((RxFifoStatus & RXSTATUS_MCF) == 0)) {
1426 LanDriver->Stats.RxUnicastFrames += 1;
1427 }
1428
1429 // Get the received packet length
1430 PLength = GET_RXSTATUS_PACKET_LENGTH(RxFifoStatus);
1431 LanDriver->Stats.RxTotalBytes += (PLength - 4);
1432
1433 // If padding is applied, read more DWORDs
1434 if (PLength % 4) {
1435 Padding = 4 - (PLength % 4);
1436 ReadLimit = (PLength + Padding)/4;
1437 } else {
1438 ReadLimit = PLength/4;
1439 Padding = 0;
1440 }
1441
1442 // Check buffer size
1443 if (*BuffSize < (PLength + Padding)) {
1444 *BuffSize = PLength + Padding;
1445 return EFI_BUFFER_TOO_SMALL;
1446 }
1447
1448 // Set the amount of data to be transfered out of FIFO for THIS packet
1449 // This can be used to trigger an interrupt, and status can be checked
1450 RxCfgValue = Lan9118MmioRead32 (LAN9118_RX_CFG);
1451 RxCfgValue &= ~(RXCFG_RX_DMA_CNT_MASK);
1452 RxCfgValue |= RXCFG_RX_DMA_CNT (ReadLimit);
1453
1454 // Set end alignment to 4-bytes
1455 RxCfgValue &= ~(RXCFG_RX_END_ALIGN_MASK);
1456 Lan9118MmioWrite32 (LAN9118_RX_CFG, RxCfgValue);
1457
1458 // Update buffer size
1459 *BuffSize = PLength; // -4 bytes may be needed: Received in buffer as
1460 // 4 bytes longer than packet actually is, unless
1461 // packet is < 64 bytes
1462
1463 if (HdrSize != NULL)
1464 *HdrSize = Snp->Mode->MediaHeaderSize;
1465
1466 // Format the pointer
1467 RawData = (UINT32*)Data;
1468
1469 // Read Rx Packet
1470 for (Count = 0; Count < ReadLimit; Count++) {
1471 RawData[Count] = Lan9118MmioRead32 (LAN9118_RX_DATA);
1472 }
1473
1474 // Get the destination address
1475 if (DstAddr != NULL) {
1476 Dst.Addr[0] = (RawData[0] & 0xFF);
1477 Dst.Addr[1] = (RawData[0] & 0xFF00) >> 8;
1478 Dst.Addr[2] = (RawData[0] & 0xFF0000) >> 16;
1479 Dst.Addr[3] = (RawData[0] & 0xFF000000) >> 24;
1480 Dst.Addr[4] = (RawData[1] & 0xFF);
1481 Dst.Addr[5] = (RawData[1] & 0xFF00) >> 8;
1482 CopyMem (DstAddr, &Dst, NET_ETHER_ADDR_LEN);
1483 }
1484
1485 // Get the source address
1486 if (SrcAddr != NULL) {
1487 Src.Addr[0] = (RawData[1] & 0xFF0000) >> 16;
1488 Src.Addr[1] = (RawData[1] & 0xFF000000) >> 24;
1489 Src.Addr[2] = (RawData[2] & 0xFF);
1490 Src.Addr[3] = (RawData[2] & 0xFF00) >> 8;
1491 Src.Addr[4] = (RawData[2] & 0xFF0000) >> 16;
1492 Src.Addr[5] = (RawData[2] & 0xFF000000) >> 24;
1493 CopyMem (SrcAddr, &Src, NET_ETHER_ADDR_LEN);
1494 }
1495
1496 // Get the protocol
1497 if (Protocol != NULL) {
1498 *Protocol = NTOHS (RawData[3] & 0xFFFF);
1499 }
1500
1501 // Check for Rx errors (worst possible error)
1502 if (Lan9118MmioRead32 (LAN9118_INT_STS) & INSTS_RXE) {
1503 DEBUG ((EFI_D_WARN, "Warning: Receiver Error. Restarting...\n"));
1504
1505 // Software reset, the RXE interrupt is cleared by the reset.
1506 Status = SoftReset (0, Snp);
1507 if (EFI_ERROR (Status)) {
1508 DEBUG ((EFI_D_ERROR, "Error: Soft Reset Failed: Hardware Error.\n"));
1509 return EFI_DEVICE_ERROR;
1510 }
1511
1512 // Reactivate the LEDs
1513 Status = ConfigureHardware (HW_CONF_USE_LEDS, Snp);
1514 if (EFI_ERROR (Status)) {
1515 return Status;
1516 }
1517
1518 //
1519 // Restart the receiver and the transmitter without resetting the FIFOs
1520 // as it has been done by SoftReset().
1521 //
1522 StartRx (0, Snp);
1523 StartTx (START_TX_MAC | START_TX_CFG, Snp);
1524
1525 // Say that command could not be sent
1526 return EFI_DEVICE_ERROR;
1527 }
1528
1529 #if defined(EVAL_PERFORMANCE)
1530 UINT64 EndClock = GetPerformanceCounter ();
1531 DEBUG ((EFI_D_ERROR, "Receive Time processing: %d counts @ %d Hz\n", StartClock - EndClock,Perf));
1532 #endif
1533
1534 LanDriver->Stats.RxGoodFrames += 1;
1535
1536 return EFI_SUCCESS;
1537 }