scif_cmn.c

WinCE5.0BSP for Renesas SH7770

    }

    // We're done with that registry key, so close it.
    RegCloseKey (hKey);

    return ( TRUE ); 
}


//
// @doc OEM 
// @func PVOID | SCIF_Deinit | De-initializes SCIF device head.  
//
ULONG
SCIF_Deinit(
    PVOID   pHead // @parm points to device head
    )
{
    PSCIF_INFO   pHWHead   = (PSCIF_INFO)pHead;

    DEBUGMSG (ZONE_CLOSE,(TEXT("+SerDeinit, 0x%X\r\n"), pHWHead));
    if ( !pHWHead )
        return 0;

    // Free the flushdone event
    if( pHWHead -> FlushDone )
        CloseHandle( pHWHead -> FlushDone );

    if ( pHWHead -> pBaseAddress )
        VirtualFree((PVOID)pHWHead -> pBaseAddress, 0, MEM_RELEASE);

    if ( pHWHead -> pDMABaseAddress )
        VirtualFree((PVOID)pHWHead -> pDMABaseAddress, 0, MEM_RELEASE);

    LocalFree(pHWHead);
    pHWHead = (PSCIF_INFO)NULL;

    DeleteCriticalSection(&(pHWHead -> TransmitCritSec));

    DEBUGMSG (ZONE_CLOSE,(TEXT("-SerDeinit, 0x%X\r\n"), pHWHead));
    return 0;
}

//
// @doc OEM
// @func void | SCIF_ClearDTR | This routine clears DTR.
//
// @rdesc None.
//
VOID
SCIF_ClearDTR(
    PVOID   pHead // @parm PVOID returned by HWinit.
    )
{
    PSCIF_INFO   pHWHead   = (PSCIF_INFO)pHead;

    DEBUGMSG (ZONE_FUNCTION, (TEXT("+SerClearDTR, 0x%X\r\n"), pHead));
    EnterCriticalSection(&(pHWHead->RegCritSec));
    try {
    	// Not support DTR
    }
    except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        // Just exit
    }
    LeaveCriticalSection(&(pHWHead->RegCritSec));

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

//
// @doc OEM
// @func VOID | SCIF_SetDTR | This routine sets DTR.
// 
// @rdesc None.
//
VOID
SCIF_SetDTR(
    PVOID   pHead // @parm PVOID returned by HWinit.
    )
{
    PSCIF_INFO   pHWHead   = (PSCIF_INFO)pHead;

    DEBUGMSG (ZONE_FUNCTION, (TEXT("+SerSetDTR, 0x%X\r\n"), pHead));
    EnterCriticalSection(&(pHWHead->RegCritSec));
    try {
    	// Not support DTR
    }
    except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        // Just exit
    }
    LeaveCriticalSection(&(pHWHead->RegCritSec));

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



//
// @doc OEM
// @func VOID | SCIF_ClearBreak | This routine clears break.
// 
// @rdesc None.
// 
VOID
SCIF_ClearBreak(
    PVOID   pHead // @parm PVOID returned by HWinit.
    )
{
    PSCIF_INFO   pHWHead   = (PSCIF_INFO)pHead;

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

    EnterCriticalSection(&(pHWHead->RegCritSec));
    try {
    	// Clear Break
        WRITE_REGISTER_USHORT(pHWHead -> pSCR, READ_REGISTER_USHORT(pHWHead -> pSCR) | SCIF_SCR_TE);
    }
    except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        // Just exit
    }
    LeaveCriticalSection(&(pHWHead->RegCritSec));

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

//
// @doc OEM
// @func VOID | SCIF_SetBreak | This routine sets break.
// 
// @rdesc None.
//
VOID
SCIF_SetBreak(
    PVOID   pHead // @parm PVOID returned by HWinit.
    )
{
    PSCIF_INFO   pHWHead   = (PSCIF_INFO)pHead;

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

    EnterCriticalSection(&(pHWHead->RegCritSec));
    try {
    	// Set Break
        WRITE_REGISTER_USHORT(pHWHead -> pSCR, READ_REGISTER_USHORT(pHWHead -> pSCR) & ~SCIF_SCR_TE);
    }
    except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        // Just exit
    }
    LeaveCriticalSection(&(pHWHead->RegCritSec));

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

