windows-server-2003/drivers/serial/mps/comtrol/rocket/setup/nt50.c

/*-----------------------------------------------------------------------
| nt50.c - NT5.0 specific code for VSLinkA/RocketPort Windows Install
  Program.

   This compiles into a DLL library which is installed(via INF) into
   the SYSTEM directory.  The INF file also hooks us into the system
   as a property page associated with the device.  Also, our co-installer
   DLL calls into us as well to perform configuration tasks(initial
   install, un-install).

   The .NumDevices option is used to save the number of Devices in
   our configuration.  Under NT50, we don't use it as such.  This setup
   dll only concerns itself with 1 device, and lets NT5.0 OS handle
   the list of devices.  So NumDevices always gets set to 1 under NT5.0
   even if we have more than one device which our driver is controlling.

11-24-98 - add some code toward clean up of files after uninstall, kpb.

Copyright 1998. Comtrol(TM) Corporation.
|-----------------------------------------------------------------------*/
#include "precomp.h"
#include <msports.h>

#define D_Level 0x40

static int write_config(int clear_it);
static int FindPortNodes(void);
static int read_config(void);
static int get_pnp_devicedesc(TCHAR *name);
static int nt5_get_pnp_dev_id(int *id);
static void uninstall_device(void);

int get_device_name(void);
int do_nt50_install(void);

BOOL WINAPI ClassInsProc(
      int func_num,     // our function to carry out.
      LPVOID our_info);  // points to our data struct

static int get_pnp_setup_info(void);
static int get_device_property(char *ret_name, int max_size);
static int get_pnp_isa_address(void);

static void test_config(void);

// following can be turned on to provide a User Interface during the
// install time of the driver.  Only problem is that NT5.0 fires up
// the driver first, and are ports
//#define TRY_UI 1
#ifdef TRY_UI
int DoCLassPropPages(HWND hwndOwner);
int FillClassPropertySheets(PROPSHEETPAGE *psp, LPARAM our_params);
BOOL WINAPI ClassSheet(
      IN HWND   hDlg,
      IN UINT   uMessage,
      IN WPARAM wParam,
      IN LPARAM lParam);
#endif

//#define DO_SHOWIT
#ifdef DO_SHOWIT
#define ShowMess(s) OutputDebugString(s);
static void show_install_info(OUR_INFO *pi);
static void show_debug_info(OUR_INFO *pi,
                           ULONG dev_id,
                           TCHAR *desc_str);

static int DumpPnpTree(void);
static void show_tree_node(DEVINST devInst,
                           ULONG dev_id,
                           TCHAR *desc_str);
static void show_tree_node_reg(DEVINST devInst,
                               TCHAR *key_name);

static TCHAR *spdrp_names[] = {
TEXT("DEVICEDESC"),
TEXT("HARDWAREID"),
TEXT("COMPATIBLEIDS"),
TEXT("NTDEVICEPATHS"),
TEXT("SERVICE"),
TEXT("CONFIGURATION"),  // x5
TEXT("CONFIGURATIONVECTOR"),
TEXT("CLASS"),
TEXT("CLASSGUID"),
TEXT("DRIVER"),
TEXT("CONFIGFLAGS"),  // xA
TEXT("MFG"),
TEXT("FRIENDLYNAME"),
TEXT("LOCATION_INFORMATION"),
TEXT("PHYSICAL_DEVICE_OBJECT_NAME"),
TEXT("CAPABILITIES"),
TEXT("UI_NUMBER"),  // x10
TEXT("UPPERFILTERS"),
TEXT("LOWERFILTERS"),
TEXT("BUSTYPEGUID"),  // x13
TEXT("LEGACYBUSTYPE"),
TEXT("BUSNUMBER"),
TEXT("invalid")};

static TCHAR *cm_drp_names[] = {
TEXT("DEVICEDESC"), // DeviceDesc REG_SZ property (RW)
TEXT("HARDWAREID"), // HardwareID REG_MULTI_SZ property (RW)
TEXT("COMPATIBLEIDS"), // CompatibleIDs REG_MULTI_SZ property (RW)
TEXT("NTDEVICEPATHS"), // Unsupported, DO NOT USE
TEXT("SERVICE"), // Service REG_SZ property (RW)
TEXT("CONFIGURATION"), // Configuration REG_RESOURCE_LIST property (R)
TEXT("CONFIGURATIONVECTOR"), // ConfigurationVector REG_RESOURCE_REQUIREMENTS_LIST property (R)
TEXT("CLASS"), // Class REG_SZ property (RW)
TEXT("CLASSGUID"), // ClassGUID REG_SZ property (RW)
TEXT("DRIVER"), // Driver REG_SZ property (RW)
TEXT("CONFIGFLAGS"), // ConfigFlags REG_DWORD property (RW)
TEXT("MFG"), // Mfg REG_SZ property (RW)
TEXT("FRIENDLYNAME"), // 0x0d FriendlyName REG_SZ property (RW)
TEXT("LOCATION_INFORMATION"), // LocationInformation REG_SZ property (RW)
TEXT("PHYSICAL_DEVICE_OBJECT_NAME"), // PhysicalDeviceObjectName REG_SZ property (R)
TEXT("CAPABILITIES"), // 0x10 Capabilities REG_DWORD property (R)
TEXT("UI_NUMBER"), // UiNumber REG_DWORD property (R)
TEXT("UPPERFILTERS"), // UpperFilters REG_MULTI_SZ property (RW)
TEXT("LOWERFILTERS"), // LowerFilters REG_MULTI_SZ property (RW)
TEXT("BUSTYPEGUID"), // Bus Type Guid, GUID, (R)
TEXT("LEGACYBUSTYPE"), // Legacy bus type, INTERFACE_TYPE, (R)
TEXT("BUSNUMBER"), // x16 Bus Number, DWORD, (R)
TEXT("invalid")};

// these are under Control\Class\Guid\Node
static TCHAR *dev_node_key_names[] = {
TEXT("ProviderName"),
TEXT("MatchingDeviceId"),
TEXT("DriverDesc"),
TEXT("InfPath"),
TEXT("InfSection"),
TEXT("isa_board_index"),
NULL};

static TCHAR glob_ourstr[4000];
/*----------------------------------------------------------
 show_install_info - show all the driver install info.
|------------------------------------------------------------*/
static void show_install_info(OUR_INFO *pi)
{
 int i;

  //if (MessageBox( GetFocus(), TEXT("Want Info?"), TEXT("aclass"), MB_YESNO | MB_ICONINFORMATION ) ==
  //   IDYES)
  {
    ShowMess(TEXT("**SPDRP****"));
    glob_ourstr[0] = 0;
    for (i=0; i<(SPDRP_MAXIMUM_PROPERTY-1); i++)
    {
      show_debug_info(pi, i, spdrp_names[i]);
    }
    ShowMess(glob_ourstr);
    //MessageBox( GetFocus(), glob_ourstr, TEXT("aclass"), MB_OK | MB_ICONINFORMATION );
  }
}

/*----------------------------------------------------------
 show_debug_info -
|------------------------------------------------------------*/
static void show_debug_info(OUR_INFO *pi,
                           ULONG dev_id,
                           TCHAR *desc_str)
{
 static TCHAR tmpstr[500];
 static TCHAR showstr[500];
 TCHAR smstr[40];
 ULONG RegType;
 ULONG ReqSize,i;
 unsigned char *b_ptr;
 int stat;

  showstr[0] = 0;

  RegType = 0;
  ReqSize = 0;
  stat = SetupDiGetDeviceRegistryProperty(pi->DeviceInfoSet,
                                   pi->DeviceInfoData,
                                   dev_id,
                                   &RegType,  // reg data type
                                   (PBYTE)tmpstr,
                                   sizeof(tmpstr),
                                   &ReqSize);  // size thing

  if (stat == FALSE)
  {
    stat = GetLastError();
    if (stat == 13)
    {
      return;  // don't display this
    }
    wsprintf(showstr, TEXT("Error:%d[%xH] ReqSize:%d"), stat, stat, ReqSize);
  }
  else if (RegType == REG_SZ)
  {
    wsprintf(showstr, TEXT("SZ:%s"), tmpstr);
  }
  else if (RegType == REG_DWORD)
  {
    wsprintf(showstr, TEXT("Dword:%xH"), *((ULONG *) tmpstr));
  }
  else if (RegType == REG_EXPAND_SZ)
  {
    wsprintf(showstr, TEXT("EXP_SZ:%s"), tmpstr);
  }
  else if (RegType == REG_MULTI_SZ)
  {
    wsprintf(showstr, TEXT("MULTI_SZ:%s"), tmpstr);
  }
  else if (RegType == REG_BINARY)
  {
    lstrcpy(showstr, TEXT("BIN:"));
    b_ptr = (unsigned char *)tmpstr;
    for (i=0; i<ReqSize; i++)
    {
      if ((b_ptr[i] >= 0x20) && (b_ptr[i] < 0x80))
        wsprintf(smstr, TEXT("%c"), b_ptr[i]);
      else
        wsprintf(smstr, TEXT("<%x>"), b_ptr[i]);
      lstrcat(showstr, smstr);
      if (i > 200) break;
    }
  }
  else
  {
    wsprintf(showstr, TEXT("BadType:%xH"), RegType);
  }
  if (lstrlen(showstr) > 200)
    showstr[200] = 0;

  if (lstrlen(glob_ourstr) < 3700)
  {
    lstrcat(glob_ourstr, desc_str);
    lstrcat(glob_ourstr, TEXT(" - "));
    lstrcat(glob_ourstr, showstr);
    lstrcat(glob_ourstr, TEXT("\n"));
  }
}

