driver.cpp

WinCE5.0部分核心源码

            #ifdef DEBUG_AUTO_CONFIG
            for (int i = 0; i < card->m_numProfiles; i++) {
                dumpProfile(&card->m_profiles[i], TRUE);
                }
            #endif

            }
        else {
            retval = FALSE;
            }

        NdisCloseConfiguration(ConfigHandle);
        }

    return retval;
}

//===========================================================================
    void DeRegisterAdapter (PCARD card)
//===========================================================================
// 
// Description: 
//    
//      Inputs: 
//    
//     Returns: 
//---------------------------------------------------------------------------
{
    if (card->m_AttribMemRegistered) {
        NdisMUnmapIoSpace( card->m_MAHandle, (void *)card->m_pAttribMemBase, CIS_ATTRIBMEM_SIZE );
        }

    //if( card->m_RadioMemBase )
    //  NdisMUnmapIoSpace( card->m_MAHandle, (void *)card->m_RadioMemBase, CIS_ATTRIBMEM_SIZE );
    
    if (card->m_ContolRegRegistered) {
        NdisMUnmapIoSpace( card->m_MAHandle, (void *)card->m_ContolRegMemBase, CTL_ATTRIBMEM_SIZE );
        }
    
    if (card->m_IoRegistered) {
        //NdisMUnmapIoSpace( card->m_MAHandle, (void *)card->m_IOBase, card->m_PortIOLen );
        NdisMDeregisterIoPortRange(card->m_MAHandle, card->m_InitialPort, card->m_PortIOLen, (void *)card->m_IOBase);
        if (card->m_PortIOLen8Bit) {
            //NdisMUnmapIoSpace( card->m_MAHandle, (void *)card->m_IOBase8Bit, card->m_PortIOLen8Bit );
            NdisMDeregisterIoPortRange(card->m_MAHandle, 
                                       card->m_InitialPort8Bit, 
                                       card->m_PortIOLen8Bit, 
                                       (void *)card->m_IOBase8Bit);
            }
        }
}

//===========================================================================
    BOOLEAN RegisterAdapter (PCARD card)
//===========================================================================
// 
// Description: 
//    
//      Inputs: 
//    
//     Returns: 
//---------------------------------------------------------------------------
{
    NDIS_STATUS             Status;
    NDIS_PHYSICAL_ADDRESS   AttributePhysicalAddress;
//  UINT                    InitialPort = card->m_IOBase;

    Status = NdisMRegisterIoPortRange((void **)&card->m_IOBase, 
                                      card->m_MAHandle, 
                                      card->m_InitialPort,  
                                      card->m_PortIOLen);

    if (NDIS_STATUS_SUCCESS != Status) {
        LogError(card, NDIS_ERROR_CODE_BAD_IO_BASE_ADDRESS, BAD_IO_BASE_ADDRESS );
        return FALSE;
        }

    if (card->m_PortIOLen8Bit) {
        //InitialPort   = card->m_IOBase8Bit;
        Status = NdisMRegisterIoPortRange((void **)&card->m_IOBase8Bit, 
                                          card->m_MAHandle, 
                                          card->m_InitialPort8Bit,
                                          card->m_PortIOLen8Bit);

        if (NDIS_STATUS_SUCCESS !=  Status) {
            NdisMUnmapIoSpace(card->m_MAHandle, (void *)card->m_IOBase, card->m_PortIOLen);
            LogError(card, NDIS_ERROR_CODE_BAD_IO_BASE_ADDRESS, BAD_IO_BASE_ADDRESS);
            return FALSE;
            }
        }
    card->m_IoRegistered = TRUE;
    
//spbMgc
#if (NDISVER < 5) || (NDISVER == 41)
    if (card->m_pAttribMemBase) {
        NdisSetPhysicalAddressHigh(AttributePhysicalAddress, 0);
        NdisSetPhysicalAddressLow(AttributePhysicalAddress, (ULONG)card->m_pAttribMemBase);
        Status = NdisMMapIoSpace((PVOID *)&card->m_pAttribMemBase,card->m_MAHandle, AttributePhysicalAddress,CIS_ATTRIBMEM_SIZE);

        if (NDIS_STATUS_SUCCESS !=  Status) {
            LogError(card, NDIS_ERROR_CODE_BAD_IO_BASE_ADDRESS, BAD_ATTRIBMEM_BASE_ADDRESS);
            card->m_AttribMemRegistered = FALSE;
            }
        else {
            card->m_AttribMemRegistered = TRUE;
            }
        }
#endif

    //------------------------------------------
    if (card->m_ContolRegMemBase) {
        NdisSetPhysicalAddressHigh(AttributePhysicalAddress, 0);
        NdisSetPhysicalAddressLow(AttributePhysicalAddress, (ULONG)card->m_ContolRegMemBase);
        Status = NdisMMapIoSpace((PVOID *)&card->m_ContolRegMemBase, 
                                 card->m_MAHandle, 
                                 AttributePhysicalAddress,
                                 CTL_ATTRIBMEM_SIZE);

        if (NDIS_STATUS_SUCCESS != Status) {
            LogError(card, NDIS_ERROR_CODE_BAD_IO_BASE_ADDRESS, BAD_ATTRIBMEM_BASE_ADDRESS );
            }
        else {
            card->m_ContolRegRegistered = TRUE;
            }
        }
    //}
    return TRUE;
}

