pcnet.c File Reference

#include "pcnet.h"
#include <debug.h>

Include dependency graph for pcnet.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
NTSTATUS NTAPI	DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
static VOID NTAPI	MiniportHandleInterrupt (IN NDIS_HANDLE MiniportAdapterContext)
static NDIS_STATUS	MiQueryCard (IN PADAPTER Adapter)
static VOID	MiFreeSharedMemory (PADAPTER Adapter)
static NDIS_STATUS	MiAllocateSharedMemory (PADAPTER Adapter)
static VOID	MiPrepareInitializationBlock (PADAPTER Adapter)
static BOOLEAN NTAPI	MiSyncStop (IN PVOID SynchronizeContext)
static VOID NTAPI	MiniportHalt (IN NDIS_HANDLE MiniportAdapterContext)
static BOOLEAN NTAPI	MiSyncMediaDetection (IN PVOID SynchronizeContext)
static VOID NTAPI	MiniportMediaDetectionTimer (IN PVOID SystemSpecific1, IN PVOID FunctionContext, IN PVOID SystemSpecific2, IN PVOID SystemSpecific3)
static VOID	MiInitChip (PADAPTER Adapter)
VOID NTAPI	MiniportShutdown (PVOID Context)
static NDIS_STATUS NTAPI	MiniportInitialize (OUT PNDIS_STATUS OpenErrorStatus, OUT PUINT SelectedMediumIndex, IN PNDIS_MEDIUM MediumArray, IN UINT MediumArraySize, IN NDIS_HANDLE MiniportAdapterHandle, IN NDIS_HANDLE WrapperConfigurationContext)
static VOID NTAPI	MiniportISR (OUT PBOOLEAN InterruptRecognized, OUT PBOOLEAN QueueMiniportHandleInterrupt, IN NDIS_HANDLE MiniportAdapterContext)
static NDIS_STATUS NTAPI	MiniportReset (OUT PBOOLEAN AddressingReset, IN NDIS_HANDLE MiniportAdapterContext)
static BOOLEAN NTAPI	MiSyncStartTransmit (IN PVOID SynchronizeContext)
static NDIS_STATUS NTAPI	MiniportSend (IN NDIS_HANDLE MiniportAdapterContext, IN PNDIS_PACKET Packet, IN UINT Flags)
static ULONG NTAPI	MiEthernetCrc (UCHAR *Address)
NDIS_STATUS NTAPI	MiSetMulticast (PADAPTER Adapter, UCHAR *Addresses, UINT AddressCount)
BOOLEAN NTAPI	MiGetMediaDuplex (PADAPTER Adapter)
UINT NTAPI	MiGetMediaSpeed (PADAPTER Adapter)
NDIS_MEDIA_STATE NTAPI	MiGetMediaState (PADAPTER Adapter)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 43 of file pcnet.c.

Function Documentation

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	IN PDRIVER_OBJECT	DriverObject,
		IN PUNICODE_STRING	RegistryPath
	)

Definition at line 1327 of file pcnet.c.

{
  NDIS_HANDLE WrapperHandle;
  NDIS_MINIPORT_CHARACTERISTICS Characteristics;
  NDIS_STATUS Status;
 
  RtlZeroMemory(&Characteristics, sizeof(Characteristics));
  Characteristics.MajorNdisVersion = NDIS_MINIPORT_MAJOR_VERSION;
  Characteristics.MinorNdisVersion = NDIS_MINIPORT_MINOR_VERSION;
  Characteristics.HaltHandler = MiniportHalt;
  Characteristics.HandleInterruptHandler = MiniportHandleInterrupt;
  Characteristics.InitializeHandler = MiniportInitialize;
  Characteristics.ISRHandler = MiniportISR;
  Characteristics.QueryInformationHandler = MiniportQueryInformation;
  Characteristics.ResetHandler = MiniportReset;
  Characteristics.SetInformationHandler = MiniportSetInformation;
  Characteristics.SendHandler = MiniportSend;
 
  NdisMInitializeWrapper(&WrapperHandle, DriverObject, RegistryPath, 0);
  if (!WrapperHandle) return NDIS_STATUS_FAILURE;
 
  Status = NdisMRegisterMiniport(WrapperHandle, &Characteristics, sizeof(Characteristics));
  if(Status != NDIS_STATUS_SUCCESS)
    {
      NdisTerminateWrapper(WrapperHandle, 0);
      return NDIS_STATUS_FAILURE;
    }
 
  return NDIS_STATUS_SUCCESS;
}

MiAllocateSharedMemory()

static NDIS_STATUS MiAllocateSharedMemory ( PADAPTER  Adapter )

static

Definition at line 353 of file pcnet.c.