//
// @doc OEM
// @func VOID | SCIF_SetBaudRate |
//  This routine sets the baud rate of the device.
//
// @rdesc None.
//
DWORD AdjustMicroSecondsToLoopCount( DWORD dwMicroSeconds );
DWORD BusyWait( DWORD dwLoopCount );
BOOL
SCIF_SetBaudRate(
    PVOID   pHead,	// @parm     PVOID returned by HWInit
    ULONG   BaudRate	// @parm     ULONG representing decimal baud rate.
    )
{
    PSCIF_INFO	pHWHead = (PSCIF_INFO)pHead;
    USHORT		divisor;
    BOOL		bRet = TRUE;

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

    EnterCriticalSection(&(pHWHead->RegCritSec));

    divisor = SCIF_DivisorOfRate(pHead, BaudRate);

    if ( divisor )
    {
        try
        {
            pHWHead->dcb.BaudRate = BaudRate;

            WRITE_REGISTER_USHORT(pHWHead -> pBRGDL, divisor);
            DEBUGMSG (ZONE_FUNCTION,
                      (TEXT("-SCIF_SetbaudRate 0x%X (%d Baud)\r\n"),
                       pHead, BaudRate));
        }
        except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
            DEBUGMSG (ZONE_FUNCTION | ZONE_ERROR,
                      (TEXT("-SCIF_SetbaudRate - Exception\r\n")) );
            bRet = FALSE;
        }
    }
    else
    {
        DEBUGMSG (ZONE_FUNCTION | ZONE_ERROR,
                  (TEXT("-SCIF_SetbaudRate - Bad BaudRate %d\r\n"),
                   BaudRate) );
        bRet = FALSE;
    }
    if ( bRet == TRUE ){
        if ( pHWHead -> bFirstBaudRate == FALSE ){
            BusyWait(AdjustMicroSecondsToLoopCount((3680000*(1/divisor)*1/16)+1));
            pHWHead -> bFirstBaudRate = TRUE;
        }else{
            BusyWait(AdjustMicroSecondsToLoopCount((3680000*(1/65535)*1/16)+1));
        }
    }

    LeaveCriticalSection(&(pHWHead->RegCritSec));

    return bRet;
}

//
// @doc OEM
// @func VOID | SCIF_SetByteSize |
//  This routine sets the WordSize of the device.
//
// @rdesc None.
//
BOOL
SCIF_SetByteSize(
    PVOID   pHead,	    // @parm     PVOID returned by HWInit
    ULONG   ByteSize	// @parm     ULONG ByteSize field from DCB.
    )
{
    PSCIF_INFO	pHWHead = (PSCIF_INFO)pHead;
    USHORT		SMR;
    BOOL		ret = TRUE;

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

    EnterCriticalSection(&(pHWHead->RegCritSec));

    try
    {
        SMR = READ_REGISTER_USHORT(pHWHead -> pSMR);
        SMR &= ~SCIF_SMR_7BIT;
        switch( ByteSize )
        {
            case 7:
                SMR |= SCIF_SMR_7BIT;
                break;
            case 8:
                SMR |= SCIF_SMR_8BIT;
                pHWHead -> dcb.ByteSize = 8;
                break;
            default :
                SMR |= SCIF_SMR_8BIT;
                pHWHead -> dcb.ByteSize = 8;
                ret = FALSE;
                break;
        }
        WRITE_REGISTER_USHORT(pHWHead -> pSMR, SMR);
    }
    except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        // Do nothing - we're in enough trouble
    }

    LeaveCriticalSection(&(pHWHead->RegCritSec));

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

    return ret;
}
//
// @doc OEM
// @func VOID | SCIF_SetParity |
//  This routine sets the parity of the device.
//
// @rdesc None.
//
BOOL
SCIF_SetParity(
    PVOID   pHead,	// @parm     PVOID returned by HWInit
    ULONG   Parity	// @parm     ULONG parity field from DCB.
    )
{
    PSCIF_INFO	pHWHead = (PSCIF_INFO)pHead;
    USHORT SMR;
    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("+SCIF_SetParity 0x%X, x%X\r\n"), pHead, Parity));

    EnterCriticalSection(&(pHWHead->RegCritSec));

    try
    {
        SMR = READ_REGISTER_USHORT(pHWHead -> pSMR);
        SMR &= ~SCIF_SMR_ODD_PAR;
        switch( Parity )
        {
            case ODDPARITY:
                SMR |= SCIF_SMR_PE | SCIF_SMR_ODD_PAR;
                break;
            case EVENPARITY:
                SMR |= SCIF_SMR_PE | SCIF_SMR_EVEN_PAR;
                break;
            case NOPARITY:
                SMR &= ~SCIF_SMR_PE;
                break;
            default:
                SMR &= ~SCIF_SMR_PE;
                pHWHead -> dcb.Parity = NOPARITY;
                break;
        }
        WRITE_REGISTER_USHORT(pHWHead -> pSMR, SMR);
    }
    except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        // Do nothing - we're in enough trouble
    }

    LeaveCriticalSection(&(pHWHead->RegCritSec));

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

    return TRUE;
}
//
// @doc OEM
// @func VOID | SCIF_SetStopBits |
//  This routine sets the Stop Bits for the device.
//
// @rdesc None.
//
BOOL
SCIF_SetStopBits(
    PVOID   pHead,	  // @parm     PVOID returned by HWInit
    ULONG   StopBits  // @parm     ULONG StopBits field from DCB.
    )
{
    PSCIF_INFO	pHWHead = (PSCIF_INFO)pHead;
    USHORT SMR;
    DEBUGMSG (ZONE_FUNCTION,
              (TEXT("+SCIF_SetStopBits 0x%X, x%X\r\n"), pHead, StopBits));

	EnterCriticalSection(&(pHWHead->RegCritSec));

    try
    {
         // Note that 1.5 stop bits only works if the word size
         // is 5 bits.  Any other xmit word size will cause the
         // 1.5 stop bit setting to generate 2 stop bits.
        SMR = READ_REGISTER_USHORT(pHWHead -> pSMR);
        SMR &= ~SCIF_SMR_2STOP;
        switch( StopBits )
        {
            case ONESTOPBIT :
                SMR |= SCIF_SMR_1STOP;
                break;
            case TWOSTOPBITS :
                SMR |= SCIF_SMR_2STOP;
                break;
            default :
                SMR |= SCIF_SMR_1STOP;
                pHWHead -> dcb.StopBits = ONESTOPBIT;
                break;
        }
        WRITE_REGISTER_USHORT(pHWHead -> pSMR, SMR);
    }
    except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        // Do nothing - we're in enough trouble
    }

	LeaveCriticalSection(&(pHWHead->RegCritSec));

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

    return TRUE;
}

