PUSBPRN_CONTEXT pUsbPrn,
    DWORD dwCode,
    PBYTE pBufIn,
    DWORD dwLenIn,
    PBYTE pBufOut,
    DWORD dwLenOut,
    PDWORD pdwActualOut
   )
{
   BOOL bRc = TRUE;

   DEBUGMSG(ZONE_LPT_IOCTL,(TEXT(">LPT_IOControl(0x%x, 0x%x, %d, 0x%x)\n"),
                                                               dwCode, pBufIn, dwLenIn, pBufOut, dwLenOut ));

   if ( ACCEPT_IO( pUsbPrn ) ) {

       switch ( dwCode ) {

            case IOCTL_SERIAL_SET_TIMEOUTS:
            case IOCTL_PARALLEL_SET_TIMEOUTS:
            DEBUGMSG(ZONE_LPT_IOCTL, (TEXT("IOCTL_PARALLEL_SET_TIMEOUTS\n")));

                if ( dwLenIn >= sizeof(COMMTIMEOUTS) ) {
               LPCOMMTIMEOUTS pTimeouts;
               EnterCriticalSection(&pUsbPrn->Lock);
               pTimeouts= &pUsbPrn->Timeouts;
                   *pTimeouts = (*(LPCOMMTIMEOUTS)pBufIn);
               LeaveCriticalSection(&pUsbPrn->Lock);
            } else {
               DEBUGMSG( ZONE_ERR,(TEXT("LPT_IOControl:ERROR_INVALID_PARAMETER\n")));
                   SetLastError(ERROR_INVALID_PARAMETER);
               bRc = FALSE;
            }
                break;

        case IOCTL_SERIAL_GET_TIMEOUTS:
            case IOCTL_PARALLEL_GET_TIMEOUTS:
            DEBUGMSG(ZONE_LPT_IOCTL,(TEXT("IOCTL_PARALLEL_GET_TIMEOUTS\n")));

                if ( (unsigned int)dwLenOut >= (unsigned int)sizeof(COMMTIMEOUTS) ) {
               LPCOMMTIMEOUTS pTimeouts;
               EnterCriticalSection(&pUsbPrn->Lock);
               pTimeouts = &pUsbPrn->Timeouts;
                   *(LPCOMMTIMEOUTS)pBufOut = *pTimeouts;
                   *pdwActualOut = sizeof(COMMTIMEOUTS);
               LeaveCriticalSection(&pUsbPrn->Lock);
            } else {
               DEBUGMSG( ZONE_ERR,(TEXT("LPT_IOControl:ERROR_INVALID_PARAMETER\n")));
                   SetLastError(ERROR_INVALID_PARAMETER);
                    *pdwActualOut = 0;
               bRc = FALSE;
            }
                break;

            case IOCTL_PARALLEL_GETDEVICEID:
            DEBUGMSG(ZONE_LPT_IOCTL,(TEXT("IOCTL_PARALLEL_GETDEVICEID\n")));
                *pdwActualOut= GetDeviceId( pUsbPrn,
                                        pBufOut,
                                        dwLenOut );
                break;

            case IOCTL_PARALLEL_WRITE:
            DEBUGMSG(ZONE_LPT_IOCTL,(TEXT("IOCTL_PARALLEL_WRITE\n")));
            *pdwActualOut = LPT_Write( pUsbPrn, pBufOut, dwLenOut );
            break;

         case IOCTL_PARALLEL_STATUS:
            DEBUGMSG(ZONE_LPT_IOCTL,(TEXT("IOCTL_PARALLEL_STATUS\n")));

                if ( (unsigned int)dwLenOut < 4 ) {
               DEBUGMSG( ZONE_ERR,(TEXT("LPT_IOControl:ERROR_INVALID_PARAMETER\n")));
                   SetLastError(ERROR_INVALID_PARAMETER);
                    *pdwActualOut=0;
               bRc = FALSE;
            } else {
               //
               // Get IEEE-1284 status bits, then convert to CE LPTx status.
               //
               USHORT usStatus, usBit;
                    DWORD  dwCommErrors = CE_DNS | CE_IOE; // (Device Not Selected | I/O Error)

               usStatus = GetPortStatus( pUsbPrn );

               // walk the 1284 bits, converting to CE bits
               for ( usBit = 0x1; usBit != 0; usBit *= 2 ) {
                        switch ( usBit & usStatus ) {
                           case USBPRN_STATUS_SELECT:
                        DEBUGMSG(ZONE_LPT_IOCTL,(TEXT("USBPRN_STATUS_SELECT\n")));
                               dwCommErrors &= ~CE_DNS;
                               break;

                           case USBPRN_STATUS_NOTERROR:
                        DEBUGMSG(ZONE_LPT_IOCTL,(TEXT("USBPRN_STATUS_NOTERROR\n")));
                               dwCommErrors &= ~CE_IOE;
                               break;

                           case USBPRN_STATUS_PAPEREMPTY:
                        DEBUGMSG(ZONE_LPT_IOCTL,(TEXT("USBPRN_STATUS_PAPEREMPTY\n")));
                               dwCommErrors |= CE_OOP; // Out Of Paper
                               break;

                           case USBPRN_STATUS_TIMEOUT:
                        DEBUGMSG(ZONE_LPT_IOCTL,(TEXT("USBPRN_STATUS_TIMEOUT\n")));
                               dwCommErrors |= CE_PTO; // Printer Time Out
                               break;

                           default:
                               break;
                        }
                    }

               DEBUGMSG(ZONE_LPT_IOCTL,(TEXT("CE LPTx Status: 0x%x\n"),dwCommErrors));

                    *(PDWORD)pBufOut = dwCommErrors;
                    *pdwActualOut = 4;
                }
            break;

            case IOCTL_PARALLEL_GET_ECP_CHANNEL32:
            DEBUGMSG( ZONE_LPT_IOCTL,(TEXT("IOCTL_PARALLEL_GET_ECP_CHANNEL32\n")));
                SetLastError(ERROR_NOT_SUPPORTED);
                bRc = FALSE;
                break;

            default:
            DEBUGMSG( ZONE_ERR,(TEXT("LPT_IOControl(0x%x) : ERROR_NOT_SUPPORTED\n"), dwCode));
                SetLastError(ERROR_NOT_SUPPORTED);
                bRc = FALSE;
                break;
      }

   } else {
      DEBUGMSG( ZONE_ERR,(TEXT("LPT_IOControl: ERROR_INVALID_HANDLE\n")));
        SetLastError(ERROR_INVALID_HANDLE);
      bRc = FALSE;
    }

   DEBUGMSG(ZONE_LPT_IOCTL,(TEXT("<LPT_IOControl:%d\n"), bRc));

   return bRc;
}


