miniport.c

网络驱动开发

/*++

Copyright (c) 1992-2000  Microsoft Corporation

Module Name:

    miniport.c

Abstract:

    NDIS Miniport Entry points and utility functions for the NDIS
    MUX Intermediate Miniport sample. The driver exposes zero or more
    Virtual Ethernet LANs (VELANs) as NDIS miniport instances over
    each lower (protocol-edge) binding to an underlying adapter.

Environment:

    Kernel mode.

Revision History:


--*/

#include "precomp.h"
#pragma hdrstop

#define MODULE_NUMBER           MODULE_MINI

NDIS_OID VElanSupportedOids[] =
{
    OID_GEN_SUPPORTED_LIST,
    OID_GEN_HARDWARE_STATUS,
    OID_GEN_MEDIA_SUPPORTED,
    OID_GEN_MEDIA_IN_USE,
    OID_GEN_MAXIMUM_LOOKAHEAD,
    OID_GEN_MAXIMUM_FRAME_SIZE,
    OID_GEN_LINK_SPEED,
    OID_GEN_TRANSMIT_BUFFER_SPACE,
    OID_GEN_RECEIVE_BUFFER_SPACE,
    OID_GEN_TRANSMIT_BLOCK_SIZE,
    OID_GEN_RECEIVE_BLOCK_SIZE,
    OID_GEN_VENDOR_ID,
    OID_GEN_VENDOR_DESCRIPTION,
    OID_GEN_VENDOR_DRIVER_VERSION,
    OID_GEN_CURRENT_PACKET_FILTER,
    OID_GEN_CURRENT_LOOKAHEAD,
    OID_GEN_DRIVER_VERSION,
    OID_GEN_MAXIMUM_TOTAL_SIZE,
    OID_GEN_PROTOCOL_OPTIONS,
    OID_GEN_MAC_OPTIONS,
    OID_GEN_MEDIA_CONNECT_STATUS,
    OID_GEN_MAXIMUM_SEND_PACKETS,
    OID_GEN_XMIT_OK,
    OID_GEN_RCV_OK,
    OID_GEN_XMIT_ERROR,
    OID_GEN_RCV_ERROR,
    OID_GEN_RCV_NO_BUFFER,
    OID_GEN_RCV_CRC_ERROR,
    OID_GEN_TRANSMIT_QUEUE_LENGTH,
    OID_802_3_PERMANENT_ADDRESS,
    OID_802_3_CURRENT_ADDRESS,
    OID_802_3_MULTICAST_LIST,
    OID_802_3_MAXIMUM_LIST_SIZE,
    OID_802_3_RCV_ERROR_ALIGNMENT,
    OID_802_3_XMIT_ONE_COLLISION,
    OID_802_3_XMIT_MORE_COLLISIONS,
    OID_802_3_XMIT_DEFERRED,
    OID_802_3_XMIT_MAX_COLLISIONS,
    OID_802_3_RCV_OVERRUN,
    OID_802_3_XMIT_UNDERRUN,
    OID_802_3_XMIT_HEARTBEAT_FAILURE,
    OID_802_3_XMIT_TIMES_CRS_LOST,
    OID_802_3_XMIT_LATE_COLLISIONS,
    OID_PNP_CAPABILITIES,
    OID_PNP_SET_POWER,
    OID_PNP_QUERY_POWER,
    OID_PNP_ADD_WAKE_UP_PATTERN,
    OID_PNP_REMOVE_WAKE_UP_PATTERN,
#if IEEE_VLAN_SUPPORT
    OID_GEN_VLAN_ID,
#endif    
    OID_PNP_ENABLE_WAKE_UP
    
};


NDIS_STATUS
MPInitialize(
    OUT PNDIS_STATUS               OpenErrorStatus,
    OUT PUINT                      SelectedMediumIndex,
    IN  PNDIS_MEDIUM               MediumArray,
    IN  UINT                       MediumArraySize,
    IN  NDIS_HANDLE                MiniportAdapterHandle,
    IN  NDIS_HANDLE                WrapperConfigurationContext
    )