/*-----------------------------------------------------------------------------
| DumpPnpTree - Dump the pnp tree devnodes.
|-----------------------------------------------------------------------------*/
static int DumpPnpTree(void)
{
  DEVINST     devInst;
  DEVINST     devInstNext;
  CONFIGRET   cr;
  ULONG       walkDone = 0;
  ULONG       len;
  static CHAR buf[800];
  HKEY hKey;
  int  di,pi;
  ULONG val_type;

#if DBG
  //DebugBreak();
#endif

  //cr = CM_Locate_DevNode(&devInst, NULL, 0);

  // Get Root DevNode
  //
  cr = CM_Locate_DevNode(&devInst, NULL, 0);

  if (cr != CR_SUCCESS)
  {
    return 1;  // err
  }

  // Do a depth first search for the DevNode with a matching parameter
  while (!walkDone)
  {
    cr = CR_SUCCESS;
    glob_ourstr[0] = 0;
    lstrcat(glob_ourstr,TEXT("-CM_DRP-----"));
    for (di=CM_DRP_MIN; di<CM_DRP_MAX; di++)
    {
      show_tree_node(devInst, di, cm_drp_names[di-CM_DRP_MIN]);
    }

    lstrcat(glob_ourstr,TEXT("-KEYS--"));
    di = 0;
    while (dev_node_key_names[di] != NULL)
    {
      show_tree_node_reg(devInst, dev_node_key_names[di]);
      ++di;
    }
    ShowMess(glob_ourstr);

#if 0
    // Get the DriverName value
    //
    buf[0] = 0;
    len = sizeof(buf);
    cr = CM_Get_DevNode_Registry_Property(devInst,
              CM_DRP_CLASS, NULL, buf, &len, 0);
    if (cr == CR_SUCCESS && strcmp("Ports", buf) == 0)
    {
      //P_TRACE("Ports");
      // grab the "MatchingDeviceId"
      cr = CM_Open_DevNode_Key(
           devInst,
           KEY_READ,    // IN  REGSAM         samDesired,
           0,           // IN  ULONG          ulHardwareProfile,
           RegDisposition_OpenExisting,
           &hKey,       //OUT PHKEY          phkDevice,
           CM_REGISTRY_SOFTWARE); // IN  ULONG          ulFlags

      if (cr == CR_SUCCESS)
      {
        buf[0] = 0;
        len = sizeof(buf);
        cr = RegQueryValueEx(hKey,
                    TEXT("MatchingDeviceId"),
                    0,
                    &val_type,
                    (PBYTE) buf,
                    &len);
        if (cr != ERROR_SUCCESS)
        {
          buf[0] = 0;
        }

        RegCloseKey(hKey);
      }  // if openreg
    } // if "Ports"
#endif

    // This DevNode didn't match, go down a level to the first child.
    //
    cr = CM_Get_Child(&devInstNext,
                      devInst,
                      0);

    if (cr == CR_SUCCESS)
    {
        devInst = devInstNext;
        continue;
    }

    // Can't go down any further, go across to the next sibling.  If
    // there are no more siblings, go back up until there is a sibling.
    // If we can't go up any further, we're back at the root and we're
    // done.
    //
    for (;;)
    {
      cr = CM_Get_Sibling(&devInstNext,
                          devInst,
                          0);
      
      if (cr == CR_SUCCESS)
      {
          devInst = devInstNext;
          break;
      }

      cr = CM_Get_Parent(&devInstNext,
                         devInst,
                         0);

      if (cr == CR_SUCCESS)
      {
          devInst = devInstNext;
      }
      else
      {
          walkDone = 1;
          break;
      }
    } // for (;;)
  } // while (!walkDone)

  return 2;  // done;
}

/*----------------------------------------------------------
 show_tree_node -
|------------------------------------------------------------*/
static void show_tree_node(DEVINST devInst,
                           ULONG dev_id,
                           TCHAR *desc_str)
{
 CONFIGRET   cr;
 static TCHAR tmpstr[500];
 static TCHAR showstr[500];
 TCHAR smstr[40];
 ULONG RegType;
 ULONG ReqSize,i;
 unsigned char *b_ptr;
 int stat;

  showstr[0] = 0;

  RegType = 0;
  ReqSize = 0;
  cr = CM_Get_DevNode_Registry_Property(devInst,
            dev_id, &RegType, tmpstr, &ReqSize, 0);

  if (cr != CR_SUCCESS)
  {
    stat = GetLastError();
    if (stat == 997)
    {
      return;  // don't display this
    }
    wsprintf(showstr, TEXT("Error:%d[%xH] ReqSize:%d"), stat, stat, ReqSize);
    //MessageBox( GetFocus(), showstr, desc_str, MB_OK | MB_ICONINFORMATION );
  }
  else if (RegType == REG_SZ)
  {
    wsprintf(showstr, TEXT("SZ:%s"), tmpstr);
    //MessageBox( GetFocus(), showstr, desc_str, MB_OK | MB_ICONINFORMATION );
  }
  else if (RegType == REG_DWORD)
  {
    wsprintf(showstr, TEXT("Dword:%xH"), *((ULONG *) tmpstr));
    //MessageBox( GetFocus(), showstr, desc_str, MB_OK | MB_ICONINFORMATION );
  }
  else if (RegType == REG_EXPAND_SZ)
  {
    wsprintf(showstr, TEXT("EXP_SZ:%s"), tmpstr);
    //MessageBox( GetFocus(), showstr, desc_str, MB_OK | MB_ICONINFORMATION );
  }
  else if (RegType == REG_MULTI_SZ)
  {
    wsprintf(showstr, TEXT("MULTI_SZ:%s"), tmpstr);
    //MessageBox( GetFocus(), showstr, desc_str, MB_OK | MB_ICONINFORMATION );
  }
  else if (RegType == REG_BINARY)
  {
    lstrcpy(showstr, TEXT("BIN:"));
    b_ptr = (unsigned char *)tmpstr;
    for (i=0; i<ReqSize; i++)
    {
      if ((b_ptr[i] >= 0x20) && (b_ptr[i] < 0x80))
        wsprintf(smstr, TEXT("%c"), b_ptr[i]);
      else
        wsprintf(smstr, TEXT("<%x>"), b_ptr[i]);
      lstrcat(showstr, smstr);
      if (i > 200) break;
    }
    //MessageBox( GetFocus(), showstr, desc_str, MB_OK | MB_ICONINFORMATION );
  }
  else
  {
    wsprintf(showstr, TEXT("BadType:%xH"), RegType);
    //MessageBox( GetFocus(), tmpstr, desc_str, MB_OK | MB_ICONINFORMATION );
  }
  if (lstrlen(showstr) > 200)
    showstr[200] = 0;

  if (lstrlen(glob_ourstr) < 3700)
  {
    lstrcat(glob_ourstr, desc_str);
    lstrcat(glob_ourstr, TEXT(" - "));
    lstrcat(glob_ourstr, showstr);
    lstrcat(glob_ourstr, TEXT("\n"));
  }
}