//
// @doc OEM
// @func ULONG | SCIF_GetRxBufferSize | This function returns
// the size of the hardware buffer passed to the interrupt
// initialize function.  It would be used only for devices
// which share a buffer between the MDD/PDD and an ISR.
//
// 
// @rdesc This routine always returns 0.
// 
ULONG
SCIF_GetRxBufferSize(
    PVOID pHead
    )
{
    return 0;
}


// @doc OEM
// @func ULONG | SCIF_RxIntr | This routine gets several characters from the hardware
//   receive buffer and puts them in a buffer provided via the second argument.
//   It returns the number of bytes lost to overrun.
// 
// @rdesc The return value indicates the number of overruns detected.
//   The actual number of dropped characters may be higher.
//
ULONG
SCIF_RxIntr(
    PVOID pHead,                // @parm Pointer to hardware head
    PUCHAR pRxBuffer,           // @parm Pointer to receive buffer
    ULONG *pBufflen             // @parm In = max bytes to read, out = bytes read
    )
{
    PSCIF_INFO  pHWHead		= (PSCIF_INFO)pHead;
    PDMA_INFO	pRxDma 		= pHWHead -> pRxDma;
    ULONG	    RetVal		= 0;
    ULONG	    TargetRoom	= *pBufflen;
    DWORD		dwCnt;
    ULONG		NextStartPoint;
#if (SH7770_REVISION != SH7770_1STCUT)
	ULONG DSTSR;
#endif

    DEBUGMSG (ZONE_THREAD, (TEXT("+SCIF_RxIntr - len %d.\r\n"),
                  *pBufflen));

    DEBUGMSG (ZONE_THREAD, (TEXT("Ticks[%d]\r\n"),GetTickCount()));

    *pBufflen = 0;
    dwCnt = 0;
#if (SH7770_REVISION == SH7770_1STCUT)
    NextStartPoint = READ_REGISTER_ULONG(pRxDma -> pvDDASR);
	NextStartPoint &= ((SCIF0_RXBUFFER_SIZE*2)-1);	
#else
    DSTSR = READ_REGISTER_ULONG(pRxDma -> pvDSTSR);
    NextStartPoint = READ_REGISTER_ULONG(pRxDma -> pvDTCSR);
	NextStartPoint &= ((SCIF0_RXBUFFER_SIZE*2)-1);	
	// get transfer count
	NextStartPoint = pHWHead->ulRxDmaBuffSize - NextStartPoint;
	if(DSTSR & 0x20) NextStartPoint += pHWHead->ulRxDmaBuffSize;
#endif

	DEBUGMSG (ZONE_THREAD, (TEXT("LSR[%04x] DDASR[0x%x] DSTSR[%04x] NextStartPoint[%d] ulReceiveDmaBufferPointer[%d] DTCSR[%d]\r\n"),
              READ_REGISTER_USHORT(pHWHead-> pLSR),
              READ_REGISTER_ULONG(pRxDma -> pvDDASR),
              READ_REGISTER_ULONG(pRxDma -> pvDSTSR),
              NextStartPoint,
              pHWHead->ulReceiveDmaBufferPointer,
              READ_REGISTER_ULONG(pRxDma -> pvDTCSR)));

    try {
		while ( TargetRoom ){
			if ( NextStartPoint == pHWHead->ulReceiveDmaBufferPointer )
				break;
			*pRxBuffer++ = *((pHWHead -> pRxBuff) + (pHWHead -> ulReceiveDmaBufferPointer));
			pHWHead->ulReceiveDmaBufferPointer++;
			pHWHead->ulReceiveDmaBufferPointer &= ((SCIF0_RXBUFFER_SIZE*2)-1);
			--TargetRoom;
			++(*pBufflen);
		}
    }
    except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ?
            EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        // just exit
    }

	// Serial TimeOut Interrupt Clear
	if (READ_REGISTER_USHORT(pHWHead -> pLSR) & SCIF_LSR_TO){
		DEBUGMSG(ZONE_THREAD, (TEXT("SCIF_LSR_TO ON-->OFF\r\n")));
		WRITE_REGISTER_USHORT(pHWHead -> pLSR, 
				READ_REGISTER_USHORT(pHWHead -> pLSR) & ~SCIF_LSR_TO);
	}