/*++

Routine Description:

    This is the Miniport Initialize routine which gets called as a
    result of our call to NdisIMInitializeDeviceInstanceEx.
    The context parameter which we pass there is the VELan structure
    which we retrieve here.

Arguments:

    OpenErrorStatus            Not used by us.
    SelectedMediumIndex        Place-holder for what media we are using
    MediumArray                Array of ndis media passed down to us to pick from
    MediumArraySize            Size of the array
    MiniportAdapterHandle       The handle NDIS uses to refer to us
    WrapperConfigurationContext    For use by NdisOpenConfiguration

Return Value:

    NDIS_STATUS_SUCCESS unless something goes wrong

--*/
{
    UINT                i;
    PVELAN              pVElan;
    NDIS_STATUS         Status = NDIS_STATUS_FAILURE;
    NDIS_HANDLE         ConfigurationHandle;
    PVOID               NetworkAddress;

#if IEEE_VLAN_SUPPORT
    PNDIS_CONFIGURATION_PARAMETER   Params;
    NDIS_STRING                     strVlanId = NDIS_STRING_CONST("VlanID");
#endif
    
    //
    // Start off by retrieving our virtual miniport context (VELAN) and 
    // storing the Miniport handle in it.
    //
    pVElan = NdisIMGetDeviceContext(MiniportAdapterHandle);

    DBGPRINT(MUX_LOUD, ("==> Miniport Initialize: VELAN %p\n", pVElan));

    ASSERT(pVElan != NULL);
    ASSERT(pVElan->pAdapt != NULL);

    do
    {
        pVElan->MiniportAdapterHandle = MiniportAdapterHandle;

        for (i = 0; i < MediumArraySize; i++)
        {
            if (MediumArray[i] == VELAN_MEDIA_TYPE)
            {
                *SelectedMediumIndex = i;
                break;
            }
        }

        if (i == MediumArraySize)
        {
            Status = NDIS_STATUS_UNSUPPORTED_MEDIA;
            break;
        }

        //
        // Access configuration parameters for this miniport.
        //
        NdisOpenConfiguration(
            &Status,
            &ConfigurationHandle,
            WrapperConfigurationContext);

        if (Status != NDIS_STATUS_SUCCESS)
        {
            break;
        }


        NdisReadNetworkAddress(
            &Status,
            &NetworkAddress,
            &i,
            ConfigurationHandle);

        //
        // If there is a NetworkAddress override, use it 
        //
        if (((Status == NDIS_STATUS_SUCCESS) 
                && (i == ETH_LENGTH_OF_ADDRESS))
                && ((!ETH_IS_MULTICAST(NetworkAddress)) 
                && (ETH_IS_LOCALLY_ADMINISTERED (NetworkAddress))))
        {
            
            ETH_COPY_NETWORK_ADDRESS(
                        pVElan->CurrentAddress,
                        NetworkAddress);
        }
        else
        {
            MPGenerateMacAddr(pVElan);
        }
   
#if IEEE_VLAN_SUPPORT
        //
        // Read VLAN ID
        //
        NdisReadConfiguration(
                &Status,
                &Params,
                ConfigurationHandle,
                &strVlanId,
                NdisParameterInteger);
        if (Status == NDIS_STATUS_SUCCESS)
        {
            //
            // Check for out of bound
            //
            if (Params->ParameterData.IntegerData > VLAN_ID_MAX)
            {
                pVElan->VlanId = VLANID_DEFAULT;
            }
            else
            {
                pVElan->VlanId = Params->ParameterData.IntegerData;
            }
        }
        else 
        {
            //
            // Should fail the initialization or use default value
            //
            pVElan->VlanId = VLANID_DEFAULT;
            Status = NDIS_STATUS_SUCCESS;
            
        }
                
#endif    
        
        NdisCloseConfiguration(ConfigurationHandle);

        //
        // Set the attributes now. NDIS_ATTRIBUTE_DESERIALIZE enables us
        // to make up-calls to NDIS from arbitrary execution contexts.
        // This also forces us to protect our data structures using
        // spinlocks where appropriate. Also in this case NDIS does not queue
        // packets on our behalf.
        //
        NdisMSetAttributesEx(MiniportAdapterHandle,
                             pVElan,
                             0,                                       
                             NDIS_ATTRIBUTE_IGNORE_PACKET_TIMEOUT    |
                                NDIS_ATTRIBUTE_IGNORE_REQUEST_TIMEOUT|
                                NDIS_ATTRIBUTE_INTERMEDIATE_DRIVER |
                                NDIS_ATTRIBUTE_DESERIALIZE |
                                NDIS_ATTRIBUTE_NO_HALT_ON_SUSPEND,
                             0);


        //
        // Create an ioctl interface
        //
        (VOID)PtRegisterDevice();

        Status = NDIS_STATUS_SUCCESS;
    } while (FALSE);
    
    //
    // If we had received an UnbindAdapter notification on the underlying
    // adapter, we would have blocked that thread waiting for the IM Init
    // process to complete. Wake up any such thread.
    //
    // See PtUnbindAdapter for more details.
    //
    ASSERT(pVElan->MiniportInitPending == TRUE);
    pVElan->MiniportInitPending = FALSE;
    NdisSetEvent(&pVElan->MiniportInitEvent);

    DBGPRINT(MUX_INFO, ("<== Miniport Initialize: VELAN %p, Status %x\n", pVElan, Status));

	*OpenErrorStatus = Status;
    return Status;
}

