// -----------------------------------------------------------------------------
//
//    THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
//    ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
//    THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//    PARTICULAR PURPOSE.
//    Copyright (c) 1995-2000 Microsoft Corporation.  All rights reserved.
//
// -----------------------------------------------------------------------------
//
//    Serial Mouse driver for CE/PC platform
//
// -----------------------------------------------------------------------------
#include <windows.h>
#include <types.h>	// For UINT8 etc.
#include <pegdser.h>  // IOCTL_SERIAL stuff.

const UINT8 gcB0BitMask = 0x20;
const UINT8 gcB1BitMask = 0x10;


HANDLE g_hReadThread;
HANDLE g_hSerial;
HANDLE g_hThreadStopped;
BOOL   g_fStopThread;

ULONG CALLBACK ReadThread(PVOID pv);
BOOL SendData(UINT8 rawData[]);
BOOL InitSerialPort();

#define GOTO_EXIT(x) { x; goto EXIT; }

#ifdef DEBUG

DBGPARAM dpCurSettings = {
    TEXT("SerMouse"), {
        TEXT("Data"),TEXT("ReadThread"),TEXT("2"),TEXT("3"),
        TEXT("4"),TEXT("5"),TEXT("6"),TEXT("7"),
        TEXT("8"),TEXT("9"),TEXT("10"),TEXT("Values"),
        TEXT("Init"),TEXT("Function"),TEXT("Warning"),TEXT("Error")},
    0x8000  // Errors only, by default
}; 

    #define ZONE_DATA       DEBUGZONE(0)
    #define ZONE_READTHREAD DEBUGZONE(1)
    #define ZONE_VALUE      DEBUGZONE(11)
    #define ZONE_INIT       DEBUGZONE(12)
    #define ZONE_FUNCTION   DEBUGZONE(13)
    #define ZONE_WARN       DEBUGZONE(14)
    #define ZONE_ERROR      DEBUGZONE(15)
#endif

#define FUNC(x)     DEBUGMSG(ZONE_FUNCTION, (TEXT("[FUNC] %a()\r\n"), x))  
#define DECVALUE(x) DEBUGMSG(ZONE_VALUE, (TEXT("\tVALUE : ")TEXT( #x )TEXT(" = %d\r\n"), x))
#define HEXVALUE(x) DEBUGMSG(ZONE_VALUE, (TEXT("\tVALUE : ")TEXT( #x )TEXT(" = 0x%X\r\n"), x))


// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
BOOL WINAPI
DllEntry(
        HANDLE  hInstDll,
        DWORD   dwReason,
        LPVOID  lpvReserved
        )
{
    switch ( dwReason ) {
    case DLL_PROCESS_ATTACH:
        DEBUGREGISTER((HINSTANCE) hInstDll);
        DEBUGMSG(ZONE_INIT, (TEXT("SerMouse : DLL_PROCESS_ATTACH\r\n")));
        break;

    case DLL_PROCESS_DETACH:
        DEBUGMSG(ZONE_INIT, (TEXT("SerMouse : DLL_PROCESS_DETACH\r\n")));
        break;
    }

    return (TRUE);
}


// -----------------------------------------------------------------------------
//
//  Read the registry to get which COM port to use. 
//
// -----------------------------------------------------------------------------
DWORD
GetCommPort(
           LPCTSTR pszReg
           )
{
    LONG lRet;
    DWORD dwType, dwSize, dwValue;
    HKEY hKey;

    if ( IsBadReadPtr(pszReg, 1) ) {
        //
        // Can't even read from that pointer. Don't try to use it.
        //
        DEBUGMSG(ZONE_INIT, (TEXT("SerMouse : Doesn't have registry, using default\r\n")));
        GOTO_EXIT(dwValue = 1);
    }

    DEBUGMSG (ZONE_INIT | ZONE_FUNCTION, (TEXT("SerMouse : +GetCommPort(%s)\r\n"), pszReg));

    if ( RegOpenKeyEx(HKEY_LOCAL_MACHINE, pszReg, 0, KEY_ALL_ACCESS, &hKey) ) {

        DEBUGMSG (ZONE_INIT | ZONE_ERROR,
                  (TEXT("SerMouse : Failed to open HKEY_LOCAL_MACHINE\\%s\r\n"), pszReg));
        GOTO_EXIT(dwValue = 1);
    }

    dwSize = sizeof(DWORD);
    lRet = RegQueryValueEx(hKey, (LPTSTR) TEXT("Port"), NULL, &dwType, (LPBYTE) &dwValue, &dwSize);

    if ( lRet != ERROR_SUCCESS )
        dwValue = 1;

    RegCloseKey (hKey);


    EXIT:
    DEBUGMSG(ZONE_INIT | ZONE_FUNCTION, (TEXT("SerMouse : -GetCommPort(%d)\r\n"), dwValue));
    return (dwValue);
}



// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
BOOL
DetectSerialMouse(
                 DWORD dwInitParam
                 )
{
    const DWORD     cBaudRate = 1200;
    const BYTE      cParity   = NOPARITY;   // No parity
    const BYTE      cByteSize = 7; 
    const BYTE      cStopBits = ONESTOPBIT; // 1 stop bit

    BOOL            fRet = FALSE;
    TCHAR           szPort[6];
    ULONG           windowsError;
    DWORD           dwTemp;
    DCB             dcb;
    BOOL            bSuccess;
    DWORD           oldBaudRate;
    BYTE            oldParity;
    BYTE            oldByteSize;
    BYTE            oldStopBits;

    BYTE            serialByte = 0x00;

    FUNC("+DetectSerialMouse");

    wsprintf(szPort, TEXT("COM%d:"), GetCommPort((LPCTSTR)dwInitParam));

    g_hSerial = CreateFile(szPort, GENERIC_READ | GENERIC_WRITE, 0, NULL,
                           OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

    if ( g_hSerial == INVALID_HANDLE_VALUE ) {
        DEBUGMSG(ZONE_ERROR, (TEXT("SerMouse : Failed to open %s. Error %d\r\n"), szPort, GetLastError()));
        g_hSerial = NULL;
        GOTO_EXIT(fRet = FALSE);
    }

    DEBUGMSG(ZONE_INIT, (TEXT("SerMouse : Opened %s.\r\n"), szPort));

    bSuccess = GetCommState(g_hSerial, (LPDCB)&dcb);
    if ( !bSuccess ) {
        DEBUGMSG(ZONE_ERROR, (TEXT("SerMouse : GetCommState error %d\r\n"), GetLastError()));
        CloseHandle(g_hSerial);
        g_hSerial = NULL;
        GOTO_EXIT(fRet = FALSE);
    }

    DEBUGMSG(ZONE_INIT, (TEXT("SerMouse : GetCommState okay.\r\n")));

    oldBaudRate = dcb.BaudRate;
    oldParity = dcb.Parity;
    oldByteSize = dcb.ByteSize;
    oldStopBits = dcb.StopBits;

    dcb.BaudRate = cBaudRate;
    dcb.Parity = cParity;
    dcb.ByteSize = cByteSize;
    dcb.StopBits = cStopBits;

    if ( !SetCommState(g_hSerial, (LPDCB)&dcb) ) {
        DEBUGMSG(ZONE_ERROR, (TEXT("SerMouse : SetCommState error %d\r\n"), GetLastError()));
        CloseHandle(g_hSerial);
        g_hSerial = NULL;
        GOTO_EXIT(fRet = FALSE);
    }

    DEBUGMSG(ZONE_INIT, (TEXT("SerMouse : SetCommState okay.\r\n")));

    DeviceIoControl(g_hSerial, IOCTL_SERIAL_CLR_RTS, NULL, 0, NULL, 0, &dwTemp, NULL);
    DeviceIoControl(g_hSerial, IOCTL_SERIAL_SET_DTR, NULL, 0, NULL, 0, &dwTemp, NULL);
    //Sleep(150);
    Sleep(1000);

    dwTemp = 1;
    while ( dwTemp != 0 ) {
        //
        // Deplete the serial port input queue.
        //
        ReadFile(g_hSerial, &serialByte, 1, &dwTemp, NULL);
    }

    DeviceIoControl(g_hSerial, IOCTL_SERIAL_SET_RTS, NULL, 0, NULL, 0, &dwTemp, NULL);
    //Sleep(10);
    Sleep(800);

    dwTemp = 1;
    while ( dwTemp != 0 ) {
        bSuccess = ReadFile(g_hSerial, &serialByte, 1, &dwTemp, NULL);
        //
        // 7-bit data only.
        //
        serialByte &= 0x7F;

        DEBUGMSG(ZONE_INIT, (TEXT("SerMouse : Init read 0x%02X (%c)\r\n"), serialByte, serialByte));

        if ( !bSuccess ) {
            windowsError = GetLastError();
            DEBUGMSG(ZONE_ERROR, (TEXT("SerMouse : ReadFile error %d\r\n"), windowsError));
            dcb.BaudRate = oldBaudRate;
            dcb.Parity   = oldParity;
            dcb.ByteSize = oldByteSize;
            dcb.StopBits = oldStopBits; 

            SetCommState(g_hSerial, (LPDCB)&dcb);
            CloseHandle(g_hSerial);
            g_hSerial = NULL;
            GOTO_EXIT(fRet = FALSE);
        }
        if ( serialByte == 'M' || serialByte == 'B' ) {
            //
            // We've successfully found that a mouse is attached. We can now
            // return true and be done with it.  We'll leave the phSerial 
            // connected with the baudrate etc set.  Deinit will close the port.
            //
            DEBUGMSG(ZONE_INIT, (TEXT("SerMouse : Found a Serial Mouse.\r\n")));
            //
            // Setup the serial port parameters (timeouts, etc).
            //
            GOTO_EXIT(fRet = InitSerialPort());

        }
    }

    // Didn't find a mouse, so put the serial port back into its old state and
    // disconnect.
    RETAILMSG(1, (TEXT("SerMouse : No mouse found. Returning serial port to original status.\r\n")));
    dcb.BaudRate = oldBaudRate;
    dcb.Parity   = oldParity;
    dcb.ByteSize = oldByteSize;
    dcb.StopBits = oldStopBits; 

    SetCommState(g_hSerial, (LPDCB)&dcb);
    CloseHandle(g_hSerial);
    g_hSerial = NULL;

    fRet = FALSE;

    EXIT:
    FUNC("-DetectSerialMouse");
    return (fRet);
}



// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
BOOL
InitSerialPort()
{
    // DetectSerialMouse connected our g_hSerial handle to the
    // serial driver and set the baudrate etc correctly.  Now we need to
    // set the comm timeouts to something acceptable for the mouse.

    COMMTIMEOUTS ctmo;

    FUNC("+InitSerialPort");

    if ( !GetCommTimeouts(g_hSerial, &ctmo) ) {
        DEBUGMSG(1, (TEXT("GetCommTimeouts error %d\r\n"), GetLastError()));
        return (FALSE);