lmi_drv.c

ARM9基于WINDOWSCE的BSP源代码

    NumberOfDWORD=NumberOfByte>>2;

    EnterCriticalSection(&(pHeader->TransmitCritSec));
   // Enable transmitting IRQ, IST will chase up pointers and fill the buffer          
    TxEnterCS(pHeader);
    pHeader->TxBufferInfo.Permissions = GetCurrentPermissions();
    pHeader->TxBufferInfo.TxBuffer = (ULONG*)pSourceBytes;
	pHeader->TxBufferInfo.Length = NumberOfDWORD;  //number of DWORD
    TxRead(pHeader) = 0;
    pHeader->TxBytesSent = 0;
    pHeader->TxBytesPending = NumberOfDWORD;
    TxLeaveCS(pHeader);
	pHeader->OpenCnt++;
  
//	RETAILMSG (TRUE, (TEXT("LMI_Write p:%x,v:%x\n"),
//	  (ULONG*)pSourceBytes,*(ULONG*)pSourceBytes));
    // Make sure an event isn't hanging around from a previous write time out.
 //   ResetEvent( pHeader->hTransmitEvent );
    
    // We call the same write routine that a TX_INTR does.  It queus as 
    // much data as possible, then returns.  From then on, the normal
    // interrupt mechanism kicks in.
    DoTxData( pHeader );   
    
  //  WaitReturn = WaitForSingleObject (pHead->hTransmitEvent, INFINITE);

    if ( !pHeader->OpenCnt ) 
    {
        RETAILMSG(1,
                 (TEXT("LMI_Write - device was closed\n\r")));
        SetLastError(ERROR_INVALID_HANDLE);

    }

    // Regardless of timeout, we need to clear the TxBufferInfo
    // to prevent ISR from possibly coming around and trying to use
    // the buffer after we have returned to the caller.
    TxEnterCS(pHeader);
    pHeader->TxBufferInfo.Permissions = 0;
    pHeader->TxBufferInfo.TxBuffer = NULL;
    pHeader->TxBufferInfo.Length = 0;
    TxRead(pHeader) = 0;
    TxLeaveCS(pHeader);
    
    LeaveCriticalSection(&(pHeader->TransmitCritSec));
     
              
    return(pHeader->TxBytesSent);   
}


/*! \brief  LMI IOControl call function.
 *  \params 
 *  \return BOOL :   boolean value indicates successful operation or not.
 */
BOOL LMI_IOControl(DWORD hOpenContext, 
                       DWORD dwCode, 
                       PBYTE pBufIn, 
                       DWORD dwLenIn, 
                       PBYTE pBufOut, 
                       DWORD dwLenOut, 
                       PDWORD pdwActualOut)
{
  PLMIOpenHead pOpenHead = (PLMIOpenHead)hOpenContext;
   //
  PLMI_Header pHeader    = pOpenHead->LmiHeader;
  
  switch(dwCode)
  {
    case IOCTL_RESETPT:
       LcdResetPtr(pHeader->pLcd);
       break;
//	case IOCTL_SETPT:
    default:
       break;
  }
  return TRUE;
}

/*! \brief  LMI write call function.
 *  \params hLMIHead     :the  LMI driver head structure point
 *  \return DWORD :      
 */
/*
static DWORD WINAPI LMI_IST(PVOID pLMIHead)
{
    PLMI_Header    pHead = (PLMI_Header)pLMIHead;
    ULONG          WaitReturn=0,val;
    ULONG          IntType=0;
    LMIReg * lmip;

    RETAILMSG (1, (TEXT("Entered LMIIST %X\r\n"),pHead));
    
    while (1) 
    {
 //       RETAILMSG (1, (TEXT("Event %X\r\n"),pHead->hLMIEvent));
//		lmip=(LMIReg*)(pHead->pLMI);
//		val=lmip->RIS;

//		Sleep(200);
        WaitReturn = WaitForSingleObject(pHead->hLMIEvent, INFINITE);
        while(1)
        {
        
        IntType=LMIGetIntType(pHead->pLMI);
        if(IntType& LMI_TX_FIFO)
        {
          
        }        
        //LMIClearTxInt(pHeader->pLMI);
        RETAILMSG (ZONE_WRITE, (TEXT("Transmission complete, %d bytes sent\r\n"), Len));
        pHeader->TxBufferInfo.Permissions = 0;
        pHeader->TxBufferInfo.TxCharBuffer = NULL;
        pHeader->TxBufferInfo.Length = 0;
        TxRead(pHeader) = 0;          
        }
        SetEvent(pHeader->hTransmitEvent);
        InterruptDone(pHead->IntID); 

    }
	
    return(0);
}
*/