VOID
MPSendPackets(
    IN    NDIS_HANDLE               MiniportAdapterContext,
    IN    PPNDIS_PACKET             PacketArray,
    IN    UINT                      NumberOfPackets
    )
/*++

Routine Description:

    Send Packet Array handler. Called by NDIS whenever a protocol
    bound to our VELAN miniport sends one or more packets.

    We forward each packet to the lower binding.

    NOTE: NDIS will not Halt this VELAN miniport until all
    these packets are "send-completed", and we don't unbind
    the lower binding until all VELANs are halted. Therefore
    we don't need locks or references on VELAN or ADAPT structures.

Arguments:

    MiniportAdapterContext    Pointer to our VELAN
    PacketArray               Set of packets to send
    NumberOfPackets           Length of above array

Return Value:

    None - we call NdisMSendComplete whenever we are done with a packet.

--*/
{
    PVELAN          pVElan = (PVELAN)MiniportAdapterContext;
    PADAPT          pAdapt = pVElan->pAdapt;
    PNDIS_PACKET    Packet, MyPacket;
    NDIS_STATUS     Status;
    PVOID           MediaSpecificInfo;
    ULONG           MediaSpecificInfoSize;
    UINT            i;

    
    for (i = 0; i < NumberOfPackets; i++)
    {
        Packet = PacketArray[i];

        //
        // Allocate a new packet to encapsulate data from the original.
        //
        NdisAllocatePacket(&Status,
                           &MyPacket,
                           pVElan->SendPacketPoolHandle);

        if (Status == NDIS_STATUS_SUCCESS)
        {
            PMUX_SEND_RSVD      pSendReserved;

            pSendReserved = MUX_RSVD_FROM_SEND_PACKET(MyPacket);
            pSendReserved->pOriginalPacket = Packet;
            pSendReserved->pVElan = pVElan;

            NdisGetPacketFlags(MyPacket) = NdisGetPacketFlags(Packet) |
                                        MUX_SEND_PACKET_FLAGS;

            NDIS_PACKET_FIRST_NDIS_BUFFER(MyPacket) = NDIS_PACKET_FIRST_NDIS_BUFFER(Packet);
            NDIS_PACKET_LAST_NDIS_BUFFER(MyPacket) = NDIS_PACKET_LAST_NDIS_BUFFER(Packet);
#ifdef WIN9X
            //
            // Work around the fact that NDIS does not initialize this
            // to FALSE on Win9x.
            //
            NDIS_PACKET_VALID_COUNTS(MyPacket) = FALSE;
#endif // WIN9X

            //
            // Copy OOB data to the new packet.
            //
            NdisMoveMemory(NDIS_OOB_DATA_FROM_PACKET(MyPacket),
                           NDIS_OOB_DATA_FROM_PACKET(Packet),
                           sizeof(NDIS_PACKET_OOB_DATA));
            //
            // Copy relevant parts of per packet info into the new packet.
            //
#ifndef WIN9X
            NdisIMCopySendPerPacketInfo(MyPacket, Packet);
#endif

            //
            // Copy Media specific information.
            //
            NDIS_GET_PACKET_MEDIA_SPECIFIC_INFO(Packet,
                                                &MediaSpecificInfo,
                                                &MediaSpecificInfoSize);

            if (MediaSpecificInfo || MediaSpecificInfoSize)
            {
                NDIS_SET_PACKET_MEDIA_SPECIFIC_INFO(MyPacket,
                                                    MediaSpecificInfo,
                                                    MediaSpecificInfoSize);
            }

#if IEEE_VLAN_SUPPORT
            Status = MPHandleSendTagging(pVElan, Packet, MyPacket);
            if (Status != NDIS_STATUS_SUCCESS)
            {
                NdisFreePacket(MyPacket);
                NdisMSendComplete(pVElan->MiniportAdapterHandle,
                                    Packet,
                                    Status);
                continue;
            }
#endif                

            //
            // Make note of the upcoming send.
            //
            MUX_INCR_PENDING_SENDS(pVElan);

            //
            // Send it to the lower binding.
            //
            NdisSend(&Status,
                     pAdapt->BindingHandle,
                     MyPacket);

            if (Status != NDIS_STATUS_PENDING)
            {
                PtSendComplete((NDIS_HANDLE)pAdapt,
                               MyPacket,
                               Status);
            }
        }
        else
        {
            //
            // Failed to allocate a packet.
            //
            break;