regparms.c

EP9315开发板的Wince6.0的BSP包文件

//**********************************************************************
//                                                                      
// Filename: regparms.c
//                                                                      
// Description: 
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Use of this source code is subject to the terms of the Cirrus end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to 
// use this source code. For a copy of the EULA, please see the 
// EULA.RTF on your install media.
//
// Copyright(c) Cirrus Logic Corporation 2005, All Rights Reserved                       
//                                                                      
//**********************************************************************



#include "ndis4cs8950.h"


//****************************************************************************
//
// Local type definitions and declarations
//
//****************************************************************************

//****************************************************************************
//
// Static variables declarations
//
//****************************************************************************


//****************************************************************************
//
// Function prototypes for functions local to this file
//
//****************************************************************************

ULONG  stol(PUCHAR szSerialnumber);



extern
DWORD
GetSerialNumber(
    IN NDIS_HANDLE ConfigHandle,
        IN NDIS_ENVIRONMENT_TYPE OSType
    )

{
	//QQQ
	return (DWORD)123456;

/*
    NDIS_STATUS Status;
    NDIS_STRING AdapterSerialNumberString = NDIS_STRING_CONST("Serial");
    PNDIS_CONFIGURATION_PARAMETER ReturnedValue;
        DWORD SerialNumber;

   
    NdisReadConfiguration(
          &Status,
          &ReturnedValue,
          ConfigHandle,
          &AdapterSerialNumberString,
          NdisParameterString
          );

    if (Status != NDIS_STATUS_SUCCESS) {

       return (DWORD)UNSPECIFIED;    // No serial number was configured

    } else {

       USHORT MaxLength;
       PUCHAR Buffer;

       UCHAR  zBuffer[9];
       USHORT k;

       MaxLength = ReturnedValue->ParameterData.StringData.MaximumLength;
       Buffer    = (PUCHAR) ReturnedValue->ParameterData.StringData.Buffer;

       for (k=0; k<9 && k<MaxLength; k++) {

          if (OSType == NdisEnvironmentWindows)
             zBuffer[k] = Buffer[k];    //WIN95 & WFW do NOT use UNICODE strings
          else // Windows NT
             zBuffer[k] = Buffer[k*2];  //NT uses UNICODE strings

       }

       zBuffer[k] = 0x00;  // null terminate the string

           SerialNumber = stol(zBuffer);

           return ( (SerialNumber == 0) ? (DWORD)UNSPECIFIED : SerialNumber );

        }
*/

}

extern
NDIS_STATUS
GetNetworkAddress(
    IN NDIS_HANDLE ConfigHandle,
    OUT PUCHAR CurrentNetworkAddress
    )

{

    NDIS_STATUS Status;
    NDIS_STRING MACAddrString[3]= { NDIS_STRING_CONST("MACAddress1"),
                                    NDIS_STRING_CONST("MACAddress2"), 
		                            NDIS_STRING_CONST("MACAddress3")};
    PNDIS_CONFIGURATION_PARAMETER ReturnedValue;
	DWORD MacAddr[3];
	int i;

	for (i=0; i<3; i++) {
      
        NdisReadConfiguration(
                &Status,
                &ReturnedValue,
                ConfigHandle,
                &MACAddrString[i],
                NdisParameterHexInteger
        );


         if (Status == NDIS_STATUS_SUCCESS) {
                MacAddr[i]=ReturnedValue->ParameterData.IntegerData; 
		 } else {
		      return NDIS_STATUS_FAILURE;
		 }
    } /* end for i loop */


     NdisMoveMemory(CurrentNetworkAddress,
                    (unsigned char *)MacAddr,
                   (ULONG) ETH_LENGTH_OF_ADDRESS);

 
     return NDIS_STATUS_SUCCESS;

}

extern
BYTE
GetDuplexMode(
    IN NDIS_HANDLE ConfigHandle
    )