/*----------------------------------------------------------
 show_tree_node_reg -
|------------------------------------------------------------*/
static void show_tree_node_reg(DEVINST devInst,
                               TCHAR *key_name)
{
 CONFIGRET   cr;
 static TCHAR tmpstr[500];
 static TCHAR showstr[500];
 TCHAR smstr[40];
 ULONG RegType;
 ULONG ReqSize,i;
 unsigned char *b_ptr;
 int stat;
 TCHAR *desc_str = key_name;
 HKEY hKey;

  showstr[0] = 0;

  cr = CM_Open_DevNode_Key(
       devInst,
       KEY_READ,    // IN  REGSAM         samDesired,
       0,           // IN  ULONG          ulHardwareProfile,
       RegDisposition_OpenExisting,
       &hKey,       //OUT PHKEY          phkDevice,
       CM_REGISTRY_SOFTWARE); // IN  ULONG          ulFlags

  if (cr == CR_SUCCESS)
  {
    RegType = 0;
    ReqSize = 0;

    tmpstr[0] = 0;
    ReqSize = sizeof(tmpstr);
    cr = RegQueryValueEx(hKey,
                key_name,
                0,
                &RegType,
                (PBYTE) tmpstr,
                &ReqSize);
    if (cr != ERROR_SUCCESS)
    {
      tmpstr[0] = 0;
    }

    RegCloseKey(hKey);
  }  // if openreg
  else
  {
    tmpstr[0] = 0;
    ShowMess(TEXT("**Error Opening Key!\n"));
  }

  if (cr != CR_SUCCESS)
  {
    stat = GetLastError();
    //if (stat == 997)
    //{
    //  return;  // don't display this
    //}
    wsprintf(showstr, TEXT("Error:%d[%xH] ReqSize:%d"), stat, stat, ReqSize);
    //MessageBox( GetFocus(), showstr, desc_str, MB_OK | MB_ICONINFORMATION );
  }
  else if (RegType == REG_SZ)
  {
    wsprintf(showstr, TEXT("SZ:%s"), tmpstr);
    //MessageBox( GetFocus(), showstr, desc_str, MB_OK | MB_ICONINFORMATION );
  }
  else if (RegType == REG_DWORD)
  {
    wsprintf(showstr, TEXT("Dword:%xH"), *((ULONG *) tmpstr));
    //MessageBox( GetFocus(), showstr, desc_str, MB_OK | MB_ICONINFORMATION );
  }
  else if (RegType == REG_EXPAND_SZ)
  {
    wsprintf(showstr, TEXT("EXP_SZ:%s"), tmpstr);
    //MessageBox( GetFocus(), showstr, desc_str, MB_OK | MB_ICONINFORMATION );
  }
  else if (RegType == REG_MULTI_SZ)
  {
    wsprintf(showstr, TEXT("MULTI_SZ:%s"), tmpstr);
    //MessageBox( GetFocus(), showstr, desc_str, MB_OK | MB_ICONINFORMATION );
  }
  else if (RegType == REG_BINARY)
  {
    lstrcpy(showstr, TEXT("BIN:"));
    b_ptr = (unsigned char *)tmpstr;
    for (i=0; i<ReqSize; i++)
    {
      if ((b_ptr[i] >= 0x20) && (b_ptr[i] < 0x80))
        wsprintf(smstr, TEXT("%c"), b_ptr[i]);
      else
        wsprintf(smstr, TEXT("<%x>"), b_ptr[i]);
      lstrcat(showstr, smstr);
      if (i > 200) break;
    }
    //MessageBox( GetFocus(), showstr, desc_str, MB_OK | MB_ICONINFORMATION );
  }
  else
  {
    wsprintf(showstr, TEXT("BadType:%xH"), RegType);
    //MessageBox( GetFocus(), tmpstr, desc_str, MB_OK | MB_ICONINFORMATION );
  }
  if (lstrlen(showstr) > 200)
    showstr[200] = 0;

  if (lstrlen(glob_ourstr) < 3700)
  {
    lstrcat(glob_ourstr, desc_str);
    lstrcat(glob_ourstr, TEXT(" - "));
    lstrcat(glob_ourstr, showstr);
    lstrcat(glob_ourstr, TEXT("\n"));
  }
}

#endif

// we are a DLL, so we need a LibMain...
/*----------------------------------------------------------
 LibMain -
|-------------------------------------------------------------*/
BOOL APIENTRY LibMain( HANDLE hDll, DWORD dwReason, LPVOID lpReserved )
{
    //DMess("LibMain");

    switch( dwReason )
    {
    case DLL_PROCESS_ATTACH:
        glob_hinst = hDll;
        DisableThreadLibraryCalls((struct HINSTANCE__ *) hDll);
        break;

    case DLL_PROCESS_DETACH:
        break;

    case DLL_THREAD_DETACH:
        break;

    case DLL_THREAD_ATTACH:
    default:
        break;
    }
    return TRUE;
}


/*----------------------------------------------------------
 DevicePropPage - DLL Entry Point from NT5.0 PnP manager to
   add property sheets.  Not the entry point for NT4.0,
   see nt40.c code WinMain().

    Exported Entry-point for adding additional device manager
    property
    sheet pages.  Registry specifies this routine under
    Control\Class\PortNode::EnumPropPage32="vssetup.dll,DevicePropPage"
    entry.  This entry-point gets called only when the Device
    Manager asks for additional property pages.

Arguments:
      LPVOID pinfo - points to PROPSHEETPAGE_REQUEST, see setupapi.h
      LPFNADDPROPSHEETPAGE pfnAdd - function ptr to call to add sheet.
      LPARAM lParam  - add sheet functions private data handle.

Return Value:
    TRUE on success
    FALSE if pages could not be added
|------------------------------------------------------------*/
BOOL WINAPI DevicePropPage(
      LPVOID pinfo,   // points to PROPSHEETPAGE_REQUEST, see setupapi.h
      LPFNADDPROPSHEETPAGE pfnAdd, // add sheet function
      LPARAM lParam)  // add sheet function data handle?
{
 PSP_PROPSHEETPAGE_REQUEST ppr = (PSP_PROPSHEETPAGE_REQUEST) pinfo;
 PROPSHEETPAGE   psp[NUM_DRIVER_SHEETS];
 HPROPSHEETPAGE  hpage[NUM_DRIVER_SHEETS];
 OUR_INFO *pi;
 int i;
 int stat;

  setup_init();  // build our main structs

  pi = glob_info;  // temporary kludge, unless we don't need re-entrantancy

    // copy the important port handles
  pi->DeviceInfoSet = ppr->DeviceInfoSet;
  pi->DeviceInfoData = ppr->DeviceInfoData;

#ifdef DO_SHOWIT
  if (MessageBox( GetFocus(), TEXT("Want Info?"), TEXT("aclass"), MB_YESNO | MB_ICONINFORMATION ) ==
     IDYES)
  {
    show_install_info(pi);
    DumpPnpTree();
  }
#endif

  //glob_hwnd = hDlg;

  wi->NumDevices = 0;

  // get the name that NT associates with this device, so we can
  // store and retrieve config information based on this also.

  stat = get_device_name();
  if (stat)
  {
    // something is seriously wrong if we can't get our device
    // name.  This is something NT uses as a name.
    DbgPrintf(D_Error, (TEXT("err5f\n")));
  }

  wi->NumDevices = 1;  // for pnp, devices are independent
  get_pnp_setup_info();  // read in pnp info
  get_pnp_devicedesc(wi->dev[0].Name);  // read in pnp description

  get_nt_config(wi);  // get configured vslink device settings.
  if (wi->dev[0].ModelName[0] == 0)
  {
#ifdef S_RK
    if ((wi->dev[0].HardwareId == PCI_DEVICE_RPLUS2) ||
        (wi->dev[0].HardwareId == PCI_DEVICE_422RPLUS2) ||
        (wi->dev[0].HardwareId == PCI_DEVICE_RPLUS4) ||
        (wi->dev[0].HardwareId == PCI_DEVICE_RPLUS8))
    {
      strcpy(wi->dev[0].ModelName, szRocketPortPlus);
    }
    else if ((wi->dev[0].HardwareId == ISA_DEVICE_RMODEM4) ||
             (wi->dev[0].HardwareId == ISA_DEVICE_RMODEM8) ||
             (wi->dev[0].HardwareId == PCI_DEVICE_RMODEM6) ||
             (wi->dev[0].HardwareId == PCI_DEVICE_RMODEM4))
    {
      strcpy(wi->dev[0].ModelName, szRocketModem);
    }
    else
    {
      strcpy(wi->dev[0].ModelName, szRocketPort);
    }
    //szRocketPort485
#endif

#ifdef S_VS
    if (wi->dev[0].HardwareId == NET_DEVICE_VS2000)
    {
      strcpy(wi->dev[0].ModelName, szVS2000);
    }
    else if ((wi->dev[0].HardwareId == NET_DEVICE_RHUB8) ||
        (wi->dev[0].HardwareId == NET_DEVICE_RHUB4))
    {
      strcpy(wi->dev[0].ModelName, szSerialHub);
    }
    else // if (wi->dev[0].HardwareId == NET_DEVICE_VS1000)
    {
      strcpy(wi->dev[0].ModelName, szVS1000);
    }
#endif

  }
  validate_config(1);

  //test_config();

  // if 0 dev-nodes setup, add 1 for the user.
  if (wi->NumDevices == 0)
  {
    ++wi->NumDevices;
    validate_device(&wi->dev[0], 1);
  }

  copy_setup_init();  // make a copy of config data for change detection

  FillDriverPropertySheets(&psp[0], (LPARAM)pi);

  // allocate our "Setting" sheet
  for (i=0; i<NUM_DRIVER_SHEETS; i++)
  {
    hpage[i] = CreatePropertySheetPage(&psp[i]);
    if (!hpage[i])
    {
      DbgPrintf(D_Error,(TEXT("err1a\n")));
      return FALSE;
    }

    // add the thing in.
    if (!pfnAdd(hpage[i], lParam))
    {
      DbgPrintf(D_Error,(TEXT("err1b\n")));
      DestroyPropertySheetPage(hpage[i]);  // error, dump it
      return FALSE;
    }
  }
 return TRUE;
}