{
  PTRANSMIT_DESCRIPTOR TransmitDescriptor;
  PRECEIVE_DESCRIPTOR  ReceiveDescriptor;
  NDIS_PHYSICAL_ADDRESS PhysicalAddress;
  ULONG i;
  ULONG BufferCount = NUMBER_OF_BUFFERS;
  ULONG LogBufferCount = LOG_NUMBER_OF_BUFFERS;
 
  while (BufferCount != 0)
  {
      /* allocate the initialization block (we have this in the loop so we can use MiFreeSharedMemory) */
      Adapter->InitializationBlockLength = sizeof(INITIALIZATION_BLOCK);
      NdisMAllocateSharedMemory(Adapter->MiniportAdapterHandle, Adapter->InitializationBlockLength,
          FALSE, (PVOID *)&Adapter->InitializationBlockVirt, &PhysicalAddress);
      if(!Adapter->InitializationBlockVirt)
      {
         /* Buffer backoff won't help us here */
         DPRINT1("insufficient resources\n");
         return NDIS_STATUS_RESOURCES;
      }
 
      if (((ULONG_PTR)Adapter->InitializationBlockVirt & 0x00000003) != 0)
      {
         DPRINT1("address 0x%x not dword-aligned\n", Adapter->InitializationBlockVirt);
         return NDIS_STATUS_RESOURCES;
      }
 
      Adapter->InitializationBlockPhys = PhysicalAddress;
 
      /* allocate the transport descriptor ring */
      Adapter->TransmitDescriptorRingLength = sizeof(TRANSMIT_DESCRIPTOR) * BufferCount;
      NdisMAllocateSharedMemory(Adapter->MiniportAdapterHandle, Adapter->TransmitDescriptorRingLength,
          FALSE, (PVOID *)&Adapter->TransmitDescriptorRingVirt, &PhysicalAddress);
      if (!Adapter->TransmitDescriptorRingVirt)
      {
          DPRINT1("Backing off buffer count by %d buffers due to allocation failure\n", (BufferCount >> 1));
          BufferCount = BufferCount >> 1;
          LogBufferCount--;
          MiFreeSharedMemory(Adapter);
          continue;
      }
 
      if (((ULONG_PTR)Adapter->TransmitDescriptorRingVirt & 0x00000003) != 0)
      {
         DPRINT1("address 0x%x not dword-aligned\n", Adapter->TransmitDescriptorRingVirt);
         return NDIS_STATUS_RESOURCES;
      }
 
      Adapter->TransmitDescriptorRingPhys = PhysicalAddress;
      RtlZeroMemory(Adapter->TransmitDescriptorRingVirt, sizeof(TRANSMIT_DESCRIPTOR) * BufferCount);
 
      /* allocate the receive descriptor ring */
      Adapter->ReceiveDescriptorRingLength = sizeof(RECEIVE_DESCRIPTOR) * BufferCount;
      NdisMAllocateSharedMemory(Adapter->MiniportAdapterHandle, Adapter->ReceiveDescriptorRingLength,
          FALSE, (PVOID *)&Adapter->ReceiveDescriptorRingVirt, &PhysicalAddress);
      if (!Adapter->ReceiveDescriptorRingVirt)
      {
          DPRINT1("Backing off buffer count by %d buffers due to allocation failure\n", (BufferCount >> 1));
          BufferCount = BufferCount >> 1;
          LogBufferCount--;
          MiFreeSharedMemory(Adapter);
          continue;
      }
 
      if (((ULONG_PTR)Adapter->ReceiveDescriptorRingVirt & 0x00000003) != 0)
      {
          DPRINT1("address 0x%x not dword-aligned\n", Adapter->ReceiveDescriptorRingVirt);
          return NDIS_STATUS_RESOURCES;
      }
 
      Adapter->ReceiveDescriptorRingPhys = PhysicalAddress;
      RtlZeroMemory(Adapter->ReceiveDescriptorRingVirt, sizeof(RECEIVE_DESCRIPTOR) * BufferCount);
 
      /* allocate transmit buffers */
      Adapter->TransmitBufferLength = BUFFER_SIZE * BufferCount;
      NdisMAllocateSharedMemory(Adapter->MiniportAdapterHandle, Adapter->TransmitBufferLength,
         TRUE, (PVOID *)&Adapter->TransmitBufferPtrVirt, &PhysicalAddress);
      if(!Adapter->TransmitBufferPtrVirt)
      {
          DPRINT1("Backing off buffer count by %d buffers due to allocation failure\n", (BufferCount >> 1));
          BufferCount = BufferCount >> 1;
          LogBufferCount--;
          MiFreeSharedMemory(Adapter);
          continue;
      }
 
      if(((ULONG_PTR)Adapter->TransmitBufferPtrVirt & 0x00000003) != 0)
      {
          DPRINT1("address 0x%x not dword-aligned\n", Adapter->TransmitBufferPtrVirt);
          return NDIS_STATUS_RESOURCES;
      }
 
      Adapter->TransmitBufferPtrPhys = PhysicalAddress;
      RtlZeroMemory(Adapter->TransmitBufferPtrVirt, BUFFER_SIZE * BufferCount);
 
      /* allocate receive buffers */
      Adapter->ReceiveBufferLength = BUFFER_SIZE * BufferCount;
      NdisMAllocateSharedMemory(Adapter->MiniportAdapterHandle, Adapter->ReceiveBufferLength,
         TRUE, (PVOID *)&Adapter->ReceiveBufferPtrVirt, &PhysicalAddress);
      if(!Adapter->ReceiveBufferPtrVirt)
      {
          DPRINT1("Backing off buffer count by %d buffers due to allocation failure\n", (BufferCount >> 1));
          BufferCount = BufferCount >> 1;
          LogBufferCount--;
          MiFreeSharedMemory(Adapter);
          continue;
      }
 
      if (((ULONG_PTR)Adapter->ReceiveBufferPtrVirt & 0x00000003) != 0)
      {
          DPRINT1("address 0x%x not dword-aligned\n", Adapter->ReceiveBufferPtrVirt);
          return NDIS_STATUS_RESOURCES;
      }
 
      Adapter->ReceiveBufferPtrPhys = PhysicalAddress;
      RtlZeroMemory(Adapter->ReceiveBufferPtrVirt, BUFFER_SIZE * BufferCount);
 
      break;
  }
 
  if (!BufferCount)
  {
      DPRINT1("Failed to allocate adapter buffers\n");
      return NDIS_STATUS_RESOURCES;
  }
 
  Adapter->BufferCount = BufferCount;
  Adapter->LogBufferCount = LogBufferCount;
 
  /* initialize tx descriptors */
  TransmitDescriptor = Adapter->TransmitDescriptorRingVirt;
  for(i = 0; i < BufferCount; i++)
    {
      (TransmitDescriptor+i)->TBADR = Adapter->TransmitBufferPtrPhys.QuadPart + i * BUFFER_SIZE;
      (TransmitDescriptor+i)->BCNT = 0xf000 | -BUFFER_SIZE; /* 2's compliment  + set top 4 bits */
      (TransmitDescriptor+i)->FLAGS = TD1_STP | TD1_ENP;
    }
 
  DPRINT("transmit ring initialized\n");
 
  /* initialize rx */
  ReceiveDescriptor = Adapter->ReceiveDescriptorRingVirt;
  for(i = 0; i < BufferCount; i++)
    {
      (ReceiveDescriptor+i)->RBADR = Adapter->ReceiveBufferPtrPhys.QuadPart + i * BUFFER_SIZE;
      (ReceiveDescriptor+i)->BCNT = 0xf000 | -BUFFER_SIZE; /* 2's compliment  + set top 4 bits */
      (ReceiveDescriptor+i)->FLAGS = RD_OWN;
    }
 
  DPRINT("receive ring initialized\n");
 
  return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportInitialize().

MiEthernetCrc()

static ULONG NTAPI MiEthernetCrc ( UCHAR *  Address )

static

Definition at line 1235 of file pcnet.c.

{
  UINT Counter, Length;
  ULONG Value = ~0;
 
  for (Length = 0; Length < 6; Length++)
    {
      Value ^= *Address++;
      for (Counter = 0; Counter < 8; Counter++)
        {
          Value >>= 1;
          Value ^= (Value & 1) * 0xedb88320;
        }
    }
 
  return Value;
}

Referenced by MiSetMulticast().

MiFreeSharedMemory()

static VOID MiFreeSharedMemory ( PADAPTER  Adapter )

static

Definition at line 301 of file pcnet.c.

{
  NDIS_PHYSICAL_ADDRESS PhysicalAddress;
 
  if(Adapter->InitializationBlockVirt)
    {
      PhysicalAddress = Adapter->InitializationBlockPhys;
      NdisMFreeSharedMemory(Adapter->MiniportAdapterHandle, Adapter->InitializationBlockLength,
          FALSE, Adapter->InitializationBlockVirt, PhysicalAddress);
      Adapter->InitializationBlockVirt = NULL;
    }
 
  if(Adapter->TransmitDescriptorRingVirt)
    {
      PhysicalAddress = Adapter->TransmitDescriptorRingPhys;
      NdisMFreeSharedMemory(Adapter->MiniportAdapterHandle, Adapter->TransmitDescriptorRingLength,
        FALSE, Adapter->TransmitDescriptorRingVirt, PhysicalAddress);
      Adapter->TransmitDescriptorRingVirt = NULL;
    }
 
  if(Adapter->ReceiveDescriptorRingVirt)
    {
      PhysicalAddress = Adapter->ReceiveDescriptorRingPhys;
      NdisMFreeSharedMemory(Adapter->MiniportAdapterHandle, Adapter->ReceiveDescriptorRingLength,
          FALSE, Adapter->ReceiveDescriptorRingVirt, PhysicalAddress);
      Adapter->ReceiveDescriptorRingVirt = NULL;
    }
 
  if(Adapter->TransmitBufferPtrVirt)
    {
      PhysicalAddress = Adapter->TransmitBufferPtrPhys;
      NdisMFreeSharedMemory(Adapter->MiniportAdapterHandle, Adapter->TransmitBufferLength,
          TRUE, Adapter->TransmitBufferPtrVirt, PhysicalAddress);
      Adapter->TransmitBufferPtrVirt = NULL;
    }
 
  if(Adapter->ReceiveBufferPtrVirt)
    {
      PhysicalAddress = Adapter->ReceiveBufferPtrPhys;
      NdisMFreeSharedMemory(Adapter->MiniportAdapterHandle, Adapter->ReceiveBufferLength,
          TRUE, Adapter->ReceiveBufferPtrVirt, PhysicalAddress);
      Adapter->ReceiveBufferPtrVirt = NULL;
    }
}

Referenced by MiAllocateSharedMemory(), MiniportHalt(), and MiniportInitialize().

MiGetMediaDuplex()

BOOLEAN NTAPI MiGetMediaDuplex

(

PADAPTER

Adapter

)

Definition at line 1285 of file pcnet.c.

{
  ULONG Data;
 
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, BCR5);
  NdisRawReadPortUshort(Adapter->PortOffset + BDP, &Data);
 
  return (Data & BCR5_LEDOUT) != 0;
}