{
    NDIS_STATUS Status;
    NDIS_STRING DuplexModeString             = NDIS_STRING_CONST("DuplexMode"); // @251
    PNDIS_CONFIGURATION_PARAMETER ReturnedValue;
    IN BYTE         DuplexMode;

      
        DuplexMode = DUPLEX_AUTO_NEGOTIATE;
        NdisReadConfiguration(
                &Status,
        &ReturnedValue,
        ConfigHandle,
        &DuplexModeString,
        NdisParameterInteger
        );


    if (Status == NDIS_STATUS_SUCCESS) {
                switch (ReturnedValue->ParameterData.IntegerData) {
                        case 0:
                                DuplexMode = DUPLEX_AUTO_NEGOTIATE;
                                break;
                        case 1:
                                DuplexMode = DUPLEX_HALF;
                                break;
                        case 2:
                                DuplexMode = DUPLEX_FULL;
                                break;
                }

    }

    return DuplexMode;
}

extern
BYTE
GetMediaSpeed(
    IN NDIS_HANDLE ConfigHandle
    )

{
    NDIS_STATUS Status;
    NDIS_STRING MediaSpeedString             = NDIS_STRING_CONST("MediaSpeed"); // @251
    PNDIS_CONFIGURATION_PARAMETER ReturnedValue;
    IN BYTE         MediaSpeed;

      
        MediaSpeed = MEDIA_AUTO_DETECT;
        NdisReadConfiguration(
                &Status,
                &ReturnedValue,
                ConfigHandle,
                &MediaSpeedString,
                NdisParameterInteger
        );


    if (Status == NDIS_STATUS_SUCCESS) {
                switch (ReturnedValue->ParameterData.IntegerData) {
                        case 10:
                               MediaSpeed = MEDIA_10_MBPS;
                               break;
                        case 100:
                               MediaSpeed = MEDIA_100_MBPS;
                                break;
                }

    }

    return MediaSpeed;
}



extern
BYTE
GetInterruptLine(
    IN NDIS_HANDLE ConfigHandle
    ) 
{
    NDIS_STATUS Status;
    NDIS_STRING InterruptString             = NDIS_STRING_CONST("Interrupt"); // @251
    PNDIS_CONFIGURATION_PARAMETER ReturnedValue;
    IN BYTE         interrupt;

      
        interrupt = 10;  //QQQQQ
        NdisReadConfiguration(
                &Status,
                &ReturnedValue,
                ConfigHandle,
                &InterruptString,
                NdisParameterInteger
        );


    if (Status == NDIS_STATUS_SUCCESS) {
         interrupt=(BYTE)ReturnedValue->ParameterData.IntegerData;
    }

    return interrupt;
}





extern
NDIS_ENVIRONMENT_TYPE
GetOSType(
    IN NDIS_HANDLE ConfigHandle
    )

{
/* QQQ */
return(NdisEnvironmentWindowsCe);


 
/*
    NDIS_STATUS Status;
    NDIS_STRING EnvironmentString = NDIS_STRING_CONST("Environment");
    PNDIS_CONFIGURATION_PARAMETER ReturnedValue;

    NdisReadConfiguration(
        &Status,
        &ReturnedValue,
        ConfigHandle,
        &EnvironmentString,
        NdisParameterString
        );

    if ((Status == NDIS_STATUS_SUCCESS) &&
            (ReturnedValue->ParameterType == NdisParameterInteger))

       return (ReturnedValue->ParameterData.IntegerData);

        else

           return (NdisEnvironmentWindows);

*/
}


ULONG  stol(
        PUCHAR szSerialnumber)
{

    ULONG  value=0;

        for (; *szSerialnumber != 0; szSerialnumber++) {

        value <<= 4;

                if ((*szSerialnumber >= '0') && (*szSerialnumber <= '9')) {

               value += *szSerialnumber - '0';

                } else if ((*szSerialnumber >= 'a') && (*szSerialnumber <= 'f')) {

               value += *szSerialnumber - 'a' + 10;

                } else if ((*szSerialnumber >= 'A') && (*szSerialnumber <= 'F')) {

               value += *szSerialnumber - 'A' + 10;
        }
        }

        return value;

}   /* end stol */