ULONG
LPT_Seek(
   PVOID Context,
   LONG  Position,
   DWORD Type
   )
{
    UNREFERENCED_PARAMETER(Context);
    UNREFERENCED_PARAMETER(Position);
    UNREFERENCED_PARAMETER(Type);
    DEBUGMSG( ZONE_LPT_INIT, (TEXT("LPT_Seek\n")));
    return (ULONG)-1;
}


BOOL
LPT_PowerUp(
   PVOID Context
   )
{
    UNREFERENCED_PARAMETER(Context);
    return 1;
}


BOOL
LPT_PowerDown(
   PVOID Context
   )
{
    UNREFERENCED_PARAMETER(Context);
    return 1;
}


PUSBPRN_CONTEXT
GetContextFromReg(
   LPTSTR  ActivePath
   )
{
   PUSBPRN_CONTEXT pUsbPrn = NULL;
   HKEY hKey;
   long lStatus;

   if (ActivePath) {
      //
      // open the registry and read out our context pointer
      // since Dev Mgr doesn't pass it in.
      //
      lStatus = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
                              ActivePath,
                              0,
                              0,
                              &hKey);

       if (lStatus==ERROR_SUCCESS) {
         DWORD dwVal;
         DWORD dwType = REG_DWORD;
         DWORD dwValLen = sizeof(dwVal);
         lStatus = RegQueryValueEx( hKey,
                                    TEXT("ClientInfo"),
                                    NULL,
                                    &dwType,
                                    (LPBYTE)(&dwVal),
                                    &dwValLen);

         if (lStatus == ERROR_SUCCESS) {
            // check the signature
            pUsbPrn = (PUSBPRN_CONTEXT)dwVal;
            if ( USB_PRN_SIG != pUsbPrn->Sig ) {
               DEBUGMSG(ZONE_ERR, (TEXT("Invalid signature!!\n")));
               TEST_TRAP();
               pUsbPrn = NULL;
            } else {
               DEBUGMSG(ZONE_LPT_INIT, (TEXT("ActivePath: %s)\n"), ActivePath));
            }
         }

         RegCloseKey(hKey);

      } else {
         DEBUGMSG(ZONE_ERR, (TEXT("Open ActivePath failed\n")));
      }
   }

   return pUsbPrn;
}


