2 Provides basic function upon network adapter card.
4 Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>
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
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.
17 UINT8 basic_config_cmd
[22] = {
27 (UINT8
)0xf2, (UINT8
)0x80, // 0x40=Force full-duplex
32 // How to wait for the command unit to accept a command.
33 // Typically this takes 0 ticks.
35 #define wait_for_cmd_done(cmd_ioaddr) \
37 INT16 wait_count = 2000; \
38 while ((InByte (AdapterInfo, cmd_ioaddr) != 0) && --wait_count >= 0) \
39 DelayIt (AdapterInfo, 10); \
40 if (wait_count == 0) \
41 DelayIt (AdapterInfo, 50); \
46 This function calls the MemIo callback to read a byte from the device's
48 Since UNDI3.0 uses the TmpMemIo function (instead of the callback routine)
49 which also takes the UniqueId parameter (as in UNDI3.1 spec) we don't have
50 to make undi3.0 a special case
52 @param Port Which port to read from.
54 @retval Results The data read from the port.
57 // TODO: AdapterInfo - add argument and description to function comment
60 IN NIC_DATA_INSTANCE
*AdapterInfo
,
66 (*AdapterInfo
->Mem_Io
) (
67 AdapterInfo
->Unique_ID
,
71 (UINT64
) (UINTN
) &Results
78 This function calls the MemIo callback to read a word from the device's
80 Since UNDI3.0 uses the TmpMemIo function (instead of the callback routine)
81 which also takes the UniqueId parameter (as in UNDI3.1 spec) we don't have
82 to make undi3.0 a special case
84 @param Port Which port to read from.
86 @retval Results The data read from the port.
89 // TODO: AdapterInfo - add argument and description to function comment
92 IN NIC_DATA_INSTANCE
*AdapterInfo
,
98 (*AdapterInfo
->Mem_Io
) (
99 AdapterInfo
->Unique_ID
,
103 (UINT64
)(UINTN
)&Results
110 This function calls the MemIo callback to read a dword from the device's
112 Since UNDI3.0 uses the TmpMemIo function (instead of the callback routine)
113 which also takes the UniqueId parameter (as in UNDI3.1 spec) we don't have
114 to make undi3.0 a special case
116 @param Port Which port to read from.
118 @retval Results The data read from the port.
121 // TODO: AdapterInfo - add argument and description to function comment
124 IN NIC_DATA_INSTANCE
*AdapterInfo
,
130 (*AdapterInfo
->Mem_Io
) (
131 AdapterInfo
->Unique_ID
,
135 (UINT64
)(UINTN
)&Results
142 This function calls the MemIo callback to write a byte from the device's
144 Since UNDI3.0 uses the TmpMemIo function (instead of the callback routine)
145 which also takes the UniqueId parameter (as in UNDI3.1 spec) we don't have
146 to make undi3.0 a special case
148 @param Data Data to write to Port.
149 @param Port Which port to write to.
154 // TODO: AdapterInfo - add argument and description to function comment
157 IN NIC_DATA_INSTANCE
*AdapterInfo
,
165 (*AdapterInfo
->Mem_Io
) (
166 AdapterInfo
->Unique_ID
,
170 (UINT64
)(UINTN
)(UINTN
)&Val
177 This function calls the MemIo callback to write a word from the device's
179 Since UNDI3.0 uses the TmpMemIo function (instead of the callback routine)
180 which also takes the UniqueId parameter (as in UNDI3.1 spec) we don't have
181 to make undi3.0 a special case
183 @param Data Data to write to Port.
184 @param Port Which port to write to.
189 // TODO: AdapterInfo - add argument and description to function comment
192 IN NIC_DATA_INSTANCE
*AdapterInfo
,
200 (*AdapterInfo
->Mem_Io
) (
201 AdapterInfo
->Unique_ID
,
212 This function calls the MemIo callback to write a dword from the device's
214 Since UNDI3.0 uses the TmpMemIo function (instead of the callback routine)
215 which also takes the UniqueId parameter (as in UNDI3.1 spec) we don't have
216 to make undi3.0 a special case
218 @param Data Data to write to Port.
219 @param Port Which port to write to.
224 // TODO: AdapterInfo - add argument and description to function comment
227 IN NIC_DATA_INSTANCE
*AdapterInfo
,
235 (*AdapterInfo
->Mem_Io
) (
236 AdapterInfo
->Unique_ID
,
247 TODO: Add function description
249 @param AdapterInfo TODO: add argument description
250 @param MemAddr TODO: add argument description
251 @param Size TODO: add argument description
252 @param Direction TODO: add argument description
253 @param MappedAddr TODO: add argument description
255 @return TODO: add return values
260 IN NIC_DATA_INSTANCE
*AdapterInfo
,
264 OUT UINT64 MappedAddr
269 PhyAddr
= (UINT64
*) (UINTN
) MappedAddr
;
271 // mapping is different for theold and new NII protocols
273 if (AdapterInfo
->VersionFlag
== 0x30) {
274 if (AdapterInfo
->Virt2Phys_30
== (VOID
*) NULL
) {
275 *PhyAddr
= (UINT64
) AdapterInfo
->MemoryPtr
;
277 (*AdapterInfo
->Virt2Phys_30
) (MemAddr
, (UINT64
) (UINTN
) PhyAddr
);
280 if (*PhyAddr
> FOUR_GIGABYTE
) {
281 return PXE_STATCODE_INVALID_PARAMETER
;
284 if (AdapterInfo
->Map_Mem
== (VOID
*) NULL
) {
286 // this UNDI cannot handle addresses beyond 4 GB without a map routine
288 if (MemAddr
> FOUR_GIGABYTE
) {
289 return PXE_STATCODE_INVALID_PARAMETER
;
294 (*AdapterInfo
->Map_Mem
) (
295 AdapterInfo
->Unique_ID
,
304 return PXE_STATCODE_SUCCESS
;
309 TODO: Add function description
311 @param AdapterInfo TODO: add argument description
312 @param MemAddr TODO: add argument description
313 @param Size TODO: add argument description
314 @param Direction TODO: add argument description
315 @param MappedAddr TODO: add argument description
317 @return TODO: add return values
322 IN NIC_DATA_INSTANCE
*AdapterInfo
,
329 if (AdapterInfo
->VersionFlag
> 0x30) {
331 // no mapping service
333 if (AdapterInfo
->UnMap_Mem
!= (VOID
*) NULL
) {
334 (*AdapterInfo
->UnMap_Mem
) (
335 AdapterInfo
->Unique_ID
,
351 @param AdapterInfo Pointer to the NIC data structure
352 information which the UNDI driver is
357 // TODO: MicroSeconds - add argument and description to function comment
360 IN NIC_DATA_INSTANCE
*AdapterInfo
,
364 if (AdapterInfo
->VersionFlag
== 0x30) {
365 (*AdapterInfo
->Delay_30
) (MicroSeconds
);
367 (*AdapterInfo
->Delay
) (AdapterInfo
->Unique_ID
, MicroSeconds
);
374 @param AdapterInfo Pointer to the NIC data structure
375 information which the UNDI driver is
380 // TODO: flag - add argument and description to function comment
383 IN NIC_DATA_INSTANCE
*AdapterInfo
,
387 if (AdapterInfo
->VersionFlag
== 0x30) {
388 (*AdapterInfo
->Block_30
) (flag
);
390 (*AdapterInfo
->Block
) (AdapterInfo
->Unique_ID
, flag
);
396 TODO: Add function description
398 @param AdapterInfo TODO: add argument description
400 @return TODO: add return values
405 NIC_DATA_INSTANCE
*AdapterInfo
409 // we will use the linear (flat) memory model and fill our base registers
410 // with 0's so that the entire physical address is our offset
413 // we reset the statistics totals here because this is where we are loading stats addr
415 AdapterInfo
->RxTotals
= 0;
416 AdapterInfo
->TxTotals
= 0;
419 // Load the statistics block address.
421 wait_for_cmd_done (AdapterInfo
->ioaddr
+ SCBCmd
);
422 OutLong (AdapterInfo
, (UINT32
) AdapterInfo
->stat_phy_addr
, AdapterInfo
->ioaddr
+ SCBPointer
);
423 OutByte (AdapterInfo
, CU_STATSADDR
, AdapterInfo
->ioaddr
+ SCBCmd
);
424 AdapterInfo
->statistics
->done_marker
= 0;
426 wait_for_cmd_done (AdapterInfo
->ioaddr
+ SCBCmd
);
427 OutLong (AdapterInfo
, 0, AdapterInfo
->ioaddr
+ SCBPointer
);
428 OutByte (AdapterInfo
, RX_ADDR_LOAD
, AdapterInfo
->ioaddr
+ SCBCmd
);
430 wait_for_cmd_done (AdapterInfo
->ioaddr
+ SCBCmd
);
431 OutLong (AdapterInfo
, 0, AdapterInfo
->ioaddr
+ SCBPointer
);
432 OutByte (AdapterInfo
, CU_CMD_BASE
, AdapterInfo
->ioaddr
+ SCBCmd
);
439 TODO: Add function description
441 @param AdapterInfo TODO: add argument description
442 @param cmd_ptr TODO: add argument description
444 @return TODO: add return values
449 NIC_DATA_INSTANCE
*AdapterInfo
,
455 wait_for_cmd_done (AdapterInfo
->ioaddr
+ SCBCmd
);
458 // read the CU status, if it is idle, write the address of cb_ptr
459 // in the scbpointer and issue a cu_start,
460 // if it is suspended, remove the suspend bit in the previous command
461 // block and issue a resume
463 // Ensure that the CU Active Status bit is not on from previous CBs.
465 status
= InWord (AdapterInfo
, AdapterInfo
->ioaddr
+ SCBStatus
);
468 // Skip acknowledging the interrupt if it is not already set
472 // ack only the cna the integer
474 if ((status
& SCB_STATUS_CNA
) != 0) {
475 OutWord (AdapterInfo
, SCB_STATUS_CNA
, AdapterInfo
->ioaddr
+ SCBStatus
);
479 if ((status
& SCB_STATUS_CU_MASK
) == SCB_STATUS_CU_IDLE
) {
483 OutLong (AdapterInfo
, cmd_ptr
->PhysTCBAddress
, AdapterInfo
->ioaddr
+ SCBPointer
);
484 OutByte (AdapterInfo
, CU_START
, AdapterInfo
->ioaddr
+ SCBCmd
);
487 // either active or suspended, give a resume
490 cmd_ptr
->PrevTCBVirtualLinkPtr
->cb_header
.command
&= ~(CmdSuspend
| CmdIntr
);
491 OutByte (AdapterInfo
, CU_RESUME
, AdapterInfo
->ioaddr
+ SCBCmd
);
499 TODO: Add function description
501 @param AdapterInfo TODO: add argument description
503 @return TODO: add return values
508 NIC_DATA_INSTANCE
*AdapterInfo
512 // all command blocks are of TxCB format
516 volatile INT16 Index
;
519 cmd_ptr
= GetFreeCB (AdapterInfo
);
520 ASSERT (cmd_ptr
!= NULL
);
521 data_ptr
= (UINT8
*) cmd_ptr
+ sizeof (struct CB_Header
);
524 // start the config data right after the command header
526 for (Index
= 0; Index
< sizeof (basic_config_cmd
); Index
++) {
527 data_ptr
[Index
] = basic_config_cmd
[Index
];
530 my_filter
= (UINT8
) ((AdapterInfo
->Rx_Filter
& PXE_OPFLAGS_RECEIVE_FILTER_PROMISCUOUS
) ? 1 : 0);
531 my_filter
= (UINT8
) (my_filter
| ((AdapterInfo
->Rx_Filter
& PXE_OPFLAGS_RECEIVE_FILTER_BROADCAST
) ? 0 : 2));
533 data_ptr
[15] = (UINT8
) (data_ptr
[15] | my_filter
);
534 data_ptr
[19] = (UINT8
) (AdapterInfo
->Duplex
? 0xC0 : 0x80);
535 data_ptr
[21] = (UINT8
) ((AdapterInfo
->Rx_Filter
& PXE_OPFLAGS_RECEIVE_FILTER_ALL_MULTICAST
) ? 0x0D : 0x05);
538 // check if we have to use the AUI port instead
540 if ((AdapterInfo
->PhyRecord
[0] & 0x8000) != 0) {
541 data_ptr
[15] |= 0x80;
545 BlockIt (AdapterInfo
, TRUE
);
546 cmd_ptr
->cb_header
.command
= CmdSuspend
| CmdConfigure
;
548 IssueCB (AdapterInfo
, cmd_ptr
);
549 wait_for_cmd_done (AdapterInfo
->ioaddr
+ SCBCmd
);
551 BlockIt (AdapterInfo
, FALSE
);
553 CommandWaitForCompletion (cmd_ptr
, AdapterInfo
);
556 // restore the cb values for tx
558 cmd_ptr
->PhysTBDArrayAddres
= cmd_ptr
->PhysArrayAddr
;
559 cmd_ptr
->ByteCount
= cmd_ptr
->Threshold
= cmd_ptr
->TBDCount
= 0;
561 // fields beyond the immediatedata are assumed to be safe
562 // add the CB to the free list again
564 SetFreeCB (AdapterInfo
, cmd_ptr
);
570 TODO: Add function description
572 @param AdapterInfo TODO: add argument description
574 @return TODO: add return values
579 NIC_DATA_INSTANCE
*AdapterInfo
583 // all command blocks are of TxCB format
589 eaddrs
= (UINT16
*) AdapterInfo
->CurrentNodeAddress
;
591 cmd_ptr
= GetFreeCB (AdapterInfo
);
592 ASSERT (cmd_ptr
!= NULL
);
593 data_ptr
= (UINT16
*) ((UINT8
*) cmd_ptr
+sizeof (struct CB_Header
));
596 // AVOID a bug (?!) here by marking the command already completed.
598 cmd_ptr
->cb_header
.command
= (CmdSuspend
| CmdIASetup
);
599 cmd_ptr
->cb_header
.status
= 0;
600 data_ptr
[0] = eaddrs
[0];
601 data_ptr
[1] = eaddrs
[1];
602 data_ptr
[2] = eaddrs
[2];
604 BlockIt (AdapterInfo
, TRUE
);
605 IssueCB (AdapterInfo
, cmd_ptr
);
606 wait_for_cmd_done (AdapterInfo
->ioaddr
+ SCBCmd
);
607 BlockIt (AdapterInfo
, FALSE
);
609 CommandWaitForCompletion (cmd_ptr
, AdapterInfo
);
612 // restore the cb values for tx
614 cmd_ptr
->PhysTBDArrayAddres
= cmd_ptr
->PhysArrayAddr
;
615 cmd_ptr
->ByteCount
= cmd_ptr
->Threshold
= cmd_ptr
->TBDCount
= 0;
617 // fields beyond the immediatedata are assumed to be safe
618 // add the CB to the free list again
620 SetFreeCB (AdapterInfo
, cmd_ptr
);
626 Instructs the NIC to stop receiving packets.
628 @param AdapterInfo Pointer to the NIC data structure
629 information which the UNDI driver is
636 IN NIC_DATA_INSTANCE
*AdapterInfo
639 if (AdapterInfo
->Receive_Started
) {
642 // Todo: verify that we must wait for previous command completion.
644 wait_for_cmd_done (AdapterInfo
->ioaddr
+ SCBCmd
);
647 // Disable interrupts, and stop the chip's Rx process.
649 OutWord (AdapterInfo
, INT_MASK
, AdapterInfo
->ioaddr
+ SCBCmd
);
650 OutWord (AdapterInfo
, INT_MASK
| RX_ABORT
, AdapterInfo
->ioaddr
+ SCBCmd
);
652 AdapterInfo
->Receive_Started
= FALSE
;
660 Instructs the NIC to start receiving packets.
662 @param AdapterInfo Pointer to the NIC data structure
663 information which the UNDI driver is
667 @retval -1 Already Started
672 NIC_DATA_INSTANCE
*AdapterInfo
676 if (AdapterInfo
->Receive_Started
) {
683 AdapterInfo
->cur_rx_ind
= 0;
684 AdapterInfo
->Int_Status
= 0;
686 wait_for_cmd_done (AdapterInfo
->ioaddr
+ SCBCmd
);
688 OutLong (AdapterInfo
, (UINT32
) AdapterInfo
->rx_phy_addr
, AdapterInfo
->ioaddr
+ SCBPointer
);
689 OutByte (AdapterInfo
, RX_START
, AdapterInfo
->ioaddr
+ SCBCmd
);
691 wait_for_cmd_done (AdapterInfo
->ioaddr
+ SCBCmd
);
693 AdapterInfo
->Receive_Started
= TRUE
;
699 Configures the chip. This routine expects the NIC_DATA_INSTANCE structure to be filled in.
701 @param AdapterInfo Pointer to the NIC data structure
702 information which the UNDI driver is
706 @retval PXE_STATCODE_NOT_ENOUGH_MEMORY Insufficient length of locked memory
707 @retval other Failure initializing chip
712 IN NIC_DATA_INSTANCE
*AdapterInfo
715 PCI_CONFIG_HEADER
*CfgHdr
;
720 if (AdapterInfo
->MemoryLength
< MEMORY_NEEDED
) {
721 return PXE_STATCODE_NOT_ENOUGH_MEMORY
;
726 AdapterInfo
->MemoryPtr
,
727 AdapterInfo
->MemoryLength
,
729 (UINT64
)(UINTN
) &AdapterInfo
->Mapped_MemoryPtr
736 CfgHdr
= (PCI_CONFIG_HEADER
*) &(AdapterInfo
->Config
[0]);
739 // fill in the ioaddr, int... from the config space
741 AdapterInfo
->int_num
= CfgHdr
->int_line
;
744 // we don't need to validate integer number, what if they don't want to assign one?
745 // if (AdapterInfo->int_num == 0 || AdapterInfo->int_num == 0xff)
746 // return PXE_STATCODE_DEVICE_FAILURE;
748 AdapterInfo
->ioaddr
= 0;
749 AdapterInfo
->VendorID
= CfgHdr
->VendorID
;
750 AdapterInfo
->DeviceID
= CfgHdr
->DeviceID
;
751 AdapterInfo
->RevID
= CfgHdr
->RevID
;
752 AdapterInfo
->SubVendorID
= CfgHdr
->SubVendorID
;
753 AdapterInfo
->SubSystemID
= CfgHdr
->SubSystemID
;
754 AdapterInfo
->flash_addr
= 0;
757 // Read the station address EEPROM before doing the reset.
758 // Perhaps this should even be done before accepting the device,
759 // then we wouldn't have a device name with which to report the error.
761 if (E100bReadEepromAndStationAddress (AdapterInfo
) != 0) {
762 return PXE_STATCODE_DEVICE_FAILURE
;
766 // ## calculate the buffer #s depending on memory given
767 // ## calculate the rx and tx ring pointers
770 AdapterInfo
->TxBufCnt
= TX_BUFFER_COUNT
;
771 AdapterInfo
->RxBufCnt
= RX_BUFFER_COUNT
;
772 rx_size
= (AdapterInfo
->RxBufCnt
* sizeof (RxFD
));
773 tx_size
= (AdapterInfo
->TxBufCnt
* sizeof (TxCB
));
774 AdapterInfo
->rx_ring
= (RxFD
*) (UINTN
) (AdapterInfo
->MemoryPtr
);
775 AdapterInfo
->tx_ring
= (TxCB
*) (UINTN
) (AdapterInfo
->MemoryPtr
+ rx_size
);
776 AdapterInfo
->statistics
= (struct speedo_stats
*) (UINTN
) (AdapterInfo
->MemoryPtr
+ rx_size
+ tx_size
);
778 AdapterInfo
->rx_phy_addr
= AdapterInfo
->Mapped_MemoryPtr
;
779 AdapterInfo
->tx_phy_addr
= AdapterInfo
->Mapped_MemoryPtr
+ rx_size
;
780 AdapterInfo
->stat_phy_addr
= AdapterInfo
->tx_phy_addr
+ tx_size
;
785 AdapterInfo
->PhyAddress
= 0xFF;
786 AdapterInfo
->Rx_Filter
= PXE_OPFLAGS_RECEIVE_FILTER_BROADCAST
;
787 AdapterInfo
->Receive_Started
= FALSE
;
788 AdapterInfo
->mcast_list
.list_len
= 0;
789 return InitializeChip (AdapterInfo
);
794 Sets the interrupt state for the NIC.
796 @param AdapterInfo Pointer to the NIC data structure
797 information which the UNDI driver is
804 E100bSetInterruptState (
805 IN NIC_DATA_INSTANCE
*AdapterInfo
809 // don't set receive interrupt if receiver is disabled...
813 if ((AdapterInfo
->int_mask
& PXE_OPFLAGS_INTERRUPT_RECEIVE
) != 0) {
814 cmd_word
= InWord (AdapterInfo
, AdapterInfo
->ioaddr
+ SCBCmd
);
815 cmd_word
&= ~INT_MASK
;
816 OutWord (AdapterInfo
, cmd_word
, AdapterInfo
->ioaddr
+ SCBCmd
);
819 // disable ints, should not be given for SW Int.
821 OutWord (AdapterInfo
, INT_MASK
, AdapterInfo
->ioaddr
+ SCBCmd
);
824 if ((AdapterInfo
->int_mask
& PXE_OPFLAGS_INTERRUPT_SOFTWARE
) != 0) {
826 // reset the bit in our mask, it is only one time!!
828 AdapterInfo
->int_mask
&= ~(PXE_OPFLAGS_INTERRUPT_SOFTWARE
);
829 cmd_word
= InWord (AdapterInfo
, AdapterInfo
->ioaddr
+ SCBCmd
);
830 cmd_word
|= DRVR_INT
;
831 OutWord (AdapterInfo
, cmd_word
, AdapterInfo
->ioaddr
+ SCBCmd
);
837 // we are not going to disable broadcast for the WOL's sake!
841 Instructs the NIC to start receiving packets.
843 @param AdapterInfo Pointer to the NIC data structure
844 information which the UNDI driver is
845 layering on.. new_filter
850 @retval -1 Already Started
855 NIC_DATA_INSTANCE
*AdapterInfo
,
861 PXE_CPB_RECEIVE_FILTERS
*mc_list
= (PXE_CPB_RECEIVE_FILTERS
*) (UINTN
)cpb
;
868 struct MC_CB_STRUCT
*data_ptr
;
871 old_filter
= AdapterInfo
->Rx_Filter
;
874 // only these bits need a change in the configuration
875 // actually change in bcast requires configure but we ignore that change
877 cfg_flt
= PXE_OPFLAGS_RECEIVE_FILTER_PROMISCUOUS
|
878 PXE_OPFLAGS_RECEIVE_FILTER_ALL_MULTICAST
;
880 if ((old_filter
& cfg_flt
) != (new_filter
& cfg_flt
)) {
881 XmitWaitForCompletion (AdapterInfo
);
883 if (AdapterInfo
->Receive_Started
) {
884 StopRU (AdapterInfo
);
887 AdapterInfo
->Rx_Filter
= (UINT8
) (new_filter
| PXE_OPFLAGS_RECEIVE_FILTER_BROADCAST
);
888 Configure (AdapterInfo
);
892 // check if mcast setting changed
894 if ( ((new_filter
& PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST
) !=
895 (old_filter
& PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST
) ) ||
896 (mc_list
!= NULL
) ) {
899 if (mc_list
!= NULL
) {
900 mc_count
= AdapterInfo
->mcast_list
.list_len
= (UINT16
) (cpbsize
/ PXE_MAC_LENGTH
);
902 for (Index
= 0; (Index
< mc_count
&& Index
< MAX_MCAST_ADDRESS_CNT
); Index
++) {
903 for (Index2
= 0; Index2
< PXE_MAC_LENGTH
; Index2
++) {
904 AdapterInfo
->mcast_list
.mc_list
[Index
][Index2
] = mc_list
->MCastList
[Index
][Index2
];
910 // are we setting the list or resetting??
912 if ((new_filter
& PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST
) != 0) {
914 // we are setting a new list!
916 mc_count
= AdapterInfo
->mcast_list
.list_len
;
918 // count should be the actual # of bytes in the list
919 // so multiply this with 6
921 mc_byte_cnt
= (UINT16
) ((mc_count
<< 2) + (mc_count
<< 1));
922 AdapterInfo
->Rx_Filter
|= PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST
;
925 // disabling the list in the NIC.
927 mc_byte_cnt
= mc_count
= 0;
928 AdapterInfo
->Rx_Filter
&= (~PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST
);
932 // before issuing any new command!
934 XmitWaitForCompletion (AdapterInfo
);
936 if (AdapterInfo
->Receive_Started
) {
937 StopRU (AdapterInfo
);
941 cmd_ptr
= GetFreeCB (AdapterInfo
);
942 if (cmd_ptr
== NULL
) {
943 return PXE_STATCODE_QUEUE_FULL
;
946 // fill the command structure and issue
948 data_ptr
= (struct MC_CB_STRUCT
*) (&cmd_ptr
->PhysTBDArrayAddres
);
950 // first 2 bytes are the count;
952 data_ptr
->count
= mc_byte_cnt
;
953 for (Index
= 0; Index
< mc_count
; Index
++) {
954 for (Index2
= 0; Index2
< PXE_HWADDR_LEN_ETHER
; Index2
++) {
955 data_ptr
->m_list
[Index
][Index2
] = AdapterInfo
->mcast_list
.mc_list
[Index
][Index2
];
959 cmd_ptr
->cb_header
.command
= CmdSuspend
| CmdMulticastList
;
960 cmd_ptr
->cb_header
.status
= 0;
962 BlockIt (AdapterInfo
, TRUE
);
963 IssueCB (AdapterInfo
, cmd_ptr
);
964 wait_for_cmd_done (AdapterInfo
->ioaddr
+ SCBCmd
);
966 BlockIt (AdapterInfo
, FALSE
);
968 CommandWaitForCompletion (cmd_ptr
, AdapterInfo
);
970 cmd_ptr
->PhysTBDArrayAddres
= cmd_ptr
->PhysArrayAddr
;
971 cmd_ptr
->ByteCount
= cmd_ptr
->Threshold
= cmd_ptr
->TBDCount
= 0;
973 // fields beyond the immediatedata are assumed to be safe
974 // add the CB to the free list again
976 SetFreeCB (AdapterInfo
, cmd_ptr
);
979 if (new_filter
!= 0) {
981 // enable unicast and start the RU
983 AdapterInfo
->Rx_Filter
= (UINT8
) (AdapterInfo
->Rx_Filter
| (new_filter
| PXE_OPFLAGS_RECEIVE_FILTER_UNICAST
));
984 StartRU (AdapterInfo
);
987 // may be disabling everything!
989 if (AdapterInfo
->Receive_Started
) {
990 StopRU (AdapterInfo
);
993 AdapterInfo
->Rx_Filter
|= (~PXE_OPFLAGS_RECEIVE_FILTER_UNICAST
);
1001 TODO: Add function description
1003 @param AdapterInfo TODO: add argument description
1004 @param cpb TODO: add argument description
1005 @param opflags TODO: add argument description
1007 @return TODO: add return values
1012 NIC_DATA_INSTANCE
*AdapterInfo
,
1017 PXE_CPB_TRANSMIT_FRAGMENTS
*tx_ptr_f
;
1018 PXE_CPB_TRANSMIT
*tx_ptr_1
;
1025 tx_ptr_1
= (PXE_CPB_TRANSMIT
*) (UINTN
) cpb
;
1026 tx_ptr_f
= (PXE_CPB_TRANSMIT_FRAGMENTS
*) (UINTN
) cpb
;
1030 // stop reentrancy here
1032 if (AdapterInfo
->in_transmit
) {
1033 return PXE_STATCODE_BUSY
;
1037 AdapterInfo
->in_transmit
= TRUE
;
1040 // Prevent interrupts from changing the Tx ring from underneath us.
1042 // Calculate the Tx descriptor entry.
1044 if ((tcb_ptr
= GetFreeCB (AdapterInfo
)) == NULL
) {
1045 AdapterInfo
->in_transmit
= FALSE
;
1046 return PXE_STATCODE_QUEUE_FULL
;
1049 AdapterInfo
->TxTotals
++;
1051 tcb_ptr
->cb_header
.command
= (CmdSuspend
| CmdTx
| CmdTxFlex
);
1052 tcb_ptr
->cb_header
.status
= 0;
1055 // no immediate data, set EOF in the ByteCount
1057 tcb_ptr
->ByteCount
= 0x8000;
1060 // The data region is always in one buffer descriptor, Tx FIFO
1061 // threshold of 256.
1062 // 82557 multiplies the threashold value by 8, so give 256/8
1064 tcb_ptr
->Threshold
= 32;
1065 if ((opflags
& PXE_OPFLAGS_TRANSMIT_FRAGMENTED
) != 0) {
1067 if (tx_ptr_f
->FragCnt
> MAX_XMIT_FRAGMENTS
) {
1068 SetFreeCB (AdapterInfo
, tcb_ptr
);
1069 AdapterInfo
->in_transmit
= FALSE
;
1070 return PXE_STATCODE_INVALID_PARAMETER
;
1073 tcb_ptr
->TBDCount
= (UINT8
) tx_ptr_f
->FragCnt
;
1075 for (Index
= 0; Index
< tx_ptr_f
->FragCnt
; Index
++) {
1078 tx_ptr_f
->FragDesc
[Index
].FragAddr
,
1079 tx_ptr_f
->FragDesc
[Index
].FragLen
,
1081 (UINT64
)(UINTN
) &Tmp_ptr
1084 SetFreeCB (AdapterInfo
, tcb_ptr
);
1085 AdapterInfo
->in_transmit
= FALSE
;
1086 return PXE_STATCODE_INVALID_PARAMETER
;
1089 tcb_ptr
->TBDArray
[Index
].phys_buf_addr
= (UINT32
) Tmp_ptr
;
1090 tcb_ptr
->TBDArray
[Index
].buf_len
= tx_ptr_f
->FragDesc
[Index
].FragLen
;
1093 tcb_ptr
->free_data_ptr
= tx_ptr_f
->FragDesc
[0].FragAddr
;
1097 // non fragmented case
1099 tcb_ptr
->TBDCount
= 1;
1102 tx_ptr_1
->FrameAddr
,
1103 tx_ptr_1
->DataLen
+ tx_ptr_1
->MediaheaderLen
,
1105 (UINT64
)(UINTN
) &Tmp_ptr
1108 SetFreeCB (AdapterInfo
, tcb_ptr
);
1109 AdapterInfo
->in_transmit
= FALSE
;
1110 return PXE_STATCODE_INVALID_PARAMETER
;
1113 tcb_ptr
->TBDArray
[0].phys_buf_addr
= (UINT32
) (Tmp_ptr
);
1114 tcb_ptr
->TBDArray
[0].buf_len
= tx_ptr_1
->DataLen
+ tx_ptr_1
->MediaheaderLen
;
1115 tcb_ptr
->free_data_ptr
= tx_ptr_1
->FrameAddr
;
1119 // must wait for previous command completion only if it was a non-transmit
1121 BlockIt (AdapterInfo
, TRUE
);
1122 IssueCB (AdapterInfo
, tcb_ptr
);
1123 BlockIt (AdapterInfo
, FALSE
);
1126 // see if we need to wait for completion here
1128 if ((opflags
& PXE_OPFLAGS_TRANSMIT_BLOCK
) != 0) {
1130 // don't wait for more than 1 second!!!
1133 while (tcb_ptr
->cb_header
.status
== 0) {
1134 DelayIt (AdapterInfo
, 10);
1136 if (wait_sec
== 0) {
1141 // we need to un-map any mapped buffers here
1143 if ((opflags
& PXE_OPFLAGS_TRANSMIT_FRAGMENTED
) != 0) {
1145 for (Index
= 0; Index
< tx_ptr_f
->FragCnt
; Index
++) {
1146 Tmp_ptr
= tcb_ptr
->TBDArray
[Index
].phys_buf_addr
;
1149 tx_ptr_f
->FragDesc
[Index
].FragAddr
,
1150 tx_ptr_f
->FragDesc
[Index
].FragLen
,
1156 Tmp_ptr
= tcb_ptr
->TBDArray
[0].phys_buf_addr
;
1159 tx_ptr_1
->FrameAddr
,
1160 tx_ptr_1
->DataLen
+ tx_ptr_1
->MediaheaderLen
,
1166 if (tcb_ptr
->cb_header
.status
== 0) {
1167 SetFreeCB (AdapterInfo
, tcb_ptr
);
1168 AdapterInfo
->in_transmit
= FALSE
;
1169 return PXE_STATCODE_DEVICE_FAILURE
;
1172 SetFreeCB (AdapterInfo
, tcb_ptr
);
1175 // CB will be set free later in get_status (or when we run out of xmit buffers
1177 AdapterInfo
->in_transmit
= FALSE
;
1184 TODO: Add function description
1186 @param AdapterInfo TODO: add argument description
1187 @param cpb TODO: add argument description
1188 @param db TODO: add argument description
1190 @return TODO: add return values
1195 NIC_DATA_INSTANCE
*AdapterInfo
,
1200 PXE_CPB_RECEIVE
*rx_cpbptr
;
1201 PXE_DB_RECEIVE
*rx_dbptr
;
1207 PXE_FRAME_TYPE pkt_type
;
1209 EtherHeader
*hdr_ptr
;
1210 ret_code
= PXE_STATCODE_NO_DATA
;
1211 pkt_type
= PXE_FRAME_TYPE_NONE
;
1212 status
= InWord (AdapterInfo
, AdapterInfo
->ioaddr
+ SCBStatus
);
1213 AdapterInfo
->Int_Status
= (UINT16
) (AdapterInfo
->Int_Status
| status
);
1215 // acknoledge the interrupts
1217 OutWord (AdapterInfo
, (UINT16
) (status
& 0xfc00), (UINT32
) (AdapterInfo
->ioaddr
+ SCBStatus
));
1220 // include the prev ints as well
1222 status
= AdapterInfo
->Int_Status
;
1223 rx_cpbptr
= (PXE_CPB_RECEIVE
*) (UINTN
) cpb
;
1224 rx_dbptr
= (PXE_DB_RECEIVE
*) (UINTN
) db
;
1226 rx_ptr
= &AdapterInfo
->rx_ring
[AdapterInfo
->cur_rx_ind
];
1229 // be in a loop just in case (we may drop a pkt)
1231 while ((status
= rx_ptr
->cb_header
.status
) & RX_COMPLETE
) {
1233 AdapterInfo
->RxTotals
++;
1235 // If we own the next entry, it's a new packet. Send it up.
1237 if (rx_ptr
->forwarded
) {
1243 // discard bad frames
1247 // crc, align, dma overrun, too short, receive error (v22 no coll)
1249 if ((status
& 0x0D90) != 0) {
1255 // make sure the status is OK
1257 if ((status
& 0x02000) == 0) {
1261 pkt_len
= (UINT16
) (rx_ptr
->ActualCount
& 0x3fff);
1266 if (pkt_len
> rx_cpbptr
->BufferLen
) {
1267 Tmp_len
= (UINT16
) rx_cpbptr
->BufferLen
;
1270 CopyMem ((INT8
*) (UINTN
) rx_cpbptr
->BufferAddr
, (INT8
*) &rx_ptr
->RFDBuffer
, Tmp_len
);
1272 hdr_ptr
= (EtherHeader
*) &rx_ptr
->RFDBuffer
;
1274 // fill the CDB and break the loop
1280 rx_dbptr
->FrameLen
= pkt_len
;
1281 rx_dbptr
->MediaHeaderLen
= PXE_MAC_HEADER_LEN_ETHER
;
1283 for (Index
= 0; Index
< PXE_HWADDR_LEN_ETHER
; Index
++) {
1284 if (hdr_ptr
->dest_addr
[Index
] != AdapterInfo
->CurrentNodeAddress
[Index
]) {
1289 if (Index
>= PXE_HWADDR_LEN_ETHER
) {
1290 pkt_type
= PXE_FRAME_TYPE_UNICAST
;
1292 for (Index
= 0; Index
< PXE_HWADDR_LEN_ETHER
; Index
++) {
1293 if (hdr_ptr
->dest_addr
[Index
] != AdapterInfo
->BroadcastNodeAddress
[Index
]) {
1298 if (Index
>= PXE_HWADDR_LEN_ETHER
) {
1299 pkt_type
= PXE_FRAME_TYPE_BROADCAST
;
1301 if ((hdr_ptr
->dest_addr
[0] & 1) == 1) {
1306 pkt_type
= PXE_FRAME_TYPE_FILTERED_MULTICAST
;
1308 pkt_type
= PXE_FRAME_TYPE_PROMISCUOUS
;
1313 rx_dbptr
->Type
= pkt_type
;
1314 rx_dbptr
->Protocol
= hdr_ptr
->type
;
1316 for (Index
= 0; Index
< PXE_HWADDR_LEN_ETHER
; Index
++) {
1317 rx_dbptr
->SrcAddr
[Index
] = hdr_ptr
->src_addr
[Index
];
1318 rx_dbptr
->DestAddr
[Index
] = hdr_ptr
->dest_addr
[Index
];
1321 rx_ptr
->forwarded
= TRUE
;
1326 Recycle_RFD (AdapterInfo
, AdapterInfo
->cur_rx_ind
);
1327 AdapterInfo
->cur_rx_ind
++;
1328 if (AdapterInfo
->cur_rx_ind
== AdapterInfo
->RxBufCnt
) {
1329 AdapterInfo
->cur_rx_ind
= 0;
1335 Recycle_RFD (AdapterInfo
, AdapterInfo
->cur_rx_ind
);
1336 AdapterInfo
->cur_rx_ind
++;
1337 if (AdapterInfo
->cur_rx_ind
== AdapterInfo
->RxBufCnt
) {
1338 AdapterInfo
->cur_rx_ind
= 0;
1341 rx_ptr
= &AdapterInfo
->rx_ring
[AdapterInfo
->cur_rx_ind
];
1344 if (pkt_type
== PXE_FRAME_TYPE_NONE
) {
1345 AdapterInfo
->Int_Status
&= (~SCB_STATUS_FR
);
1348 status
= InWord (AdapterInfo
, AdapterInfo
->ioaddr
+ SCBStatus
);
1349 if ((status
& SCB_RUS_NO_RESOURCES
) != 0) {
1351 // start the receive unit here!
1352 // leave all the filled frames,
1354 SetupReceiveQueues (AdapterInfo
);
1355 OutLong (AdapterInfo
, (UINT32
) AdapterInfo
->rx_phy_addr
, AdapterInfo
->ioaddr
+ SCBPointer
);
1356 OutWord (AdapterInfo
, RX_START
, AdapterInfo
->ioaddr
+ SCBCmd
);
1357 AdapterInfo
->cur_rx_ind
= 0;
1365 TODO: Add function description
1367 @param AdapterInfo TODO: add argument description
1369 @return TODO: add return values
1373 E100bReadEepromAndStationAddress (
1374 NIC_DATA_INSTANCE
*AdapterInfo
1384 eedata
= (UINT16
*) (&AdapterInfo
->NVData
[0]);
1387 addr_len
= E100bGetEepromAddrLen (AdapterInfo
);
1392 AdapterInfo
->NVData_Len
= eeprom_len
= (UINT16
) (1 << addr_len
);
1393 for (Index2
= 0, Index
= 0; ((Index2
< PXE_MAC_LENGTH
- 1) && (Index
< eeprom_len
)); Index
++) {
1395 value
= E100bReadEeprom (AdapterInfo
, Index
, addr_len
);
1396 eedata
[Index
] = value
;
1397 sum
= (UINT16
) (sum
+ value
);
1399 AdapterInfo
->PermNodeAddress
[Index2
++] = (UINT8
) value
;
1400 AdapterInfo
->PermNodeAddress
[Index2
++] = (UINT8
) (value
>> 8);
1404 if (sum
!= 0xBABA) {
1408 for (Index
= 0; Index
< PXE_HWADDR_LEN_ETHER
; Index
++) {
1409 AdapterInfo
->CurrentNodeAddress
[Index
] = AdapterInfo
->PermNodeAddress
[Index
];
1412 for (Index
= 0; Index
< PXE_HWADDR_LEN_ETHER
; Index
++) {
1413 AdapterInfo
->BroadcastNodeAddress
[Index
] = 0xff;
1416 for (Index
= PXE_HWADDR_LEN_ETHER
; Index
< PXE_MAC_LENGTH
; Index
++) {
1417 AdapterInfo
->CurrentNodeAddress
[Index
] = 0;
1418 AdapterInfo
->PermNodeAddress
[Index
] = 0;
1419 AdapterInfo
->BroadcastNodeAddress
[Index
] = 0;
1426 // CBList is a circular linked list
1427 // 1) When all are free, Tail->next == Head and FreeCount == # allocated
1428 // 2) When none are free, Tail == Head and FreeCount == 0
1429 // 3) when one is free, Tail == Head and Freecount == 1
1430 // 4) First non-Free frame is always at Tail->next
1434 TODO: Add function description
1436 @param AdapterInfo TODO: add argument description
1438 @return TODO: add return values
1443 NIC_DATA_INSTANCE
*AdapterInfo
1452 cur_ptr
= &(AdapterInfo
->tx_ring
[0]);
1453 array_off
= (UINTN
) (&cur_ptr
->TBDArray
) - (UINTN
) cur_ptr
;
1454 for (Index
= 0; Index
< AdapterInfo
->TxBufCnt
; Index
++) {
1455 cur_ptr
[Index
].cb_header
.status
= 0;
1456 cur_ptr
[Index
].cb_header
.command
= 0;
1458 cur_ptr
[Index
].PhysTCBAddress
=
1459 (UINT32
) AdapterInfo
->tx_phy_addr
+ (Index
* sizeof (TxCB
));
1461 cur_ptr
[Index
].PhysArrayAddr
= (UINT32
)(cur_ptr
[Index
].PhysTCBAddress
+ array_off
);
1462 cur_ptr
[Index
].PhysTBDArrayAddres
= (UINT32
)(cur_ptr
[Index
].PhysTCBAddress
+ array_off
);
1464 cur_ptr
->free_data_ptr
= (UINT64
) 0;
1466 if (Index
< AdapterInfo
->TxBufCnt
- 1) {
1467 cur_ptr
[Index
].cb_header
.link
= cur_ptr
[Index
].PhysTCBAddress
+ sizeof (TxCB
);
1468 cur_ptr
[Index
].NextTCBVirtualLinkPtr
= &cur_ptr
[Index
+ 1];
1469 cur_ptr
[Index
+ 1].PrevTCBVirtualLinkPtr
= &cur_ptr
[Index
];
1473 head_ptr
= &cur_ptr
[0];
1474 tail_ptr
= &cur_ptr
[AdapterInfo
->TxBufCnt
- 1];
1475 tail_ptr
->cb_header
.link
= head_ptr
->PhysTCBAddress
;
1476 tail_ptr
->NextTCBVirtualLinkPtr
= head_ptr
;
1477 head_ptr
->PrevTCBVirtualLinkPtr
= tail_ptr
;
1479 AdapterInfo
->FreeCBCount
= AdapterInfo
->TxBufCnt
;
1480 AdapterInfo
->FreeTxHeadPtr
= head_ptr
;
1482 // set tail of the free list, next to this would be either in use
1483 // or the head itself
1485 AdapterInfo
->FreeTxTailPtr
= tail_ptr
;
1487 AdapterInfo
->xmit_done_head
= AdapterInfo
->xmit_done_tail
= 0;
1494 TODO: Add function description
1496 @param AdapterInfo TODO: add argument description
1498 @return TODO: add return values
1503 NIC_DATA_INSTANCE
*AdapterInfo
1509 // claim any hanging free CBs
1511 if (AdapterInfo
->FreeCBCount
<= 1) {
1512 CheckCBList (AdapterInfo
);
1516 // don't use up the last CB problem if the previous CB that the CU used
1517 // becomes the last CB we submit because of the SUSPEND bit we set.
1518 // the CU thinks it was never cleared.
1521 if (AdapterInfo
->FreeCBCount
<= 1) {
1525 BlockIt (AdapterInfo
, TRUE
);
1526 free_cb_ptr
= AdapterInfo
->FreeTxHeadPtr
;
1527 AdapterInfo
->FreeTxHeadPtr
= free_cb_ptr
->NextTCBVirtualLinkPtr
;
1528 --AdapterInfo
->FreeCBCount
;
1529 BlockIt (AdapterInfo
, FALSE
);
1535 TODO: Add function description
1537 @param AdapterInfo TODO: add argument description
1538 @param cb_ptr TODO: add argument description
1540 @return TODO: add return values
1545 IN NIC_DATA_INSTANCE
*AdapterInfo
,
1550 // here we assume cb are returned in the order they are taken out
1551 // and we link the newly freed cb at the tail of free cb list
1553 cb_ptr
->cb_header
.status
= 0;
1554 cb_ptr
->free_data_ptr
= (UINT64
) 0;
1556 AdapterInfo
->FreeTxTailPtr
= cb_ptr
;
1557 ++AdapterInfo
->FreeCBCount
;
1563 TODO: Add function description
1565 @param ind TODO: add argument description
1567 @return TODO: add return values
1577 Tmp
= (UINT16
) (ind
+ 1);
1578 if (Tmp
>= (TX_BUFFER_COUNT
<< 1)) {
1587 TODO: Add function description
1589 @param AdapterInfo TODO: add argument description
1591 @return TODO: add return values
1596 IN NIC_DATA_INSTANCE
*AdapterInfo
1604 Tmp_ptr
= AdapterInfo
->FreeTxTailPtr
->NextTCBVirtualLinkPtr
;
1605 if ((Tmp_ptr
->cb_header
.status
& CMD_STATUS_MASK
) != 0) {
1607 // check if Q is full
1609 if (next (AdapterInfo
->xmit_done_tail
) != AdapterInfo
->xmit_done_head
) {
1610 AdapterInfo
->xmit_done
[AdapterInfo
->xmit_done_tail
] = Tmp_ptr
->free_data_ptr
;
1614 Tmp_ptr
->free_data_ptr
,
1615 Tmp_ptr
->TBDArray
[0].buf_len
,
1617 (UINT64
) Tmp_ptr
->TBDArray
[0].phys_buf_addr
1620 AdapterInfo
->xmit_done_tail
= next (AdapterInfo
->xmit_done_tail
);
1623 SetFreeCB (AdapterInfo
, Tmp_ptr
);
1632 // Description : Initialize the RFD list list by linking each element together
1633 // in a circular list. The simplified memory model is used.
1634 // All data is in the RFD. The RFDs are linked together and the
1635 // last one points back to the first one. When the current RFD
1636 // is processed (frame received), its EL bit is set and the EL
1637 // bit in the previous RXFD is cleared.
1638 // Allocation done during INIT, this is making linked list.
1642 TODO: Add function description
1644 @param AdapterInfo TODO: add argument description
1646 @return TODO: add return values
1650 SetupReceiveQueues (
1651 IN NIC_DATA_INSTANCE
*AdapterInfo
1658 AdapterInfo
->cur_rx_ind
= 0;
1659 rx_ptr
= (&AdapterInfo
->rx_ring
[0]);
1661 for (Index
= 0; Index
< AdapterInfo
->RxBufCnt
; Index
++) {
1662 rx_ptr
[Index
].cb_header
.status
= 0;
1663 rx_ptr
[Index
].cb_header
.command
= 0;
1664 rx_ptr
[Index
].RFDSize
= RX_BUFFER_SIZE
;
1665 rx_ptr
[Index
].ActualCount
= 0;
1667 // RBDs not used, simple memory model
1669 rx_ptr
[Index
].rx_buf_addr
= (UINT32
) (-1);
1672 // RBDs not used, simple memory model
1674 rx_ptr
[Index
].forwarded
= FALSE
;
1677 // don't use Tmp_ptr if it is beyond the last one
1679 if (Index
< AdapterInfo
->RxBufCnt
- 1) {
1680 rx_ptr
[Index
].cb_header
.link
= (UINT32
) AdapterInfo
->rx_phy_addr
+ ((Index
+ 1) * sizeof (RxFD
));
1684 tail_ptr
= (&AdapterInfo
->rx_ring
[AdapterInfo
->RxBufCnt
- 1]);
1685 tail_ptr
->cb_header
.link
= (UINT32
) AdapterInfo
->rx_phy_addr
;
1690 tail_ptr
->cb_header
.command
= 0xC000;
1691 AdapterInfo
->RFDTailPtr
= tail_ptr
;
1697 TODO: Add function description
1699 @param AdapterInfo TODO: add argument description
1700 @param rx_index TODO: add argument description
1702 @return TODO: add return values
1707 IN NIC_DATA_INSTANCE
*AdapterInfo
,
1714 // change the EL bit and change the AdapterInfo->RxTailPtr
1715 // rx_ptr is assumed to be the head of the Q
1716 // AdapterInfo->rx_forwarded[rx_index] = FALSE;
1718 rx_ptr
= &AdapterInfo
->rx_ring
[rx_index
];
1719 tail_ptr
= AdapterInfo
->RFDTailPtr
;
1721 // set el_bit and suspend bit
1723 rx_ptr
->cb_header
.command
= 0xc000;
1724 rx_ptr
->cb_header
.status
= 0;
1725 rx_ptr
->ActualCount
= 0;
1726 rx_ptr
->forwarded
= FALSE
;
1727 AdapterInfo
->RFDTailPtr
= rx_ptr
;
1729 // resetting the el_bit.
1731 tail_ptr
->cb_header
.command
= 0;
1733 // check the receive unit, fix if there is any problem
1738 // Serial EEPROM section.
1740 // EEPROM_Ctrl bits.
1742 #define EE_SHIFT_CLK 0x01 /* EEPROM shift clock. */
1743 #define EE_CS 0x02 /* EEPROM chip select. */
1744 #define EE_DI 0x04 /* EEPROM chip data in. */
1745 #define EE_WRITE_0 0x01
1746 #define EE_WRITE_1 0x05
1747 #define EE_DO 0x08 /* EEPROM chip data out. */
1748 #define EE_ENB (0x4800 | EE_CS)
1751 // Delay between EEPROM clock transitions.
1752 // This will actually work with no delay on 33Mhz PCI.
1754 #define eeprom_delay(nanosec) DelayIt (AdapterInfo, nanosec);
1757 // The EEPROM commands include the alway-set leading bit.
1759 #define EE_WRITE_CMD 5 // 101b
1760 #define EE_READ_CMD 6 // 110b
1761 #define EE_ERASE_CMD (7 << 6)
1765 IN NIC_DATA_INSTANCE
*AdapterInfo
,
1771 Routine Description:
1773 TODO: Add function description
1777 AdapterInfo - TODO: add argument description
1778 val - TODO: add argument description
1779 num_bits - TODO: add argument description
1783 TODO: add return values
1791 EEAddr
= AdapterInfo
->ioaddr
+ SCBeeprom
;
1793 for (Index
= num_bits
; Index
>= 0; Index
--) {
1799 dataval
= (INT16
) ((val
& (1 << Index
)) ? EE_DI
: 0);
1802 // mask off the data_in bit
1804 Tmp
= (UINT8
) (InByte (AdapterInfo
, EEAddr
) &~EE_DI
);
1805 Tmp
= (UINT8
) (Tmp
| dataval
);
1806 OutByte (AdapterInfo
, Tmp
, EEAddr
);
1809 // raise the eeprom clock
1811 OutByte (AdapterInfo
, (UINT8
) (Tmp
| EE_SHIFT_CLK
), EEAddr
);
1814 // lower the eeprom clock
1816 OutByte (AdapterInfo
, (UINT8
) (Tmp
&~EE_SHIFT_CLK
), EEAddr
);
1823 TODO: Add function description
1825 @param AdapterInfo TODO: add argument description
1827 @return TODO: add return values
1832 IN NIC_DATA_INSTANCE
*AdapterInfo
1840 EEAddr
= AdapterInfo
->ioaddr
+ SCBeeprom
;
1843 for (Index
= 15; Index
>= 0; Index
--) {
1849 // mask off the data_in bit
1851 Tmp
= InByte (AdapterInfo
, EEAddr
);
1852 OutByte (AdapterInfo
, (UINT8
) (Tmp
| EE_SHIFT_CLK
), EEAddr
);
1854 Tmp
= InByte (AdapterInfo
, EEAddr
);
1855 retval
= (UINT16
) ((retval
<< 1) | ((Tmp
& EE_DO
) ? 1 : 0));
1859 OutByte (AdapterInfo
, (UINT8
) (Tmp
&~EE_SHIFT_CLK
), EEAddr
);
1868 This routine sets the EEPROM lockout bit to gain exclusive access to the
1869 eeprom. the access bit is the most significant bit in the General Control
1870 Register 2 in the SCB space.
1872 @param AdapterInfo Pointer to the NIC data structure
1873 information which the UNDI driver is
1876 @retval TRUE if it got the access
1877 @retval FALSE if it fails to get the exclusive access
1881 E100bSetEepromLockOut (
1882 IN NIC_DATA_INSTANCE
*AdapterInfo
1888 if ((AdapterInfo
->DeviceID
== D102_DEVICE_ID
) ||
1889 (AdapterInfo
->RevID
>= D102_REVID
)) {
1895 tmp
= InByte (AdapterInfo
, AdapterInfo
->ioaddr
+ SCBGenCtrl2
);
1896 tmp
|= GCR2_EEPROM_ACCESS_SEMAPHORE
;
1897 OutByte (AdapterInfo
, tmp
, AdapterInfo
->ioaddr
+ SCBGenCtrl2
);
1899 DelayIt (AdapterInfo
, 50);
1900 tmp
= InByte (AdapterInfo
, AdapterInfo
->ioaddr
+ SCBGenCtrl2
);
1902 if (tmp
& GCR2_EEPROM_ACCESS_SEMAPHORE
) {
1915 This routine Resets the EEPROM lockout bit to giveup access to the
1916 eeprom. the access bit is the most significant bit in the General Control
1917 Register 2 in the SCB space.
1919 @param AdapterInfo Pointer to the NIC data structure
1920 information which the UNDI driver is
1927 E100bReSetEepromLockOut (
1928 IN NIC_DATA_INSTANCE
*AdapterInfo
1933 if ((AdapterInfo
->DeviceID
== D102_DEVICE_ID
) ||
1934 (AdapterInfo
->RevID
>= D102_REVID
)) {
1936 tmp
= InByte (AdapterInfo
, AdapterInfo
->ioaddr
+ SCBGenCtrl2
);
1937 tmp
&= ~(GCR2_EEPROM_ACCESS_SEMAPHORE
);
1938 OutByte (AdapterInfo
, tmp
, AdapterInfo
->ioaddr
+ SCBGenCtrl2
);
1940 DelayIt (AdapterInfo
, 50);
1946 Using the NIC data structure information, read the EEPROM to get a Word of data for the MAC address.
1948 @param AdapterInfo Pointer to the NIC data structure
1949 information which the UNDI driver is
1951 @param Location Word offset into the MAC address to read.
1952 @param AddrLen Number of bits of address length.
1954 @retval RetVal The word read from the EEPROM.
1959 IN NIC_DATA_INSTANCE
*AdapterInfo
,
1970 EEAddr
= AdapterInfo
->ioaddr
+ SCBeeprom
;
1971 ReadCmd
= (UINT16
) (Location
| (EE_READ_CMD
<< AddrLen
));
1976 // get exclusive access to the eeprom first!
1978 E100bSetEepromLockOut (AdapterInfo
);
1981 // eeprom control reg bits: x,x,x,x,DO,DI,CS,SK
1982 // to write the opcode+data value out one bit at a time in DI starting at msb
1983 // and then out a 1 to sk, wait, out 0 to SK and wait
1984 // repeat this for all the bits to be written
1990 Tmp
= (UINT8
) (InByte (AdapterInfo
, EEAddr
) & 0xF2);
1991 OutByte (AdapterInfo
, (UINT8
) (Tmp
| EE_CS
), EEAddr
);
1994 // 3 for the read opcode 110b
1996 shift_bits_out (AdapterInfo
, ReadCmd
, (UINT8
) (3 + AddrLen
));
1999 // read the eeprom word one bit at a time
2001 RetVal
= shift_bits_in (AdapterInfo
);
2004 // Terminate the EEPROM access and leave eeprom in a clean state.
2006 Tmp
= InByte (AdapterInfo
, EEAddr
);
2007 Tmp
&= ~(EE_CS
| EE_DI
);
2008 OutByte (AdapterInfo
, Tmp
, EEAddr
);
2011 // raise the clock and lower the eeprom shift clock
2013 OutByte (AdapterInfo
, (UINT8
) (Tmp
| EE_SHIFT_CLK
), EEAddr
);
2016 OutByte (AdapterInfo
, (UINT8
) (Tmp
&~EE_SHIFT_CLK
), EEAddr
);
2020 // giveup access to the eeprom
2022 E100bReSetEepromLockOut (AdapterInfo
);
2029 Using the NIC data structure information, read the EEPROM to determine how many bits of address length
2030 this EEPROM is in Words.
2032 @param AdapterInfo Pointer to the NIC data structure
2033 information which the UNDI driver is
2036 @retval RetVal The word read from the EEPROM.
2040 E100bGetEepromAddrLen (
2041 IN NIC_DATA_INSTANCE
*AdapterInfo
2048 // assume 64word eeprom (so,6 bits of address_length)
2052 EEAddr
= AdapterInfo
->ioaddr
+ SCBeeprom
;
2053 ReadCmd
= (EE_READ_CMD
<< 6);
2056 // get exclusive access to the eeprom first!
2058 E100bSetEepromLockOut (AdapterInfo
);
2061 // address we are trying to read is 0
2062 // eeprom control reg bits: x,x,x,x,DO,,DI,,CS,SK
2063 // to write the opcode+data value out one bit at a time in DI starting at msb
2064 // and then out a 1 to sk, wait, out 0 to SK and wait
2065 // repeat this for all the bits to be written
2067 Tmp
= (UINT8
) (InByte (AdapterInfo
, EEAddr
) & 0xF2);
2070 // enable eeprom access
2072 OutByte (AdapterInfo
, (UINT8
) (Tmp
| EE_CS
), EEAddr
);
2075 // 3 for opcode, 6 for the default address len
2077 shift_bits_out (AdapterInfo
, ReadCmd
, (UINT8
) (3 + 6));
2080 // (in case of a 64 word eeprom).
2081 // read the "dummy zero" from EE_DO to say that the address we wrote
2082 // (six 0s) is accepted, write more zeros (until 8) to get a "dummy zero"
2086 // assume the smallest
2089 Tmp
= InByte (AdapterInfo
, EEAddr
);
2090 while ((AddrLen
< 8) && ((Tmp
& EE_DO
) != 0)) {
2091 OutByte (AdapterInfo
, (UINT8
) (Tmp
&~EE_DI
), EEAddr
);
2095 // raise the eeprom clock
2097 OutByte (AdapterInfo
, (UINT8
) (Tmp
| EE_SHIFT_CLK
), EEAddr
);
2101 // lower the eeprom clock
2103 OutByte (AdapterInfo
, (UINT8
) (Tmp
&~EE_SHIFT_CLK
), EEAddr
);
2105 Tmp
= InByte (AdapterInfo
, EEAddr
);
2110 // read the eeprom word, even though we don't need this
2112 shift_bits_in (AdapterInfo
);
2115 // Terminate the EEPROM access.
2117 Tmp
= InByte (AdapterInfo
, EEAddr
);
2118 Tmp
&= ~(EE_CS
| EE_DI
);
2119 OutByte (AdapterInfo
, Tmp
, EEAddr
);
2122 // raise the clock and lower the eeprom shift clock
2124 OutByte (AdapterInfo
, (UINT8
) (Tmp
| EE_SHIFT_CLK
), EEAddr
);
2127 OutByte (AdapterInfo
, (UINT8
) (Tmp
&~EE_SHIFT_CLK
), EEAddr
);
2131 // giveup access to the eeprom!
2133 E100bReSetEepromLockOut (AdapterInfo
);
2140 TODO: Add function description
2142 @param AdapterInfo TODO: add argument description
2143 @param DBaddr TODO: add argument description
2144 @param DBsize TODO: add argument description
2146 @return TODO: add return values
2151 NIC_DATA_INSTANCE
*AdapterInfo
,
2156 PXE_DB_STATISTICS db
;
2158 // wait upto one second (each wait is 100 micro s)
2162 wait_for_cmd_done (AdapterInfo
->ioaddr
+ SCBCmd
);
2165 // Clear statistics done marker.
2167 AdapterInfo
->statistics
->done_marker
= 0;
2170 // Issue statistics dump (or dump w/ reset) command.
2174 (UINT8
) (DBsize
? CU_SHOWSTATS
: CU_DUMPSTATS
),
2175 (UINT32
) (AdapterInfo
->ioaddr
+ SCBCmd
)
2179 // Wait for command to complete.
2181 // zero the db here just to chew up a little more time.
2184 ZeroMem ((VOID
*) &db
, sizeof db
);
2188 // Wait a bit before checking.
2191 DelayIt (AdapterInfo
, 100);
2194 // Look for done marker at end of statistics.
2197 switch (AdapterInfo
->statistics
->done_marker
) {
2208 // if we did not "continue" from the above switch, we are done,
2214 // If this is a reset, we are out of here!
2217 return PXE_STATCODE_SUCCESS
;
2221 // Convert NIC statistics counter format to EFI/UNDI
2222 // specification statistics counter format.
2226 // 54 3210 fedc ba98 7654 3210
2227 // db.Supported = 01 0000 0100 1101 0001 0111;
2229 db
.Supported
= 0x104D17;
2232 // Statistics from the NIC
2235 db
.Data
[0x01] = AdapterInfo
->statistics
->rx_good_frames
;
2237 db
.Data
[0x02] = AdapterInfo
->statistics
->rx_runt_errs
;
2239 db
.Data
[0x08] = AdapterInfo
->statistics
->rx_crc_errs
+
2240 AdapterInfo
->statistics
->rx_align_errs
;
2242 db
.Data
[0x04] = db
.Data
[0x02] +
2244 AdapterInfo
->statistics
->rx_resource_errs
+
2245 AdapterInfo
->statistics
->rx_overrun_errs
;
2247 db
.Data
[0x00] = db
.Data
[0x01] + db
.Data
[0x04];
2249 db
.Data
[0x0B] = AdapterInfo
->statistics
->tx_good_frames
;
2251 db
.Data
[0x0E] = AdapterInfo
->statistics
->tx_coll16_errs
+
2252 AdapterInfo
->statistics
->tx_late_colls
+
2253 AdapterInfo
->statistics
->tx_underruns
+
2254 AdapterInfo
->statistics
->tx_one_colls
+
2255 AdapterInfo
->statistics
->tx_multi_colls
;
2257 db
.Data
[0x14] = AdapterInfo
->statistics
->tx_total_colls
;
2259 db
.Data
[0x0A] = db
.Data
[0x0B] +
2261 AdapterInfo
->statistics
->tx_lost_carrier
;
2263 if (DBsize
> sizeof db
) {
2264 DBsize
= (UINT16
) sizeof (db
);
2267 CopyMem ((VOID
*) (UINTN
) DBaddr
, (VOID
*) &db
, (UINTN
) DBsize
);
2269 return PXE_STATCODE_SUCCESS
;
2274 TODO: Add function description
2276 @param AdapterInfo TODO: add argument description
2277 @param OpFlags TODO: add argument description
2279 @return TODO: add return values
2284 IN NIC_DATA_INSTANCE
*AdapterInfo
,
2291 // disable the interrupts
2293 OutWord (AdapterInfo
, INT_MASK
, AdapterInfo
->ioaddr
+ SCBCmd
);
2296 // wait for the tx queue to complete
2298 CheckCBList (AdapterInfo
);
2300 XmitWaitForCompletion (AdapterInfo
);
2302 if (AdapterInfo
->Receive_Started
) {
2303 StopRU (AdapterInfo
);
2306 InitializeChip (AdapterInfo
);
2309 // check the opflags and restart receive filters
2311 if ((OpFlags
& PXE_OPFLAGS_RESET_DISABLE_FILTERS
) == 0) {
2313 save_filter
= AdapterInfo
->Rx_Filter
;
2315 // if we give the filter same as Rx_Filter,
2316 // this routine will not set mcast list (it thinks there is no change)
2317 // to force it, we will reset that flag in the Rx_Filter
2319 AdapterInfo
->Rx_Filter
&= (~PXE_OPFLAGS_RECEIVE_FILTER_FILTERED_MULTICAST
);
2320 E100bSetfilter (AdapterInfo
, save_filter
, (UINT64
) 0, (UINT32
) 0);
2323 if ((OpFlags
& PXE_OPFLAGS_RESET_DISABLE_INTERRUPTS
) != 0) {
2325 // disable the interrupts
2327 AdapterInfo
->int_mask
= 0;
2330 // else leave the interrupt in the pre-set state!!!
2332 E100bSetInterruptState (AdapterInfo
);
2339 TODO: Add function description
2341 @param AdapterInfo TODO: add argument description
2343 @return TODO: add return values
2348 IN NIC_DATA_INSTANCE
*AdapterInfo
2352 // disable the interrupts
2354 OutWord (AdapterInfo
, INT_MASK
, AdapterInfo
->ioaddr
+ SCBCmd
);
2357 // stop the receive unit
2359 if (AdapterInfo
->Receive_Started
) {
2360 StopRU (AdapterInfo
);
2364 // wait for the tx queue to complete
2366 CheckCBList (AdapterInfo
);
2367 if (AdapterInfo
->FreeCBCount
!= AdapterInfo
->TxBufCnt
) {
2368 wait_for_cmd_done (AdapterInfo
->ioaddr
+ SCBCmd
);
2372 // we do not want to reset the phy, it takes a long time to renegotiate the
2373 // link after that (3-4 seconds)
2375 InitializeChip (AdapterInfo
);
2376 SelectiveReset (AdapterInfo
);
2382 This routine will write a value to the specified MII register
2383 of an external MDI compliant device (e.g. PHY 100). The command will
2384 execute in polled mode.
2386 @param AdapterInfo pointer to the structure that contains
2388 @param RegAddress The MII register that we are writing to
2389 @param PhyAddress The MDI address of the Phy component.
2390 @param DataValue The value that we are writing to the MII
2398 IN NIC_DATA_INSTANCE
*AdapterInfo
,
2399 IN UINT8 RegAddress
,
2400 IN UINT8 PhyAddress
,
2404 UINT32 WriteCommand
;
2406 WriteCommand
= ((UINT32
) DataValue
) |
2407 ((UINT32
)(RegAddress
<< 16)) |
2408 ((UINT32
)(PhyAddress
<< 21)) |
2409 ((UINT32
)(MDI_WRITE
<< 26));
2412 // Issue the write command to the MDI control register.
2414 OutLong (AdapterInfo
, WriteCommand
, AdapterInfo
->ioaddr
+ SCBCtrlMDI
);
2417 // wait 20usec before checking status
2419 DelayIt (AdapterInfo
, 20);
2422 // poll for the mdi write to complete
2423 while ((InLong (AdapterInfo
, AdapterInfo
->ioaddr
+ SCBCtrlMDI
) &
2424 MDI_PHY_READY
) == 0){
2425 DelayIt (AdapterInfo
, 20);
2431 This routine will read a value from the specified MII register
2432 of an external MDI compliant device (e.g. PHY 100), and return
2433 it to the calling routine. The command will execute in polled mode.
2435 @param AdapterInfo pointer to the structure that contains
2437 @param RegAddress The MII register that we are reading from
2438 @param PhyAddress The MDI address of the Phy component.
2439 @param DataValue pointer to the value that we read from
2446 IN NIC_DATA_INSTANCE
*AdapterInfo
,
2447 IN UINT8 RegAddress
,
2448 IN UINT8 PhyAddress
,
2449 IN OUT UINT16
*DataValue
2454 ReadCommand
= ((UINT32
) (RegAddress
<< 16)) |
2455 ((UINT32
) (PhyAddress
<< 21)) |
2456 ((UINT32
) (MDI_READ
<< 26));
2459 // Issue the read command to the MDI control register.
2461 OutLong (AdapterInfo
, ReadCommand
, AdapterInfo
->ioaddr
+ SCBCtrlMDI
);
2464 // wait 20usec before checking status
2466 DelayIt (AdapterInfo
, 20);
2469 // poll for the mdi read to complete
2471 while ((InLong (AdapterInfo
, AdapterInfo
->ioaddr
+ SCBCtrlMDI
) &
2472 MDI_PHY_READY
) == 0) {
2473 DelayIt (AdapterInfo
, 20);
2477 *DataValue
= InWord (AdapterInfo
, AdapterInfo
->ioaddr
+ SCBCtrlMDI
);
2482 This routine will reset the PHY that the adapter is currently
2485 @param AdapterInfo pointer to the structure that contains
2492 NIC_DATA_INSTANCE
*AdapterInfo
2495 UINT16 MdiControlReg
;
2497 MdiControlReg
= (MDI_CR_AUTO_SELECT
|
2498 MDI_CR_RESTART_AUTO_NEG
|
2502 // Write the MDI control register with our new Phy configuration
2507 AdapterInfo
->PhyAddress
,
2516 This routine will detect what phy we are using, set the line
2517 speed, FDX or HDX, and configure the phy if necessary.
2518 The following combinations are supported:
2519 - TX or T4 PHY alone at PHY address 1
2520 - T4 or TX PHY at address 1 and MII PHY at address 0
2521 - 82503 alone (10Base-T mode, no full duplex support)
2522 - 82503 and MII PHY (TX or T4) at address 0
2523 The sequence / priority of detection is as follows:
2524 - PHY 1 with cable termination
2525 - PHY 0 with cable termination
2526 - PHY 1 (if found) without cable termination
2528 Additionally auto-negotiation capable (NWAY) and parallel
2529 detection PHYs are supported. The flow-chart is described in
2530 the 82557 software writer's manual.
2531 NOTE: 1. All PHY MDI registers are read in polled mode.
2532 2. The routines assume that the 82557 has been RESET and we have
2533 obtained the virtual memory address of the CSR.
2534 3. PhyDetect will not RESET the PHY.
2535 4. If FORCEFDX is set, SPEED should also be set. The driver will
2536 check the values for inconsistency with the detected PHY
2538 5. PHY 1 (the PHY on the adapter) may have an address in the range
2539 1 through 31 inclusive. The driver will accept addresses in
2541 6. Driver ignores FORCEFDX and SPEED overrides if a 503 interface
2544 @param AdapterInfo pointer to the structure that contains
2547 @retval TRUE If a Phy was detected, and configured
2549 @retval FALSE If a valid phy could not be detected and
2555 NIC_DATA_INSTANCE
*AdapterInfo
2559 UINT16 MdiControlReg
;
2560 UINT16 MdiStatusReg
;
2562 UINT8 ReNegotiateTime
;
2564 eedata
= (UINT16
*) (&AdapterInfo
->NVData
[0]);
2567 ReNegotiateTime
= 35;
2569 // EEPROM word [6] contains the Primary PHY record in which the least 3 bits
2570 // indicate the PHY address
2571 // and word [7] contains the secondary PHY record
2573 AdapterInfo
->PhyRecord
[0] = eedata
[6];
2574 AdapterInfo
->PhyRecord
[1] = eedata
[7];
2575 AdapterInfo
->PhyAddress
= (UINT8
) (AdapterInfo
->PhyRecord
[0] & 7);
2578 // Check for a phy address over-ride of 32 which indicates force use of 82503
2579 // not detecting the link in this case
2581 if (AdapterInfo
->PhyAddress
== 32) {
2583 // 503 interface over-ride
2584 // Record the current speed and duplex. We will be in half duplex
2585 // mode unless the user used the force full duplex over-ride.
2587 AdapterInfo
->LinkSpeed
= 10;
2592 // If the Phy Address is between 1-31 then we must first look for phy 1,
2595 if ((AdapterInfo
->PhyAddress
> 0) && (AdapterInfo
->PhyAddress
< 32)) {
2598 // Read the MDI control and status registers at phy 1
2599 // and check if we found a valid phy
2604 AdapterInfo
->PhyAddress
,
2611 AdapterInfo
->PhyAddress
,
2615 if (!((MdiControlReg
== 0xffff) ||
2616 ((MdiStatusReg
== 0) && (MdiControlReg
== 0)))) {
2619 // we have a valid phy1
2620 // Read the status register again because of sticky bits
2626 AdapterInfo
->PhyAddress
,
2631 // If there is a valid link then use this Phy.
2633 if (MdiStatusReg
& MDI_SR_LINK_STATUS
) {
2634 return (SetupPhy(AdapterInfo
));
2640 // Next try to detect a PHY at address 0x00 because there was no Phy 1,
2641 // or Phy 1 didn't have link, or we had a phy 0 over-ride
2645 // Read the MDI control and status registers at phy 0
2647 MdiRead (AdapterInfo
, MDI_CONTROL_REG
, 0, &MdiControlReg
);
2648 MdiRead (AdapterInfo
, MDI_STATUS_REG
, 0, &MdiStatusReg
);
2651 // check if we found a valid phy 0
2653 if (((MdiControlReg
== 0xffff) ||
2654 ((MdiStatusReg
== 0) && (MdiControlReg
== 0)))) {
2657 // we don't have a valid phy at address 0
2658 // if phy address was forced to 0, then error out because we
2659 // didn't find a phy at that address
2661 if (AdapterInfo
->PhyAddress
== 0x0000) {
2665 // at this point phy1 does not have link and there is no phy 0 at all
2666 // if we are forced to detect the cable, error out here!
2668 if (AdapterInfo
->CableDetect
!= 0) {
2675 // no phy 0, but there is a phy 1 (no link I guess), so use phy 1
2677 return SetupPhy (AdapterInfo
);
2680 // didn't find phy 0 or phy 1, so assume a 503 interface
2682 AdapterInfo
->PhyAddress
= 32;
2685 // Record the current speed and duplex. We'll be in half duplex
2686 // mode unless the user used the force full duplex over-ride.
2688 AdapterInfo
->LinkSpeed
= 10;
2694 // We have a valid phy at address 0. If phy 0 has a link then we use
2695 // phy 0. If Phy 0 doesn't have a link then we use Phy 1 (no link)
2696 // if phy 1 is present, or phy 0 if phy 1 is not present
2697 // If phy 1 was present, then we must isolate phy 1 before we enable
2698 // phy 0 to see if Phy 0 has a link.
2707 AdapterInfo
->PhyAddress
,
2712 // wait 100 microseconds for the phy to isolate.
2714 DelayIt (AdapterInfo
, 100);
2718 // Since this Phy is at address 0, we must enable it. So clear
2719 // the isolate bit, and set the auto-speed select bit
2729 // wait 100 microseconds for the phy to be enabled.
2731 DelayIt (AdapterInfo
, 100);
2734 // restart the auto-negotion process
2740 MDI_CR_RESTART_AUTO_NEG
| MDI_CR_AUTO_SELECT
2744 // wait no more than 3.5 seconds for auto-negotiation to complete
2746 while (ReNegotiateTime
) {
2748 // Read the status register twice because of sticky bits
2750 MdiRead (AdapterInfo
, MDI_STATUS_REG
, 0, &MdiStatusReg
);
2751 MdiRead (AdapterInfo
, MDI_STATUS_REG
, 0, &MdiStatusReg
);
2753 if (MdiStatusReg
& MDI_SR_AUTO_NEG_COMPLETE
) {
2757 DelayIt (AdapterInfo
, 100);
2762 // Read the status register again because of sticky bits
2764 MdiRead (AdapterInfo
, MDI_STATUS_REG
, 0, &MdiStatusReg
);
2767 // If the link was not set
2769 if ((MdiStatusReg
& MDI_SR_LINK_STATUS
) == 0) {
2771 // PHY1 does not have a link and phy 0 does not have a link
2772 // do not proceed if we need to detect the link!
2774 if (AdapterInfo
->CableDetect
!= 0) {
2779 // the link wasn't set, so use phy 1 if phy 1 was present
2785 MdiWrite (AdapterInfo
, MDI_CONTROL_REG
, 0, MDI_CR_ISOLATE
);
2788 // wait 100 microseconds for the phy to isolate.
2790 DelayIt (AdapterInfo
, 100);
2793 // Now re-enable PHY 1
2798 AdapterInfo
->PhyAddress
,
2803 // wait 100 microseconds for the phy to be enabled
2805 DelayIt (AdapterInfo
, 100);
2808 // restart the auto-negotion process
2813 AdapterInfo
->PhyAddress
,
2814 MDI_CR_RESTART_AUTO_NEG
| MDI_CR_AUTO_SELECT
2818 // Don't wait for it to complete (we didn't have link earlier)
2820 return (SetupPhy (AdapterInfo
));
2825 // Definitely using Phy 0
2827 AdapterInfo
->PhyAddress
= 0;
2828 return (SetupPhy(AdapterInfo
));
2834 This routine will setup phy 1 or phy 0 so that it is configured
2835 to match a speed and duplex over-ride option. If speed or
2836 duplex mode is not explicitly specified in the registry, the
2837 driver will skip the speed and duplex over-ride code, and
2838 assume the adapter is automatically setting the line speed, and
2839 the duplex mode. At the end of this routine, any truly Phy
2840 specific code will be executed (each Phy has its own quirks,
2841 and some require that certain special bits are set).
2842 NOTE: The driver assumes that SPEED and FORCEFDX are specified at the
2843 same time. If FORCEDPX is set without speed being set, the driver
2844 will encouter a fatal error and log a message into the event viewer.
2846 @param AdapterInfo pointer to the structure that contains
2849 @retval TRUE If the phy could be configured correctly
2850 @retval FALSE If the phy couldn't be configured
2851 correctly, because an unsupported
2852 over-ride option was used
2857 IN NIC_DATA_INSTANCE
*AdapterInfo
2860 UINT16 MdiControlReg
;
2861 UINT16 MdiStatusReg
;
2863 UINT16 MdiIdHighReg
;
2866 BOOLEAN ForcePhySetting
;
2868 ForcePhySetting
= FALSE
;
2871 // If we are NOT forcing a setting for line speed or full duplex, then
2872 // we won't force a link setting, and we'll jump down to the phy
2875 if (((AdapterInfo
->LinkSpeedReq
) || (AdapterInfo
->DuplexReq
))) {
2877 // Find out what kind of technology this Phy is capable of.
2882 AdapterInfo
->PhyAddress
,
2887 // Read the MDI control register at our phy
2892 AdapterInfo
->PhyAddress
,
2897 // Now check the validity of our forced option. If the force option is
2898 // valid, then force the setting. If the force option is not valid,
2899 // we'll set a flag indicating that we should error out.
2903 // If speed is forced to 10mb
2905 if (AdapterInfo
->LinkSpeedReq
== 10) {
2907 // If half duplex is forced
2909 if ((AdapterInfo
->DuplexReq
& PXE_FORCE_HALF_DUPLEX
) != 0) {
2910 if (MdiStatusReg
& MDI_SR_10T_HALF_DPX
) {
2912 MdiControlReg
&= ~(MDI_CR_10_100
| MDI_CR_AUTO_SELECT
| MDI_CR_FULL_HALF
);
2913 ForcePhySetting
= TRUE
;
2915 } else if ((AdapterInfo
->DuplexReq
& PXE_FORCE_FULL_DUPLEX
) != 0) {
2918 // If full duplex is forced
2920 if (MdiStatusReg
& MDI_SR_10T_FULL_DPX
) {
2922 MdiControlReg
&= ~(MDI_CR_10_100
| MDI_CR_AUTO_SELECT
);
2923 MdiControlReg
|= MDI_CR_FULL_HALF
;
2924 ForcePhySetting
= TRUE
;
2928 // If auto duplex (we actually set phy to 1/2)
2930 if (MdiStatusReg
& (MDI_SR_10T_FULL_DPX
| MDI_SR_10T_HALF_DPX
)) {
2932 MdiControlReg
&= ~(MDI_CR_10_100
| MDI_CR_AUTO_SELECT
| MDI_CR_FULL_HALF
);
2933 ForcePhySetting
= TRUE
;
2939 // If speed is forced to 100mb
2941 else if (AdapterInfo
->LinkSpeedReq
== 100) {
2943 // If half duplex is forced
2945 if ((AdapterInfo
->DuplexReq
& PXE_FORCE_HALF_DUPLEX
) != 0) {
2946 if (MdiStatusReg
& (MDI_SR_TX_HALF_DPX
| MDI_SR_T4_CAPABLE
)) {
2948 MdiControlReg
&= ~(MDI_CR_AUTO_SELECT
| MDI_CR_FULL_HALF
);
2949 MdiControlReg
|= MDI_CR_10_100
;
2950 ForcePhySetting
= TRUE
;
2952 } else if ((AdapterInfo
->DuplexReq
& PXE_FORCE_FULL_DUPLEX
) != 0) {
2954 // If full duplex is forced
2956 if (MdiStatusReg
& MDI_SR_TX_FULL_DPX
) {
2957 MdiControlReg
&= ~MDI_CR_AUTO_SELECT
;
2958 MdiControlReg
|= (MDI_CR_10_100
| MDI_CR_FULL_HALF
);
2959 ForcePhySetting
= TRUE
;
2963 // If auto duplex (we set phy to 1/2)
2965 if (MdiStatusReg
& (MDI_SR_TX_HALF_DPX
| MDI_SR_T4_CAPABLE
)) {
2967 MdiControlReg
&= ~(MDI_CR_AUTO_SELECT
| MDI_CR_FULL_HALF
);
2968 MdiControlReg
|= MDI_CR_10_100
;
2969 ForcePhySetting
= TRUE
;
2974 if (!ForcePhySetting
) {
2979 // Write the MDI control register with our new Phy configuration
2984 AdapterInfo
->PhyAddress
,
2989 // wait 100 milliseconds for auto-negotiation to complete
2991 DelayIt (AdapterInfo
, 100);
2995 // Find out specifically what Phy this is. We do this because for certain
2996 // phys there are specific bits that must be set so that the phy and the
2997 // 82557 work together properly.
3003 AdapterInfo
->PhyAddress
,
3009 AdapterInfo
->PhyAddress
,
3013 PhyId
= ((UINT32
) MdiIdLowReg
| ((UINT32
) MdiIdHighReg
<< 16));
3016 // And out the revsion field of the Phy ID so that we'll be able to detect
3017 // future revs of the same Phy.
3019 PhyId
&= PHY_MODEL_REV_ID_MASK
;
3022 // Handle the National TX
3024 if (PhyId
== PHY_NSC_TX
) {
3028 NSC_CONG_CONTROL_REG
,
3029 AdapterInfo
->PhyAddress
,
3033 MdiMiscReg
|= (NSC_TX_CONG_TXREADY
| NSC_TX_CONG_F_CONNECT
);
3037 NSC_CONG_CONTROL_REG
,
3038 AdapterInfo
->PhyAddress
,
3043 FindPhySpeedAndDpx (AdapterInfo
, PhyId
);
3046 // We put a hardware fix on to our adapters to work-around the PHY_100 errata
3047 // described below. The following code is only compiled in, if we wanted
3048 // to attempt a software workaround to the PHY_100 A/B step problem.
3056 This routine will figure out what line speed and duplex mode
3057 the PHY is currently using.
3059 @param AdapterInfo pointer to the structure that contains
3061 @param PhyId The ID of the PHY in question.
3067 FindPhySpeedAndDpx (
3068 IN NIC_DATA_INSTANCE
*AdapterInfo
,
3072 UINT16 MdiStatusReg
;
3075 UINT16 MdiLinkPartnerAdReg
;
3078 // If there was a speed and/or duplex override, then set our current
3079 // value accordingly
3081 AdapterInfo
->LinkSpeed
= AdapterInfo
->LinkSpeedReq
;
3082 AdapterInfo
->Duplex
= (UINT8
) ((AdapterInfo
->DuplexReq
& PXE_FORCE_FULL_DUPLEX
) ?
3083 FULL_DUPLEX
: HALF_DUPLEX
);
3086 // If speed and duplex were forced, then we know our current settings, so
3087 // we'll just return. Otherwise, we'll need to figure out what NWAY set
3090 if (AdapterInfo
->LinkSpeed
&& AdapterInfo
->Duplex
) {
3095 // If we didn't have a valid link, then we'll assume that our current
3096 // speed is 10mb half-duplex.
3100 // Read the status register twice because of sticky bits
3105 AdapterInfo
->PhyAddress
,
3111 AdapterInfo
->PhyAddress
,
3116 // If there wasn't a valid link then use default speed & duplex
3118 if (!(MdiStatusReg
& MDI_SR_LINK_STATUS
)) {
3120 AdapterInfo
->LinkSpeed
= 10;
3121 AdapterInfo
->Duplex
= HALF_DUPLEX
;
3126 // If this is an Intel PHY (a T4 PHY_100 or a TX PHY_TX), then read bits
3127 // 1 and 0 of extended register 0, to get the current speed and duplex
3130 if ((PhyId
== PHY_100_A
) || (PhyId
== PHY_100_C
) || (PhyId
== PHY_TX_ID
)) {
3132 // Read extended register 0
3137 AdapterInfo
->PhyAddress
,
3142 // Get current speed setting
3144 if (MdiMiscReg
& PHY_100_ER0_SPEED_INDIC
) {
3145 AdapterInfo
->LinkSpeed
= 100;
3147 AdapterInfo
->LinkSpeed
= 10;
3151 // Get current duplex setting -- if bit is set then FDX is enabled
3153 if (MdiMiscReg
& PHY_100_ER0_FDX_INDIC
) {
3154 AdapterInfo
->Duplex
= FULL_DUPLEX
;
3156 AdapterInfo
->Duplex
= HALF_DUPLEX
;
3162 // Read our link partner's advertisement register
3166 AUTO_NEG_LINK_PARTNER_REG
,
3167 AdapterInfo
->PhyAddress
,
3168 &MdiLinkPartnerAdReg
3172 // See if Auto-Negotiation was complete (bit 5, reg 1)
3177 AdapterInfo
->PhyAddress
,
3182 // If a True NWAY connection was made, then we can detect speed/duplex by
3183 // ANDing our adapter's advertised abilities with our link partner's
3184 // advertised ablilities, and then assuming that the highest common
3185 // denominator was chosed by NWAY.
3187 if ((MdiLinkPartnerAdReg
& NWAY_LP_ABILITY
) &&
3188 (MdiStatusReg
& MDI_SR_AUTO_NEG_COMPLETE
)) {
3191 // Read our advertisement register
3195 AUTO_NEG_ADVERTISE_REG
,
3196 AdapterInfo
->PhyAddress
,
3201 // AND the two advertisement registers together, and get rid of any
3204 MdiOwnAdReg
= (UINT16
) (MdiOwnAdReg
& (MdiLinkPartnerAdReg
& NWAY_LP_ABILITY
));
3207 // Get speed setting
3209 if (MdiOwnAdReg
& (NWAY_AD_TX_HALF_DPX
| NWAY_AD_TX_FULL_DPX
| NWAY_AD_T4_CAPABLE
)) {
3210 AdapterInfo
->LinkSpeed
= 100;
3212 AdapterInfo
->LinkSpeed
= 10;
3216 // Get duplex setting -- use priority resolution algorithm
3218 if (MdiOwnAdReg
& (NWAY_AD_T4_CAPABLE
)) {
3219 AdapterInfo
->Duplex
= HALF_DUPLEX
;
3221 } else if (MdiOwnAdReg
& (NWAY_AD_TX_FULL_DPX
)) {
3222 AdapterInfo
->Duplex
= FULL_DUPLEX
;
3224 } else if (MdiOwnAdReg
& (NWAY_AD_TX_HALF_DPX
)) {
3225 AdapterInfo
->Duplex
= HALF_DUPLEX
;
3227 } else if (MdiOwnAdReg
& (NWAY_AD_10T_FULL_DPX
)) {
3228 AdapterInfo
->Duplex
= FULL_DUPLEX
;
3231 AdapterInfo
->Duplex
= HALF_DUPLEX
;
3237 // If we are connected to a dumb (non-NWAY) repeater or hub, and the line
3238 // speed was determined automatically by parallel detection, then we have
3239 // no way of knowing exactly what speed the PHY is set to unless that PHY
3240 // has a propietary register which indicates speed in this situation. The
3241 // NSC TX PHY does have such a register. Also, since NWAY didn't establish
3242 // the connection, the duplex setting should HALF duplex.
3244 AdapterInfo
->Duplex
= HALF_DUPLEX
;
3246 if (PhyId
== PHY_NSC_TX
) {
3248 // Read register 25 to get the SPEED_10 bit
3253 AdapterInfo
->PhyAddress
,
3258 // If bit 6 was set then we're at 10mb
3260 if (MdiMiscReg
& NSC_TX_SPD_INDC_SPEED
) {
3261 AdapterInfo
->LinkSpeed
= 10;
3263 AdapterInfo
->LinkSpeed
= 100;
3268 // If we don't know what line speed we are set at, then we'll default to
3272 AdapterInfo
->LinkSpeed
= 10;
3278 TODO: Add function description
3280 @param AdapterInfo TODO: add argument description
3282 @return TODO: add return values
3286 XmitWaitForCompletion (
3287 NIC_DATA_INSTANCE
*AdapterInfo
3292 if (AdapterInfo
->FreeCBCount
== AdapterInfo
->TxBufCnt
) {
3297 // used xmit cb list starts right after the free tail (ends before the
3300 TxPtr
= AdapterInfo
->FreeTxTailPtr
->NextTCBVirtualLinkPtr
;
3301 while (TxPtr
!= AdapterInfo
->FreeTxHeadPtr
) {
3302 CommandWaitForCompletion (TxPtr
, AdapterInfo
);
3303 SetFreeCB (AdapterInfo
, TxPtr
);
3304 TxPtr
= TxPtr
->NextTCBVirtualLinkPtr
;
3310 TODO: Add function description
3312 @param cmd_ptr TODO: add argument description
3313 @param AdapterInfo TODO: add argument description
3315 @return TODO: add return values
3319 CommandWaitForCompletion (
3321 NIC_DATA_INSTANCE
*AdapterInfo
3326 while ((cmd_ptr
->cb_header
.status
== 0) && (--wait
> 0)) {
3327 DelayIt (AdapterInfo
, 10);
3330 if (cmd_ptr
->cb_header
.status
== 0) {
3339 TODO: Add function description
3341 @param AdapterInfo TODO: add argument description
3343 @return TODO: add return values
3348 NIC_DATA_INSTANCE
*AdapterInfo
3357 // Reset the chip: stop Tx and Rx processes and clear counters.
3358 // This takes less than 10usec and will easily finish before the next
3362 OutLong (AdapterInfo
, PORT_RESET
, AdapterInfo
->ioaddr
+ SCBPort
);
3364 // wait for 5 milli seconds here!
3366 DelayIt (AdapterInfo
, 5000);
3368 // TCO Errata work around for 559s only
3369 // -----------------------------------------------------------------------------------
3370 // TCO Workaround Code
3372 // -----------------------------------------------------------------------------------
3373 // 1. Issue SW-RST ^^^ (already done above)
3374 // 2. Issue a redundant Set CU Base CMD immediately
3375 // Do not set the General Pointer before the Set CU Base cycle
3376 // Do not check the SCB CMD before the Set CU Base cycle
3377 // 3. Wait for the SCB-CMD to be cleared
3378 // this indicates the transition to post-driver
3379 // 4. Poll the TCO-Req bit in the PMDR to be cleared
3380 // this indicates the tco activity has stopped for real
3381 // 5. Proceed with the nominal Driver Init:
3382 // Actual Set CU & RU Base ...
3384 // Check for ICH2 device ID. If this is an ICH2,
3385 // do the TCO workaround code.
3387 if (AdapterInfo
->VendorID
== D102_DEVICE_ID
||
3388 AdapterInfo
->VendorID
== ICH3_DEVICE_ID_1
||
3389 AdapterInfo
->VendorID
== ICH3_DEVICE_ID_2
||
3390 AdapterInfo
->VendorID
== ICH3_DEVICE_ID_3
||
3391 AdapterInfo
->VendorID
== ICH3_DEVICE_ID_4
||
3392 AdapterInfo
->VendorID
== ICH3_DEVICE_ID_5
||
3393 AdapterInfo
->VendorID
== ICH3_DEVICE_ID_6
||
3394 AdapterInfo
->VendorID
== ICH3_DEVICE_ID_7
||
3395 AdapterInfo
->VendorID
== ICH3_DEVICE_ID_8
||
3396 AdapterInfo
->RevID
>= 8) { // do the TCO fix
3398 // donot load the scb pointer but just give load_cu cmd.
3400 OutByte (AdapterInfo
, CU_CMD_BASE
, AdapterInfo
->ioaddr
+ SCBCmd
);
3402 // wait for command to be accepted.
3404 wait_for_cmd_done (AdapterInfo
->ioaddr
+ SCBCmd
);
3406 // read PMDR register and check bit 1 in it to see if TCO is active
3410 // wait for 5 milli seconds
3414 tco_stat
= InByte (AdapterInfo
, AdapterInfo
->ioaddr
+ 0x1b);
3415 if ((tco_stat
& 2) == 0) {
3417 // is the activity bit clear??
3423 DelayIt (AdapterInfo
, 1);
3426 if ((tco_stat
& 2) != 0) {
3439 TODO: Add function description
3441 @param AdapterInfo TODO: add argument description
3443 @return TODO: add return values
3448 IN NIC_DATA_INSTANCE
*AdapterInfo
3456 OutLong (AdapterInfo
, POR_SELECTIVE_RESET
, AdapterInfo
->ioaddr
+ SCBPort
);
3458 // wait for this to complete
3462 // wait for 2 milli seconds here!
3464 DelayIt (AdapterInfo
, 2000);
3467 stat
= InLong (AdapterInfo
, AdapterInfo
->ioaddr
+ SCBPort
);
3473 // wait for 1 milli second
3475 DelayIt (AdapterInfo
, 1000);
3479 return PXE_STATCODE_DEVICE_FAILURE
;
3487 TODO: Add function description
3489 @param AdapterInfo TODO: add argument description
3491 @return TODO: add return values
3496 IN NIC_DATA_INSTANCE
*AdapterInfo
3500 if (SoftwareReset (AdapterInfo
) != 0) {
3501 return PXE_STATCODE_DEVICE_FAILURE
;
3505 // disable interrupts
3507 OutWord (AdapterInfo
, INT_MASK
, AdapterInfo
->ioaddr
+ SCBCmd
);
3510 // Load the base registers with 0s (we will give the complete address as
3511 // offset later when we issue any command
3513 if ((ret_val
= Load_Base_Regs (AdapterInfo
)) != 0) {
3517 if ((ret_val
= SetupCBlink (AdapterInfo
)) != 0) {
3521 if ((ret_val
= SetupReceiveQueues (AdapterInfo
)) != 0) {
3526 // detect the PHY only if we need to detect the cable as requested by the
3527 // initialize parameters
3529 AdapterInfo
->PhyAddress
= 0xFF;
3531 if (AdapterInfo
->CableDetect
!= 0) {
3532 if (!PhyDetect (AdapterInfo
)) {
3533 return PXE_STATCODE_DEVICE_FAILURE
;
3537 if ((ret_val
= E100bSetupIAAddr (AdapterInfo
)) != 0) {
3541 if ((ret_val
= Configure (AdapterInfo
)) != 0) {