mx21ddk.cpp

BGW211针对freescale的MX21的无线WIFI驱动（WINCE5.0）

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft 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 LICENSE.RTF on your
// install media.
//
//------------------------------------------------------------------------------
//
//  Copyright (C) 2005-2006, Freescale Semiconductor, Inc. All Rights Reserved
//  THIS SOURCE CODE IS CONFIDENTIAL AND PROPRIETARY AND MAY NOT
//  BE USED OR DISTRIBUTED WITHOUT THE WRITTEN PERMISSION OF
//  FREESCALE SEMICONDUCTOR, INC.
//
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
//  Module: mx21_ddk.c
//
//  Interface to MX21DDK service.
//
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
// INCLUDE FILES  
//------------------------------------------------------------------------------
#include <windows.h>
#include <csp.h>
#include <cspddk.h>


//-----------------------------------------------------------------------------
// Types and Enumerations
typedef enum {
    DDK_GPIO_HANDLE,
    DDK_TIMER_HANDLE,
    DDK_CSPI_HANDLE,
    DDK_I2C_HANDLE
} DDK_HANDLE_TYPE;

typedef void* DDKObject;
typedef struct __tagDDkObject {
        DDKObject  DdkObj;
        DDK_HANDLE_TYPE HandleType;
}DDK_OBJECT,* DDK_OBJECT_HANDLE;

#ifdef DEBUG

DBGPARAM dpCurSettings = {
    L"MX21DDK", {
        L"Info",	L"Function",    L"Warnings",    L"Errors",
        L"Init",	L"Undefined",	L"Undefined",   L"Undefined",
        L"Undefined",   L"Undefined",   L"Undefined",   L"Undefined",
        L"Undefined",	L"Undefined",	L"Undefined",	L"Undefined"
    },
    0x0008
};
#endif
//------------------------------------------------------------------------------
// EXPORTED FUNCTIONS
//------------------------------------------------------------------------------

//-----------------------------------------------------------------------------
//
// Function:  DDKCreateGpioObject
//
// This function initializes GPIO object.  Called by routine to
// initialize a GPIO object
//
// Parameters:
//      None.
//
// Returns:
//      Returns the Handle to the GPIO if successful, otherwise returns NULL.
//
//-----------------------------------------------------------------------------
GPIOHANDLE DDKCreateGpioObject(void)
{
    DDK_OBJECT_HANDLE hDdkObj;

    DRV_FUNCTION_ENTRY();
    hDdkObj = new DDK_OBJECT;
    
    if(hDdkObj){
        hDdkObj->HandleType = DDK_GPIO_HANDLE;
        hDdkObj->DdkObj = (DDKObject) new GpioClass();
        if(!hDdkObj->DdkObj){
            delete hDdkObj;
            hDdkObj = NULL;
        }
    }
    if(!hDdkObj)
        DEBUGMSG(ZONE_ERROR, (_T("DDKCreateGpioObject(void) failed\r\n")));
        
    DRV_FUNCTION_EXIT();
    return (GPIOHANDLE)hDdkObj;
}
    