Referenced by MiInitChip(), and MiSyncMediaDetection().

MiGetMediaSpeed()

UINT NTAPI MiGetMediaSpeed

(

PADAPTER

Adapter

)

Definition at line 1297 of file pcnet.c.

{
  ULONG Data;
 
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, BCR6);
  NdisRawReadPortUshort(Adapter->PortOffset + BDP, &Data);
 
  return Data & BCR6_LEDOUT ? 100 : 10;
}

Referenced by MiInitChip(), and MiSyncMediaDetection().

MiGetMediaState()

NDIS_MEDIA_STATE NTAPI MiGetMediaState

(

PADAPTER

Adapter

)

Definition at line 1309 of file pcnet.c.

{
  ULONG Data;
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, BCR4);
  NdisRawReadPortUshort(Adapter->PortOffset + BDP, &Data);
  return Data & BCR4_LEDOUT ? NdisMediaStateConnected : NdisMediaStateDisconnected;
}

Referenced by MiInitChip(), and MiSyncMediaDetection().

MiInitChip()

static VOID MiInitChip ( PADAPTER  Adapter )

static

Definition at line 675 of file pcnet.c.

{
  USHORT Data = 0;
 
  DPRINT("Called\n");
 
  /*
   * first reset the chip - 32-bit reset followed by 16-bit reset.  if it's in 32-bit mode, it'll reset
   * twice.  if it's in 16-bit mode, the first read will be nonsense and the second will be a reset.  the
   * card is reset by reading from the reset register.  on reset it's in 16-bit i/o mode.
   */
  NdisRawReadPortUshort(Adapter->PortOffset + RESET32, &Data);
  NdisRawReadPortUshort(Adapter->PortOffset + RESET16, &Data);
 
  /* stop the chip */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, CSR0_STOP);
 
  /* pause for 1ms so the chip will have time to reset */
  NdisStallExecution(1);
 
  DPRINT("chip stopped\n");
 
  /* set the software style to 2 (32 bits) */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR58);
  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);
 
  Data |= SW_STYLE_2;
 
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, Data);
 
  /* set up csr4: auto transmit pad, disable polling, disable transmit interrupt, dmaplus */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR4);
  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);
 
  Data |= CSR4_APAD_XMT | /* CSR4_DPOLL |*/ CSR4_TXSTRTM | CSR4_DMAPLUS;
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, Data);
 
  /* set up bcr18: burst read/write enable */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, BCR18);
  NdisRawReadPortUshort(Adapter->PortOffset + BDP, &Data);
 
  Data |= BCR18_BREADE | BCR18_BWRITE ;
  NdisRawWritePortUshort(Adapter->PortOffset + BDP, Data);
 
  /* set up csr1 and csr2 with init block */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR1);
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, (USHORT)(Adapter->InitializationBlockPhys.LowPart & 0xffff));
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR2);
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, (USHORT)(Adapter->InitializationBlockPhys.LowPart >> 16) & 0xffff);
 
  DPRINT("programmed with init block\n");
 
  /* Set mode to 0 */
  Data = 0;
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR15);
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, Data);
 
  /* load init block and start the card */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, CSR0_STRT|CSR0_INIT|CSR0_IENA);
 
  /* Allow LED programming */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, BCR2);
  NdisRawWritePortUshort(Adapter->PortOffset + BDP, BCR2_LEDPE);
 
  /* LED0 is configured for link status (on = up, off = down) */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, BCR4);
  NdisRawWritePortUshort(Adapter->PortOffset + BDP, BCR4_LNKSTE | BCR4_PSE);
 
  /* LED1 is configured for link duplex (on = full, off = half) */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, BCR5);
  NdisRawWritePortUshort(Adapter->PortOffset + BDP, BCR5_FDLSE | BCR5_PSE);
 
  /* LED2 is configured for link speed (on = 100M, off = 10M) */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, BCR6);
  NdisRawWritePortUshort(Adapter->PortOffset + BDP, BCR6_E100 | BCR6_PSE);
 
  /* LED3 is configured for trasmit/receive activity */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, BCR7);
  NdisRawWritePortUshort(Adapter->PortOffset + BDP, BCR7_XMTE | BCR7_RCVE | BCR7_PSE);
 
  Adapter->MediaState = MiGetMediaState(Adapter);
  Adapter->FullDuplex = MiGetMediaDuplex(Adapter);
  Adapter->MediaSpeed = MiGetMediaSpeed(Adapter);
 
  DPRINT("card started\n");
 
  Adapter->Flags &= ~RESET_IN_PROGRESS;
}

