scif_cmn.c

WinCE5.0BSP for Renesas SH7770

    DEBUGMSG (ZONE_THREAD, (TEXT("-SCIF_RxIntr - rx'ed %d, dropped %d.\r\n"),
                  *pBufflen,
                  pHWHead->DroppedBytes));

    RetVal = pHWHead->DroppedBytes;
    pHWHead->DroppedBytes = 0;

    return RetVal;
}

//
// @doc OEM
// @func ULONG | SCIF_LineIntr | This routine is called from the MDD
//   whenever INTR_LINE is returned by SCIF_GetInterruptType.
// 
// @rdesc None
//
VOID
SCIF_LineIntr(
    PVOID pHead                // Hardware Head
    )
{
    PSCIF_INFO   pHWHead	= (PSCIF_INFO)pHead;

    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("+SCIF_LineIntr 0x%X\r\n"), pHead));

    ReadStatus( pHWHead );

    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("-SCIF_LineIntr 0x%X\r\n"), pHead));
}

//
// @doc OEM
// @func ULONG | SCIF_OtherIntr | This routine is called from the MDD
//   whenever INTR_MODEM is returned by SCIF_GetInterruptType.
// 
// @rdesc None
//
VOID
SCIF_OtherIntr(
    PVOID pHead                // Hardware Head
    )
{
    PSCIF_INFO   pHWHead	= (PSCIF_INFO)pHead;

    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("+SCIF_OtherIntr 0x%X\r\n"), pHead));

    ReadModemStatus( pHWHead );

    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("-SCIF_OtherIntr 0x%X\r\n"), pHead));
}



//
// @doc OEM
// @func	ULONG | SCIF_Reset | Perform any operations associated
//   with a device reset
//
// @rdesc	None.
//
VOID
SCIF_Reset(
    PVOID   pHead	// @parm PVOID returned by HWInit.
    )
{
    PSCIF_INFO pHWHead = (PSCIF_INFO)pHead;

    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("+SCIF_Reset 0x%X\r\n"), pHead));

    memset(&pHWHead->Status, 0, sizeof(COMSTAT));

    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("-SCIF_Reset 0x%X\r\n"), pHead));
}

//
// @doc OEM
// @func	VOID | SCIF_GetModemStatus | Retrieves modem status.
//
// @rdesc	None.
//
VOID
SCIF_GetModemStatus(
    PVOID   pHead,	    // @parm PVOID returned by HWInit.
    PULONG  pModemStatus    // @parm PULONG passed in by user.
    )
{
    PSCIF_INFO pHWHead = (PSCIF_INFO)pHead;
    USHORT	MSR;

    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("+SCIF_GetModemStatus 0x%X\r\n"), pHead));

    MSR = ReadModemStatus( pHWHead );

    *pModemStatus = pHWHead->ModemStatus;

    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("-SCIF_GetModemStatus 0x%X\r\n"), pHead));
    return;
}

//
// @doc OEM
// @func	VOID | SCIF_PurgeComm | Purge RX and/or TX
// 
// @rdesc	None.
//

VOID
SCIF_PurgeComm(
    PVOID   pHead,	    // @parm PVOID returned by HWInit.
    DWORD   fdwAction	    // @parm Action to take. 
    )
{
    PSCIF_INFO pHWHead = (PSCIF_INFO)pHead;
    USHORT	FCR;

    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("+SCIF_PurgeComm 0x%X\r\n"), pHead));

    try
    {
        FCR = READ_REGISTER_USHORT(pHWHead -> pFCR);
        if ( fdwAction & PURGE_TXCLEAR )
        {
            WRITE_REGISTER_USHORT(pHWHead -> pFCR, FCR | SCIF_FCR_TFRST);
            WRITE_REGISTER_USHORT(pHWHead -> pFCR, FCR);
        }

        if ( fdwAction & PURGE_RXCLEAR )
        {
            WRITE_REGISTER_USHORT(pHWHead -> pFCR, FCR | SCIF_FCR_RFRST);
            WRITE_REGISTER_USHORT(pHWHead -> pFCR, FCR);
        }
    }
    except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        // Just exit
    }
    
    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("-SCIF_PurgeComm 0x%X\r\n"), pHead));
    return;
}

