reactos/drivers/input/kbdclass/kbdclass.c

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