lmi_drv.c

ARM9基于WINDOWSCE的BSP源代码

#include "LMI.h"
#include "LMIdrv.h"
#include "LMIfuncs.h"
#include <windows.h>
#include <pkfuncs.h>
#include <tchar.h>
#include <platform.h>
#include <ceddk.h>
#include <oalintr.h>
#include "stdio.h"

HANDLE LMIint;                  // Event for interrupts to trigger

#define LMI_TX_FIFO 0x08


void DoTxData( PLMI_Header pHead ) ;
static DWORD WINAPI LMI_IST(PVOID pLMIHead);


//------------------------------------------------------------------------------
//
// LMI.DLL entry
//
//------------------------------------------------------------------------------
/*BOOL WINAPI DllMain(HANDLE hinstDLL, 
                    unsigned long  dwReason, 
	            LPVOID lpReserved)
{
    return TRUE;
}   // DllMain
*/


BOOL
DllEntry(
              HINSTANCE   hinstDll,             /*@parm Instance pointer. */
              DWORD   dwReason,                 /*@parm Reason routine is called. */
              LPVOID  lpReserved                /*@parm system parameter. */
              )
{
    if ( dwReason == DLL_PROCESS_ATTACH ) {
      //  DEBUGREGISTER(hinstDll);        RETAILMSG (TRUE, (TEXT("LMI_lcd process attach\r\n")));
	DisableThreadLibraryCalls((HMODULE) hinstDll);
    }

    if ( dwReason == DLL_PROCESS_DETACH ) {
       RETAILMSG (TRUE, (TEXT("process detach called\r\n")));
    }

    return(TRUE);
}

/*! \brief  Initialize LMI module
 *
 *  Map the LMI & little lcd address from physical to virtual
 *  \param  DWORD
 *
 */
DWORD LMI_Init(DWORD dwContext)
{
        DWORD dwRet = 0;
        unsigned long * pMax;
	 int i=0;
                // Setup Virtual/Physical memory
        PHYSICAL_ADDRESS PhysicalAddress;
       
        PLMI_Header pLMIHead  =  (PLMI_Header)LocalAlloc(LPTR, sizeof(LMI_Header));
        pLMIHead->temp = LocalAlloc(LPTR, 10);

        RETAILMSG (TRUE, (TEXT("LMI: LMI_Init\n")));        

        PhysicalAddress.HighPart = 0;
        PhysicalAddress.LowPart = LMI_BASE;
        
        if (0==(pLMIHead->pLMI = (LMIReg*)MmMapIoSpace(PhysicalAddress, (ULONG)sizeof(LMIReg),0)))
        {
            RETAILMSG(TRUE, (TEXT("Cannot alloc LMI memory\r\n")));
            return FALSE;
        }
        
        PhysicalAddress.HighPart = 0;
        PhysicalAddress.LowPart = LCD_BASE;
        
        if (0==(pLMIHead->pLcd = (LCDReg*)MmMapIoSpace(PhysicalAddress, (ULONG)sizeof(LCDReg),0)))
        {
            RETAILMSG(TRUE, (TEXT("Cannot alloc LMI memory\r\n")));
            return FALSE;
        }
        
        PhysicalAddress.HighPart = 0;
        PhysicalAddress.LowPart = LCD_PMAX;
        
        if (0==( pMax= (unsigned long*)MmMapIoSpace(PhysicalAddress, (ULONG)sizeof(ULONG),0)))
        {
            RETAILMSG(TRUE, (TEXT("Cannot alloc LMI memory\r\n")));
            return FALSE;
        }
        
        //set GPIO to LMI
       // *pMax=0x248620;
   	*pMax |=0x220;

        PhysicalAddress.HighPart = 0;
        PhysicalAddress.LowPart = LCD_GPIOGRP56;
        
        if (0==( pMax= (unsigned long*)MmMapIoSpace(PhysicalAddress, (LCD_GPIOGRP5-LCD_GPIOGRP56)+(ULONG)sizeof(ULONG),0)))
        {
            RETAILMSG(TRUE, (TEXT("Cannot alloc LMI memory\r\n")));
            return FALSE;
        }
   	*(unsigned long*) ((unsigned long)pMax+(LCD_GPIOGRP5-LCD_GPIOGRP56)) |=0x40;
        *pMax= 0x00;
        for(i=0;i<2560;i++)
        *pMax=0xff;

        // SETUP default values for LMI
        LMIInit(pLMIHead->pLMI);
        LcdInit(pLMIHead->pLcd);
        //LmiBInit(pLMIHead->pLMI,320*240*2,16,0,0);        
        LcdResetPtr(pLMIHead->pLcd);

        //dispaly full-screen RED
        LcdDisplayFullRed(pLMIHead->pLcd);
		//point to the start of the lcd
		LcdResetPtr(pLMIHead->pLcd);
		//
        pLMIHead->DMA_Enable     = 1;    
        pLMIHead->hLMIEvent      = CreateEvent(0,FALSE,FALSE,NULL);
        pLMIHead->hTransmitEvent = CreateEvent(0, FALSE, FALSE, NULL);
        //pLMIHead->IntID          = SYSINTR_LMI;
        
        InitializeCriticalSection(&(pLMIHead->TransmitCritSec));
        InitializeCriticalSection(&(pLMIHead->TxBufferInfo.CS));
        InitializeCriticalSection(&(pLMIHead->OpenCS));
        /*
         * setup: assign the interrupt event (LMIint) to the correct system call
         * SYSINTR_LMI
         */
   /*     if (!InterruptInitialize(SYSINTR_LMI,pLMIHead->hLMIEvent, NULL, 0))
        {
            RETAILMSG(TRUE,(TEXT("LMI: LMI_Init failed - Cannot initialise SYSINTR_LMI:%d\n"),GetLastError()));
            return FALSE;
        }    
        InterruptDone(SYSINTR_LMI);
     */
        /*
         * setup: create the Interrupt Service Thread and set to high priority
         */
/*        pLMIHead->pDispatchThread = CreateThread(NULL,0,&LMI_IST,pLMIHead,0,NULL);
        
        if( pLMIHead->pDispatchThread == NULL ) 
        {
        RETAILMSG(TRUE,
                 (TEXT("Error creating dispatch thread (%d)\n\r"),
                  GetLastError()));
        return(FALSE);
        }
        CeSetThreadPriority(pLMIHead->pDispatchThread, 99); // set to high priority 
*/
        return (DWORD)pLMIHead;        
} 