BOOL
RegisterLPTName(
   LPTSTR ActivePath,
   LPTSTR PortName
   )
{
    HKEY hKey;
    BOOL bReturn=FALSE;
    long lStatus;
    
    if (!ActivePath || !PortName) {
        DEBUGMSG(ZONE_ERR, (TEXT("Invalid parameter\n")));
        return FALSE;
    }
    
    DEBUGMSG(ZONE_LPT_INIT, (TEXT(">RegisterLPTName\n")));
    
    //
    // Open \Drivers\Active key reading our "LPTx:" device name,
    // which must then be registered under \Printers\Ports
    //
    lStatus = RegOpenKeyEx(
        HKEY_LOCAL_MACHINE,
        ActivePath,
        0,
        0,
        &hKey);
    
    if (lStatus==ERROR_SUCCESS) {
        //
        // Query our indexed file device name, e.g. "LPT1:"
        //
        TCHAR DevName[DEVNAME_LEN];
        DWORD dwType=REG_SZ;
        DWORD dwValLen = sizeof(DevName);
        lStatus = RegQueryValueEx(
            hKey,
            TEXT("Name"),
            NULL,
            &dwType,
            (PUCHAR)DevName,
            &dwValLen);
        
        if (lStatus == ERROR_SUCCESS) {
            //
            // write our device name out to the next available "PortX" value under \Printers\Ports
            //
            HKEY hPrint;
            DWORD dwDisposition;
            TCHAR portStr[MAX_PATH];
            TCHAR portName[PORTNAME_LEN];
            lStatus = RegCreateKeyEx(
                HKEY_LOCAL_MACHINE,
                g_sPortsKey,
                0,
                NULL,
                REG_OPTION_NON_VOLATILE,
                0,
                NULL,
                &hPrint,     // HKEY result
                &dwDisposition);
            
            if (lStatus==ERROR_SUCCESS) {
                DWORD dwIndex;
                for (dwIndex = 1; dwIndex < MAX_LPT_NAME_INDEX; dwIndex++) {
                    _sntprintf(portName,PORTNAME_LEN,TEXT("Port%d"),dwIndex);
                    portName[PORTNAME_LEN-1]=0;
                    dwType=REG_SZ;
                    dwValLen = sizeof(portStr);
                    lStatus = RegQueryValueEx(
                        hPrint,
                        portName,
                        NULL,
                        &dwType,
                        (PUCHAR)portStr,
                        &dwValLen);
                    if (lStatus!=ERROR_SUCCESS) {
                        break;
                    } else if(_tcsncmp(portStr, DevName, DEVNAME_LEN) == 0) {
                        // found a duplicate entry for this device, use that
                        DEBUGMSG(ZONE_INIT, 
                            (_T("RegisterLPTName: found pre-existing entry for '%s' at '%s'\r\n"),
                            DevName, portName));
                        bReturn = TRUE;
                        break;
                    }
                }
                
                // only create a new entry if necessary
                if(lStatus != ERROR_SUCCESS) {
                    ASSERT(dwIndex<MAX_LPT_NAME_INDEX);
                    dwType=REG_SZ;
                    lStatus = RegSetValueEx(
                        hPrint,
                        portName,
                        0, //NULL,
                        dwType,
                        (PUCHAR)DevName,
                        (_tcslen(DevName)+1)*sizeof(TCHAR));
                    
                    if (lStatus==ERROR_SUCCESS) {
                        // copy to caller
                        _tcsncpy(PortName,  // dst
                            portName,  // src
                            PORTNAME_LEN);  
                        bReturn=TRUE;
                        DEBUGMSG(ZONE_LPT_INIT, (TEXT("\\%s\\%s\n"),g_sPortsKey,PortName));
                    }
                }
                
                RegCloseKey(hPrint);
            }
            
        } else {
            DEBUGMSG(ZONE_ERR,(TEXT("RegisterLPTName can not get value: %s\\Name\n"),ActivePath));
        }
        
        RegCloseKey(hKey);
        
    } else {
        DEBUGMSG(ZONE_ERR,(TEXT("RegisterLPTName can not open: %s\n"),ActivePath));
    }
    
    DEBUGMSG(ZONE_LPT_INIT, (TEXT("<RegisterLPTName\n")));
    
    return bReturn;
}


BOOL
DeregisterLPTName(
   LPTSTR PortName
   )
{
   HKEY hKey;
   long lStatus;

   if (!PortName) {
      DEBUGMSG(ZONE_ERR, (TEXT("Invalid parameter\n")));
      return FALSE;
   }

   DEBUGMSG(ZONE_LPT_INIT,(TEXT("DeregisterLPTName: \\%s\\%s\n"),g_sPortsKey,PortName));

   lStatus = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
                           g_sPortsKey,
                           0,
                           0,
                           &hKey);

    if (lStatus==ERROR_SUCCESS) {
        BOOL bReturn = (RegDeleteValue(hKey,PortName)==ERROR_SUCCESS);
        RegCloseKey(hKey);
        return bReturn;
    }
    else
        return FALSE;
}


//#pragma warning( push )
//#pragma warning( disable : 4706 ) // assignment within conditional expression
/*++

Populates the Registry with our Printer Driver Settings
[HKEY_LOCAL_MACHINE\Printers\<DESCRIPTION>
   "Driver"="pcl.dll"      // names the DLL that contains the printer driver
   "High Quality"="300"    // the resolution of high-quality mode
   "Draft Quality"="150