comeml.c

The Lite Evaluation/Demonstration Kit is intended to illustrate use of the AN3042. The AN3042 is c

         sizeof(SubKeyString));

      paramPath.Length = paramPath.MaximumLength;
   }
   else
   {
      return STATUS_INSUFFICIENT_RESOURCES;
   }


   RtlZeroMemory(&paramTable[0], sizeof(paramTable));

   paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
   paramTable[0].Name = L"VendorId";
   paramTable[0].EntryContext = vendorId;
   paramTable[0].DefaultType = REG_DWORD;
   paramTable[0].DefaultData = &zero;
   paramTable[0].DefaultLength = sizeof(ULONG);


   if (!NT_SUCCESS(RtlQueryRegistryValues(
      RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
      paramPath.Buffer, &paramTable[0], NULL, NULL)))
   {
      return STATUS_UNSUCCESSFUL;
   }

   if (paramPath.Buffer)
   {
      ExFreePool( paramPath.Buffer );
   }

   CoMemKdPrint (("COMEM.SYS: Exit CoMemGetVendorId\n"));
}   

NTSTATUS
CoMemGetDeviceId(
    IN PUNICODE_STRING RegistryPath,
    OUT WORD * deviceId
)
{
   UNICODE_STRING  paramPath;
   static  WCHAR   SubKeyString[] = L"\\Parameters";
   RTL_QUERY_REGISTRY_TABLE    paramTable[2];
   ULONG                       zero = 0;

   CoMemKdPrint (("COMEM.SYS: Enter CoMemGetDeviceId\n"));

   //
   // The registry path parameter points to our key, we will append
   // the Parameters key and look for any additional configuration items
   // there.  We add room for a trailing NUL for those routines which
   // require it.

   paramPath.MaximumLength = RegistryPath->Length + sizeof(SubKeyString);
   paramPath.Buffer = ExAllocatePool(PagedPool, paramPath.MaximumLength);

   if (paramPath.Buffer != NULL)
   {
      RtlCopyMemory(paramPath.Buffer, RegistryPath->Buffer, RegistryPath->Length);

      RtlCopyMemory(&paramPath.Buffer[RegistryPath->Length / 2], SubKeyString,
         sizeof(SubKeyString));

      paramPath.Length = paramPath.MaximumLength;
   }
   else
   {
      return STATUS_INSUFFICIENT_RESOURCES;
   }


   RtlZeroMemory(&paramTable[0], sizeof(paramTable));

   paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
   paramTable[0].Name = L"DeviceId";
   paramTable[0].EntryContext = deviceId;
   paramTable[0].DefaultType = REG_DWORD;
   paramTable[0].DefaultData = &zero;
   paramTable[0].DefaultLength = sizeof(ULONG);


   if (!NT_SUCCESS(RtlQueryRegistryValues(
      RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
      paramPath.Buffer, &paramTable[0], NULL, NULL)))
   {
      return STATUS_UNSUCCESSFUL;
   }

   if (paramPath.Buffer)
   {
      ExFreePool( paramPath.Buffer );
   }

   CoMemKdPrint (("COMEM.SYS: Exit CoMemGetDeviceId\n"));
}   

