cs8900a.c

来自「PXA255/270平台的 CS8900网卡驱动程序」· C语言 代码 · 共 741 行 · 第 1/2 页

//---------------------------------------------------------------------------
//
//  Copyright (C) 1996-2003. Unpublished Work of Cirrus Logic Corp.
//  All Rights Reserved.
//
//  THIS WORK IS AN UNPUBLISHED WORK AND CONTAINS CONFIDENTIAL,
//  PROPRIETARY AND TRADE SECRET INFORMATION OF CRYSTAL SEMICONDUCTOR.
//  ACCESS TO THIS WORK IS RESTRICTED TO (I) CRYSTAL SEMICONDUCTOR EMPLOYEES
//  WHO HAVE A NEED TO KNOW TO PERFORM TASKS WITHIN THE SCOPE OF THEIR
//  ASSIGNMENTS  AND (II) ENTITIES OTHER THAN CRYSTAL SEMICONDUCTOR WHO
//  HAVE ENTERED INTO  APPROPRIATE LICENSE AGREEMENTS.  NO PART OF THIS
//  WORK MAY BE USED, PRACTICED, PERFORMED, COPIED, DISTRIBUTED, REVISED,
//  MODIFIED, TRANSLATED, ABRIDGED, CONDENSED, EXPANDED, COLLECTED,
//  COMPILED,LINKED,RECAST, TRANSFORMED, ADAPTED IN ANY FORM OR BY ANY
//  MEANS,MANUAL, MECHANICAL, CHEMICAL, ELECTRICAL, ELECTRONIC, OPTICAL,
//  BIOLOGICAL, OR OTHERWISE WITHOUT THE PRIOR WRITTEN PERMISSION AND
//  CONSENT OF CRYSTAL SEMICONDUCTOR . ANY USE OR EXPLOITATION OF THIS WORK
//  WITHOUT THE PRIOR WRITTEN CONSENT OF CRYSTAL SEMICONDUCTOR  COULD
//  SUBJECT THE PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY.
//
//---------------------------------------------------------------------------

#include "cs8900a.h"
#include "cshrd.h"
#include <bsp.h>
#include <oal_intr.h>
#include "bsp_cfg.h"

//#include "bvd1bd.h"
//#include "oalintr.h"
//#include "Oemioctl.h"

#if __DBG
#include "version.h"
#endif


BYTE        NDISVerMajor;
BYTE        NDISVerMinor;

HANDLE  gCS8900Thread;

volatile CS8900_REGS *v_pCS8900Regs;
//****************************************************************************
//
// Local type definitions and declarations
//
//****************************************************************************

typedef enum 
{
    CrystalHardwareOk,
    CrystalHardwareChecksum,
    CrystalHardwareConfig
} CRYSTAL_HARDWARE_STATUS;

//****************************************************************************
//
// Static variables declrations
//
//****************************************************************************

// CRYSTAL_DRIVER CrystalDriver;

//
// This variable is used to control debug output.
//

#if DBG
   INT CrystalDbg = 0;
#endif

extern PVPMINIPDATA gMini_Context;

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


#pragma NDIS_INIT_FUNCTION(DriverEntry)

/*++

Routine Description:

    This is the primary initialization routine for the driver.
    It is simply responsible for the intializing the wrapper and registering
    the MAC.  It then calls a system and architecture specific routine that
    will initialize and register each adapter.

Arguments:

    DriverObject - Pointer to driver object created by the system.

Return Value:

    The status of the operation.

--*/

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

    //
    // Receives the status of the NdisRegisterMac operation.
    //
    NDIS_STATUS Status;

    NDIS_HANDLE CrystalWrapperHandle;
    #define BUS_TYPE NdisInterfaceIsa
    #define BUS_MASTER FALSE
    NDIS_MINIPORT_CHARACTERISTICS CrystalChar;
    NdisZeroMemory( &CrystalChar, sizeof(CrystalChar));

    //
    // Initialize the wrapper.
    //
    PRINTDEBUGMSG(1, (TEXT("==>CS8900:DriverEntry\r\n")));   
    RETAILMSG(1, (TEXT("dlp#: ==>CS8900:DriverEntry\r\n")));

    NdisMInitializeWrapper(
                &CrystalWrapperHandle,
                DriverObject,
                RegistryPath,
                NULL
                );