//-----------------------------------------------------------------------------
//
// Function:  DDKDeleteObject
//
// This function delete the DDK Object
//
// Parameters:
//      None.
//
// Returns:
//      None.
//
//-----------------------------------------------------------------------------      
void DDKDeleteObject(DDKHANDLE hObj)
{
     DDK_OBJECT_HANDLE hDdkObj;
 
     DRV_FUNCTION_ENTRY();    
     if(!hObj){
         DEBUGMSG(ZONE_ERROR, (_T("DDKDeleteObject(): NULL pointer\r\n")));
         DRV_FUNCTION_EXIT();
         return;
     }
	 
     hDdkObj = (DDK_OBJECT_HANDLE) hObj;
     // Destroy the corresponding object	 
     switch(hDdkObj->HandleType){
         case DDK_GPIO_HANDLE:
              delete (GpioClass*)hDdkObj->DdkObj;
              break;
         case DDK_TIMER_HANDLE:
              delete (TimerClass*)hDdkObj->DdkObj;
              break;
         case DDK_CSPI_HANDLE:
              delete (CspiClass*)hDdkObj->DdkObj;
              break;  
         case DDK_I2C_HANDLE:
              delete (I2cClass*)hDdkObj->DdkObj;
              break; 
     }
	 
     delete hDdkObj;
    DRV_FUNCTION_EXIT();
     return;
}                             
//------------------------------------------------------------------------------
//
//  FUNCTION:       DDKGetGpioSignalState
//
//  DESCRIPTION:    Returns the current state reading for 
//                  pin specified by signal
//
//  PARAMETERS:     gpiohandle  - handle to gpio
//                  port        - port id
//                  signal      - pin number
//
//  RETURNS:        1           - pin HIGH
//                  0           - pin LOW
//                  -1          - Failed
//
//------------------------------------------------------------------------------
INT8 DDKGetGpioSignalState(GPIOHANDLE gpiohandle, GPIO_PORT port, UINT32 signal)
{
      DDK_OBJECT_HANDLE hDdkObj;
      GpioClass* pGpio;
      INT8 ret;

     DRV_FUNCTION_ENTRY();      
      hDdkObj = (DDK_OBJECT_HANDLE)gpiohandle;
      // Check the invalid pointer
      if(!hDdkObj || !hDdkObj->DdkObj){
          DEBUGMSG(ZONE_ERROR, (_T("DDKGetGpioSignalState(): NULL pointer\r\n")));
          DRV_FUNCTION_EXIT();
          return -1;
      }
	  
	  // Do operation by it's original memember function
      pGpio = (GpioClass*)hDdkObj->DdkObj;
      ret = pGpio->GetSignalState(port, signal);
      DRV_FUNCTION_EXIT();
      return ret;
}

//------------------------------------------------------------------------------
//
//  FUNCTION:       DDKSetGpioSignalState
//
//  DESCRIPTION:    Sets the current state specotif
//                  pin specified by signal
//
//  PARAMETERS:     gpiohandle  - handle to gpio
//                  port    - port id
//                  signal  - pin number
//                  state   - desired state of pin
//                  bIsPowerMode    - whether is used in power mode
//
//  RETURNS:        None
//
//------------------------------------------------------------------------------     
void DDKSetGpioSignalState(GPIOHANDLE gpiohandle,GPIO_PORT port,UINT32 signal,
                          UINT8 state,BOOL bInPowerMode)     
{
      DDK_OBJECT_HANDLE hDdkObj;
      GpioClass* pGpio;
      
      DRV_FUNCTION_ENTRY();      
      hDdkObj = (DDK_OBJECT_HANDLE)gpiohandle;
      // Check the invalid pointer
      if(!hDdkObj || !hDdkObj->DdkObj){
            DEBUGMSG(ZONE_ERROR, (_T("DDKSetGpioSignalState(): NULL pointer\r\n")));
            DRV_FUNCTION_EXIT();
            return ;
      }
      
	  // Do operation by it's original memember function
      pGpio = (GpioClass*)hDdkObj->DdkObj;
      pGpio->SetSignalState(port, signal, state, bInPowerMode);
      DRV_FUNCTION_EXIT();
}         

//------------------------------------------------------------------------------
//
//  FUNCTION:       DDKGetGpioSignals
//
//  DESCRIPTION:    Returns the current state reading for 
//                  pins specified by signalMask
//
//  PARAMETERS:     gpiohandle  - handle to gpio
//                  port        - port id
//                  signalMask  - bitmap of desired pins
//
//  RETURNS:        
//                  bitmap indicating desired pin states
//
//------------------------------------------------------------------------------
UINT32 DDKGetGpioSignals(GPIOHANDLE gpiohandle,GPIO_PORT port, UINT32 signalMask)
{
      DDK_OBJECT_HANDLE hDdkObj;
      GpioClass* pGpio;
      UINT32 ret;
      
      DRV_FUNCTION_ENTRY();
      hDdkObj = (DDK_OBJECT_HANDLE)gpiohandle;
      // Check the invalid pointer
      if(!hDdkObj || !hDdkObj->DdkObj){
            DEBUGMSG(ZONE_ERROR, (_T("DDKGetGpioSignals(): NULL pointer\r\n")));
            DRV_FUNCTION_EXIT();
            return 0;
      }
	  // Do operation by it's original memember function
      pGpio = (GpioClass*)hDdkObj->DdkObj;  
      ret = pGpio->GetSignals(port, signalMask);
      DRV_FUNCTION_EXIT();
      return ret;
} 
   
