reactos/drivers/input/mouclass/mouclass.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Mouse class driver
   4  * FILE:            drivers/mouclass/mouclass.c
   5  * PURPOSE:         Mouse class driver
   6  *
   7  * PROGRAMMERS:     Hervé Poussineau (hpoussin@reactos.org)
   8  */
   9
  10 #define NDEBUG
  11 #include <debug.h>
  12
  13 #define INITGUID
  14 #include "mouclass.h"
  15
  16 static NTSTATUS
  17 SearchForLegacyDrivers(
  18         IN PDRIVER_OBJECT DriverObject,
  19         IN PCLASS_DRIVER_EXTENSION DriverExtension);
  20
  21 static VOID NTAPI
  22 DriverUnload(IN PDRIVER_OBJECT DriverObject)
  23 {
  24         // nothing to do here yet
  25 }
  26
  27 static NTSTATUS NTAPI
  28 ClassCreate(
  29         IN PDEVICE_OBJECT DeviceObject,
  30         IN PIRP Irp)
  31 {
  32         DPRINT("IRP_MJ_CREATE\n");
  33
  34         if (!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
  35                 return ForwardIrpAndForget(DeviceObject, Irp);
  36
  37         /* FIXME: open all associated Port devices */
  38         Irp->IoStatus.Status = STATUS_SUCCESS;
  39         Irp->IoStatus.Information = 0;
  40         IoCompleteRequest(Irp, IO_NO_INCREMENT);
  41         return STATUS_SUCCESS;
  42 }
  43
  44 static NTSTATUS NTAPI
  45 ClassClose(
  46         IN PDEVICE_OBJECT DeviceObject,
  47         IN PIRP Irp)
  48 {
  49         DPRINT("IRP_MJ_CLOSE\n");
  50
  51         if (!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
  52                 return ForwardIrpAndForget(DeviceObject, Irp);
  53
  54         /* FIXME: close all associated Port devices */
  55         Irp->IoStatus.Status = STATUS_SUCCESS;
  56         Irp->IoStatus.Information = 0;
  57         IoCompleteRequest(Irp, IO_NO_INCREMENT);
  58         return STATUS_SUCCESS;
  59 }
  60
  61 static NTSTATUS NTAPI
  62 ClassCleanup(
  63         IN PDEVICE_OBJECT DeviceObject,
  64         IN PIRP Irp)
  65 {
  66         DPRINT("IRP_MJ_CLEANUP\n");
  67
  68         if (!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
  69                 return ForwardIrpAndForget(DeviceObject, Irp);
  70
  71         /* FIXME: cleanup all associated Port devices */
  72         Irp->IoStatus.Status = STATUS_SUCCESS;
  73         Irp->IoStatus.Information = 0;
  74         IoCompleteRequest(Irp, IO_NO_INCREMENT);
  75         return STATUS_SUCCESS;
  76 }
  77
  78 static NTSTATUS NTAPI
  79 ClassRead(
  80         IN PDEVICE_OBJECT DeviceObject,
  81         IN PIRP Irp)
  82 {
  83         DPRINT("IRP_MJ_READ\n");
  84
  85         if (!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
  86                 return ForwardIrpAndForget(DeviceObject, Irp);
  87
  88         if (IoGetCurrentIrpStackLocation(Irp)->Parameters.Read.Length < sizeof(MOUSE_INPUT_DATA))
  89         {
  90                 Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
  91                 Irp->IoStatus.Information = 0;
  92                 IoCompleteRequest(Irp, IO_NO_INCREMENT);
  93
  94                 return STATUS_BUFFER_TOO_SMALL;
  95         }
  96
  97         IoMarkIrpPending(Irp);
  98         IoStartPacket(DeviceObject, Irp, NULL, NULL);
  99         return STATUS_PENDING;
 100 }
 101
 102 static NTSTATUS NTAPI
 103 ClassDeviceControl(
 104         IN PDEVICE_OBJECT DeviceObject,
 105         IN PIRP Irp)
 106 {
 107         PCLASS_DEVICE_EXTENSION DeviceExtension;
 108         NTSTATUS Status = Irp->IoStatus.Status;
 109
 110         DPRINT("IRP_MJ_DEVICE_CONTROL\n");
 111
 112         if (!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
 113                 return ForwardIrpAndForget(DeviceObject, Irp);
 114
 115         DeviceExtension = (PCLASS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 116
 117         switch (IoGetCurrentIrpStackLocation(Irp)->Parameters.DeviceIoControl.IoControlCode)
 118         {
 119                 case IOCTL_MOUSE_QUERY_ATTRIBUTES:
 120                 {
 121                         /* FIXME: We hope that all devices will return the same result.
 122                          * Ask only the first one */
 123                         PLIST_ENTRY Head = &((PCLASS_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->ListHead;
 124                         if (Head->Flink != Head)
 125                         {
 126                                 /* We have at least one mouse */
 127                                 PPORT_DEVICE_EXTENSION DevExt = CONTAINING_RECORD(Head->Flink, PORT_DEVICE_EXTENSION, ListEntry);
 128                                 IoGetCurrentIrpStackLocation(Irp)->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;
 129                                 IoSkipCurrentIrpStackLocation(Irp);
 130                                 return IoCallDriver(DevExt->DeviceObject, Irp);
 131                         }
 132                         break;
 133                 }
 134                 default:
 135                         DPRINT1("IRP_MJ_DEVICE_CONTROL / unknown I/O control code 0x%lx\n",
 136                                 IoGetCurrentIrpStackLocation(Irp)->Parameters.DeviceIoControl.IoControlCode);
 137                         ASSERT(FALSE);
 138                         break;
 139         }
 140
 141         Irp->IoStatus.Status = Status;
 142         Irp->IoStatus.Information = 0;
 143         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 144
 145         return Status;
 146 }
 147
 148 static NTSTATUS NTAPI
 149 IrpStub(
 150         IN PDEVICE_OBJECT DeviceObject,
 151         IN PIRP Irp)
 152 {
 153         NTSTATUS Status = STATUS_NOT_SUPPORTED;
 154
 155         if (!((PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->IsClassDO)
 156         {
 157                 /* Forward some IRPs to lower device */
 158                 switch (IoGetCurrentIrpStackLocation(Irp)->MajorFunction)
 159                 {
 160                         case IRP_MJ_PNP:
 161                         case IRP_MJ_INTERNAL_DEVICE_CONTROL:
 162                                 return ForwardIrpAndForget(DeviceObject, Irp);
 163                         default:
 164                         {
 165                                 DPRINT1("Port DO stub for major function 0x%lx\n",
 166                                         IoGetCurrentIrpStackLocation(Irp)->MajorFunction);
 167                                 ASSERT(FALSE);
 168                                 Status = Irp->IoStatus.Status;
 169                         }
 170                 }
 171         }
 172         else
 173         {
 174                 DPRINT1("Class DO stub for major function 0x%lx\n",
 175                         IoGetCurrentIrpStackLocation(Irp)->MajorFunction);
 176                 ASSERT(FALSE);
 177                 Status = Irp->IoStatus.Status;
 178         }
 179
 180         Irp->IoStatus.Status = Status;
 181         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 182         return Status;
 183 }
 184
 185 static NTSTATUS
 186 ReadRegistryEntries(
 187         IN PUNICODE_STRING RegistryPath,
 188         IN PCLASS_DRIVER_EXTENSION DriverExtension)
 189 {
 190         UNICODE_STRING ParametersRegistryKey;
 191         RTL_QUERY_REGISTRY_TABLE Parameters[4];
 192         NTSTATUS Status;
 193
 194         ULONG DefaultConnectMultiplePorts = 1;
 195         ULONG DefaultDataQueueSize = 0x64;
 196         UNICODE_STRING DefaultDeviceBaseName = RTL_CONSTANT_STRING(L"PointerClass");
 197
 198         ParametersRegistryKey.Length = 0;
 199         ParametersRegistryKey.MaximumLength = RegistryPath->Length + sizeof(L"\\Parameters") + sizeof(UNICODE_NULL);
 200         ParametersRegistryKey.Buffer = ExAllocatePool(PagedPool, ParametersRegistryKey.MaximumLength);
 201         if (!ParametersRegistryKey.Buffer)
 202         {
 203                 DPRINT("ExAllocatePool() failed\n");
 204                 return STATUS_INSUFFICIENT_RESOURCES;
 205         }
 206         RtlCopyUnicodeString(&ParametersRegistryKey, RegistryPath);
 207         RtlAppendUnicodeToString(&ParametersRegistryKey, L"\\Parameters");
 208         ParametersRegistryKey.Buffer[ParametersRegistryKey.Length / sizeof(WCHAR)] = UNICODE_NULL;
 209
 210         RtlZeroMemory(Parameters, sizeof(Parameters));
 211
 212         Parameters[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
 213         Parameters[0].Name = L"ConnectMultiplePorts";
 214         Parameters[0].EntryContext = &DriverExtension->ConnectMultiplePorts;
 215         Parameters[0].DefaultType = REG_DWORD;
 216         Parameters[0].DefaultData = &DefaultConnectMultiplePorts;
 217         Parameters[0].DefaultLength = sizeof(ULONG);
 218
 219         Parameters[1].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
 220         Parameters[1].Name = L"MouseDataQueueSize";
 221         Parameters[1].EntryContext = &DriverExtension->DataQueueSize;
 222         Parameters[1].DefaultType = REG_DWORD;
 223         Parameters[1].DefaultData = &DefaultDataQueueSize;
 224         Parameters[1].DefaultLength = sizeof(ULONG);
 225
 226         Parameters[2].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_REGISTRY_OPTIONAL;
 227         Parameters[2].Name = L"PointerDeviceBaseName";
 228         Parameters[2].EntryContext = &DriverExtension->DeviceBaseName;
 229         Parameters[2].DefaultType = REG_SZ;
 230         Parameters[2].DefaultData = &DefaultDeviceBaseName;
 231         Parameters[2].DefaultLength = 0;
 232
 233         Status = RtlQueryRegistryValues(
 234                 RTL_REGISTRY_ABSOLUTE,
 235                 ParametersRegistryKey.Buffer,
 236                 Parameters,
 237                 NULL,
 238                 NULL);
 239
 240         if (NT_SUCCESS(Status))
 241         {
 242                 /* Check values */
 243                 if (DriverExtension->ConnectMultiplePorts != 0
 244                         && DriverExtension->ConnectMultiplePorts != 1)
 245                 {
 246                         DriverExtension->ConnectMultiplePorts = DefaultConnectMultiplePorts;
 247                 }
 248                 if (DriverExtension->DataQueueSize == 0)
 249                 {
 250                         DriverExtension->DataQueueSize = DefaultDataQueueSize;
 251                 }
 252         }
 253         else if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
 254         {
 255                 /* Registry path doesn't exist. Set defaults */
 256                 DriverExtension->ConnectMultiplePorts = DefaultConnectMultiplePorts;
 257                 DriverExtension->DataQueueSize = DefaultDataQueueSize;
 258                 Status = RtlDuplicateUnicodeString(
 259                         RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
 260                         &DefaultDeviceBaseName,
 261                         &DriverExtension->DeviceBaseName);
 262         }
 263
 264         return Status;
 265 }
 266
 267 static NTSTATUS
 268 CreateClassDeviceObject(
 269         IN PDRIVER_OBJECT DriverObject,
 270         OUT PDEVICE_OBJECT *ClassDO OPTIONAL)
 271 {
 272         PCLASS_DRIVER_EXTENSION DriverExtension;
 273         ULONG DeviceId = 0;
 274         ULONG PrefixLength;
 275         UNICODE_STRING DeviceNameU;
 276         PWSTR DeviceIdW = NULL; /* Pointer into DeviceNameU.Buffer */
 277         PDEVICE_OBJECT Fdo;
 278         PCLASS_DEVICE_EXTENSION DeviceExtension;
 279         NTSTATUS Status;
 280
 281         DPRINT("CreateClassDeviceObject(0x%p)\n", DriverObject);
 282
 283         /* Create new device object */
 284         DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
 285         DeviceNameU.Length = 0;
 286         DeviceNameU.MaximumLength =
 287                 wcslen(L"\\Device\\") * sizeof(WCHAR)    /* "\Device\" */
 288                 + DriverExtension->DeviceBaseName.Length /* "PointerClass" */
 289                 + 4 * sizeof(WCHAR)                      /* Id between 0 and 9999 */
 290                 + sizeof(UNICODE_NULL);                  /* Final NULL char */
 291         DeviceNameU.Buffer = ExAllocatePool(PagedPool, DeviceNameU.MaximumLength);
 292         if (!DeviceNameU.Buffer)
 293         {
 294                 DPRINT("ExAllocatePool() failed\n");
 295                 return STATUS_INSUFFICIENT_RESOURCES;
 296         }
 297         Status = RtlAppendUnicodeToString(&DeviceNameU, L"\\Device\\");
 298         if (!NT_SUCCESS(Status))
 299         {
 300                 DPRINT("RtlAppendUnicodeToString() failed with status 0x%08lx\n", Status);
 301                 goto cleanup;
 302         }
 303         Status = RtlAppendUnicodeStringToString(&DeviceNameU, &DriverExtension->DeviceBaseName);
 304         if (!NT_SUCCESS(Status))
 305         {
 306                 DPRINT("RtlAppendUnicodeStringToString() failed with status 0x%08lx\n", Status);
 307                 goto cleanup;
 308         }
 309         PrefixLength = DeviceNameU.MaximumLength - 4 * sizeof(WCHAR) - sizeof(UNICODE_NULL);
 310         DeviceIdW = &DeviceNameU.Buffer[PrefixLength / sizeof(WCHAR)];
 311         while (DeviceId < 9999)
 312         {
 313                 DeviceNameU.Length = PrefixLength + swprintf(DeviceIdW, L"%lu", DeviceId) * sizeof(WCHAR);
 314                 Status = IoCreateDevice(
 315                         DriverObject,
 316                         sizeof(CLASS_DEVICE_EXTENSION),
 317                         &DeviceNameU,
 318                         FILE_DEVICE_MOUSE,
 319                         FILE_DEVICE_SECURE_OPEN,
 320                         TRUE,
 321                         &Fdo);
 322                 if (NT_SUCCESS(Status))
 323                         goto cleanup;
 324                 else if (Status != STATUS_OBJECT_NAME_COLLISION)
 325                 {
 326                         DPRINT("IoCreateDevice() failed with status 0x%08lx\n", Status);
 327                         goto cleanup;
 328                 }
 329                 DeviceId++;
 330         }
 331         DPRINT("Too many devices starting with '\\Device\\%wZ'\n", &DriverExtension->DeviceBaseName);
 332         Status = STATUS_TOO_MANY_NAMES;
 333 cleanup:
 334         if (!NT_SUCCESS(Status))
 335         {
 336                 ExFreePool(DeviceNameU.Buffer);
 337                 return Status;
 338         }
 339
 340         DeviceExtension = (PCLASS_DEVICE_EXTENSION)Fdo->DeviceExtension;
 341         RtlZeroMemory(DeviceExtension, sizeof(CLASS_DEVICE_EXTENSION));
 342         DeviceExtension->Common.IsClassDO = TRUE;
 343         DeviceExtension->DriverExtension = DriverExtension;
 344         InitializeListHead(&DeviceExtension->ListHead);
 345         KeInitializeSpinLock(&DeviceExtension->ListSpinLock);
 346         KeInitializeSpinLock(&DeviceExtension->SpinLock);
 347         DeviceExtension->ReadIsPending = FALSE;
 348         DeviceExtension->InputCount = 0;
 349         DeviceExtension->PortData = ExAllocatePool(NonPagedPool, DeviceExtension->DriverExtension->DataQueueSize * sizeof(MOUSE_INPUT_DATA));
 350         Fdo->Flags |= DO_POWER_PAGABLE;
 351         Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
 352
 353         /* Add entry entry to HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP\[DeviceBaseName] */
 354         RtlWriteRegistryValue(
 355                 RTL_REGISTRY_DEVICEMAP,
 356                 DriverExtension->DeviceBaseName.Buffer,
 357                 DeviceNameU.Buffer,
 358                 REG_SZ,
 359                 DriverExtension->RegistryPath.Buffer,
 360                 DriverExtension->RegistryPath.MaximumLength);
 361
 362         ExFreePool(DeviceNameU.Buffer);
 363
 364         if (ClassDO)
 365                 *ClassDO = Fdo;
 366
 367         return STATUS_SUCCESS;
 368 }
 369
 370 static NTSTATUS
 371 FillOneEntry(
 372         IN PDEVICE_OBJECT ClassDeviceObject,
 373         IN PIRP Irp,
 374         IN PMOUSE_INPUT_DATA DataStart)
 375 {
 376         NTSTATUS Status = STATUS_SUCCESS;
 377
 378         if (ClassDeviceObject->Flags & DO_BUFFERED_IO)
 379         {
 380                 RtlCopyMemory(
 381                         Irp->AssociatedIrp.SystemBuffer,
 382                         DataStart,
 383                         sizeof(MOUSE_INPUT_DATA));
 384         }
 385         else if (ClassDeviceObject->Flags & DO_DIRECT_IO)
 386         {
 387                 PVOID DestAddress = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
 388                 if (DestAddress)
 389                 {
 390                         RtlCopyMemory(
 391                                 DestAddress,
 392                                 DataStart,
 393                                 sizeof(MOUSE_INPUT_DATA));
 394                 }
 395                 else
 396                         Status = STATUS_UNSUCCESSFUL;
 397         }
 398         else
 399         {
 400                 _SEH_TRY
 401                 {
 402                         RtlCopyMemory(
 403                                 Irp->UserBuffer,
 404                                 DataStart,
 405                                 sizeof(MOUSE_INPUT_DATA));
 406                 }
 407                 _SEH_HANDLE
 408                 {
 409                         Status = _SEH_GetExceptionCode();
 410                 }
 411                 _SEH_END;
 412         }
 413
 414         return Status;
 415 }
 416
 417 static BOOLEAN
 418 ClassCallback(
 419         IN PDEVICE_OBJECT ClassDeviceObject,
 420         IN OUT PMOUSE_INPUT_DATA DataStart,
 421         IN PMOUSE_INPUT_DATA DataEnd,
 422         IN OUT PULONG ConsumedCount)
 423 {
 424         PCLASS_DEVICE_EXTENSION ClassDeviceExtension = ClassDeviceObject->DeviceExtension;
 425         PIRP Irp = NULL;
 426         KIRQL OldIrql;
 427         PIO_STACK_LOCATION Stack;
 428         ULONG InputCount = DataEnd - DataStart;
 429         ULONG ReadSize;
 430
 431         ASSERT(ClassDeviceExtension->Common.IsClassDO);
 432
 433         KeAcquireSpinLock(&ClassDeviceExtension->SpinLock, &OldIrql);
 434
 435         DPRINT("ClassCallback()\n");
 436         /* A filter driver might have consumed all the data already; I'm
 437          * not sure if they are supposed to move the packets when they
 438          * consume them though.
 439          */
 440         if (ClassDeviceExtension->ReadIsPending == TRUE && InputCount)
 441         {
 442                 NTSTATUS Status;
 443
 444                 Irp = ClassDeviceObject->CurrentIrp;
 445                 ClassDeviceObject->CurrentIrp = NULL;
 446                 Stack = IoGetCurrentIrpStackLocation(Irp);
 447
 448                 /* A read request is waiting for input, so go straight to it */
 449                 Status = FillOneEntry(
 450                         ClassDeviceObject,
 451                         Irp,
 452                         DataStart);
 453
 454                 if (NT_SUCCESS(Status))
 455                 {
 456                         /* Go to next packet and complete this request with STATUS_SUCCESS */
 457                         Irp->IoStatus.Status = STATUS_SUCCESS;
 458                         Irp->IoStatus.Information = sizeof(MOUSE_INPUT_DATA);
 459                         Stack->Parameters.Read.Length = sizeof(MOUSE_INPUT_DATA);
 460
 461                         ClassDeviceExtension->ReadIsPending = FALSE;
 462
 463                         /* Skip the packet we just sent away */
 464                         DataStart++;
 465                         (*ConsumedCount)++;
 466                         InputCount--;
 467                 }
 468         }
 469
 470         /* If we have data from the port driver and a higher service to send the data to */
 471         if (InputCount != 0)
 472         {
 473                 if (ClassDeviceExtension->InputCount + InputCount > ClassDeviceExtension->DriverExtension->DataQueueSize)
 474                 {
 475                         /*
 476                          * We're exceeding the buffer, and data will be thrown away...
 477                          * FIXME: What could we do, as we are at DISPATCH_LEVEL?
 478                          */
 479                         ReadSize = ClassDeviceExtension->DriverExtension->DataQueueSize - ClassDeviceExtension->InputCount;
 480                 }
 481                 else
 482                         ReadSize = InputCount;
 483
 484                 /*
 485                  * Move the input data from the port data queue to our class data
 486                  * queue.
 487                  */
 488                 RtlMoveMemory(
 489                         ClassDeviceExtension->PortData,
 490                         (PCHAR)DataStart,
 491                         sizeof(MOUSE_INPUT_DATA) * ReadSize);
 492
 493                 /* Move the pointer and counter up */
 494                 ClassDeviceExtension->PortData += ReadSize;
 495                 ClassDeviceExtension->InputCount += ReadSize;
 496
 497                 (*ConsumedCount) += ReadSize;
 498         }
 499         else
 500         {
 501                 DPRINT("ClassCallBack() entered, InputCount = %lu - DOING NOTHING\n", InputCount);
 502         }
 503
 504         KeReleaseSpinLock(&ClassDeviceExtension->SpinLock, OldIrql);
 505
 506         if (Irp != NULL)
 507         {
 508                 IoStartNextPacket(ClassDeviceObject, FALSE);
 509                 IoCompleteRequest(Irp, IO_MOUSE_INCREMENT);
 510         }
 511
 512         DPRINT("Leaving ClassCallback()\n");
 513         return TRUE;
 514 }
 515
 516 /* Send IOCTL_INTERNAL_*_CONNECT to port */
 517 static NTSTATUS
 518 ConnectPortDriver(
 519         IN PDEVICE_OBJECT PortDO,
 520         IN PDEVICE_OBJECT ClassDO)
 521 {
 522         KEVENT Event;
 523         PIRP Irp;
 524         IO_STATUS_BLOCK IoStatus;
 525         CONNECT_DATA ConnectData;
 526         NTSTATUS Status;
 527
 528         KeInitializeEvent(&Event, NotificationEvent, FALSE);
 529
 530         ConnectData.ClassDeviceObject = ClassDO;
 531         ConnectData.ClassService      = ClassCallback;
 532
 533         Irp = IoBuildDeviceIoControlRequest(IOCTL_INTERNAL_MOUSE_CONNECT,
 534                 PortDO,
 535                 &ConnectData, sizeof(CONNECT_DATA),
 536                 NULL, 0,
 537                 TRUE, &Event, &IoStatus);
 538
 539         Status = IoCallDriver(PortDO, Irp);
 540
 541         if (Status == STATUS_PENDING)
 542                 KeWaitForSingleObject(&Event, Suspended, KernelMode, FALSE, NULL);
 543         else
 544                 IoStatus.Status = Status;
 545
 546         if (NT_SUCCESS(IoStatus.Status))
 547         {
 548                 ObReferenceObject(PortDO);
 549                 ExInterlockedInsertTailList(
 550                         &((PCLASS_DEVICE_EXTENSION)ClassDO->DeviceExtension)->ListHead,
 551                         &((PPORT_DEVICE_EXTENSION)PortDO->DeviceExtension)->ListEntry,
 552                         &((PCLASS_DEVICE_EXTENSION)ClassDO->DeviceExtension)->ListSpinLock);
 553                 if (ClassDO->StackSize <= PortDO->StackSize)
 554                 {
 555                         /* Increase the stack size, in case we have to
 556                          * forward some IRPs to the port device object
 557                          */
 558                         ClassDO->StackSize = PortDO->StackSize + 1;
 559                 }
 560         }
 561
 562         return IoStatus.Status;
 563 }
 564
 565 static NTSTATUS NTAPI
 566 ClassAddDevice(
 567         IN PDRIVER_OBJECT DriverObject,
 568         IN PDEVICE_OBJECT Pdo)
 569 {
 570         PCLASS_DRIVER_EXTENSION DriverExtension;
 571         PDEVICE_OBJECT Fdo = NULL;
 572         PPORT_DEVICE_EXTENSION DeviceExtension = NULL;
 573         NTSTATUS Status;
 574
 575         DPRINT("ClassAddDevice called. Pdo = 0x%p\n", Pdo);
 576
 577         DriverExtension = IoGetDriverObjectExtension(DriverObject, DriverObject);
 578
 579         if (Pdo == NULL)
 580                 /* We're getting a NULL Pdo at the first call as we're a legacy driver.
 581                  * Use it to search for legacy port drivers. */
 582                 return SearchForLegacyDrivers(DriverObject, DriverExtension);
 583
 584         /* Create new device object */
 585         Status = IoCreateDevice(
 586                 DriverObject,
 587                 sizeof(PORT_DEVICE_EXTENSION),
 588                 NULL,
 589                 Pdo->DeviceType,
 590                 Pdo->Characteristics & FILE_DEVICE_SECURE_OPEN ? FILE_DEVICE_SECURE_OPEN : 0,
 591                 TRUE,
 592                 &Fdo);
 593         if (!NT_SUCCESS(Status))
 594         {
 595                 DPRINT("IoCreateDevice() failed with status 0x%08lx\n", Status);
 596                 goto cleanup;
 597         }
 598
 599         DeviceExtension = (PPORT_DEVICE_EXTENSION)Fdo->DeviceExtension;
 600         RtlZeroMemory(DeviceExtension, sizeof(CLASS_DEVICE_EXTENSION));
 601         DeviceExtension->Common.IsClassDO = FALSE;
 602         DeviceExtension->DeviceObject = Fdo;
 603         DeviceExtension->PnpState = dsStopped;
 604         Status = IoAttachDeviceToDeviceStackSafe(Fdo, Pdo, &DeviceExtension->LowerDevice);
 605         if (!NT_SUCCESS(Status))
 606         {
 607                 DPRINT("IoAttachDeviceToDeviceStackSafe() failed with status 0x%08lx\n", Status);
 608                 goto cleanup;
 609         }
 610         if (DeviceExtension->LowerDevice->Flags & DO_POWER_PAGABLE)
 611                 Fdo->Flags |= DO_POWER_PAGABLE;
 612         if (DeviceExtension->LowerDevice->Flags & DO_BUFFERED_IO)
 613                 Fdo->Flags |= DO_BUFFERED_IO;
 614         if (DeviceExtension->LowerDevice->Flags & DO_DIRECT_IO)
 615                 Fdo->Flags |= DO_DIRECT_IO;
 616
 617         if (DriverExtension->ConnectMultiplePorts)
 618                 DeviceExtension->ClassDO = DriverExtension->MainClassDeviceObject;
 619         else
 620         {
 621                 /* We need a new class device object for this Fdo */
 622                 Status = CreateClassDeviceObject(
 623                         DriverObject,
 624                         &DeviceExtension->ClassDO);
 625                 if (!NT_SUCCESS(Status))
 626                 {
 627                         DPRINT("CreateClassDeviceObject() failed with status 0x%08lx\n", Status);
 628                         goto cleanup;
 629                 }
 630         }
 631         Status = ConnectPortDriver(Fdo, DeviceExtension->ClassDO);
 632         if (!NT_SUCCESS(Status))
 633         {
 634                 DPRINT("ConnectPortDriver() failed with status 0x%08lx\n", Status);
 635                 goto cleanup;
 636         }
 637         Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
 638
 639         /* Register interface */
 640         Status = IoRegisterDeviceInterface(
 641                 Pdo,
 642                 &GUID_DEVINTERFACE_MOUSE,
 643                 NULL,
 644                 &DeviceExtension->InterfaceName);
 645         if (Status == STATUS_INVALID_PARAMETER_1)
 646         {
 647                 /* The Pdo was a strange one ; maybe it is a legacy device.
 648                  * Ignore the error. */
 649                 return STATUS_SUCCESS;
 650         }
 651         else if (!NT_SUCCESS(Status))
 652         {
 653                 DPRINT("IoRegisterDeviceInterface() failed with status 0x%08lx\n", Status);
 654                 goto cleanup;
 655         }
 656
 657         return STATUS_SUCCESS;
 658
 659 cleanup:
 660         if (DeviceExtension)
 661         {
 662                 if (DeviceExtension->LowerDevice)
 663                         IoDetachDevice(DeviceExtension->LowerDevice);
 664                 if (DriverExtension->ConnectMultiplePorts && DeviceExtension->ClassDO)
 665                 {
 666                         PCLASS_DEVICE_EXTENSION ClassDeviceExtension;
 667                         ClassDeviceExtension = (PCLASS_DEVICE_EXTENSION)DeviceExtension->ClassDO->DeviceExtension;
 668                         ExFreePool(ClassDeviceExtension->PortData);
 669                 }
 670         }
 671         if (Fdo)
 672                 IoDeleteDevice(Fdo);
 673         return Status;
 674 }
 675
 676 static VOID NTAPI
 677 ClassStartIo(
 678         IN PDEVICE_OBJECT DeviceObject,
 679         IN PIRP Irp)
 680 {
 681         PCLASS_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
 682         PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
 683
 684         ASSERT(DeviceExtension->Common.IsClassDO);
 685
 686         if (DeviceExtension->InputCount > 0)
 687         {
 688                 KIRQL oldIrql;
 689                 NTSTATUS Status;
 690
 691                 KeAcquireSpinLock(&DeviceExtension->SpinLock, &oldIrql);
 692
 693                 Status = FillOneEntry(
 694                         DeviceObject,
 695                         Irp,
 696                         DeviceExtension->PortData - DeviceExtension->InputCount);
 697
 698                 if (NT_SUCCESS(Status))
 699                 {
 700                         if (DeviceExtension->InputCount > 1)
 701                         {
 702                                 RtlMoveMemory(
 703                                         DeviceExtension->PortData - DeviceExtension->InputCount,
 704                                         DeviceExtension->PortData - DeviceExtension->InputCount + 1,
 705                                         (DeviceExtension->InputCount - 1) * sizeof(MOUSE_INPUT_DATA));
 706                         }
 707
 708                         DeviceExtension->PortData--;
 709                         DeviceExtension->InputCount--;
 710                         DeviceExtension->ReadIsPending = FALSE;
 711
 712                         Irp->IoStatus.Information = sizeof(MOUSE_INPUT_DATA);
 713                         Stack->Parameters.Read.Length = sizeof(MOUSE_INPUT_DATA);
 714                 }
 715
 716                 /* Go to next packet and complete this request */
 717                 Irp->IoStatus.Status = Status;
 718                 IoCompleteRequest(Irp, IO_MOUSE_INCREMENT);
 719
 720                 IoStartNextPacket(DeviceObject, FALSE);
 721                 KeReleaseSpinLock(&DeviceExtension->SpinLock, oldIrql);
 722         }
 723         else
 724         {
 725                 DeviceExtension->ReadIsPending = TRUE;
 726         }
 727 }
 728
 729 static NTSTATUS
 730 SearchForLegacyDrivers(
 731         IN PDRIVER_OBJECT DriverObject,
 732         IN PCLASS_DRIVER_EXTENSION DriverExtension)
 733 {
 734         UNICODE_STRING DeviceMapKeyU = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\HARDWARE\\DEVICEMAP");
 735         UNICODE_STRING PortBaseName = {0, };
 736         PKEY_VALUE_BASIC_INFORMATION KeyValueInformation = NULL;
 737         OBJECT_ATTRIBUTES ObjectAttributes;
 738         HANDLE hDeviceMapKey = (HANDLE)-1;
 739         HANDLE hPortKey = (HANDLE)-1;
 740         ULONG Index = 0;
 741         ULONG Size, ResultLength;
 742         NTSTATUS Status;
 743
 744         /* Create port base name, by replacing Class by Port at the end of the class base name */
 745         Status = RtlDuplicateUnicodeString(
 746                 RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
 747                 &DriverExtension->DeviceBaseName,
 748                 &PortBaseName);
 749         if (!NT_SUCCESS(Status))
 750         {
 751                 DPRINT("RtlDuplicateUnicodeString() failed with status 0x%08lx\n", Status);
 752                 goto cleanup;
 753         }
 754         PortBaseName.Length -= (sizeof(L"Class") - sizeof(UNICODE_NULL));
 755         RtlAppendUnicodeToString(&PortBaseName, L"Port");
 756
 757         /* Allocate memory */
 758         Size = sizeof(KEY_VALUE_BASIC_INFORMATION) + MAX_PATH;
 759         KeyValueInformation = ExAllocatePool(PagedPool, Size);
 760         if (!KeyValueInformation)
 761         {
 762                 DPRINT("ExAllocatePool() failed\n");
 763                 Status = STATUS_INSUFFICIENT_RESOURCES;
 764                 goto cleanup;
 765         }
 766
 767         /* Open HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP */
 768         InitializeObjectAttributes(&ObjectAttributes, &DeviceMapKeyU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
 769         Status = ZwOpenKey(&hDeviceMapKey, 0, &ObjectAttributes);
 770         if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
 771         {
 772                 DPRINT("HKLM\\HARDWARE\\DEVICEMAP is non-existent\n");
 773                 Status = STATUS_SUCCESS;
 774                 goto cleanup;
 775         }
 776         else if (!NT_SUCCESS(Status))
 777         {
 778                 DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
 779                 goto cleanup;
 780         }
 781
 782         /* Open sub key */
 783         InitializeObjectAttributes(&ObjectAttributes, &PortBaseName, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hDeviceMapKey, NULL);
 784         Status = ZwOpenKey(&hPortKey, KEY_QUERY_VALUE, &ObjectAttributes);
 785         if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
 786         {
 787                 DPRINT("HKLM\\HARDWARE\\DEVICEMAP\\%wZ is non-existent\n", &PortBaseName);
 788                 Status = STATUS_SUCCESS;
 789                 goto cleanup;
 790         }
 791         else if (!NT_SUCCESS(Status))
 792         {
 793                 DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
 794                 goto cleanup;
 795         }
 796
 797         /* Read each value name */
 798         while (ZwEnumerateValueKey(hPortKey, Index++, KeyValueBasicInformation, KeyValueInformation, Size, &ResultLength) == STATUS_SUCCESS)
 799         {
 800                 UNICODE_STRING PortName;
 801                 PDEVICE_OBJECT PortDeviceObject = NULL;
 802                 PFILE_OBJECT FileObject = NULL;
 803
 804                 PortName.Length = PortName.MaximumLength = KeyValueInformation->NameLength;
 805                 PortName.Buffer = KeyValueInformation->Name;
 806
 807                 /* Open the device object pointer */
 808                 Status = IoGetDeviceObjectPointer(&PortName, FILE_READ_ATTRIBUTES, &FileObject, &PortDeviceObject);
 809                 if (!NT_SUCCESS(Status))
 810                 {
 811                         DPRINT("IoGetDeviceObjectPointer(%wZ) failed with status 0x%08lx\n", Status);
 812                         continue;
 813                 }
 814                 DPRINT("Legacy driver found: %wZ\n", &PortDeviceObject->DriverObject->DriverName);
 815
 816                 Status = ClassAddDevice(DriverObject, PortDeviceObject);
 817                 if (!NT_SUCCESS(Status))
 818                 {
 819                         /* FIXME: Log the error */
 820                         DPRINT("ClassAddDevice() failed with status 0x%08lx\n", Status);
 821                 }
 822         }
 823         if (Status == STATUS_NO_MORE_ENTRIES)
 824                 Status = STATUS_SUCCESS;
 825
 826 cleanup:
 827         if (KeyValueInformation != NULL)
 828                 ExFreePool(KeyValueInformation);
 829         if (hDeviceMapKey != (HANDLE)-1)
 830                 ZwClose(hDeviceMapKey);
 831         if (hPortKey != (HANDLE)-1)
 832                 ZwClose(hPortKey);
 833         return Status;
 834 }
 835
 836 /*
 837  * Standard DriverEntry method.
 838  */
 839 NTSTATUS NTAPI
 840 DriverEntry(
 841         IN PDRIVER_OBJECT DriverObject,
 842         IN PUNICODE_STRING RegistryPath)
 843 {
 844         PCLASS_DRIVER_EXTENSION DriverExtension;
 845         ULONG i;
 846         NTSTATUS Status;
 847
 848         Status = IoAllocateDriverObjectExtension(
 849                 DriverObject,
 850                 DriverObject,
 851                 sizeof(CLASS_DRIVER_EXTENSION),
 852                 (PVOID*)&DriverExtension);
 853         if (!NT_SUCCESS(Status))
 854         {
 855                 DPRINT("IoAllocateDriverObjectExtension() failed with status 0x%08lx\n", Status);
 856                 return Status;
 857         }
 858         RtlZeroMemory(DriverExtension, sizeof(CLASS_DRIVER_EXTENSION));
 859
 860         Status = RtlDuplicateUnicodeString(
 861                 RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
 862                 RegistryPath,
 863                 &DriverExtension->RegistryPath);
 864         if (!NT_SUCCESS(Status))
 865         {
 866                 DPRINT("RtlDuplicateUnicodeString() failed with status 0x%08lx\n", Status);
 867                 return Status;
 868         }
 869
 870         Status = ReadRegistryEntries(RegistryPath, DriverExtension);
 871         if (!NT_SUCCESS(Status))
 872         {
 873                 DPRINT("ReadRegistryEntries() failed with status 0x%08lx\n", Status);
 874                 return Status;
 875         }
 876
 877         if (DriverExtension->ConnectMultiplePorts == 1)
 878         {
 879                 Status = CreateClassDeviceObject(
 880                         DriverObject,
 881                         &DriverExtension->MainClassDeviceObject);
 882                 if (!NT_SUCCESS(Status))
 883                 {
 884                         DPRINT("CreateClassDeviceObject() failed with status 0x%08lx\n", Status);
 885                         return Status;
 886                 }
 887         }
 888
 889         DriverObject->DriverExtension->AddDevice = ClassAddDevice;
 890         DriverObject->DriverUnload = DriverUnload;
 891
 892         for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
 893                 DriverObject->MajorFunction[i] = IrpStub;
 894
 895         DriverObject->MajorFunction[IRP_MJ_CREATE]         = ClassCreate;
 896         DriverObject->MajorFunction[IRP_MJ_CLOSE]          = ClassClose;
 897         DriverObject->MajorFunction[IRP_MJ_CLEANUP]        = ClassCleanup;
 898         DriverObject->MajorFunction[IRP_MJ_READ]           = ClassRead;
 899         DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ClassDeviceControl;
 900         DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = ForwardIrpAndForget;
 901         DriverObject->DriverStartIo                        = ClassStartIo;
 902
 903         return STATUS_SUCCESS;
 904 }