serial.c

usb to rs232 虚拟RS232串口驱动程序

/*++

Copyright (c) 2005-2006  E0 Technology,Inc.

Module Name:

	serial.c

Abstract:

	Virtual Com Port Driver for USB to RS232 Converter of E0 Technology,Inc.

Environment:

	Kernel mode

Notes:

Revision History:

    2006/3/1 : 	Adapted from the serial DDK sample.
--*/

#include "usb2com.h"

ULONG SerialDebugLevel = 0xff;
#define SERIAL_DBGPRINT_BUFSIZE 512

ULONG
SerialDbgPrintEx(IN ULONG Level, PCHAR Format, ...)
{
   va_list arglist;
   ULONG rval;
   ULONG Mask;
   ULONG cb;
   UCHAR buffer[SERIAL_DBGPRINT_BUFSIZE];

   if (Level > 31) {
        Mask = Level;

   } else {
      Mask = 1 << Level;
   }

   if ((Mask & SerialDebugLevel) == 0) {
      return STATUS_SUCCESS;
   }

   va_start(arglist, Format);

   DbgPrint("SERIAL: ");

   cb = _vsnprintf(buffer, sizeof(buffer), Format, arglist);

   if (cb == -1) {
      buffer[sizeof(buffer) - 2] = '\n';
   }

   DbgPrint("%s", buffer);

//   rval = vDbgPrintEx(DPFLTR_SERIAL_ID, Level, Format, arglist);

   va_end(arglist);

   rval = STATUS_SUCCESS;

   return rval;
}

NTSTATUS
SerialGetRegistryKeyValue (
    IN HANDLE Handle,
    IN PWCHAR KeyNameString,
    IN ULONG KeyNameStringLength,
    OUT PVOID Data,
    IN ULONG DataLength
    )
/*++

Routine Description:

    Reads a registry key value from an already opened registry key.

Arguments:

    Handle              Handle to the opened registry key

    KeyNameString       ANSI string to the desired key

    KeyNameStringLength Length of the KeyNameString

    Data                Buffer to place the key value in

    DataLength          Length of the data buffer

Return Value:

    STATUS_SUCCESS if all works, otherwise status of system call that
    went wrong.

--*/
{
   UNICODE_STRING              keyName;
   ULONG                       length;
   PKEY_VALUE_FULL_INFORMATION fullInfo;

   NTSTATUS                    ntStatus = STATUS_INSUFFICIENT_RESOURCES;

   PAGED_CODE();

   SerialDbgPrintEx(DPFLTR_TRACE_LEVEL, ">SerialGetRegistryKeyValue(XXX)\n");


   RtlInitUnicodeString (&keyName, KeyNameString);

   length = sizeof(KEY_VALUE_FULL_INFORMATION) + KeyNameStringLength
      + DataLength;
   fullInfo = USB2COM_ExAllocatePool(PagedPool, length);

   if (fullInfo) {
      ntStatus = ZwQueryValueKey (Handle,
                                  &keyName,
                                  KeyValueFullInformation,
                                  fullInfo,
                                  length,
                                  &length);

      if (NT_SUCCESS(ntStatus)) {
         //
         // If there is enough room in the data buffer, copy the output
         //

         if (DataLength >= fullInfo->DataLength) {
            RtlCopyMemory (Data,
                           ((PUCHAR) fullInfo) + fullInfo->DataOffset,
                           fullInfo->DataLength);
         }
      }

      USB2COM_ExFreePool(fullInfo);
   }

   SerialDbgPrintEx(DPFLTR_TRACE_LEVEL, "<SerialGetRegistryKeyValue %X\n",
                    ntStatus);

   return ntStatus;
}


NTSTATUS
SerialPutRegistryKeyValue(
    IN HANDLE Handle,
    IN PWCHAR PKeyNameString,
    IN ULONG KeyNameStringLength,
    IN ULONG Dtype,
    OUT PVOID PData,
    IN ULONG DataLength
    )