//    CrystalDriver.WrapperHandle = CrystalWrapperHandle;

    //
    // Initialize the miniport characteristics for the call to
    // NdisMRegisterMiniport.
    //
    NDISVerMajor = CRYSTAL_NDIS_MAJOR_VERSION;
    NDISVerMinor = CRYSTAL_NDIS_MINOR_VERSION;
    CrystalChar.MajorNdisVersion        = CRYSTAL_NDIS_MAJOR_VERSION;
    CrystalChar.MinorNdisVersion        = CRYSTAL_NDIS_MINOR_VERSION;
    CrystalChar.InitializeHandler       = CrystalInitialize;
    CrystalChar.CheckForHangHandler     = CrystalCheckForHang;
    CrystalChar.DisableInterruptHandler = CrystalDisableInterrupt;
    CrystalChar.EnableInterruptHandler  = CrystalEnableInterrupt;
    CrystalChar.HaltHandler             = CrystalHalt;
    CrystalChar.HandleInterruptHandler  = CrystalHandleInterrupt;
    CrystalChar.ISRHandler              = CrystalInterruptService;
    CrystalChar.QueryInformationHandler = CrystalQueryInformation;
    CrystalChar.ReconfigureHandler      = NULL;
    CrystalChar.ResetHandler            = CrystalReset;
    CrystalChar.SendHandler             = CrystalSend;
    CrystalChar.SetInformationHandler   = CrystalSetInformation;
    CrystalChar.TransferDataHandler     = CrystalTransferData;
    CrystalChar.ReturnPacketHandler     = NULL;
    CrystalChar.SendPacketsHandler      = CrystalSendPackets;
    CrystalChar.AllocateCompleteHandler = NULL;

    Status = NdisMRegisterMiniport(
                 CrystalWrapperHandle,
                 &CrystalChar,
                 sizeof(CrystalChar)
                 );

    if (Status == NDIS_STATUS_SUCCESS) 
    {
        PRINTDEBUGMSG(1, (TEXT("<==CS8900:DriverEntry SUCCESS\r\n")));   
        RETAILMSG(1, (TEXT("dlp#: <==CS8900:DriverEntry SUCCESS\r\n")));   
        return NDIS_STATUS_SUCCESS;
    }

    //
    // We can only get here if something went wrong with registering
    // the mac or *all* of the adapters.
    //

    NdisTerminateWrapper(CrystalWrapperHandle, NULL);

    PRINTDEBUGMSG(1, (TEXT("<==CS8900:DriverEntry FAILURE\r\n")));   
    RETAILMSG(1, (TEXT("dlp#: <==CS8900:DriverEntry FAILURE\r\n")));   
    return NDIS_STATUS_FAILURE;

}



#pragma NDIS_PAGABLE_FUNCTION(CrystalInitialize)

/*++

Routine Description:

    CrystalInitialize adds finds and initializes the adapter.

Arguments:

    OpenErrorStatus - Extra status bytes for opening token ring adapters.

    SelectedMediumIndex - Index of the media type chosen by the driver.

    MediumArray - Array of media types for the driver to chose from.

    MediumArraySize - Number of entries in the array.

    MiniportAdapterHandle - Handle for passing to the wrapper when
       referring to this adapter.

    ConfigurationHandle - A handle to pass to NdisOpenConfiguration.

Return Value:

    NDIS_STATUS_SUCCESS
    NDIS_STATUS_FAILURE
    NDIS_STATUS_UNSUPPORTED_MEDIA

Assumptions:

  The NDIS3 spec states that the miniport driver will not re-entered during
  CrystalInitialize().


--*/