Referenced by MiniportInitialize().

MiniportHalt()

static VOID NTAPI MiniportHalt ( IN NDIS_HANDLE  MiniportAdapterContext )

static

Definition at line 570 of file pcnet.c.

{
  PADAPTER Adapter = (PADAPTER)MiniportAdapterContext;
  BOOLEAN TimerCancelled;
 
  DPRINT("Called\n");
  ASSERT(Adapter);
 
  /* stop the media detection timer */
  NdisMCancelTimer(&Adapter->MediaDetectionTimer, &TimerCancelled);
 
  /* stop the chip */
  NdisMSynchronizeWithInterrupt(&Adapter->InterruptObject, MiSyncStop, Adapter);
 
  /* deregister the interrupt */
  NdisMDeregisterInterrupt(&Adapter->InterruptObject);
 
  /* deregister i/o port range */
  NdisMDeregisterIoPortRange(Adapter->MiniportAdapterHandle, Adapter->IoBaseAddress, NUMBER_OF_PORTS, (PVOID)Adapter->PortOffset);
 
  /* deregister the shutdown routine */
  NdisMDeregisterAdapterShutdownHandler(Adapter->MiniportAdapterHandle);
 
  /* free shared memory */
  MiFreeSharedMemory(Adapter);
 
  /* free map registers */
  NdisMFreeMapRegisters(Adapter->MiniportAdapterHandle);
 
  /* free the lock */
  NdisFreeSpinLock(&Adapter->Lock);
 
  /* free the adapter */
  NdisFreeMemory(Adapter, 0, 0);
}

Referenced by DriverEntry().

MiniportHandleInterrupt()

static VOID NTAPI MiniportHandleInterrupt ( IN NDIS_HANDLE  MiniportAdapterContext )

static

Definition at line 54 of file pcnet.c.