/*! \brief  LMI open call function.
 *  \params hHead      :the LMI head structure point
 *  \params AccessCode :
 *  \params ShareMode  :
 *  \return HANDLE
 */
HANDLE LMI_Open(HANDLE pHead, DWORD AccessCode, DWORD ShareMode)
{
    PLMI_Header pLmiHeader= (PLMI_Header) pHead;

    PLMIOpenHead pOpenHead  = (PLMIOpenHead)LocalAlloc(LPTR, sizeof(LMIOpenHead));
    
    pOpenHead->LmiHeader=pLmiHeader;
        
    
    // Disallow multiple, simultaneous opens
    //
    EnterCriticalSection(&pLmiHeader->OpenCS);
    
    if(pLmiHeader->DMA_Enable>0)
    {
      if( LMIInitDma(pLmiHeader)== FALSE)
      {
       	return FALSE;
      };
    }    
	
    // Increment the open count
    //
    pLmiHeader->OpenCnt++;
    LMIEnableTxInt(pLmiHeader->pLMI);
    
    LeaveCriticalSection(&pLmiHeader->OpenCS);
    return pOpenHead;
}

/*! \brief  LMI tx data call function.
 *  \params hHead     :the LMI head structure point
 *  \return void.
 */
void DoTxData( PLMI_Header pHead ) 
{       
    ULONG      Len;

    TxEnterCS(pHead);
    // If device was closed from under us, stop transmitting
    if (!pHead->OpenCnt )
    {
        
        RETAILMSG (1,
                    (TEXT("EventHandler: %d sent up-to-now.\n\r"),pHead->TxBytesSent));
        pHead->TxBufferInfo.Permissions = 0;
        pHead->TxBufferInfo.TxBuffer = NULL;
        pHead->TxBufferInfo.Length = 0;
        TxRead(pHead) = 0;
        return;
    }             
    // Check the flow control status, and if not flowed off, call the
    // hw TX routine to actually transmit some data.
    if ( pHead->TxBufferInfo.TxBuffer && TxBytesAvail(pHead) ) 
    {
        DWORD oldPerm = SetProcPermissions(pHead->TxBufferInfo.Permissions);
        Len = TxBytesAvail(pHead);        
		//RETAILMSG (TRUE, (TEXT("LMI_Write p:%x,v:%x\n"),pHead->TxBufferInfo.TxBuffer,*pHead->TxBufferInfo.TxBuffer));
        if(pHead->DMA_Enable&&Len>=sizeof(DWORD))
        {
          LmiBInit(pHead->pLMI,Len*2,16,1,0);
          LMIStartDma(pHead,pHead->TxBufferInfo.TxBuffer,&Len);          
		  //RETAILMSG(1,(TEXT("start dma\n")));
        }
        else
        {
          LmiBInit(pHead->pLMI,Len*2,16,1,0);
          LMISendBytes(pHead->pLMI,pHead->TxBufferInfo.TxBuffer,&Len);
		  //RETAILMSG(1,(TEXT("start sent bytes\n")));
        }        	
        // Update Fifo info
        pHead->TxBytes += Len;
        pHead->TxBytesSent += Len;
        TxRead(pHead) += Len;
        SetProcPermissions(oldPerm);
    } 
    TxLeaveCS(pHead);
    
                      
}




ULONG
LMI_Seek(
   PVOID Context,
   LONG Position,
   DWORD Type
   )
{
    
    return (DWORD)-1;
}

BOOL
LMI_PowerUp(HANDLE pHead)
{
    return FALSE;
}

BOOL
LMI_PowerDown(HANDLE pHead)
{
    return FALSE;
}