/*------------------------------------------------------------------------
| ClassInsProc - Class Install entry for NT5.0 setup of driver.
    The co-class installer file(ctmasetp.dll,..) gets called at inital
    setup time, and calls us to bring up an initial user interface,
    or to handle other items.
|------------------------------------------------------------------------*/
BOOL WINAPI ClassInsProc(
      int func_num,     // our function to carry out.
      LPVOID our_info)  // points to our data struct
{
  int stat;
  //TCHAR tmpstr[200];
  typedef struct {
    ULONG size;
    HDEVINFO         DeviceInfoSet;  // a plug & play context handle
    PSP_DEVINFO_DATA DeviceInfoData; // a plug & play context handle
  } CLASS_OUR_INFO;
  CLASS_OUR_INFO *ci;
  OUR_INFO *pi;
  int i;

  switch (func_num)
  {
    case 0x40:  // RocketPort Class Install time.
    case 0x41:  // RocketPort Class Install time, quite install
    case 0x80:  // VS Class Install time.
    case 0x81:  // VS Class Install time, quite install
#if 0
    // don't pop up user interface on install, just use defaults
    // as best we can for now.

      ci = (CLASS_OUR_INFO *) our_info;
      setup_init();  // build our main structs

      pi = glob_info;  // temporary kludge, unless we don't need re-entrantancy

      // copy the important port handles
      pi->DeviceInfoSet = ci->DeviceInfoSet;
      pi->DeviceInfoData = ci->DeviceInfoData;

      //glob_hwnd = hDlg;
      wi->NumDevices = 1;

      // get the name that NT associates with this device, so we can
      // store and retrieve config information based on this also.
      stat = get_device_name();
      {
        get_pnp_setup_info();
        get_nt_config(wi);  // get configured vslink device settings.
        //validate_config();
      }
      if (stat)
      {
        // something is seriously wrong if we can't get our device
        // name.  This is something NT uses as a name.
        DbgPrintf(D_Error,(TEXT("err5f\n")));
      }

      // if 0 dev-nodes setup, add 1 for the user.
      if (wi->NumDevices == 0)
      {
        ++wi->NumDevices;
        validate_device(&wi->dev[0], 1);
      }

      copy_setup_init();  // make a copy of config data for change detection

      validate_config(1);  // make sure port names are setup

      if ((func_num & 1) == 0) // normal
      {
        DoDriverPropPages(GetFocus());  // in nt40.c
        // force it to save things off(probably should disable
        // cancel button, instead of this kludge).
        do_nt50_install();
      }
      else  // quite
      {
        wi->ip.prompting_off = 1;  // turn our_message() prompting off.
        do_nt50_install();
      }
#endif
    break;

    case 0x42:  // UnInstall RocketPort Device time.
    case 0x82:  // UnInstall VS Device time.
      DbgPrintf(D_Test, (TEXT("uninstall time\n")));

      ci = (CLASS_OUR_INFO *) our_info;
      setup_init();  // build our main structs

      pi = glob_info;  // temporary kludge, unless we don't need re-entrantancy
      // copy the important port handles
      pi->DeviceInfoSet = ci->DeviceInfoSet;
      pi->DeviceInfoData = ci->DeviceInfoData;
      wi->NumDevices = 1;

      // get the name that NT associates with this device, so we can
      // store and retrieve config information based on this also.
      stat = get_device_name();
      if (stat == 0)
      {
        get_pnp_setup_info();
        //get_nt_config(wi);  // get configured vslink device settings.
        //validate_config();
        uninstall_device();
      }
    break;

    default:
      return 1;  // error, bad func_num
    break;
  }  // switch

  return 0;
}

/*-----------------------------------------------------------------------------
| get_pnp_setup_info - 
|-----------------------------------------------------------------------------*/
static int get_pnp_setup_info(void)
{
 static TCHAR tmpstr[600];
 TCHAR *ptr;
 int stat;
 int Hardware_ID = 0;

  // grab the board type information.  Tells us what type of
  // board we have
  stat = get_device_property(tmpstr, 580);
  if (stat != 0)
    return 1;
  DbgPrintf(D_Level, (TEXT("dev_prop:%s\n"), tmpstr) );

  // Find out what the PnP manager thinks my NT Hardware ID is
  // "CtmPort0000" for RocketPort port,
  // "CtmVPort0000" for VS port,
  // "CtmRK1002" for isa-board rocketport,
  // "CtmRM1002" for isa-board rocketmodem,
  // "CtmVS1003" for VS1000
  // for pci we are getting a multi-wstring, 400 bytes long with
  //  "PCI\VEN_11FE&DEV_0003&SUBSYS00000...",0,"PCI\VEN.."

  stat = HdwIDStrToID(&Hardware_ID, tmpstr);
  if (stat)
  {
    DbgPrintf(D_Error, (TEXT("Err, Unknown pnpid:%s\n"), tmpstr))
  }

  stat = id_to_num_ports(Hardware_ID);

  if ((Hardware_ID & 0xfff) == 0)  // marked as pci
    wi->dev[0].IoAddress = 1;  // indicate to setup prog it is a PCI board

  if (Hardware_ID & 0x1000)  // marked as isa
    get_pnp_isa_address();

  // correct number of ports setting if it doesn't match
  //if (wi->dev[0].NumPorts != stat)
  //{
  //  DbgPrintf(D_Level, (TEXT("Correct NumPorts!\n")));
    wi->dev[0].NumPorts = stat;
  //}

  wi->dev[0].HardwareId = Hardware_ID;

  // check for HubDevice, ModemDevice, etc.
  if (IsHubDevice(Hardware_ID))
    wi->dev[0].HubDevice = 1;

  if (IsModemDevice(Hardware_ID))
    wi->dev[0].ModemDevice = 1;

  DbgPrintf(D_Level, (TEXT("Num Ports:%d\n"),stat));

  return 0;
}

/*-----------------------------------------------------------------------------
| get_device_property - return "rckt1003", or whatever, see INF file for
   selections.  For PCI this returns a long multi-sz string.
|-----------------------------------------------------------------------------*/
static int get_device_property(char *ret_name, int max_size)
{
  int stat, i,j;
  ULONG RegType;
  ULONG ReqSize;

  ret_name[0] = 0;
  stat = SetupDiGetDeviceRegistryProperty(glob_info->DeviceInfoSet,
                                 glob_info->DeviceInfoData,
                                 SPDRP_HARDWAREID,
                                 &RegType,  // reg data type
                                 (PBYTE)ret_name,
                                 max_size,
                                 &ReqSize);  // size thing
  if (stat == FALSE)
  {
    return 1;  // err
  }
  if ((RegType != REG_MULTI_SZ) && (RegType != REG_SZ))
  {
    return 2;  // err
    // error
  }

  return 0;  // ok
}