//
// @doc OEM
// @func	BOOL | SCIF_XmitComChar | Transmit a char immediately
// 
// @rdesc	TRUE if succesful
//
BOOL
SCIF_XmitComChar(
    PVOID   pHead,    // @parm PVOID returned by HWInit.
    UCHAR   ComChar   // @parm Character to transmit. 
    )
{
    PSCIF_INFO pHWHead = (PSCIF_INFO)pHead;
    
    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("+SCIF_XmitComChar 0x%X\r\n"), pHead));

     // Get critical section, then transmit when buffer empties
    DEBUGMSG (ZONE_WRITE, (TEXT("XmitComChar wait for CritSec %x.\r\n"),
                           &(pHWHead->TransmitCritSec)));
    EnterCriticalSection(&(pHWHead->TransmitCritSec));
    DEBUGMSG (ZONE_WRITE, (TEXT("XmitComChar got CritSec %x.\r\n"),
                           &(pHWHead->TransmitCritSec)));
    try
    {
        while( TRUE )  // We know THR will eventually empty
        {
            if ( READ_REGISTER_USHORT(pHWHead -> pFSR) & SCIF_SSR_TDFE ){
                WRITE_REGISTER_UCHAR(pHWHead -> pFTDR, ComChar);
                DEBUGMSG (ZONE_WRITE, (TEXT("XmitComChar wrote x%X\r\n"),
                                         ComChar));
                break;
            }

            // If we couldn't write the data yet, then wait for a
            // TXINTR to come in and try it again.
            
            // Enable xmit intr.
            WRITE_REGISTER_USHORT(pHWHead -> pSCR, READ_REGISTER_USHORT(pHWHead -> pSCR) | SCIF_SCR_TIE);
             // Wait until the txintr has signalled.
            DEBUGMSG (ZONE_WRITE, (TEXT("XmitComChar WaitIntr x%X\r\n"),
                                     pHWHead->FlushDone));
            WaitForSingleObject(pHWHead->FlushDone, (ULONG)1000);
        }
    }
    except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        // Just exit
    }
    
    LeaveCriticalSection(&(pHWHead->TransmitCritSec));
    DEBUGMSG (ZONE_WRITE, (TEXT("XmitComChar released CritSec %x.\r\n"),
                           &(pHWHead->TransmitCritSec)));
    
    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("-SCIF_XmitComChar 0x%X\r\n"), pHead));
    
    return TRUE;
}

//
// @doc OEM
// @func	BOOL | SCIF_PowerOff | Perform powerdown sequence.
// 
// @rdesc	TRUE if succesful
//
BOOL
SCIF_PowerOff(
    PVOID   pHead	    // @parm	PVOID returned by HWInit.
    )
{
    PSCIF_INFO pHWHead = (PSCIF_INFO)pHead;

    pHWHead -> SMR = READ_REGISTER_USHORT(pHWHead -> pSMR);
    pHWHead -> BRR = READ_REGISTER_USHORT(pHWHead -> pBRR);
    pHWHead -> SCR = READ_REGISTER_USHORT(pHWHead -> pSCR);
    pHWHead -> FCR = READ_REGISTER_USHORT(pHWHead -> pFCR);
    pHWHead -> BRGDL = READ_REGISTER_USHORT(pHWHead -> pBRGDL);
    pHWHead -> BRGCKS = READ_REGISTER_USHORT(pHWHead -> pBRGCKS);
    if ( pHWHead -> pSCSMR )
        pHWHead -> SCSMR = (USHORT)READ_REGISTER_ULONG(pHWHead -> pSCSMR);

    SerSetOutputMode( pHWHead, FALSE, FALSE );

    return TRUE;
}