/*! \brief  LMI deinitialize function.
 *
 *
 *
 */
BOOL LMI_Deinit(HANDLE pHead)
{
        BOOL bRet = TRUE;
        
        PLMI_Header pLmiHeader= (PLMI_Header) pHead;

	 RETAILMSG (TRUE, (TEXT("LMI: LMI_Deinit\n")));
         //TODO Mask Interupts here, disable LMI and clear buffers
        // This function should never be called as the LMI driver is setup by the 
        // never unloaded - This function is included for testing     
        //LMIMaskInt(pHead->pLmi);    
        return bRet;
} 

BOOL LMI_Close(DWORD hOpenContext)
{
        BOOL bRet = TRUE;
        PLMIOpenHead pOpenHead = (PLMIOpenHead)hOpenContext;
        //
        PLMI_Header pHeader    = pOpenHead->LmiHeader;

        RETAILMSG (TRUE, (TEXT("LMI: LMI_Close\n")));

  //      LeaveCriticalSection(&(pHeader->TransmitCritSec));

        return bRet;
}

/*! \brief  LMI driver read  function.
 *   this function does nothing.
 * 
 *
 */
DWORD LMI_Read(DWORD hOpenContext, LPVOID pBuffer, DWORD Count)
{
   RETAILMSG(TRUE,(TEXT("LMI: LMI_Read\n")));                                                                                                                                                                                                                                                                                                                                  
   if (pBuffer==NULL)                                                                                                                                                                                                                                                                                                                                                              
   {                                                                                                                                                                                                                                                                                                                                                                               
       return (-1);                                                                                                                                                                                                                                                                                                                                                                
   }                                                                                                                                                                                                                                                                                                                                                                               
      
   RETAILMSG(TRUE,(TEXT("LMI: LMI_Read return\n")));                                                                                                                                                                                                                                                                                                                           
   // Return number of bytes read.
   return Count;                                                                                                                                                                                                                                                                                                                                                                   
} 

/*! \brief  LMI write call function.
 *  \params hOpenHead     :the open head structure point
 *  \params pSourceBytes  :the pointer of the source .
 *  \params NumberOfByters:the number of the source in bytes 
 *  \return DWORD :        the total bytes sent.
 */
DWORD LMI_Write(HANDLE hOpenHead, LPCVOID pSourceBytes, DWORD NumberOfByte)
{
   
   //open head struct point
   PLMIOpenHead pOpenHead = (PLMIOpenHead)hOpenHead;
   //
   PLMI_Header pHeader    = pOpenHead->LmiHeader;
   ULONG               NumberOfDWORD;
   *pHeader->temp = (UCHAR)0x3;
  // RETAILMSG(TRUE,(TEXT("+LMI: LMI_Write : %d bytes \n"),NumberOfByte));
   // Check validity of handle
   if ( !pHeader || !pHeader->OpenCnt ) 
   {
        RETAILMSG (1,
                  (TEXT("COM_WRITE, device not open\r\n") ));
        SetLastError (ERROR_INVALID_HANDLE);
        return(ULONG)-1;
   }
   // Clear any pending event
  //  WaitForSingleObject(pHead->hTransmitEvent,0);