/*-----------------------------------------------------------------------------
| our_nt50_exit - return 1 if not allowing to exit.  return 0 if ok to exit.
|-----------------------------------------------------------------------------*/
int our_nt50_exit(void)
{
 int stat;

 OUR_INFO *pi;
 DWORD  DataSize;
 DWORD DataType;
 DWORD dstat;
 DWORD Val;
 HKEY   hkey;

  pi = glob_info;  // temporary kludge, unless we don't need re-entrantancy
  {
    stat = do_nt50_install();

    if (wi->NeedReset)
      our_message(&wi->ip,RcStr((MSGSTR+4)), MB_OK);

    write_config(1);  // clear out msports claims
    write_config(0);  // reclaim any new changed port names
  }
  return 0; 
}

/*-----------------------------------------------------------------------------
| get_device_name - return name in wi->ip.szNt50DevObjName[], ret 0 on success.
   Pnp puts config data into a registry node associated with the device.
   We put a lot of our config information into a related registry node.
   This related node is derived by and index saved and read from the pnp-node.
   So the first device added we assign a index of 0, and get a derived name
   of "Device0".  The 2nd device we add to the system sees the first, and
   saves an index value of 1, to get a associated device name of "Device1".

   The driver actually writes these index values out to the registry, not
   the setup program.   This is because the driver fires up before setup
   has a chance to run.
|-----------------------------------------------------------------------------*/
int get_device_name(void)
{
  int i;
  int stat;

  i = 0;
  stat = nt5_get_pnp_dev_id(&i);
  if (stat)
  {
    DbgPrintf(D_Test,(TEXT("failed to get pnp id\n")))
  }
  wsprintf(wi->ip.szNt50DevObjName, "Device%d", i);

  DbgPrintf(D_Test,(TEXT("pnp idstr:%s\n"), wi->ip.szNt50DevObjName))

  return 0;  // ok
}

/*-----------------------------------------------------------------------------
| nt5_get_pnp_dev_id - Get pnp device ID.  Pnp can have devices come and go
   dynamically, so a simple list of devices does not work. This is because
   we are no longer in charge of the master list.  We just get called
   from ths OS, which handles half of the installation.  This approximates
   a simple list of devices by reading a unique "Device#" number which the
   driver creates and stores in the software key:
   Driver:
     Upon startup, reads Pnp_Software_Reg_Area\CtmNodeID
     if (not exist)
     {
       derive unique device id number by enumerating
         Service\Rocketport\Parameters\"Device#" key entries.
       Add this key entry and also save number off as CtmNodeID.
     }
     Read in its device configuration from 
         Service\Rocketport\Parameters\"Device#" key.
   Setup Config Program:
     Upon startup, reads Pnp_Software_Reg_Area\CtmNodeID
     for its "Device#" to use in reading reg config area:
         Service\Rocketport\Parameters\"Device#" key entries.

Note on pnp registr areas:

  Hardware key is something like:
    HKLM\CurrentControlSet\Enum\Root\MultiPortSerial\0000   ; ISA or net device
    or 
    HKLM\CurrentControlSet\Enum\VEN_11FE&DEV......\0000   ; PCI device
    or (vs driver bus enumerated port entry):
    HKLM\CurrentControlSet\Enum\CtmvPort\RDevice\10&Port000 ; enumerated port

  Software key is something like:
    HKLM\CurrentControlSet\Control\Class\{50906CB8-....}\0000   ; MPS
    or for a port:
    HKLM\CurrentControlSet\Control\Class\{4D36E978-....}\0000   ; PORTS

  The hardware key is a reg. tree structure which reflects the hardware
  configuration.  The software key is more of a flat reg. structure
  which reflects the devices in the system.  Software area uses GUID
  names to catagorize and name types of hardware.

  The Hardware keys are hidden by default in the NT5 registry.
  Use a tool called PNPREG.EXE /U to Unlock this area, then regedit
  will see beyond enum.  PNPREG /L will lock(hide) it.

  The hardware key contains a link to the software key.
|-----------------------------------------------------------------------------*/
static int nt5_get_pnp_dev_id(int *id)
{
 HKEY hkey;
 int stat;
 DWORD id_dword;

  stat = nt5_open_dev_key(&hkey);
  if (stat)
  {
    *id = 0;
    return 1;
  }
  stat = reg_get_dword(hkey, "", "CtmNodeId", &id_dword);
  reg_close_key(hkey);
  if (stat)
  {
    // it should have been there, the driver should set this up to
    // a unique index value.  But if not, we use 0.
    *id = 0;
    return 2;
  }
  // return the unique index value which is used to derive the
  // registry configuration area "Device#".
  *id = (int) id_dword;

  return 0;
}

/*-----------------------------------------------------------------------------
| nt5_open_dev_key -
|-----------------------------------------------------------------------------*/
int nt5_open_dev_key(HKEY *hkey)
{
  CONFIGRET   cr;

  cr = CM_Open_DevNode_Key(
           glob_info->DeviceInfoData->DevInst,
           KEY_ALL_ACCESS,
           0,           
           RegDisposition_OpenExisting,
           hkey,       
           CM_REGISTRY_SOFTWARE); // _SOFTWARE worked!(under CLASS)
           //CM_REGISTRY_HARDWARE); // _HARDWARE no open!
           //CM_REGISTRY_CONFIG); // _CONFIG wrote under HardwareConfig

  if (cr != CR_SUCCESS)
  {
    DbgPrintf(D_Error,(TEXT("nt50 pnp reg open fail:%d\n"), GetLastError()));
    *hkey = NULL;
    return 1;
  }
  return 0;
}

#if DBG
/*-----------------------------------------------------------------------------
| read_config - Save the config for the device  Just a test.
|-----------------------------------------------------------------------------*/
static int read_config(void)
{
int stat;

 DWORD  DataSize;
 DWORD DataType;
 DWORD Err;
 DWORD Val;
 HKEY   hkey;
  DEVINST     devInst;
  CONFIGRET   cr;


static char *szNumPorts = {"NumPorts"};
static char *szTestVal = {"TestVal"};
  stat = 0;

  DbgPrintf(D_Test,(TEXT("read config\n")));
  if((hkey = SetupDiOpenDevRegKey(glob_info->DeviceInfoSet,
                                  glob_info->DeviceInfoData,
                                  DICS_FLAG_GLOBAL,
                                  0,
                                  DIREG_DEV,
                                  //DIREG_DRV,
                                  KEY_READ)) == INVALID_HANDLE_VALUE) {
      DbgPrintf(D_Error,(TEXT("DI open fail:%xH\n"), GetLastError()));
      stat = 1;
  }
  if (stat == 0)
  {
    DataSize = sizeof(DWORD);   // max size of return str
    Err = RegQueryValueEx(hkey, szNumPorts, NULL, &DataType,
                        (BYTE *) &Val, &DataSize);
    if (Err != ERROR_SUCCESS)
    {
        DbgPrintf(D_Error,(TEXT("OpenDevReg fail\n")));
        Val = 0;
    }
    DbgPrintf(D_Test,(TEXT("NumPorts=%d\n"), Val));
    RegCloseKey(hkey);
  }

  DbgPrintf(D_Test,(TEXT("write config\n")));
  stat = 0;
  if((hkey = SetupDiOpenDevRegKey(glob_info->DeviceInfoSet,
                                  glob_info->DeviceInfoData,
                                  DICS_FLAG_GLOBAL,
                                  0,
                                  DIREG_DEV,
                                  //DIREG_DRV,
                                  //KEY_ALL_ACCESS)) == INVALID_HANDLE_VALUE) {
                                  KEY_WRITE)) == INVALID_HANDLE_VALUE) {
      DbgPrintf(D_Error,(TEXT("DI write open fail:%xH\n"), GetLastError()));
      stat = 1;
  }
  if (stat == 0)
  {
    stat = reg_set_dword(hkey, "", szTestVal, 0x1234);
    if (stat)
    {
      DbgPrintf(D_Error,(TEXT("write val fail\n")));
    }
    RegCloseKey(hkey);
  }

  devInst = glob_info->DeviceInfoData->DevInst;
  if (devInst == 0)
  {
    DbgPrintf(D_Error,(TEXT("err6g\n")));
    return 1;  // err
  }

  cr = CM_Open_DevNode_Key(
           devInst,
           KEY_READ,    // IN  REGSAM         samDesired,
           0,           // IN  ULONG          ulHardwareProfile,
           RegDisposition_OpenExisting,
           &hkey,       //OUT PHKEY          phkDevice,
           //CM_REGISTRY_SOFTWARE); // _SOFTWARE worked!(under CLASS)
           CM_REGISTRY_HARDWARE); // _HARDWARE no open!
           //CM_REGISTRY_CONFIG); // _CONFIG wrote under HardwareConfig

  if (cr == CR_SUCCESS)
  {
    DataSize = sizeof(DWORD);   // max size of return str
    Err = RegQueryValueEx(hkey, szNumPorts, NULL, &DataType,
                        (BYTE *) &Val, &DataSize);
    if (Err != ERROR_SUCCESS)
    {
        DbgPrintf(D_Error,(TEXT("Reg query fail\n")));
        Val = 0;
    }
    DbgPrintf(D_Test,(TEXT("cr NumPorts=%d\n"), Val));
    RegCloseKey(hkey);
  }
  else
  {
    DbgPrintf(D_Error,(TEXT("CM open fail:%d\n"), GetLastError()));
  }

  cr = CM_Open_DevNode_Key(
           devInst,
           //KEY_ALL_ACCESS,
           KEY_WRITE,
           0,           
           RegDisposition_OpenExisting,
           &hkey,       
           //CM_REGISTRY_SOFTWARE); // _SOFTWARE worked!(under CLASS)
           CM_REGISTRY_HARDWARE); // _HARDWARE no open!
           //CM_REGISTRY_CONFIG); // _CONFIG wrote under HardwareConfig

  if (cr == CR_SUCCESS)
  {
    stat = reg_set_dword(hkey, "", szTestVal, 0x1234);
    if (stat)
    {
      DbgPrintf(D_Error,(TEXT("write val fail\n")));
    }
    else
    {
      DbgPrintf(D_Test,(TEXT("write val ok\n")));
    }
    RegCloseKey(hkey);
  }
  else
  {
    DbgPrintf(D_Error,(TEXT("CM write open fail:%d\n"), GetLastError()));
  }

  return 0;
}
#endif