/*++

Routine Description:

    Writes a registry key value to an already opened registry key.

Arguments:

    Handle              Handle to the opened registry key

    PKeyNameString      ANSI string to the desired key

    KeyNameStringLength Length of the KeyNameString

    Dtype      REG_XYZ value type

    PData               Buffer to place the key value in

    DataLength          Length of the data buffer

Return Value:

    STATUS_SUCCESS if all works, otherwise status of system call that
    went wrong.

--*/
{
   NTSTATUS status;
   UNICODE_STRING keyname;

   PAGED_CODE();

   SerialDbgPrintEx(DPFLTR_TRACE_LEVEL, ">SerialPutRegistryKeyValue(XXX)\n");

   RtlInitUnicodeString(&keyname, NULL);
   keyname.MaximumLength = (USHORT)(KeyNameStringLength + sizeof(WCHAR));
   keyname.Buffer = USB2COM_ExAllocatePool(PagedPool, keyname.MaximumLength);

   if (keyname.Buffer == NULL) {
      return STATUS_INSUFFICIENT_RESOURCES;
   }

   RtlAppendUnicodeToString(&keyname, PKeyNameString);

   status = ZwSetValueKey(Handle, &keyname, 0, Dtype, PData, DataLength);

   USB2COM_ExFreePool(keyname.Buffer);

   SerialDbgPrintEx(DPFLTR_TRACE_LEVEL, "<SerialPutRegistryKeyValue %X\n",
                    status);

   return status;
}
NTSTATUS
SerialReadSymName(IN PDEVICE_EXTENSION PDevExt, IN HANDLE hRegKey,
                  OUT PUNICODE_STRING PSymName, OUT PWCHAR *PpRegName)
{
   NTSTATUS status;
   UNICODE_STRING linkName;
   PDRIVER_OBJECT pDrvObj;
   PDEVICE_OBJECT pDevObj;

   pDevObj = PDevExt->DeviceObject;
   pDrvObj = pDevObj->DriverObject;
   *PpRegName = NULL;

   RtlZeroMemory(&linkName, sizeof(UNICODE_STRING));

   linkName.MaximumLength = SYMBOLIC_NAME_LENGTH*sizeof(WCHAR);
   linkName.Buffer = USB2COM_ExAllocatePool(PagedPool, linkName.MaximumLength
                                    + sizeof(WCHAR));

   if (linkName.Buffer == NULL) {
      SerialDbgPrintEx(SERERRORS, "Couldn't allocate memory for device name\n");

      status = STATUS_INSUFFICIENT_RESOURCES;
      goto SerialReadSymNameError;

   }

   RtlZeroMemory(linkName.Buffer, linkName.MaximumLength + sizeof(WCHAR));


   *PpRegName = USB2COM_ExAllocatePool(PagedPool, SYMBOLIC_NAME_LENGTH * sizeof(WCHAR)
                               + sizeof(WCHAR));

   if (*PpRegName == NULL) {
      SerialDbgPrintEx(SERERRORS, "Couldn't allocate memory for buffer\n");

      status = STATUS_INSUFFICIENT_RESOURCES;
      goto SerialReadSymNameError;

   }

   //
   // Fetch PortName which contains the suggested REG_SZ symbolic name.
   //

   status = SerialGetRegistryKeyValue(hRegKey, L"PortName",
                                      sizeof(L"PortName"), *PpRegName,
                                      SYMBOLIC_NAME_LENGTH * sizeof(WCHAR));

   if (!NT_SUCCESS(status)) {

      //
      // This is for PCMCIA which currently puts the name under Identifier.
      //

      status = SerialGetRegistryKeyValue(hRegKey, L"Identifier",
                                         sizeof(L"Identifier"),
                                         *PpRegName, SYMBOLIC_NAME_LENGTH
                                         * sizeof(WCHAR));

      if (!NT_SUCCESS(status)) {

         //
         // Hmm.  Either we have to pick a name or bail...
         //
         // ...we will bail.
         //

         SerialDbgPrintEx(SERERRORS, "Getting PortName/Identifier failed - "
                          "%x\n", status);
         goto SerialReadSymNameError;
      }

   }


   //
   // Create the "\\DosDevices\\<symbolicName>" string
   //

   RtlAppendUnicodeToString(&linkName, L"\\DosDevices\\");
   RtlAppendUnicodeToString(&linkName, *PpRegName);

   PSymName->MaximumLength = linkName.Length + sizeof(WCHAR);
   PSymName->Buffer = USB2COM_ExAllocatePool(NonPagedPool, PSymName->MaximumLength);

   if (PSymName->Buffer == NULL) {
      status = STATUS_INSUFFICIENT_RESOURCES;
      goto SerialReadSymNameError;
   }

   RtlZeroMemory(PSymName->Buffer, PSymName->MaximumLength);

   RtlAppendUnicodeStringToString(PSymName, &linkName);

   SerialDbgPrintEx(SERDIAG1, "Read name %wZ\n", PSymName);

SerialReadSymNameError:

   if (linkName.Buffer != NULL) {
      USB2COM_ExFreePool(linkName.Buffer);
      linkName.Buffer = NULL;
   }

   if (!NT_SUCCESS(status)) {
      if (*PpRegName != NULL) {
         USB2COM_ExFreePool(*PpRegName);
         *PpRegName = NULL;
      }
   }

   return status;

}

NTSTATUS