unit1.cpp

Serial ports. Enumeration and FIFO controls.

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;

#include <setupapi.h>
#include <dbt.h>

#define MAX_NAME_PORTS 7
#define RegDisposition_OpenExisting (0x00000001)   // open key only if exists
#define CM_REGISTRY_HARDWARE        (0x00000000)



typedef DWORD WINAPI
  (* CM_Open_DevNode_Key)(DWORD, DWORD, DWORD, DWORD, ::PHKEY, DWORD);

HKEY GetDeviceKey(LPTSTR portName)
        {
static HINSTANCE CfgMan;        
static CM_Open_DevNode_Key OpenDevNodeKey=NULL;        
int numDev=0;
        int res1;
        BOOL guidTest=FALSE;
        DWORD RequiredSize=0;
        char* buf;
        HDEVINFO DeviceInfoSet;
        SP_DEVINFO_DATA DeviceInfoData={0};
        char DevName[MAX_NAME_PORTS]={0};

        guidTest=SetupDiClassGuidsFromNameA(
        "Ports",0,0,&RequiredSize);
        if(RequiredSize < 1)return (HANDLE)-1;

        buf=(char *)malloc(RequiredSize*sizeof(GUID));

        guidTest=SetupDiClassGuidsFromNameA(
        "Ports",(GUID *)buf,RequiredSize*sizeof(GUID),&RequiredSize);

        if(!guidTest)return (HANDLE)-1;


           DeviceInfoSet=SetupDiGetClassDevs(
             (GUID *)buf,NULL,NULL,DIGCF_PRESENT);
             if(DeviceInfoSet == INVALID_HANDLE_VALUE)return (HANDLE)-1;

           free(buf);

if(!OpenDevNodeKey)
   {
        CfgMan=LoadLibrary("cfgmgr32");
        if(!CfgMan)return (HANDLE)-1;
        OpenDevNodeKey=(CM_Open_DevNode_Key)GetProcAddress(CfgMan,"CM_Open_DevNode_Key");
        if(!OpenDevNodeKey)
               {
                FreeLibrary(CfgMan);
                return (HANDLE)-1;
               }
   }

        DeviceInfoData.cbSize=sizeof(SP_DEVINFO_DATA);

        while(TRUE)
        {
                HKEY KeyDevice;
                DWORD len;
                res1=SetupDiEnumDeviceInfo(
                DeviceInfoSet,numDev,&DeviceInfoData);

                if(!res1)
                {
                SetupDiDestroyDeviceInfoList(DeviceInfoSet);
                FreeLibrary(CfgMan);
                OpenDevNodeKey=NULL;
                return (HANDLE)-1;
                }

                res1=OpenDevNodeKey(DeviceInfoData.DevInst,KEY_QUERY_VALUE | KEY_WRITE,0,
                RegDisposition_OpenExisting,&KeyDevice,CM_REGISTRY_HARDWARE);
                if(res1 != ERROR_SUCCESS)
                {
                SetupDiDestroyDeviceInfoList(DeviceInfoSet);
                FreeLibrary(CfgMan);
                OpenDevNodeKey=NULL;
                return (HANDLE)-1;
                }
                len=MAX_NAME_PORTS;

                res1=RegQueryValueEx(
                        KeyDevice,	// handle of key to query
                        "portname",	// address of name of value to query
                        NULL,	// reserved
                        NULL,	// address of buffer for value type
                        DevName,	// address of data buffer
                        &len 	// address of data buffer size
                        );
                if(res1 != ERROR_SUCCESS)
                       {
                        FreeLibrary(CfgMan);
                        OpenDevNodeKey=NULL;
                        return (HANDLE)-1;
                       }
                if(!stricmp(DevName,portName))
                       {
                        FreeLibrary(CfgMan);
                        OpenDevNodeKey=NULL;
                        return KeyDevice;
                       }
                RegCloseKey(KeyDevice);
                numDev++;
               }

        }


HANDLE  BeginEnumeratePorts(VOID)
{
  BOOL guidTest=FALSE;
  DWORD RequiredSize=0;
  int j;
  HDEVINFO DeviceInfoSet;
  char* buf;

        guidTest=SetupDiClassGuidsFromNameA(
        "Ports",0,0,&RequiredSize);
        if(RequiredSize < 1)return HANDLE(-1);

        buf=(char *)malloc(RequiredSize*sizeof(GUID));

        guidTest=SetupDiClassGuidsFromNameA(
        "Ports",(GUID *)buf,RequiredSize*sizeof(GUID),&RequiredSize);

        if(!guidTest)return HANDLE(-1);


           DeviceInfoSet=SetupDiGetClassDevs(
             (GUID *)buf,NULL,NULL,DIGCF_PRESENT);
             if(DeviceInfoSet == INVALID_HANDLE_VALUE)return (HANDLE)-1;

           free(buf);

return DeviceInfoSet;
}