{
  PADAPTER Adapter = (PADAPTER)MiniportAdapterContext;
  USHORT Data;
  UINT i = 0;
 
  DPRINT("Called\n");
 
  ASSERT_IRQL_EQUAL(DISPATCH_LEVEL);
 
  NdisDprAcquireSpinLock(&Adapter->Lock);
 
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);
 
  DPRINT("CSR0 is 0x%x\n", Data);
 
  while((Data & CSR0_INTR) && i++ < INTERRUPT_LIMIT)
    {
      /* Clear interrupt flags early to avoid race conditions. */
      NdisRawWritePortUshort(Adapter->PortOffset + RDP, Data);
 
      if(Data & CSR0_ERR)
        {
          DPRINT("error: %x\n", Data & (CSR0_MERR|CSR0_BABL|CSR0_CERR|CSR0_MISS));
          if (Data & CSR0_CERR)
            Adapter->Statistics.XmtCollisions++;
        }
      if(Data & CSR0_IDON)
        {
          DPRINT("IDON\n");
        }
      if(Data & CSR0_RINT)
        {
          BOOLEAN IndicatedData = FALSE;
 
          DPRINT("receive interrupt\n");
 
          while(1)
            {
              PRECEIVE_DESCRIPTOR Descriptor = Adapter->ReceiveDescriptorRingVirt + Adapter->CurrentReceiveDescriptorIndex;
              PCHAR Buffer;
              ULONG ByteCount;
 
              if(Descriptor->FLAGS & RD_OWN)
                {
                  DPRINT("no more receive descriptors to process\n");
                  break;
                }
 
              if(Descriptor->FLAGS & RD_ERR)
                {
                  DPRINT("receive descriptor error: 0x%x\n", Descriptor->FLAGS);
                  if (Descriptor->FLAGS & RD_BUFF)
                    Adapter->Statistics.RcvBufferErrors++;
                  if (Descriptor->FLAGS & RD_CRC)
                    Adapter->Statistics.RcvCrcErrors++;
                  if (Descriptor->FLAGS & RD_OFLO)
                    Adapter->Statistics.RcvOverflowErrors++;
                  if (Descriptor->FLAGS & RD_FRAM)
                    Adapter->Statistics.RcvFramingErrors++;
                  break;
                }
 
              if(!((Descriptor->FLAGS & RD_STP) && (Descriptor->FLAGS & RD_ENP)))
                {
                  DPRINT("receive descriptor not start&end: 0x%x\n", Descriptor->FLAGS);
                  break;
                }
 
              Buffer = Adapter->ReceiveBufferPtrVirt + Adapter->CurrentReceiveDescriptorIndex * BUFFER_SIZE;
              ByteCount = Descriptor->MCNT & 0xfff;
 
              DPRINT("Indicating a %d-byte packet (index %d)\n", ByteCount, Adapter->CurrentReceiveDescriptorIndex);
 
              NdisMEthIndicateReceive(Adapter->MiniportAdapterHandle, 0, Buffer, 14, Buffer+14, ByteCount-14, ByteCount-14);
 
              IndicatedData = TRUE;
 
              RtlZeroMemory(Descriptor, sizeof(RECEIVE_DESCRIPTOR));
              Descriptor->RBADR = Adapter->ReceiveBufferPtrPhys.QuadPart +
                                  (Adapter->CurrentReceiveDescriptorIndex * BUFFER_SIZE);
              Descriptor->BCNT = (-BUFFER_SIZE) | 0xf000;
              Descriptor->FLAGS |= RD_OWN;
 
              Adapter->CurrentReceiveDescriptorIndex++;
              Adapter->CurrentReceiveDescriptorIndex %= Adapter->BufferCount;
 
              Adapter->Statistics.RcvGoodFrames++;
            }
 
            if (IndicatedData)
                NdisMEthIndicateReceiveComplete(Adapter->MiniportAdapterHandle);
        }
      if(Data & CSR0_TINT)
        {
          PTRANSMIT_DESCRIPTOR Descriptor;
 
          DPRINT("transmit interrupt\n");
 
          while (Adapter->CurrentTransmitStartIndex !=
                 Adapter->CurrentTransmitEndIndex)
            {
              Descriptor = Adapter->TransmitDescriptorRingVirt + Adapter->CurrentTransmitStartIndex;
 
              DPRINT("buffer %d flags %x flags2 %x\n",
                     Adapter->CurrentTransmitStartIndex,
                     Descriptor->FLAGS, Descriptor->FLAGS2);
 
              if (Descriptor->FLAGS & TD1_OWN)
                {
                  DPRINT("non-TXed buffer\n");
                  break;
                }
 
              if (Descriptor->FLAGS & TD1_STP)
                {
                  if (Descriptor->FLAGS & TD1_ONE)
                    Adapter->Statistics.XmtOneRetry++;
                  else if (Descriptor->FLAGS & TD1_MORE)
                    Adapter->Statistics.XmtMoreThanOneRetry++;
                }
 
              if (Descriptor->FLAGS & TD1_ERR)
                {
                  DPRINT("major error: %x\n", Descriptor->FLAGS2);
                  if (Descriptor->FLAGS2 & TD2_RTRY)
                    Adapter->Statistics.XmtRetryErrors++;
                  if (Descriptor->FLAGS2 & TD2_LCAR)
                    Adapter->Statistics.XmtLossesOfCarrier++;
                  if (Descriptor->FLAGS2 & TD2_LCOL)
                    Adapter->Statistics.XmtLateCollisions++;
                  if (Descriptor->FLAGS2 & TD2_EXDEF)
                    Adapter->Statistics.XmtExcessiveDeferrals++;
                  if (Descriptor->FLAGS2 & TD2_UFLO)
                    Adapter->Statistics.XmtBufferUnderflows++;
                  if (Descriptor->FLAGS2 & TD2_BUFF)
                    Adapter->Statistics.XmtBufferErrors++;
                  break;
                }
 
              Adapter->CurrentTransmitStartIndex++;
              Adapter->CurrentTransmitStartIndex %= Adapter->BufferCount;
 
              Adapter->Statistics.XmtGoodFrames++;
            }
          NdisMSendResourcesAvailable(Adapter->MiniportAdapterHandle);
        }
      if(Data & ~(CSR0_ERR | CSR0_IDON | CSR0_RINT | CSR0_TINT))
        {
          DPRINT("UNHANDLED INTERRUPT CSR0 0x%x\n", Data);
        }
 
      NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);
    }
 
  /* re-enable interrupts */
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, CSR0_IENA);
 
  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);
  DPRINT("CSR0 is now 0x%x\n", Data);
 
  NdisDprReleaseSpinLock(&Adapter->Lock);
}

Referenced by DriverEntry().

MiniportInitialize()

static NDIS_STATUS NTAPI MiniportInitialize ( OUT PNDIS_STATUS  OpenErrorStatus, OUT PUINT  SelectedMediumIndex, IN PNDIS_MEDIUM  MediumArray, IN UINT  MediumArraySize, IN NDIS_HANDLE  MiniportAdapterHandle, IN NDIS_HANDLE  WrapperConfigurationContext  )

static

Definition at line 853 of file pcnet.c.