/*-----------------------------------------------------------------------------
| get_pnp_devicedesc -
|-----------------------------------------------------------------------------*/
static int get_pnp_devicedesc(TCHAR *name)
{
 CONFIGRET cr;
 DWORD len;
  // Get the Device name
  len = 60;

  cr = CM_Get_DevNode_Registry_Property(glob_info->DeviceInfoData->DevInst,
            CM_DRP_DEVICEDESC,
            NULL,
            (PBYTE)name,
            &len,
            0);

  if (cr != CR_SUCCESS)
  {
    DbgPrintf(D_Error,(TEXT("err, no fr.name.\n")));
    return 2;  // err
  }
  DbgPrintf(D_Test, (TEXT("get friendlyname:%s\n"), name));
  return 0;  // ok
}

#if 0
/*-----------------------------------------------------------------------------
| set_pnp_devicedesc -
|-----------------------------------------------------------------------------*/
static int set_pnp_devicedesc(TCHAR *name)
{
 CONFIGRET cr;

  // Set the Device name

  cr = CM_Set_DevNode_Registry_Property(
          glob_info->DeviceInfoData->DevInst,
          CM_DRP_DEVICEDESC,
          (PBYTE)name,
          (lstrlen(name) + 1) * sizeof(TCHAR),
          0);

  if (cr != CR_SUCCESS)
  {
    DbgPrintf(D_Error,(TEXT("err3d\n")));
    return 2;  // err
  }
  return 0;  // ok
}
#endif

/*-----------------------------------------------------------------------------
| write_config - Save the config for the device - Set pnp port names so
   they match our configuration.  Also, try to keep MSPORTS.DLL com-port
   name database in sync with our stuff by detecting when our pnp comport
   name changes, and calling msports routines to free and claim port names.

   We call this routine once with clear_it SET, then call it again with
   it clear.  This is because we must clear ALL port claims from msports.dll
   (which holds a database in services\serial reg area) prior to re-claiming
   new port names.  This is because if we overlap, we run into trouble.
|-----------------------------------------------------------------------------*/
static int write_config(int clear_it)
{
 DEVINST devInst;
 Device_Config *dev;
 Port_Config *port;
 int  i,pi, str_i, stat;
 CONFIGRET cr;
 ULONG len;
 TCHAR buf[120];
 TCHAR curname[40];
 HKEY hKey;
 int port_index = 0;
 int port_i;
 ULONG val_type;
 HCOMDB hPort = NULL;

  FindPortNodes();  // fill in all port->hPnpNode

  for(i=0; i<wi->NumDevices; i++)   // Loop through all possible boards
  {
    dev = &wi->dev[i];
    for(pi=0; pi<dev->NumPorts; pi++)   // Loop through all ports
    {
      port = &dev->ports[pi];

      if (port->hPnpNode != 0) // have a DEVINST handle for it.
      {
        devInst = (DEVINST) port->hPnpNode;

        if (!clear_it)
        {
          len = sizeof(buf);
#ifdef S_RK
          wsprintf(buf, "Comtrol RocketPort %d (%s)", port_index, port->Name);
#else
          wsprintf(buf, "Comtrol VS Port %d (%s)", port_index, port->Name);
#endif
          cr = CM_Set_DevNode_Registry_Property(devInst,
                                        CM_DRP_FRIENDLYNAME,
                                        (PBYTE)buf,
                                        (lstrlen(buf) + 1) * sizeof(TCHAR),
                                        0);
          if (cr != CR_SUCCESS)
          {
            DbgPrintf(D_Error,(TEXT("err7d\n")));
          }
        }
        cr = CM_Open_DevNode_Key(
             devInst,
             KEY_ALL_ACCESS,   // IN  REGSAM         samDesired,
             0,           // IN  ULONG          ulHardwareProfile,
             RegDisposition_OpenExisting,
             &hKey,       //OUT PHKEY          phkDevice,
             CM_REGISTRY_HARDWARE); // IN  ULONG          ulFlags

        wsprintf(buf, "%s", port->Name);
        if (cr == CR_SUCCESS)
        {
          curname[0] = 0;
          len = sizeof(curname);
          cr = RegQueryValueEx(hKey,
                    TEXT("PortName"),
                    0,
                    &val_type,
                    (PBYTE) curname,
                    &len);
          if (cr != CR_SUCCESS)
          {
            DbgPrintf(D_Error,(TEXT("error reading portname\n")));
          }

          if (_tcsicmp(curname, buf) != 0)  // it's changed!
          {
            DbgPrintf(D_Test,(TEXT("com name from:%s, to %s\n"), curname, buf));
            if (hPort == NULL)
              cr = ComDBOpen(&hPort);
            if (hPort == NULL)
            {
              DbgPrintf(D_Error,(TEXT("err dbcom 1d\n")));
            }
            else
            {
              if (clear_it)
              {
                // clear out name
                port_i = ExtractNameNum(curname);
                if ((port_i > 0) && (port_i < 256))
                {
                  ComDBReleasePort(hPort, port_i);
                  DbgPrintf(D_Test,(TEXT("Free Old:%d\n"), port_i));
                }
              }
              else
              {
                port_i = ExtractNameNum(buf);
                if ((port_i > 0) && (port_i < 256))
                {
                  ComDBClaimPort(hPort, port_i, 1 /* force*/, NULL);
                  DbgPrintf(D_Test,(TEXT("Claim New:%d\n"), port_i));
                }
              }
            }
            if (!clear_it)
            {
              RegSetValueEx(hKey,
                          "PortName",
                          0,
                          REG_SZ,
                          (PBYTE) buf,
                          (lstrlen(buf) + 1) * sizeof(TCHAR) );
            }
          }  // not matched, com-port name changed
          RegCloseKey(hKey);
        }  // opened dev node key
        else {
          DbgPrintf(D_Error,(TEXT("err7e\n")));
             }
      } // if (port->hPnpNode != 0)
      else
      {
        DbgPrintf(D_Level,(TEXT("Bad Pnp Name Find\n")));
      }
      ++port_index;
    }  // for(pi=0; pi<dev->NumPorts; pi++)
  } // for(i=0; i<wi->NumDevices; i++)

  if (hPort != NULL)
    ComDBClose(hPort);

  return 0; 
}

/*------------------------------------------------------------------------
| uninstall_device - 
|------------------------------------------------------------------------*/
static void uninstall_device(void)
{

#ifdef DO_SHOWIT
  if (MessageBox( GetFocus(), TEXT("UNINSTALL, Want Info?"), TEXT("aclass"), MB_YESNO | MB_ICONINFORMATION ) ==
     IDYES)
  {
    show_install_info(glob_info);
    DumpPnpTree();
  }
#endif

  clear_nt_device(wi);

  //if (this_is_last_device)
  //  remove_driver(1);
}