//
// @doc OEM
// @func	BOOL | SCIF_PowerOn | Perform poweron sequence.
// 
// @rdesc	TRUE if succesful
//
BOOL
SCIF_PowerOn(
    PVOID   pHead	    // @parm	PVOID returned by HWInit.
    )
{
    PSCIF_INFO pHWHead = (PSCIF_INFO)pHead;
    DWORD	dcr_value;

    WRITE_REGISTER_USHORT(pHWHead -> pFCR, pHWHead -> FCR);
    WRITE_REGISTER_USHORT(pHWHead -> pBRGDL, pHWHead -> BRGDL);
    WRITE_REGISTER_USHORT(pHWHead -> pBRGCKS, pHWHead -> BRGCKS);
    WRITE_REGISTER_USHORT(pHWHead -> pSMR, pHWHead -> SMR);
    WRITE_REGISTER_USHORT(pHWHead -> pBRR, pHWHead -> BRR);
    WRITE_REGISTER_USHORT(pHWHead -> pSCR, pHWHead -> SCR);
    if ( pHWHead -> pSCSMR )
        WRITE_REGISTER_ULONG(pHWHead -> pSCSMR, pHWHead -> SCSMR);

     // And we didn't save the Divisor Reg, so set baud rate
    SCIF_SetBaudRate( pHWHead, pHWHead->dcb.BaudRate );

    pHWHead->ulReceiveDmaBufferPointer = 0;

    dcr_value = DCR_DPDS_8BIT		|
                DCR_DDRMD_MODULE	|
                DCR_DPDAM_FIX	 	|
		DCR_DMDL_MEMORY		|
		DCR_SPDS_8BIT		|
		DCR_SDRMD_MODULE	|
		DCR_SPDAM_FIX		|
		DCR_SMDL_PERIPHERAL	|
		DCR_DIP_2PAGE		|
		DCR_ACMD_ENABLE		|
		DCR_CT_ENABLE		|
		DCR_PKMD_DISABLE	|
		DCR_BTMD_DISABLE	|
		DCR_DTAU_BYTE		|
		DCR_DTAC_DISABLE	|
		DCR_DTAMD_DTAC		;

    dma_SetPage(pHWHead -> pRxDma, 0, pHWHead -> ulRxDmaRegBase,
					   pHWHead -> ulRxDmaBuffBase1,  pHWHead -> ulRxDmaBuffSize);
    dma_SetPage(pHWHead -> pRxDma, 1, pHWHead -> ulRxDmaRegBase,
					   pHWHead -> ulRxDmaBuffBase2,  pHWHead -> ulRxDmaBuffSize); 
    dma_SetPort(pHWHead -> pRxDma, pHWHead -> dwRxDmaPort);
    dma_SetControl(pHWHead -> pRxDma, dcr_value);
    dma_SetCommand(pHWHead -> pRxDma, DCMDR_DMEN);

#if (SH7770_REVISION == SH7770_1STCUT)
		WRITE_REGISTER_USHORT(pHWHead -> pSCR,
				 SCIF_SCR_TOIE|SCIF_SCR_TE|SCIF_SCR_RE|SCIF_SCR_REIE|SCIF_SCR_CKE_2|SCIF_SCR_RIE);
#else
		WRITE_REGISTER_USHORT(pHWHead -> pSCR,
				 SCIF_SCR_TOIE|SCIF_SCR_TE|SCIF_SCR_RE|SCIF_SCR_REIE|SCIF_SCR_CKE_2);
#endif

    dma_InterruptEnable(pHWHead -> pRxDma);

    return TRUE;
}

//
// @doc OEM
// @func	BOOL | SCIF_SetDCB | Sets new values for DCB.  This
// routine gets a DCB from the MDD.  It must then compare
// this to the current DCB, and if any fields have changed take
// appropriate action.
// 
// @rdesc	ULONG
//
ULONG
SCIF_SetDCB(
    PVOID   pHead,	    // @parm	PVOID returned by HWInit.
    LPDCB   lpDCB       // @parm    Pointer to DCB structure
    )
{
    PSCIF_INFO pHWHead = (PSCIF_INFO)pHead;
    ULONG	ret = TRUE;
    
    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("+SCIF_SetDCB 0x%X\r\n"), pHead));

	while( !(READ_REGISTER_USHORT(pHWHead -> pFSR) & SCIF_SSR_TEND) );

     // If the device is open, scan for changes and do whatever
     // is needed for the changed fields.  if the device isn't
     // open yet, just save the DCB for later use by the open.
    if( pHWHead->OpenCount )
    {
         // Note, fparity just says whether we should check
         // receive parity.  And the 16550 won't let us NOT
         // check parity if we generate it.  So this field
         // has no effect on the hardware.

		DEBUGMSG (ZONE_FUNCTION, (TEXT(" SCIF_SetDCB SetBaudRate[%d]-->[%d]\r\n"), pHWHead->dcb.BaudRate,lpDCB->BaudRate));
		DEBUGMSG (ZONE_FUNCTION, (TEXT(" SCIF_SetDCB SetByteSize[%d]-->[%d]\r\n"), pHWHead->dcb.ByteSize,lpDCB->ByteSize));
		DEBUGMSG (ZONE_FUNCTION, (TEXT(" SCIF_SetDCB SetParity[%d]-->[%d]\r\n"), pHWHead->dcb.Parity,lpDCB->Parity));
		DEBUGMSG (ZONE_FUNCTION, (TEXT(" SCIF_SetDCB SetStopBits[%d]-->[%d]\r\n"), pHWHead->dcb.StopBits,lpDCB->StopBits));

        if( lpDCB->BaudRate != pHWHead->dcb.BaudRate )
        {
            ret = SCIF_SetBaudRate( pHWHead, lpDCB->BaudRate );
        }
    
        if( lpDCB->ByteSize != pHWHead->dcb.ByteSize )
        {
            ret = SCIF_SetByteSize( pHWHead, lpDCB->ByteSize );
        }
    
        if( lpDCB->Parity != pHWHead->dcb.Parity )
        {
            ret = SCIF_SetParity( pHWHead, lpDCB->Parity );
        }
    
        if( lpDCB->StopBits != pHWHead->dcb.StopBits )
        {
            ret = SCIF_SetStopBits( pHWHead, lpDCB->StopBits );
        }

         // Don't worry about fOutxCtsFlow.  It is a flag which
         // will be examined every time we load the TX buffer.
         // No special action required here.
    }
    
     // Now that we have done the right thing, store this DCB
    pHWHead->dcb = *lpDCB;

    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("-SCIF_SetDCB 0x%X\r\n"), pHead));

    return ret;
}