{
  UINT i = 0;
  PADAPTER Adapter = 0;
  NDIS_STATUS Status = NDIS_STATUS_FAILURE;
  BOOLEAN InterruptRegistered = FALSE, MapRegistersAllocated = FALSE;
  NDIS_HANDLE ConfigurationHandle;
  UINT *RegNetworkAddress = 0;
  UINT RegNetworkAddressLength = 0;
 
  ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
 
  /* Pick a medium */
  for(i = 0; i < MediumArraySize; i++)
    if(MediumArray[i] == NdisMedium802_3)
      break;
 
  if(i == MediumArraySize)
    {
      Status = NDIS_STATUS_UNSUPPORTED_MEDIA;
      DPRINT1("unsupported media\n");
      *OpenErrorStatus = Status;
      return Status;
    }
 
  *SelectedMediumIndex = i;
 
  /* allocate our adapter struct */
  Status = NdisAllocateMemoryWithTag((PVOID *)&Adapter, sizeof(ADAPTER), PCNET_TAG);
  if(Status != NDIS_STATUS_SUCCESS)
    {
      Status =  NDIS_STATUS_RESOURCES;
      DPRINT1("Insufficient resources\n");
      *OpenErrorStatus = Status;
      return Status;
    }
 
  RtlZeroMemory(Adapter, sizeof(ADAPTER));
 
  Adapter->MiniportAdapterHandle = MiniportAdapterHandle;
 
  /* register our adapter structwith ndis */
  NdisMSetAttributesEx(Adapter->MiniportAdapterHandle, Adapter, 0, NDIS_ATTRIBUTE_BUS_MASTER, NdisInterfacePci);
 
  do
    {
      /* Card-specific detection and setup */
      Status = MiQueryCard(Adapter);
      if(Status != NDIS_STATUS_SUCCESS)
        {
          DPRINT1("MiQueryCard failed\n");
          Status = NDIS_STATUS_ADAPTER_NOT_FOUND;
          break;
        }
 
      /* register an IO port range */
      Status = NdisMRegisterIoPortRange((PVOID*)&Adapter->PortOffset, Adapter->MiniportAdapterHandle,
          (UINT)Adapter->IoBaseAddress, NUMBER_OF_PORTS);
      if(Status != NDIS_STATUS_SUCCESS)
        {
          DPRINT1("NdisMRegisterIoPortRange failed: 0x%x\n", Status);
          break;
        }
 
      /* Allocate map registers */
      Status = NdisMAllocateMapRegisters(Adapter->MiniportAdapterHandle, 0,
          NDIS_DMA_32BITS, 8, BUFFER_SIZE);
      if(Status != NDIS_STATUS_SUCCESS)
        {
          DPRINT1("NdisMAllocateMapRegisters failed: 0x%x\n", Status);
          break;
        }
 
      MapRegistersAllocated = TRUE;
 
      /* set up the interrupt */
      Status = NdisMRegisterInterrupt(&Adapter->InterruptObject, Adapter->MiniportAdapterHandle, Adapter->InterruptVector,
          Adapter->InterruptVector, TRUE, TRUE, NdisInterruptLevelSensitive);
      if(Status != NDIS_STATUS_SUCCESS)
        {
          DPRINT1("NdisMRegisterInterrupt failed: 0x%x\n", Status);
          break;
        }
 
      InterruptRegistered = TRUE;
 
      /* Allocate and initialize shared data structures */
      Status = MiAllocateSharedMemory(Adapter);
      if(Status != NDIS_STATUS_SUCCESS)
        {
          Status = NDIS_STATUS_RESOURCES;
          DPRINT1("MiAllocateSharedMemory failed\n", Status);
          break;
        }
 
      /* set up the initialization block */
      MiPrepareInitializationBlock(Adapter);
 
      /* see if someone set a network address manually */
      NdisOpenConfiguration(&Status, &ConfigurationHandle, WrapperConfigurationContext);
      if (Status == NDIS_STATUS_SUCCESS)
      {
         NdisReadNetworkAddress(&Status, (PVOID *)&RegNetworkAddress, &RegNetworkAddressLength, ConfigurationHandle);
         if(Status == NDIS_STATUS_SUCCESS && RegNetworkAddressLength == 6)
         {
             int i;
             DPRINT("NdisReadNetworkAddress returned successfully, address %x:%x:%x:%x:%x:%x\n",
                     RegNetworkAddress[0], RegNetworkAddress[1], RegNetworkAddress[2], RegNetworkAddress[3],
                     RegNetworkAddress[4], RegNetworkAddress[5]);
 
             for(i = 0; i < 6; i++)
                 Adapter->InitializationBlockVirt->PADR[i] = RegNetworkAddress[i];
         }
 
         NdisCloseConfiguration(ConfigurationHandle);
      }
 
      DPRINT("Interrupt registered successfully\n");
 
      /* Initialize and start the chip */
      MiInitChip(Adapter);
 
      NdisAllocateSpinLock(&Adapter->Lock);
 
      Status = NDIS_STATUS_SUCCESS;
    }
  while(0);
 
  if(Status != NDIS_STATUS_SUCCESS && Adapter)
    {
      DPRINT("Error; freeing stuff\n");
 
      MiFreeSharedMemory(Adapter);
 
      if(MapRegistersAllocated)
        NdisMFreeMapRegisters(Adapter->MiniportAdapterHandle);
 
      if(Adapter->PortOffset)
        NdisMDeregisterIoPortRange(Adapter->MiniportAdapterHandle, Adapter->IoBaseAddress, NUMBER_OF_PORTS, (PVOID)Adapter->PortOffset);
 
      if(InterruptRegistered)
        NdisMDeregisterInterrupt(&Adapter->InterruptObject);
 
      NdisFreeMemory(Adapter, 0, 0);
    }
 
  if(Status == NDIS_STATUS_SUCCESS)
    {
      NdisMInitializeTimer(&Adapter->MediaDetectionTimer,
                           Adapter->MiniportAdapterHandle,
                           MiniportMediaDetectionTimer,
                           Adapter);
      NdisMSetPeriodicTimer(&Adapter->MediaDetectionTimer,
                            MEDIA_DETECTION_INTERVAL);
      NdisMRegisterAdapterShutdownHandler(Adapter->MiniportAdapterHandle,
                                          Adapter,
                                          MiniportShutdown);
    }
 
#if DBG
  if(!MiTestCard(Adapter))
    ASSERT(0);
#endif
 
  DPRINT("returning 0x%x\n", Status);
  *OpenErrorStatus = Status;
  return Status;
}

Referenced by DriverEntry().

MiniportISR()

static VOID NTAPI MiniportISR ( OUT PBOOLEAN  InterruptRecognized, OUT PBOOLEAN  QueueMiniportHandleInterrupt, IN NDIS_HANDLE  MiniportAdapterContext  )

static

Definition at line 1050 of file pcnet.c.

{
  USHORT Data;
  USHORT Rap;
  PADAPTER Adapter = (PADAPTER)MiniportAdapterContext;
 
  DPRINT("Called\n");
 
  /* save the old RAP value */
  NdisRawReadPortUshort(Adapter->PortOffset + RAP, &Rap);
 
  /* is this ours? */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
  NdisRawReadPortUshort(Adapter->PortOffset + RDP, &Data);
 
  if(!(Data & CSR0_INTR))
    {
      DPRINT("not our interrupt.\n");
      *InterruptRecognized = FALSE;
      *QueueMiniportHandleInterrupt = FALSE;
    }
  else
    {
      DPRINT("detected our interrupt\n");
 
      /* disable interrupts */
      NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
      NdisRawWritePortUshort(Adapter->PortOffset + RDP, 0);
 
      *InterruptRecognized = TRUE;
      *QueueMiniportHandleInterrupt = TRUE;
    }
 
  /* restore the rap */
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, Rap);
}