/*-----------------------------------------------------------------------------
| FindPortNodes - Find the pnp tree devnodes which hold our port names.
    Put the handle into our port config struct for easy access.
    We start the search at our device node.
|-----------------------------------------------------------------------------*/
static int FindPortNodes(void)
{
  DEVINST     devInst;
  DEVINST     devInstNext;
  CONFIGRET   cr;
  ULONG       walkDone = 0;
  ULONG       len;
  CHAR buf[120];
  HKEY hKey;
  int  di,pi;
  int port_index;
  Device_Config *dev;
  Port_Config *port;
  ULONG val_type;

  // clear out all stale pnpnode handles before re-creating this list
  for(di=0; di<wi->NumDevices; di++)   // Loop through all possible boards
  {
    dev = &wi->dev[di];
    for(pi=0; pi<dev->NumPorts; pi++)   // Loop through all ports
    {
      dev->ports[pi].hPnpNode = 0;
    }
  }

#if 0
  // Get Root DevNode
  //
  cr = CM_Locate_DevNode(&devInst, NULL, 0);

  if (cr != CR_SUCCESS)
  {
    return 1;  // err
  }
#endif
  devInst = glob_info->DeviceInfoData->DevInst;
  if (devInst == 0)
  {
    DbgPrintf(D_Error,(TEXT("err6g\n")));
    return 1;  // err
  }

DbgPrintf(D_Level, (TEXT("search nodes\n")));

  cr = CM_Get_Child(&devInstNext,
                    devInst,
                    0);

  while (cr == CR_SUCCESS)
  {
    devInst = devInstNext;

    // Get the DriverName value
    //
    buf[0] = 0;
    len = sizeof(buf);
    cr = CM_Get_DevNode_Registry_Property(devInst,
              CM_DRP_CLASS, NULL, buf, &len, 0);
    if (cr == CR_SUCCESS && strcmp("Ports", buf) == 0)
    {
      // grab the "MatchingDeviceId"
      cr = CM_Open_DevNode_Key(
           devInst,
           KEY_READ,    // IN  REGSAM         samDesired,
           0,           // IN  ULONG          ulHardwareProfile,
           RegDisposition_OpenExisting,
           &hKey,       //OUT PHKEY          phkDevice,
           CM_REGISTRY_SOFTWARE); // IN  ULONG          ulFlags

      if (cr == CR_SUCCESS)
      {
        buf[0] = 0;
        len = sizeof(buf);
        cr = RegQueryValueEx(hKey,
                    TEXT("MatchingDeviceId"),
                    0,
                    &val_type,
                    (PBYTE) buf,
                    &len);
        if (cr != ERROR_SUCCESS)
        {
          buf[0] = 0;
        }
#ifdef S_RK
        if (strstr(buf, "ctmport") != NULL)  // found it
#else
        if (strstr(buf, "ctmvport") != NULL)  // found it
#endif
        {
          int k, dev_num;

          k = sscanf(&buf[8], "%d", &dev_num);
          if (k==1)
          {
            port_index = 0;
            // found a vs port node, so save a reference to this node
            // in our config struct for simple reference.
            //save_pnp_node(j, devInst);
            for(di=0; di<wi->NumDevices; di++)   // Loop through all possible boards
            {
              dev = &wi->dev[di];
              for(pi=0; pi<dev->NumPorts; pi++)   // Loop through all ports
              {
                port = &dev->ports[pi];
                if (port_index == dev_num) // found our matching index
                {
                  port->hPnpNode = (HANDLE) devInst;
                }
                ++port_index;
              }  // for pi
            }  // for di
          }  // if scanf
        }  // if strstr "ctmvport"

        RegCloseKey(hKey);
      }  // if openreg
    } // if "Ports"

    // Get next child
    cr = CM_Get_Sibling(&devInstNext,
                          devInst,
                          0);
  } // while (!cr_success)

  return 2;  // done;
}

/*-----------------------------------------------------------------------------
| do_nt50_install -
|-----------------------------------------------------------------------------*/
int do_nt50_install(void)
{
 int stat = 0;
 int do_remove = 0;
 int do_modem_inf = 0;
 static int in_here = 0;

  if (in_here)  // problem hitting OK button twice(sets off two of these)
    return 2;

  in_here = 1;

  if (wi->nt_reg_flags & 4) // initial install, no setupversion string found
  {
    if (setup_utils_exist())
    {
      setup_make_progman_group(1);  // 1=with prompt
    }
    wi->nt_reg_flags &= ~4;
  }

  if (!wi->ChangesMade)
    send_to_driver(0);  // evaluate if anything changed

  stat = send_to_driver(1);
  stat = set_nt_config(wi);
  in_here = 0;

  if (stat)
    return 1; // error

  return 0; // ok
}

/*----------------------------------------------------------------------------
| get_pnp_isa_address - 
|-----------------------------------------------------------------------------*/
static int get_pnp_isa_address(void)
{
  int IoBase;
  LOG_CONF LogConfig;
  RES_DES ResDes;
  IO_RESOURCE IoResource;
  //IRQ_RESOURCE IrqResource;
  CONFIGRET cr;
  int status;

  status = CM_Get_First_Log_Conf(&LogConfig,
             (DEVINST)(glob_info->DeviceInfoData->DevInst),
             ALLOC_LOG_CONF);
  //if (status != CR_SUCCESS)
  //  mess(&wi->ip, "No ALLOC lc %xH\n",status);

  if (status != CR_SUCCESS)
    return 1;

  // get the Io base port
  status = CM_Get_Next_Res_Des(&ResDes, LogConfig, ResType_IO, NULL, 0);
  if (status != CR_SUCCESS)
  {
    return 2;
  }

  cr = CM_Get_Res_Des_Data(ResDes, &IoResource, sizeof(IO_RESOURCE), 0);
  CM_Free_Res_Des_Handle(ResDes);

  if(cr != CR_SUCCESS)
  {
    return 3;
  }

  IoBase = (int)IoResource.IO_Header.IOD_Alloc_Base;
  //mess(&wi->ip, "OK 1c, Base:%xH\n", IoBase);

  if ((IoBase < 0x400) && (IoBase >= 0x100))
    wi->dev[0].IoAddress = IoBase;
  else
    wi->dev[0].IoAddress = 0;

  return 0;
}

#if 0
/*----------------------------------------------------------------------------
| test_config - See what we can do concerning the allocated IO resources.
|-----------------------------------------------------------------------------*/
static void test_config(void)
{
  int IoBase;
  LOG_CONF LogConfig;
  RES_DES ResDes;
  IO_RESOURCE IoResource;
  //IRQ_RESOURCE IrqResource;
  CONFIGRET cr;
  int status;

  //glob_ourstr[0] = 0;
  //lstrcat(glob_ourstr, "Test Config:\n");
//  mess(&wi->ip, "Test Config");

  status = CM_Get_First_Log_Conf(&LogConfig,
             (DEVINST)(glob_info->DeviceInfoData->DevInst),
             BOOT_LOG_CONF);
  if (status != CR_SUCCESS)
    mess(&wi->ip, "No BOOT lc %xH\n",status);
  else
    mess(&wi->ip, "Got BOOT lc\n");

  status = CM_Get_First_Log_Conf(&LogConfig,
             (DEVINST)(glob_info->DeviceInfoData->DevInst),
             FORCED_LOG_CONF);
  if (status != CR_SUCCESS)
    mess(&wi->ip, "No FORCED lc %xH\n",status);
  else
    mess(&wi->ip, "Got FORCED lc\n");

  status = CM_Get_First_Log_Conf(&LogConfig,
             (DEVINST)(glob_info->DeviceInfoData->DevInst),
             BASIC_LOG_CONF);
  if (status != CR_SUCCESS)
    mess(&wi->ip, "No BASIC lc %xH\n",status);
  else
    mess(&wi->ip, "Got BASIC lc\n");

  status = CM_Get_First_Log_Conf(&LogConfig,
             (DEVINST)(glob_info->DeviceInfoData->DevInst),
             FORCED_LOG_CONF);
  if (status != CR_SUCCESS)
    mess(&wi->ip, "No FORCED lc %xH\n",status);
  else
    mess(&wi->ip, "Got FORCED lc\n");

  status = CM_Get_First_Log_Conf(&LogConfig,
             (DEVINST)(glob_info->DeviceInfoData->DevInst),
             ALLOC_LOG_CONF);
  if (status != CR_SUCCESS)
    mess(&wi->ip, "No ALLOC lc %xH\n",status);
  else
    mess(&wi->ip, "Got ALLOC lc\n");

  if (status != CR_SUCCESS)
    return;
  //
  // First, get the Io base port
  //
  status = CM_Get_Next_Res_Des(&ResDes, LogConfig, ResType_IO, NULL, 0);
  if (status != CR_SUCCESS)
  {
    mess(&wi->ip, "Error 1b\n");
    return;
  }
  mess(&wi->ip, "OK 1b\n");

  cr = CM_Get_Res_Des_Data(ResDes, &IoResource, sizeof(IO_RESOURCE), 0);
  CM_Free_Res_Des_Handle(ResDes);

  if(cr != CR_SUCCESS)
  {
    mess(&wi->ip, "Error 1c\n");
    return;
  }

  IoBase = (int)IoResource.IO_Header.IOD_Alloc_Base;
  mess(&wi->ip, "OK 1c, Base:%xH\n", IoBase);

   //OldIrq = IrqResource.IRQ_Header.IRQD_Alloc_Num;

#if 0
  // We don't want to popup the configuration UI if the 'quiet install' flag is
  // set _and_ we already have a forced config (pre-install support).
  if (CM_Get_First_Log_Conf(&ForcedLogConf, glob_info->DeviceInfoData->DevInst, FORCED_LOG_CONF) == CR_SUCCESS)
  {
    CM_Free_Log_Conf_Handle(ForcedLogConf);

    DeviceInstallParams.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
    if (SetupDiGetDeviceInstallParams(DeviceInfoSet, DeviceInfoData, &DeviceInstallParams))
    {
      if(FirstTime && (DeviceInstallParams.Flags & DI_QUIETINSTALL))
      {
        DisplayPropSheet = FALSE;
      }
    }
  }
#endif
}
#endif