//
// @doc OEM
// @func	BOOL | SCIF_SetCommTimeouts | Sets new values for the
// CommTimeouts structure. routine gets a DCB from the MDD.  It
// must then compare this to the current DCB, and if any fields
// have changed take appropriate action.
// 
// @rdesc	ULONG
//
ULONG
SCIF_SetCommTimeouts(
    PVOID   pHead,	    // @parm	PVOID returned by HWInit.
    LPCOMMTIMEOUTS   lpCommTimeouts // @parm Pointer to CommTimeout structure
    )
{
    PSCIF_INFO pHWHead = (PSCIF_INFO)pHead;
    ULONG retval = 0;
    
    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("+SCIF_SetCommTimeout 0x%X\r\n"), pHead));

    DEBUGMSG (ZONE_FUNCTION,
              (TEXT(" SCIF_SetCommTimeouts (%d,%d,%d,%d,%d)\r\n"),
               ((COMMTIMEOUTS *)lpCommTimeouts)->ReadIntervalTimeout,
               ((COMMTIMEOUTS *)lpCommTimeouts)->ReadTotalTimeoutMultiplier,
               ((COMMTIMEOUTS *)lpCommTimeouts)->ReadTotalTimeoutConstant,
               ((COMMTIMEOUTS *)lpCommTimeouts)->WriteTotalTimeoutMultiplier,
               ((COMMTIMEOUTS *)lpCommTimeouts)->WriteTotalTimeoutConstant));

     // OK, first check for any changes and act upon them
    if( lpCommTimeouts->WriteTotalTimeoutMultiplier !=
        pHWHead->CommTimeouts.WriteTotalTimeoutMultiplier )
    {
    }
    
     // Now that we have done the right thing, store this DCB
    pHWHead->CommTimeouts = *lpCommTimeouts;

    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("-SCIF_SetCommTimeout 0x%X\r\n"), pHead));

    return retval;
}

//
//  @doc OEM
//  @func	BOOL | SCIF_Ioctl | Device IO control routine.  
//  @parm DWORD | dwOpenData | value returned from COM_Open call
//	@parm DWORD | dwCode | io control code to be performed
//	@parm PBYTE | pBufIn | input data to the device
//	@parm DWORD | dwLenIn | number of bytes being passed in
//	@parm PBYTE | pBufOut | output data from the device
//	@parm DWORD | dwLenOut |maximum number of bytes to receive from device
//	@parm PDWORD | pdwActualOut | actual number of bytes received from device
//
//	@rdesc		Returns TRUE for success, FALSE for failure
//
//  @remark  The MDD will pass any unrecognized IOCTLs through to this function.
//
BOOL
SCIF_Ioctl(PVOID pHead,
           DWORD dwCode,
           PBYTE pBufIn,
           DWORD dwLenIn,
           PBYTE pBufOut,
           DWORD dwLenOut,
           PDWORD pdwActualOut)
{
    BOOL RetVal = TRUE;
    DEBUGMSG (ZONE_FUNCTION, (TEXT("+SCIF_Ioctl 0x%X\r\n"), pHead));
    switch (dwCode) {

        // Currently, no defined IOCTLs
        default:
            RetVal = FALSE;
            DEBUGMSG (ZONE_FUNCTION, (TEXT(" Unsupported ioctl 0x%X\r\n"), dwCode));
            break;            
	}
    DEBUGMSG (ZONE_FUNCTION, (TEXT("-SCIF_Ioctl 0x%X\r\n"), pHead));
    return RetVal;
}

/*
 @doc OEM
 @func	VOID | SCIF_GetCommProperties | Retrieves Comm Properties.
 *
 @rdesc	None.
 */
VOID
SCIF_GetCommProperties(
    PVOID	pHead,	    // @parm PVOID returned by SerInit. 
    LPCOMMPROP	pCommProp   // @parm Pointer to receive COMMPROP structure. 
    )
{
    PSCIF_INFO	pHWHead = (PSCIF_INFO)pHead;

    *pCommProp = pHWHead->CommProp;
    return;
}