Referenced by DriverEntry().

MiniportMediaDetectionTimer()

static VOID NTAPI MiniportMediaDetectionTimer ( IN PVOID  SystemSpecific1, IN PVOID  FunctionContext, IN PVOID  SystemSpecific2, IN PVOID  SystemSpecific3  )

static

Definition at line 645 of file pcnet.c.

{
  PADAPTER Adapter = (PADAPTER)FunctionContext;
 
  ASSERT_IRQL_EQUAL(DISPATCH_LEVEL);
 
  if (NdisMSynchronizeWithInterrupt(&Adapter->InterruptObject,
                                    MiSyncMediaDetection,
                                    FunctionContext))
    {
      NdisMIndicateStatus(Adapter->MiniportAdapterHandle,
        Adapter->MediaState == NdisMediaStateConnected ?
        NDIS_STATUS_MEDIA_CONNECT : NDIS_STATUS_MEDIA_DISCONNECT,
        (PVOID)0, 0);
      NdisMIndicateStatusComplete(Adapter->MiniportAdapterHandle);
    }
}

Referenced by MiniportInitialize().

MiniportReset()

static NDIS_STATUS NTAPI MiniportReset ( OUT PBOOLEAN  AddressingReset, IN NDIS_HANDLE  MiniportAdapterContext  )

static

Definition at line 1103 of file pcnet.c.

{
  DPRINT("Called\n");
 
  /* MiniportReset doesn't do anything at the moment... perhaps this should be fixed. */
 
  *AddressingReset = FALSE;
  return NDIS_STATUS_SUCCESS;
}

Referenced by DriverEntry().

MiniportSend()

static NDIS_STATUS NTAPI MiniportSend ( IN NDIS_HANDLE  MiniportAdapterContext, IN PNDIS_PACKET  Packet, IN UINT  Flags  )

static

Definition at line 1144 of file pcnet.c.

{
  PADAPTER Adapter = (PADAPTER)MiniportAdapterContext;
  PTRANSMIT_DESCRIPTOR Desc;
  PNDIS_BUFFER NdisBuffer;
  PVOID SourceBuffer;
  UINT TotalPacketLength, SourceLength, Position = 0;
 
  DPRINT("Called\n");
 
  ASSERT_IRQL_EQUAL(DISPATCH_LEVEL);
 
  NdisDprAcquireSpinLock(&Adapter->Lock);
 
  /* Check if we have free entry in our circular buffer. */
  if ((Adapter->CurrentTransmitEndIndex + 1 ==
       Adapter->CurrentTransmitStartIndex) ||
      (Adapter->CurrentTransmitEndIndex == Adapter->BufferCount - 1 &&
       Adapter->CurrentTransmitStartIndex == 0))
    {
      DPRINT1("No free space in circular buffer\n");
      NdisDprReleaseSpinLock(&Adapter->Lock);
      return NDIS_STATUS_RESOURCES;
    }
 
  Desc = Adapter->TransmitDescriptorRingVirt + Adapter->CurrentTransmitEndIndex;
 
  NdisQueryPacket(Packet, NULL, NULL, &NdisBuffer, &TotalPacketLength);
  ASSERT(TotalPacketLength <= BUFFER_SIZE);
 
  DPRINT("TotalPacketLength: %x\n", TotalPacketLength);
 
  while (NdisBuffer)
    {
      NdisQueryBuffer(NdisBuffer, &SourceBuffer, &SourceLength);
 
      DPRINT("Buffer: %x Length: %x\n", SourceBuffer, SourceLength);
 
      RtlCopyMemory(Adapter->TransmitBufferPtrVirt +
                    Adapter->CurrentTransmitEndIndex * BUFFER_SIZE + Position,
                    SourceBuffer, SourceLength);
 
      Position += SourceLength;
 
      NdisGetNextBuffer(NdisBuffer, &NdisBuffer);
    }
 
#if DBG && 0
  {
    PUCHAR Ptr = Adapter->TransmitBufferPtrVirt +
                 Adapter->CurrentTransmitEndIndex * BUFFER_SIZE;
    for (Position = 0; Position < TotalPacketLength; Position++)
      {
        if (Position % 16 == 0)
          DbgPrint("\n");
        DbgPrint("%x ", *Ptr++);
      }
  }
  DbgPrint("\n");
#endif
 
  Adapter->CurrentTransmitEndIndex++;
  Adapter->CurrentTransmitEndIndex %= Adapter->BufferCount;
 
  Desc->FLAGS = TD1_OWN | TD1_STP | TD1_ENP;
  Desc->BCNT = 0xf000 | -(INT)TotalPacketLength;
 
  NdisMSynchronizeWithInterrupt(&Adapter->InterruptObject, MiSyncStartTransmit, Adapter);
 
  NdisDprReleaseSpinLock(&Adapter->Lock);
 
  return NDIS_STATUS_SUCCESS;
}

Referenced by DriverEntry().

MiniportShutdown()

VOID NTAPI MiniportShutdown

(

PVOID

Context

)

Definition at line 841 of file pcnet.c.

{
  PADAPTER Adapter = Context;
 
  DPRINT("Stopping the chip\n");
 
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, CSR0_STOP);
}

Referenced by MiniportInitialize().

MiPrepareInitializationBlock()

static VOID MiPrepareInitializationBlock ( PADAPTER  Adapter )

static

Definition at line 518 of file pcnet.c.