#ifdef TRY_UI

#define MAX_NUM_CLASS_SHEETS 3

PROPSHEETPAGE class_psp[MAX_NUM_CLASS_SHEETS];
int num_class_pages = 0;

/*------------------------------------------------------------------------
| DoCLassPropPages - 
|------------------------------------------------------------------------*/
int DoCLassPropPages(HWND hwndOwner,
                     SP_PROPSHEETPAGE_REQUEST *propreq)
{
    PROPSHEETPAGE *psp;
    PROPSHEETHEADER psh;
    OUR_INFO * our_params;
    INT stat;
    //SP_PROPSHEETPAGE_REQUEST propreq;
    //typedef struct _SP_PROPSHEETPAGE_REQUEST {
    //DWORD            cbSize;
    //DWORD            PageRequested;
    //HDEVINFO         DeviceInfoSet;
    //PSP_DEVINFO_DATA DeviceInfoData;


    //Fill out the PROPSHEETPAGE data structure for the Background Color
    //sheet

//    our_params = glob_info;  // temporary kludge, unless we don't need re-entrantancy 
    psp = &class_psp[0];

    //Fill out the PROPSHEETPAGE data structure for the Client Area Shape
    //sheet
    FillClassPropertySheets(&psp[0], (LPARAM)our_params);
    ++num_class_pages;

    //Fill out the PROPSHEETHEADER

    //stat = DevicePropPage(
    //  (LPVOID) propreq,   // points to PROPSHEETPAGE_REQUEST, see setupapi.h
    //  (LPFNADDPROPSHEETPAGE) ClassAddPropPage, // add sheet function
    //  0)  // add sheet function data handle?

    memset(&psh, 0, sizeof(PROPSHEETHEADER));  // add fix 11-24-98

    psh.dwSize = sizeof(PROPSHEETHEADER);
    //psh.dwFlags = PSH_USEICONID | PSH_PROPSHEETPAGE;
    psh.dwFlags = PSH_PROPSHEETPAGE | PSH_NOAPPLYNOW;
    psh.hwndParent = hwndOwner;
    psh.hInstance = glob_hinst;
    psh.pszIcon = TEXT("");
    psh.nPages = num_class_pages;
    psh.ppsp = (LPCPROPSHEETPAGE) &psp;

    //And finally display the dialog with the two property sheets.


    stat = PropertySheet(&psh);

//BOOL WINAPI DevicePropPage(
//      LPVOID pinfo,   // points to PROPSHEETPAGE_REQUEST, see setupapi.h
//      LPFNADDPROPSHEETPAGE pfnAdd, // add sheet function
//      LPARAM lParam)  // add sheet function data handle?

  return 0;
}

/*------------------------------------------------------------------------
| ClassAddPropPage - Call back function to add a prop page.
|------------------------------------------------------------------------*/
BOOL WINAPI ClassAddPropPage(HPROPSHEETPAGE hpage, LPARAM lparam)
{
  PropSheet_AddPage(lparam, hpage);
}

/*------------------------------------------------------------------------
| FillClassPropertySheets - Setup pages for driver level property sheets.
|------------------------------------------------------------------------*/
int FillClassPropertySheets(PROPSHEETPAGE *psp, LPARAM our_params)
{
  INT pi;
  static TCHAR titlestr[40];

  memset(psp, 0, sizeof(*psp) * NUM_CLASS_SHEETS);

  pi = 0;

  psp[pi].dwSize = sizeof(PROPSHEETPAGE);
  psp[pi].dwFlags = PSP_USETITLE | PSP_HASHELP | PSH_NOAPPLYNOW;
  psp[pi].hInstance = glob_hinst;
//  psp[pi].pszTemplate = MAKEINTRESOURCE(IDD_CLASS_DLG);
  psp[pi].pszTemplate = MAKEINTRESOURCE(IDD_DRIVER_OPTIONS);
  psp[pi].pfnDlgProc = ClassSheet;
  load_str( glob_hinst, (TITLESTR+3), titlestr, CharSizeOf(titlestr) );
  psp[pi].pszTitle = TEXT("Setup");
  psp[pi].lParam = (LPARAM)our_params;
  psp[pi].pfnCallback = NULL;
  ++pi;

  return 0;
}

/*----------------------------------------------------------
 ClassSheet - Dlg window procedure for add on Advanced sheet.
|-------------------------------------------------------------*/
BOOL WINAPI ClassSheet(
      IN HWND   hDlg,
      IN UINT   uMessage,
      IN WPARAM wParam,
      IN LPARAM lParam)
{
 ////OUR_INFO *OurProps = (OUR_INFO *)GetWindowLong(hDlg, DWL_USER);

  switch(uMessage)
  {
    case WM_INITDIALOG :
      ////OurProps = (OUR_INFO *)((LPPROPSHEETPAGE)lParam)->lParam;
      ////SetWindowLong(hDlg, DWL_USER, (LONG)OurProps);
#ifdef NT50
      glob_hwnd = hDlg;
#endif
    stat = DevicePropPage(
      (LPVOID) propreq,   // points to PROPSHEETPAGE_REQUEST, see setupapi.h
      (LPFNADDPROPSHEETPAGE) ClassAddPropPage, // add sheet function
      0)  // add sheet function data handle?

      //set_field(hDlg, IDC_VERBOSE);
    return TRUE;  // No need for us to set the focus.

    case WM_COMMAND:
    return FALSE;

    case WM_PAINT:
    return FALSE;

    case WM_CONTEXTMENU:     // right-click
      //context_menu();
    break;

    case WM_HELP:            // question mark thing
      //our_context_help(lParam);
    return FALSE;

    case WM_NOTIFY :
      switch (((NMHDR *)lParam)->code)
      {
        case PSN_KILLACTIVE :
          // we're losing focus to another page...
          // make sure we update the Global485 variable here.
          //get_field(hDlg, IDC_GLOBAL485);
          SetWindowLong(hDlg, DWL_MSGRESULT, PSNRET_NOERROR);
          return FALSE;  // allow focus change
        break;

        case PSN_HELP :
          //our_help(&wi->ip, WIN_NT);
        break;

        case PSN_QUERYCANCEL :
            // the DWL_MSGRESULT field must be *FALSE* to tell QueryCancel
            // that an exit is acceptable.  The function result must be
            // *TRUE* to acknowledge that we handled the message.
            SetWindowLong(hDlg, DWL_MSGRESULT, FALSE); // allow cancel
            return TRUE;
        break;

        case PSN_APPLY :
              SetWindowLong(hDlg, DWL_MSGRESULT, PSNRET_NOERROR);
          return TRUE;

        default :
        return FALSE;
      }  // switch ->code
    break;  // case wmnotify

    default :
    return FALSE;
  }  // switch(uMessage)
}

#endif