BOOLEAN         
RegisterInterrupt(
    PCARD   card
    )
{
    NDIS_STATUS Status = NdisMRegisterInterrupt( &card->Interrupt, card->m_MAHandle, 
                            card->m_InterruptNumber, card->m_InterruptNumber, 
                            TRUE, TRUE, NdisInterruptLevelSensitive );

    if ( Status != NDIS_STATUS_SUCCESS) 
        LogError(card, NDIS_ERROR_CODE_INTERRUPT_CONNECT, INTERRUPT_CONNECT);

    return card->m_InterruptRegistered = (NDIS_STATUS_SUCCESS == Status);   
}   


#ifndef UNDER_CE
extern "C" {
#define WANTVXDWRAPS
#include <basedef.h>        
#include <VMM.H>
#include <vxdldr.h>
#include <VXDWRAPS.H>
}

#include <AiroVxdWrap.H>

BOOLEAN         
LoadVxd(
    PCARD   card
    )
{
    #define VXDLDR_INIT_DEVICE  0x000000001 
    
    if ( OS_WIN95!=OSType || NULL == VxdLoadName)
        return FALSE;
    
    ULONG   flags           = VXDLDR_INIT_DEVICE;
    struct  VxD_Desc_Block  *ddb    = NULL;
    struct  DeviceInfo      *handle = NULL;
    ULONG                   ret;

    if( 0 == (ret = VXDLDR_LoadDevice(  &ddb, &handle, VxdLoadName, flags )) && handle ){
         card->m_VxdLoaded = TRUE;
        STDRIVER_ENTRY ld   ={VXD_LOAD,0,(UINT)cbQueryInformation};
        ld.card             = (UINT)card;
        ld.CardType         = (VXD_CARDTYPE)card->m_CardType;

        MiniPortEntry(&ld);

    }
    else
        LogError(card, NDIS_ERROR_CODE_UNSUPPORTED_CONFIGURATION, VXD_NOTLOADED );

    return 0==ret;
}

void            
UnloadVxd(
    PCARD   card
    )
{
    if( OS_WIN95!=OSType || FALSE == card->m_VxdLoaded || NULL == VxdUnloadName)
        return;

    STDRIVER_ENTRY ld ={VXD_UNLOAD,0,0};
    ld.card = (UINT)card;
    MiniPortEntry(&ld);
    VXDLDR_UnloadDevice(  (unsigned short)0xffff, VxdUnloadName);
}
#endif


//spb023
#ifdef MICROSOFT
BOOLEAN CheckRev(PCARD card)
{
    extern unsigned char imageData[];

    STCAPS  caps;

    if ( ! cmdCapsGet(card, &caps ) ) {
        return FALSE;
    }

    #if DBG
        DbgPrint("Caps Software is %x\n",caps.u16SoftwareVersion);
        DbgPrint("Caps SubSoftware is %x\n",caps.u16SoftwareSubVersion);
    #endif
  
    unsigned int myRev, thisRev, x1, x2, y1, y2;

    myRev=imageData[0x178];                 // hard coded in image file
    myRev = (myRev<<8) + imageData[0x179];
    myRev = (myRev<<16) + imageData[0x17a];

    x1= ((ULONG)caps.u16SoftwareVersion) >> 12;
    x2= (((ULONG)caps.u16SoftwareVersion) >> 8) % 16;
    y1= (((ULONG)caps.u16SoftwareVersion) >> 4) % 16;
    y2= ((ULONG)caps.u16SoftwareVersion) % 16;

    if ((x1 > 9) || (y1 > 9) || (x2 > 9) || (y2 > 9)) {
        #if DBG
            DbgPrint("Cant determine the version %x,%x,%x,%x\n",x1,y1,x2,y2);
        #endif

        return TRUE;  // can't determine what it is so flash it
    }

    thisRev = (((x1*10+x2) << 8) + (y1*10+y2)) << 16;

    x1= ((ULONG)caps.u16SoftwareSubVersion) >> 12;
    x2= (((ULONG)caps.u16SoftwareSubVersion) >> 8) % 16;
    y1= (((ULONG)caps.u16SoftwareSubVersion) >> 4) % 16;
    y2= ((ULONG)caps.u16SoftwareSubVersion) % 16;

    //spb027
    if ((x1 > 16) || (y1 > 16) || (x2 > 16) || (y2 > 16)) {
        #if DBG
            DbgPrint("Cant determine the subversion %x,%x,%x,%x\n",x1,y1,x2,y2);
        #endif

        return TRUE;  // can't determine what it is so flash it
    }

//spb027    thisRev += (x1*1000+x2*100+y1*10+y2);
    thisRev += (x1*64+x2*32+y1*16+y2);

    #if DBG
        DbgPrint("Driver Rev is %x.\n",myRev);
        DbgPrint("MAC Rev is %x.\n",thisRev);
    #endif

    if (myRev > thisRev)
        return TRUE;
    else
        return FALSE;
}

#include "flash.h"

//spb026
//Note THIS FUNCTION CAN ONLY BE CALLED AT IRQL < DISPATCH_LEVEL
void FlashImage(PCARD card)
{
    extern unsigned char imageData[];

    char *pBuffer = (char *)&imageData[16+256];
    DbgPrint("Starting to Flash\n");

    card->m_IsFlashing  = TRUE;

    //Init Flash
    FlashInit(card);
    FLASH_STRUCT        *p = &card->FlashSt;    

    //Copy flash image
    for( int i =0; i<128; i++ ) {
        FlashCopyNextBlock(card, pBuffer + i * 1024 );
    }

    //Ok Simulate the timer tick.
    do {
        if (p->m_delay) {
            //Simulate a timer tick
            #if DBG
            DbgPrint("Sleeping for %d\n",p->m_delay*1000);
            #endif
            NdisMSleep(p->m_delay*1000);
        }

        FlashStartFlashing(card,FALSE);
    } while (FLASHCMD_INPROGRESS == p->m_Progress);
}


#endif