static
NDIS_STATUS
CrystalInitialize(
    OUT PNDIS_STATUS OpenErrorStatus,
    OUT PUINT SelectedMediumIndex,
    IN PNDIS_MEDIUM MediumArray,
    IN UINT MediumArraySize,
    IN NDIS_HANDLE MiniportAdapterHandle,
    IN NDIS_HANDLE ConfigurationHandle
    )
{
    UINT i;
    NDIS_STATUS Status=NDIS_STATUS_SUCCESS;
    NDIS_HANDLE ConfigHandle;
    WORD Result;
    PVOMINIPDATA pOSD;
    PVPMINIPDATA pvMini_Context;
    PCHIP  pChip;
    PCD    pData;
    NDIS_PHYSICAL_ADDRESS Temp = NDIS_PHYSICAL_ADDRESS_CONST(-1, -1);
    int    step;

    PRINTDEBUGMSG(1, (TEXT("==>CS8900:CrystalInitialize\r\n")));

    for (step=1; step<20 && Status==NDIS_STATUS_SUCCESS; step++) 		
//    for (step=1; step<20; step++) //dlp
    {        
        PRINTDEBUGMSG(1, (TEXT("cs8900a(): step=%d\r\n"),step));
        switch (step) 
        {
        case 1:
            //
            // Search for the 802.3 media type
            //
            Status=NDIS_STATUS_UNSUPPORTED_MEDIA;
            for (i=0; i<MediumArraySize && Status!=NDIS_STATUS_SUCCESS; i++) 
            {
                if (MediumArray[i] == NdisMedium802_3) 
                {
                    *SelectedMediumIndex = i;
                    Status=NDIS_STATUS_SUCCESS;
                } /* endif */
            } /* endfor */
            break;
        case 2:
            Status = NdisAllocateMemory(
  		                  (PVOID)&pChip,
  		                  (ULONG) sizeof(CHIP),
  		                  0,
  		                  Temp
  		                  );
            
            if (Status != NDIS_STATUS_SUCCESS) 
            {
                NdisWriteErrorLogEntry(MiniportAdapterHandle,
                                       NDIS_ERROR_CODE_OUT_OF_RESOURCES,
                                       2,
                                       2,
                                       2);

                Status=NDIS_ERROR_CODE_OUT_OF_RESOURCES;
            } /* endif */
            break;
        case 3:
            //
            //zero CHIP cntl blk and set up pointers
            //
            NdisZeroMemory( pChip, sizeof(CHIP) );
            pvMini_Context        =  pChip->pPSD  = &pChip->higherdata;    
            pOSD                  =  pChip->pOSD  = &pChip->timerdata;    
            pData                 =  pChip->pData = &pChip->lowerdata;   
            //
            //setup some of the "higher" cntl blk
            //
            pvMini_Context->pChip =  pChip;
            pvMini_Context->vpMiniportAdapterHandle = MiniportAdapterHandle;
            pvMini_Context->pChip->pPSD = pvMini_Context;
            pvMini_Context->CableConnected = NdisMediaStateDisconnected;
            pvMini_Context->CurrentState = NdisHardwareStatusNotReady;

            gMini_Context = pvMini_Context;

            break;
        case 4:
            VominiStartup( pOSD, MiniportAdapterHandle ); 
            break;
        case 5:
            NdisMSetAttributes(MiniportAdapterHandle,
                               (NDIS_HANDLE)pvMini_Context,
                               BUS_MASTER,
                               BUS_TYPE);
            break;
        case 6:
            //
            // Open the configuration information.
            //
            NdisOpenConfiguration(&Status,
                                  &ConfigHandle,
                                  ConfigurationHandle);
            break;
        case 7:
            v_pCS8900Regs = VirtualAlloc(0, sizeof(CS8900_REGS), MEM_RESERVE, PAGE_NOACCESS);
            if (v_pCS8900Regs == NULL) 
            {
                PRINTDEBUGMSG (1,(TEXT("[CS8900] v_pCS8900Regs is not allocated\n\r")));
                Status = NDIS_ERROR_CODE_OUT_OF_RESOURCES;
            }
            if (!VirtualCopy((PVOID)v_pCS8900Regs, (PVOID)ETHERNET_CS8900_BASE_U_VIRTUAL, sizeof(CS8900_REGS), PAGE_READWRITE|PAGE_NOCACHE)) 
			{
                PRINTDEBUGMSG (1,(TEXT("[CS8900] v_pIOPRegs is not mapped\n\r")));
                Status = NDIS_ERROR_CODE_OUT_OF_RESOURCES;
            }

            if (Status == NDIS_ERROR_CODE_OUT_OF_RESOURCES) 
            {
                NdisWriteErrorLogEntry(MiniportAdapterHandle,
                                       NDIS_ERROR_CODE_OUT_OF_RESOURCES,
                                       2,
                                       2,
                                       2);
                if (v_pCS8900Regs) 
                   VirtualFree((PVOID)v_pCS8900Regs, 0, MEM_RELEASE);
            } /* endif */
            break;
        case 8:
			Result = AssignedUserDefinedConfig(pvMini_Context->pChip);
            if (Result != CHIP_SUCCESS) 
                Status=NDIS_STATUS_FAILURE;
            else
                Status=VchipFindIOBase(pChip);
		    break;
        case 9:
            /*Status = NdisMRegisterIoPortRange(&pData->PortOffset,
                                              MiniportAdapterHandle,
                                              (DWORD)pChip->Config.IOBase,
                                              (DWORD)CRYSTAL_IO_SIZE);
            if (Status != NDIS_STATUS_SUCCESS) 
            {            
                NdisWriteErrorLogEntry(MiniportAdapterHandle,
                                       NDIS_ERROR_CODE_BAD_IO_BASE_ADDRESS,
                                       2,
                                       Status,
                                       pChip->Config.IOBase);
     	    } *//* endif */
            break;