//------------------------------------------------------------------------------
//
//  FUNCTION:       DDKSetGpioSignals
//
//  DESCRIPTION:    Sets the current state specotif
//                  pin specified by signal
//
//  PARAMETERS:     gpiohandle  - handle to gpio
//                  port        - port id
//                  signalMask  - bitmap of desired pins to set
//                  state       - bitmap of desired states of pins
//
//  RETURNS:        None
//
//------------------------------------------------------------------------------
void DDKSetGpioSignals(GPIOHANDLE gpiohandle,GPIO_PORT port,UINT32 signalMask,UINT32 stateMask)
{
      DDK_OBJECT_HANDLE hDdkObj;
      GpioClass* pGpio;
      
      DRV_FUNCTION_ENTRY();
      hDdkObj = (DDK_OBJECT_HANDLE)gpiohandle;
      // Check the invalid pointer
      if(!hDdkObj || !hDdkObj->DdkObj){
            DEBUGMSG(ZONE_ERROR, (_T("DDKSetGpioSignals(): NULL pointer\r\n")));
            DRV_FUNCTION_EXIT();
            return ;
      }
	  // Do operation by it's original memember function
      pGpio = (GpioClass*)hDdkObj->DdkObj;
      pGpio->SetSignals(port, signalMask, stateMask);
      DRV_FUNCTION_EXIT();
}
   
//------------------------------------------------------------------------------
//
//  FUNCTION:       DDKSetGpioInterruptType
//
//  DESCRIPTION:    Sets the current type setting reading for 
//                  pin specified by signal. The pin should have already
//                  been initialised as an interrupt pin during GPIO
//                  initialisation
//
//  PARAMETERS:     gpiohandle  - handle to gpio
//                  port    - port id
//                  signal  - pin number
//                  state   - interrupt type setting
//
//  RETURNS:        previous interrupt setting
//
//------------------------------------------------------------------------------  
   
GPIO_INT_TYPE DDKSetGpioInterruptType(GPIOHANDLE gpiohandle,GPIO_PORT port, 
                                    UINT32 signal,GPIO_INT_TYPE type)
{
      DDK_OBJECT_HANDLE hDdkObj;
      GpioClass* pGpio;
      GPIO_INT_TYPE ret;
      
      
      DRV_FUNCTION_ENTRY();
      hDdkObj = (DDK_OBJECT_HANDLE)gpiohandle;
      // Check the invalid pointer
      if(!hDdkObj || !hDdkObj->DdkObj){
            DEBUGMSG(ZONE_ERROR, (_T("DDKSetGpioInterruptType(): NULL pointer\r\n")));
            DRV_FUNCTION_EXIT();
            return GPIO_INT_TYPE_MAX;
      }
	  
	  // Do operation by it's original memember function
      pGpio = (GpioClass*)hDdkObj->DdkObj;
      ret = pGpio->SetInterruptType(port, signal, type);  
      DRV_FUNCTION_EXIT();
      return ret;                                  
}                                        