{
  ULONG i = 0;
 
  RtlZeroMemory(Adapter->InitializationBlockVirt, sizeof(INITIALIZATION_BLOCK));
 
  /* read burned-in address from card */
  for(i = 0; i < 6; i++)
    NdisRawReadPortUchar(Adapter->PortOffset + i, Adapter->InitializationBlockVirt->PADR + i);
  DPRINT("MAC address: %02x-%02x-%02x-%02x-%02x-%02x\n",
         Adapter->InitializationBlockVirt->PADR[0],
         Adapter->InitializationBlockVirt->PADR[1],
         Adapter->InitializationBlockVirt->PADR[2],
         Adapter->InitializationBlockVirt->PADR[3],
         Adapter->InitializationBlockVirt->PADR[4],
         Adapter->InitializationBlockVirt->PADR[5]);
 
  /* set up receive ring */
  DPRINT("Receive ring physical address: 0x%x\n", Adapter->ReceiveDescriptorRingPhys);
  Adapter->InitializationBlockVirt->RDRA = Adapter->ReceiveDescriptorRingPhys.QuadPart;
  Adapter->InitializationBlockVirt->RLEN = (Adapter->LogBufferCount << 4) & 0xf0;
 
  /* set up transmit ring */
  DPRINT("Transmit ring physical address: 0x%x\n", Adapter->TransmitDescriptorRingPhys);
  Adapter->InitializationBlockVirt->TDRA = Adapter->TransmitDescriptorRingPhys.QuadPart;
  Adapter->InitializationBlockVirt->TLEN = (Adapter->LogBufferCount << 4) & 0xf0;
}

Referenced by MiniportInitialize().

MiQueryCard()

static NDIS_STATUS MiQueryCard ( IN PADAPTER  Adapter )

static

Definition at line 228 of file pcnet.c.

{
  ULONG  buf32 = 0;
  UCHAR  buf8  = 0;
  NDIS_STATUS Status;
 
  /* Detect the card in the configured slot */
  Status = NdisReadPciSlotInformation(Adapter->MiniportAdapterHandle, 0, PCI_PCIID, &buf32, 4);
  if(Status != 4)
    {
      Status =  NDIS_STATUS_FAILURE;
      DPRINT1("NdisReadPciSlotInformation failed\n");
      return Status;
    }
 
  if(buf32 != PCI_ID)
    {
      Status = NDIS_STATUS_ADAPTER_NOT_FOUND;
      DPRINT1("card in slot isn't our: 0x%x\n", 0, buf32);
      return Status;
    }
 
  /* set busmaster and io space enable bits */
  buf32 = PCI_BMEN | PCI_IOEN;
  NdisWritePciSlotInformation(Adapter->MiniportAdapterHandle, 0, PCI_COMMAND, &buf32, 4);
 
  /* get IO base physical address */
  buf32 = 0;
  Status = NdisReadPciSlotInformation(Adapter->MiniportAdapterHandle, 0, PCI_IOBAR, &buf32, 4);
  if(Status != 4)
    {
      Status = NDIS_STATUS_FAILURE;
      DPRINT1("NdisReadPciSlotInformation failed\n");
      return Status;
    }
 
  if(!buf32)
    {
      DPRINT1("No base i/o address set\n");
      return NDIS_STATUS_FAILURE;
    }
 
  buf32 &= ~1;  /* even up address - comes out odd for some reason */
 
  DPRINT("detected io address 0x%x\n", buf32);
  Adapter->IoBaseAddress = buf32;
 
  /* get interrupt vector */
  Status = NdisReadPciSlotInformation(Adapter->MiniportAdapterHandle, 0, PCI_ILR, &buf8, 1);
  if(Status != 1)
    {
      Status = NDIS_STATUS_FAILURE;
      DPRINT1("NdisReadPciSlotInformation failed\n");
      return Status;
    }
 
  DPRINT("interrupt: 0x%x\n", buf8);
  Adapter->InterruptVector = buf8;
 
  return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportInitialize().

MiSetMulticast()

NDIS_STATUS NTAPI MiSetMulticast	(	PADAPTER	Adapter,
		UCHAR *	Addresses,
		UINT	AddressCount
	)

Definition at line 1262 of file pcnet.c.

{
  UINT Index;
  ULONG CrcIndex;
 
  NdisZeroMemory(Adapter->InitializationBlockVirt->LADR, 8);
  for (Index = 0; Index < AddressCount; Index++)
    {
      CrcIndex = MiEthernetCrc(Addresses) >> 26;
      Adapter->InitializationBlockVirt->LADR[CrcIndex >> 3] |= 1 << (CrcIndex & 15);
      Addresses += 6;
    }
 
  /* FIXME: The specification mentions we need to reload the init block here. */
 
  return NDIS_STATUS_SUCCESS;
}

Referenced by MiniportSetInformation().

MiSyncMediaDetection()

static BOOLEAN NTAPI MiSyncMediaDetection ( IN PVOID  SynchronizeContext )

static

Definition at line 616 of file pcnet.c.

{
  PADAPTER Adapter = (PADAPTER)SynchronizeContext;
  NDIS_MEDIA_STATE MediaState = MiGetMediaState(Adapter);
  UINT MediaSpeed = MiGetMediaSpeed(Adapter);
  BOOLEAN FullDuplex = MiGetMediaDuplex(Adapter);
 
  DPRINT("Called\n");
  DPRINT("MediaState: %d\n", MediaState);
  if (MediaState != Adapter->MediaState ||
      MediaSpeed != Adapter->MediaSpeed ||
      FullDuplex != Adapter->FullDuplex)
    {
      Adapter->MediaState = MediaState;
      Adapter->MediaSpeed = MediaSpeed;
      Adapter->FullDuplex = FullDuplex;
      return TRUE;
    }
  return FALSE;
}

Referenced by MiniportMediaDetectionTimer().

MiSyncStartTransmit()

static BOOLEAN NTAPI MiSyncStartTransmit ( IN PVOID  SynchronizeContext )

static

Definition at line 1128 of file pcnet.c.

{
  PADAPTER Adapter = (PADAPTER)SynchronizeContext;
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, CSR0_IENA | CSR0_TDMD);
  return TRUE;
}

Referenced by MiniportSend().

MiSyncStop()

static BOOLEAN NTAPI MiSyncStop ( IN PVOID  SynchronizeContext )

static

Definition at line 554 of file pcnet.c.

{
  PADAPTER Adapter = (PADAPTER)SynchronizeContext;
  NdisRawWritePortUshort(Adapter->PortOffset + RAP, CSR0);
  NdisRawWritePortUshort(Adapter->PortOffset + RDP, CSR0_STOP);
  return TRUE;
}

Referenced by MiniportHalt().