//////////////////////////////////////////////////////////////////////////
// 
// Routine Description:
// 
//     Process the IRPs sent to this device.
// 
// Arguments:
// 
//     DeviceObject - pointer to a device object
// 
//     Irp          - pointer to an I/O Request Packet
// 
// Return Value:
// 
// 
//////////////////////////////////////////////////////////////////////////
NTSTATUS
CoMemDispatch(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )
{
   PIO_STACK_LOCATION irpStack;
   PVOID              ioBuffer;
   ULONG              inputBufferLength;
   ULONG              outputBufferLength;
   ULONG              ioControlCode;
   NTSTATUS           ntStatus = STATUS_SUCCESS;
   PDEVICE_EXTENSION  deviceExtension;
   int                completeTheIrp = TRUE;


   //
   // Init to default settings- we only expect 1 type of
   //     IOCTL to roll through here, all others an error.
   //

   Irp->IoStatus.Status      = STATUS_SUCCESS;
   Irp->IoStatus.Information = 0;


   //
   // Get a pointer to the current location in the Irp. This is where
   //     the function codes and parameters are located.
   //

   irpStack = IoGetCurrentIrpStackLocation(Irp);


   //
   // Get the pointer to the input/output buffer and it's length
   //

   ioBuffer           = Irp->AssociatedIrp.SystemBuffer;
   inputBufferLength  = irpStack->Parameters.DeviceIoControl.InputBufferLength;
   outputBufferLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;

   deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;

   switch (irpStack->MajorFunction)
   {
      case IRP_MJ_CREATE:
         CoMemKdPrint (("COMEM.SYS: IRP_MJ_CREATE\n"));
         deviceExtension->referenceCount++;
      break;

      case IRP_MJ_CLOSE:
         CoMemKdPrint (("COMEM.SYS: IRP_MJ_CLOSE\n"));

         deviceExtension->referenceCount--;

         //
         // Unmap and free the DMA buffer if the user mode app is
         // going away or closing its driver handle.
         //
         CoMemDeAllocContigMemory(DeviceObject);

      break;
     
      case IRP_MJ_DEVICE_CONTROL:

         ioControlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;

         switch (ioControlCode)
         {         
            case IOCTL_COMEM_CREATEBARPTR:

               CoMemKdPrint (("COMEM.SYS: IOCTL_COMEM_CREATEBARPTR\n"));

               //
               // check the Input and Output buffers before proceeding
               //   
               if ((inputBufferLength != sizeof(CreateBarPtrIn)) ||
                   (outputBufferLength != sizeof(CreateBarPtrOut)))
               {
                  CoMemKdPrint (("COMEM.SYS: INVALID_PARAMETER\n"));
                  Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                  break;
               }

               Irp->IoStatus.Status = CoMemMapBars(DeviceObject,Irp);
               Irp->IoStatus.Information = sizeof(CreateBarPtrOut);

            break;

            case IOCTL_COMEM_DESTROYBARPTR:

               CoMemKdPrint (("COMEM.SYS: IOCTL_COMEM_DESTROYBARPTR\n"));

               //
               // check the Input and Output buffers before proceeding
               //   
               if ((inputBufferLength != sizeof(DestroyBarPtrIn)) ||
                   (outputBufferLength != sizeof(DestroyBarPtrOut)))
               {
                  CoMemKdPrint (("COMEM.SYS: INVALID_PARAMETER\n"));
                  Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                  break;
               }
      
               CoMemUnmapBars(DeviceObject);
               Irp->IoStatus.Status = STATUS_SUCCESS;
               Irp->IoStatus.Information = sizeof(DestroyBarPtrOut);

            break;

            case IOCTL_COMEM_ALLOCCONTIGMEM:
               CoMemKdPrint (("COMEM.SYS: IOCTL_COMEM_ALLOCCONTIGMEM\n"));

               //
               // check the Input and Output buffers before proceeding
               //   
               if ((inputBufferLength != sizeof(AllocContigMemIn)) ||
                   (outputBufferLength != sizeof(AllocContigMemOut)))
               {
                  CoMemKdPrint (("COMEM.SYS: INVALID_PARAMETER\n"));
                  Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                  break;
               }
      
               Irp->IoStatus.Status = CoMemAllocContigMemory(DeviceObject,Irp);
               Irp->IoStatus.Information = sizeof(AllocContigMemOut);
            break;

            case IOCTL_COMEM_DEALLOCCONTIGMEM:
               CoMemKdPrint (("COMEM.SYS: IOCTL_COMEM_DEALLOCCONTIGMEM\n"));

               //
               // check the Input and Output buffers before proceeding
               //   
               if ((inputBufferLength != sizeof(DeallocContigMemIn)) ||
                   (outputBufferLength != sizeof(DeallocContigMemOut)))
               {
                  CoMemKdPrint (("COMEM.SYS: INVALID_PARAMETER\n"));
                  Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                  break;
               }

               CoMemDeAllocContigMemory(DeviceObject);
               Irp->IoStatus.Status = STATUS_SUCCESS;
               Irp->IoStatus.Information = sizeof(DeallocContigMemOut);
            break;

            case IOCTL_COMEM_GETSTATUS:
               CoMemKdPrint (("COMEM.SYS: IOCTL_COMEM_GETSTATUS\n"));

               //
               // check the Input and Output buffers before proceeding
               //   
               if ((inputBufferLength != sizeof(GetStatusIn)) ||
                   (outputBufferLength != sizeof(GetStatusOut)))
               {
                  CoMemKdPrint (("COMEM.SYS: INVALID_PARAMETER\n"));
                  Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                  break;
               }

               ((GetStatusOut *) Irp->AssociatedIrp.SystemBuffer)->referenceCount = 
                  deviceExtension->referenceCount;

               //
               // GetStatus always succeeds
               //
               ((GetStatusOut *) Irp->AssociatedIrp.SystemBuffer)->status = NO_ERROR;
               Irp->IoStatus.Information = sizeof(GetStatusOut);
               Irp->IoStatus.Status = STATUS_SUCCESS;

            break;

            case IOCTL_COMEM_GETPCICFG:
            {
               WORD VendorId, DeviceId;
               int Instance;
               GetPciCfgOut *pciCfgOut = (GetPciCfgOut *)Irp->AssociatedIrp.SystemBuffer;

               CoMemKdPrint (("COMEM.SYS: IOCTL_COMEM_GETPCICFG\n"));

               //
               // check the Input and Output buffers before proceeding
               //   
               if ((inputBufferLength != sizeof(GetPciCfgIn)) ||
                   (outputBufferLength != sizeof(GetPciCfgOut)))
               {
                  CoMemKdPrint (("COMEM.SYS: INVALID_PARAMETER\n"));
                  Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                  break;
               }

               VendorId = deviceExtension->vendorId;
               DeviceId = deviceExtension->deviceId;
               Instance = deviceExtension->instance;

               ntStatus = CoMemGetPciConfig(VendorId,
                                            DeviceId,
                                            Instance,
                                            (PCI_CONFIG_HEADER_0 *)Irp->AssociatedIrp.SystemBuffer);

               if (NT_SUCCESS(ntStatus))
               {
                  Irp->IoStatus.Status = STATUS_SUCCESS;
                  pciCfgOut->status = NO_ERROR;
               }
               else
               {
                  Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
                  pciCfgOut->status = ERROR_UNKNOWN;
               }

               //
               // regardless of status, always return data
               //
               Irp->IoStatus.Information = sizeof(GetPciCfgOut);

            }
            break;

            case IOCTL_COMEM_SETPCICFG:
            {
               WORD VendorId, DeviceId;
               int Instance;
               SetPciCfgOut *pciCfgOut = (SetPciCfgOut *)Irp->AssociatedIrp.SystemBuffer;

               CoMemKdPrint (("COMEM.SYS: IOCTL_COMEM_SETPCICFG\n"));

               //
               // check the Input and Output buffers before proceeding
               //   
               if ((inputBufferLength != sizeof(SetPciCfgIn)) ||
                   (outputBufferLength != sizeof(SetPciCfgOut)))
               {
                  CoMemKdPrint (("COMEM.SYS: INVALID_PARAMETER\n"));
                  Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                  break;
               }

               VendorId = deviceExtension->vendorId;
               DeviceId = deviceExtension->deviceId;
               Instance = deviceExtension->instance;

               Irp->IoStatus.Status = CoMemSetPciConfig(VendorId,
                                            DeviceId,
                                            Instance,
                                            (PCI_CONFIG_HEADER_0 *)Irp->AssociatedIrp.SystemBuffer);

               if (NT_SUCCESS(Irp->IoStatus.Status))
               {
                  pciCfgOut->status = NO_ERROR;
               }
               else
               {
                  pciCfgOut->status = ERROR_UNKNOWN;
               }

               //
               // regardless of status, always return data
               //
               Irp->IoStatus.Information = sizeof(SetPciCfgOut);
            }
            break;


            default:
               CoMemKdPrint (("COMEM.SYS: unknown IRP_MJ_DEVICE_CONTROL\n"));

               Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;

            break;

         }

      break;
   }
 

   ntStatus = Irp->IoStatus.Status;