//------------------------------------------------------------------------------
//
//  FUNCTION:       DDKSetGpioInterruptState
//
//  DESCRIPTION:    Unmasks/Masks the interrupt specified by signal
//
//  PARAMETERS:     gpiohandle  - handle to gpio
//                  port    - port id
//                  signal  - pin number
//                  bIsPowerMode    - whether is used in power mode 
//                  bEnable     - TURE for Unmask, FALSE for Mask                 
//
//  RETURNS:        None
//------------------------------------------------------------------------------     
void DDKSetGpioInterruptState(GPIOHANDLE gpiohandle,GPIO_PORT port, UINT32 signal,
                            BOOL bInPowerMode,BOOL bEnable)
{
      DDK_OBJECT_HANDLE hDdkObj;
      GpioClass* pGpio;
      
      DRV_FUNCTION_ENTRY();
      hDdkObj = (DDK_OBJECT_HANDLE)gpiohandle;
      // Check the invalid pointer
      if(!hDdkObj || !hDdkObj->DdkObj){
            DEBUGMSG(ZONE_ERROR, (_T("DDKSetGpioInterruptState(): NULL pointer\r\n")));
            DRV_FUNCTION_EXIT();
            return ;
      }
	  
      pGpio = (GpioClass*)hDdkObj->DdkObj;    
      // Do operation by it's original memember function  
      if(bEnable)
          pGpio->EnableInterrupt(port, signal, bInPowerMode);
      else
          pGpio->DisableInterrupt(port, signal, bInPowerMode);   
      DRV_FUNCTION_EXIT();              
}


//-----------------------------------------------------------------------------
//
// Function:  DDKCreateTimerObject
//
// This function initializes TIMER object.  Called by routine to
// initialize a GTIMER object
//
// Parameters:
//      timerisr: The timer interrupt service routine.
//      timerID : The timer ID on which the timer object is created based
//
// Returns:
//      Returns the Handle to the TIMER if successful, otherwise returns NULL.
//
//-----------------------------------------------------------------------------
TIMERHANDLE DDKCreateTimerObject(TIMERISR timerisr, TIMERID_C timerID)
{
    DDK_OBJECT_HANDLE hDdkObj;
    
    
    DRV_FUNCTION_ENTRY();
    hDdkObj = new DDK_OBJECT;
    
    if(hDdkObj){
        hDdkObj->HandleType = DDK_TIMER_HANDLE;
        hDdkObj->DdkObj = (TimerClass*) new TimerClass(timerID);
        if(!hDdkObj->DdkObj){
            delete hDdkObj;
            hDdkObj = NULL;
        }
        else { 
            ((TimerClass*)(hDdkObj->DdkObj))->SetISR(timerisr);
            ((TimerClass*)(hDdkObj->DdkObj))->TimerInit();
        }
    }
	// Check if creating is successful
    if(!hDdkObj)
        DEBUGMSG(ZONE_ERROR, (_T("DDKCreateTimerObject(void) failed\r\n")));

        
    DRV_FUNCTION_EXIT();
    return (TIMERHANDLE)hDdkObj;
}    
    
void DDKSetTimerStart(TIMERHANDLE timerhandle, BOOL bStart)
{
      DDK_OBJECT_HANDLE hDdkObj;
      TimerClass* pTimer;
      
      
      DRV_FUNCTION_ENTRY();
      hDdkObj = (DDK_OBJECT_HANDLE)timerhandle;
      // Check the invalid pointer
      if(!hDdkObj || !hDdkObj->DdkObj){
            DEBUGMSG(ZONE_ERROR, (_T("DDKSetTimerStart(): NULL pointer\r\n")));
            DRV_FUNCTION_EXIT();
            return ;
      }
	  
      pTimer = (TimerClass*)hDdkObj->DdkObj; 
      
      // Do operation by it's original memember function
      if(bStart)
          pTimer->StartTimer();
      else
          pTimer->StopTimer();
      DRV_FUNCTION_EXIT();
}        

void DDKSetTimerInterrupt(TIMERHANDLE timerhandle, BOOL bEnable)
{
      DDK_OBJECT_HANDLE hDdkObj;
      TimerClass* pTimer;
      
      
      DRV_FUNCTION_ENTRY();
      hDdkObj = (DDK_OBJECT_HANDLE)timerhandle;
      // Check the invalid pointer
      if(!hDdkObj || !hDdkObj->DdkObj){
            DEBUGMSG(ZONE_ERROR, (_T("DDKSetTimerStart(): NULL pointer\r\n")));
            DRV_FUNCTION_EXIT();