BOOL EnumeratePortsNext(HANDLE DeviceInfoSet, LPTSTR lpBuffer)
{
static CM_Open_DevNode_Key OpenDevNodeKey=NULL;
static HINSTANCE CfgMan;

int res1;
char DevName[MAX_NAME_PORTS]={0};
static int numDev=0;
int numport;

SP_DEVINFO_DATA DeviceInfoData={0};
DeviceInfoData.cbSize=sizeof(SP_DEVINFO_DATA);


if(!DeviceInfoSet || !lpBuffer)return -1;
if(!OpenDevNodeKey)
   {
        CfgMan=LoadLibrary("cfgmgr32");
        if(!CfgMan)return FALSE;
        OpenDevNodeKey=(CM_Open_DevNode_Key)GetProcAddress(CfgMan,"CM_Open_DevNode_Key");
        if(!OpenDevNodeKey)
               {
                FreeLibrary(CfgMan);
                return FALSE;
               }
   }

while(TRUE)
     {

        HKEY KeyDevice;
        DWORD len;
        res1=SetupDiEnumDeviceInfo(
        DeviceInfoSet,numDev,&DeviceInfoData);

        if(!res1)
          {
          SetupDiDestroyDeviceInfoList(DeviceInfoSet);
          FreeLibrary(CfgMan);
          OpenDevNodeKey=NULL;
          return FALSE;
                }


        res1=OpenDevNodeKey(DeviceInfoData.DevInst,KEY_QUERY_VALUE,0,
            RegDisposition_OpenExisting,&KeyDevice,CM_REGISTRY_HARDWARE);
        if(res1 != ERROR_SUCCESS)return NULL;
        len=MAX_NAME_PORTS;

        res1=RegQueryValueEx(
                KeyDevice,	// handle of key to query
                "portname",	// address of name of value to query
                NULL,	// reserved
                NULL,	// address of buffer for value type
                DevName,	// address of data buffer
                &len 	// address of data buffer size
                );

        RegCloseKey(KeyDevice);
        if(res1 != ERROR_SUCCESS)return NULL;
        numDev++;
        if(memicmp(DevName, "com", 3))continue;
        numport=atoi(DevName+3);
        if(numport > 0)
         {
          strcpy(lpBuffer,DevName);
          return TRUE;
         }

        FreeLibrary(CfgMan);
        OpenDevNodeKey=NULL;
        return FALSE;
   }
}

//---------------------------------------------------------------------------

BOOL  EndEnumeratePorts(HANDLE DeviceInfoSet)
{
if(SetupDiDestroyDeviceInfoList(DeviceInfoSet))return TRUE;
        else return FALSE;
}

bool EnableFIFO(bool SetFIFO)
        {
char Name1[100]={0};
DWORD cbData=100;
if(Form1->keyDevice == NULL)return false;
DWORD result;

DWORD setF;
        if(SetFIFO)setF=1; else setF=0;

         if(Win32Platform == VER_PLATFORM_WIN32_NT)
          {
                  result=RegSetValueEx(
                  Form1->keyDevice,	// handle of key to set value for
                  "ForceFifoEnable",	// address of value to set
                  0,	// reserved
                  REG_DWORD,	// flag for value type
                  (unsigned char*)&setF,	// address of value data
                  sizeof(setF) 	// size of value data
                  );
                  //RegCloseKey(keyDevice);
                  if(result != ERROR_SUCCESS)return false;
                   else return true;
          }

         else
         if(Win32Platform == VER_PLATFORM_WIN32_WINDOWS)
          {
                  DWORD td;
                  RegQueryValueEx(
                  Form1->keyDevice,	// handle of key to query
                  "settings",	// address of name of value to query
                  0,	// reserved
                  &td,	// address of buffer for value type
                  Name1,	// address of data buffer
                  &cbData 	// address of data buffer size
                  );

                  if(SetFIFO)Name1[0] |= 0x02;
                   else Name1[0] &= 0xFD;

                  result=RegSetValueEx(
                  Form1->keyDevice,	// handle of key to set value for
                  "settings",	// address of value to set
                  0,	// reserved
                  td,	// flag for value type
                  Name1,	// address of value data
                  cbData 	// size of value data
                  );
                  //RegCloseKey(keyDevice);

                  if(result != ERROR_SUCCESS)return false;
                   else return true;
          }

         else return false;
        }

//---------------------------------------------------------------------------

int IsFIFOEnable(void)
        {
char Name1[100];
DWORD cbData=100;
if(Form1->keyDevice == NULL)return -1;
DWORD result;

DWORD sFIFO;
DWORD size=4;

         if(Win32Platform == VER_PLATFORM_WIN32_NT)
          {

                  result=RegQueryValueEx(
                  Form1->keyDevice,	// handle of key to query
                  "ForceFifoEnable",	// address of name of value to query
                  NULL,	// reserved
                  NULL,	// address of buffer for value type
                  (unsigned char*)&sFIFO,	// address of data buffer
                  &size 	// address of data buffer size
                  );

                  //RegCloseKey(keyDevice);

                  if(result != ERROR_SUCCESS)return -1;
                   else return sFIFO;
          }
         else
         if(Win32Platform == VER_PLATFORM_WIN32_WINDOWS)
          {
                  DWORD td;
                  result=RegQueryValueEx(
                  Form1->keyDevice,	// handle of key to query
                  "settings",	// address of name of value to query
                  0,	// reserved
                  &td,	// address of buffer for value type
                  Name1,	// address of data buffer
                  &cbData 	// address of data buffer size