drivers/input/i8042prt/i8042prt.c

   1 /*
   2  * PROJECT:     ReactOS i8042 (ps/2 keyboard-mouse controller) driver
   3  * LICENSE:     GPL - See COPYING in the top level directory
   4  * FILE:        drivers/input/i8042prt/i8042prt.c
   5  * PURPOSE:     Driver entry function
   6  * PROGRAMMERS: Copyright Victor Kirhenshtein (sauros@iname.com)
   7                 Copyright Jason Filby (jasonfilby@yahoo.com)
   8                 Copyright Martijn Vernooij (o112w8r02@sneakemail.com)
   9                 Copyright 2006-2007 Hervé Poussineau (hpoussin@reactos.org)
  10  */
  11
  12 /* INCLUDES ******************************************************************/
  13
  14 #include "i8042prt.h"
  15
  16 #include <debug.h>
  17
  18 /* FUNCTIONS *****************************************************************/
  19
  20 static DRIVER_STARTIO i8042StartIo;
  21 static DRIVER_DISPATCH IrpStub;
  22 _Dispatch_type_(IRP_MJ_DEVICE_CONTROL)
  23 static DRIVER_DISPATCH i8042DeviceControl;
  24 _Dispatch_type_(IRP_MJ_INTERNAL_DEVICE_CONTROL)
  25 static DRIVER_DISPATCH i8042InternalDeviceControl;
  26 _Dispatch_type_(IRP_MJ_SYSTEM_CONTROL)
  27 static DRIVER_DISPATCH i8042SystemControl;
  28 _Dispatch_type_(IRP_MJ_POWER)
  29 static DRIVER_DISPATCH i8042Power;
  30 DRIVER_INITIALIZE DriverEntry;
  31
  32 NTSTATUS NTAPI
  33 i8042AddDevice(
  34         IN PDRIVER_OBJECT DriverObject,
  35         IN PDEVICE_OBJECT Pdo)
  36 {
  37         PI8042_DRIVER_EXTENSION DriverExtension;
  38         PFDO_DEVICE_EXTENSION DeviceExtension = NULL;
  39         PDEVICE_OBJECT Fdo = NULL;
  40         ULONG DeviceExtensionSize;
  41         NTSTATUS Status;
  42
  43         TRACE_(I8042PRT, "i8042AddDevice(%p %p)\n", DriverObject, Pdo);
  44
  45         DriverExtension = (PI8042_DRIVER_EXTENSION)IoGetDriverObjectExtension(DriverObject, DriverObject);
  46
  47         if (Pdo == NULL)
  48         {
  49                 /* We're getting a NULL Pdo at the first call as
  50                  * we are a legacy driver. Ignore it */
  51                 return STATUS_SUCCESS;
  52         }
  53
  54         /* Create new device object. As we don't know if the device would be a keyboard
  55          * or a mouse, we have to allocate the biggest device extension. */
  56         DeviceExtensionSize = MAX(sizeof(I8042_KEYBOARD_EXTENSION), sizeof(I8042_MOUSE_EXTENSION));
  57         Status = IoCreateDevice(
  58                 DriverObject,
  59                 DeviceExtensionSize,
  60                 NULL,
  61                 Pdo->DeviceType,
  62                 FILE_DEVICE_SECURE_OPEN,
  63                 TRUE,
  64                 &Fdo);
  65         if (!NT_SUCCESS(Status))
  66         {
  67                 WARN_(I8042PRT, "IoCreateDevice() failed with status 0x%08lx\n", Status);
  68                 goto cleanup;
  69         }
  70
  71         DeviceExtension = (PFDO_DEVICE_EXTENSION)Fdo->DeviceExtension;
  72         RtlZeroMemory(DeviceExtension, DeviceExtensionSize);
  73         DeviceExtension->Type = Unknown;
  74         DeviceExtension->Fdo = Fdo;
  75         DeviceExtension->Pdo = Pdo;
  76         DeviceExtension->PortDeviceExtension = &DriverExtension->Port;
  77         Status = IoAttachDeviceToDeviceStackSafe(Fdo, Pdo, &DeviceExtension->LowerDevice);
  78         if (!NT_SUCCESS(Status))
  79         {
  80                 WARN_(I8042PRT, "IoAttachDeviceToDeviceStackSafe() failed with status 0x%08lx\n", Status);
  81                 goto cleanup;
  82         }
  83
  84         ExInterlockedInsertTailList(
  85                 &DriverExtension->DeviceListHead,
  86                 &DeviceExtension->ListEntry,
  87                 &DriverExtension->DeviceListLock);
  88
  89         Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
  90         return STATUS_SUCCESS;
  91
  92 cleanup:
  93         if (DeviceExtension && DeviceExtension->LowerDevice)
  94                 IoDetachDevice(DeviceExtension->LowerDevice);
  95         if (Fdo)
  96                 IoDeleteDevice(Fdo);
  97         return Status;
  98 }
  99
 100 VOID NTAPI
 101 i8042SendHookWorkItem(
 102         IN PDEVICE_OBJECT DeviceObject,
 103         IN PVOID Context)
 104 {
 105         PI8042_HOOK_WORKITEM WorkItemData;
 106         PFDO_DEVICE_EXTENSION FdoDeviceExtension;
 107         PPORT_DEVICE_EXTENSION PortDeviceExtension;
 108         PDEVICE_OBJECT TopOfStack = NULL;
 109         ULONG IoControlCode;
 110         PVOID InputBuffer;
 111         ULONG InputBufferLength;
 112         IO_STATUS_BLOCK IoStatus;
 113         KEVENT Event;
 114         PIRP NewIrp;
 115         NTSTATUS Status;
 116
 117         TRACE_(I8042PRT, "i8042SendHookWorkItem(%p %p)\n", DeviceObject, Context);
 118
 119         WorkItemData = (PI8042_HOOK_WORKITEM)Context;
 120         FdoDeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 121         PortDeviceExtension = FdoDeviceExtension->PortDeviceExtension;
 122
 123         switch (FdoDeviceExtension->Type)
 124         {
 125                 case Keyboard:
 126                 {
 127                         PI8042_KEYBOARD_EXTENSION DeviceExtension;
 128                         DeviceExtension = (PI8042_KEYBOARD_EXTENSION)FdoDeviceExtension;
 129                         IoControlCode = IOCTL_INTERNAL_I8042_HOOK_KEYBOARD;
 130                         InputBuffer = &DeviceExtension->KeyboardHook;
 131                         InputBufferLength = sizeof(INTERNAL_I8042_HOOK_KEYBOARD);
 132                         break;
 133                 }
 134                 case Mouse:
 135                 {
 136                         PI8042_MOUSE_EXTENSION DeviceExtension;
 137                         DeviceExtension = (PI8042_MOUSE_EXTENSION)FdoDeviceExtension;
 138                         IoControlCode = IOCTL_INTERNAL_I8042_HOOK_MOUSE;
 139                         InputBuffer = &DeviceExtension->MouseHook;
 140                         InputBufferLength = sizeof(INTERNAL_I8042_HOOK_MOUSE);
 141                         break;
 142                 }
 143                 default:
 144                 {
 145                         ERR_(I8042PRT, "Unknown FDO type %u\n", FdoDeviceExtension->Type);
 146                         ASSERT(FALSE);
 147                         WorkItemData->Irp->IoStatus.Status = STATUS_INTERNAL_ERROR;
 148                         goto cleanup;
 149                 }
 150         }
 151
 152         KeInitializeEvent(&Event, NotificationEvent, FALSE);
 153         TopOfStack = IoGetAttachedDeviceReference(DeviceObject);
 154
 155         NewIrp = IoBuildDeviceIoControlRequest(
 156                 IoControlCode,
 157                 TopOfStack,
 158                 InputBuffer,
 159                 InputBufferLength,
 160                 NULL,
 161                 0,
 162                 TRUE,
 163                 &Event,
 164                 &IoStatus);
 165
 166         if (!NewIrp)
 167         {
 168                 WARN_(I8042PRT, "IoBuildDeviceIoControlRequest() failed\n");
 169                 WorkItemData->Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
 170                 goto cleanup;
 171         }
 172
 173         Status = IoCallDriver(TopOfStack, NewIrp);
 174         if (Status == STATUS_PENDING)
 175         {
 176                 KeWaitForSingleObject(
 177                         &Event,
 178                         Executive,
 179                         KernelMode,
 180                         FALSE,
 181                         NULL);
 182                 Status = IoStatus.Status;
 183         }
 184         if (!NT_SUCCESS(Status))
 185         {
 186                 WARN_(I8042PRT, "IoCallDriver() failed with status 0x%08lx\n", Status);
 187                 goto cleanup;
 188         }
 189
 190         if (FdoDeviceExtension->Type == Keyboard)
 191         {
 192                 PI8042_KEYBOARD_EXTENSION DeviceExtension;
 193
 194                 DeviceExtension = (PI8042_KEYBOARD_EXTENSION)FdoDeviceExtension;
 195                 /* Call the hooked initialization if it exists */
 196                 if (DeviceExtension->KeyboardHook.InitializationRoutine)
 197                 {
 198                         Status = DeviceExtension->KeyboardHook.InitializationRoutine(
 199                                 DeviceExtension->KeyboardHook.Context,
 200                                 PortDeviceExtension,
 201                                 i8042SynchReadPort,
 202                                 i8042SynchWritePortKbd,
 203                                 FALSE);
 204                         if (!NT_SUCCESS(Status))
 205                         {
 206                                 WARN_(I8042PRT, "KeyboardHook.InitializationRoutine() failed with status 0x%08lx\n", Status);
 207                                 WorkItemData->Irp->IoStatus.Status = Status;
 208                                 goto cleanup;
 209                         }
 210                 }
 211         }
 212
 213         WorkItemData->Irp->IoStatus.Status = STATUS_SUCCESS;
 214
 215 cleanup:
 216         if (TopOfStack != NULL)
 217                 ObDereferenceObject(TopOfStack);
 218         WorkItemData->Irp->IoStatus.Information = 0;
 219         IoCompleteRequest(WorkItemData->Irp, IO_NO_INCREMENT);
 220
 221         IoFreeWorkItem(WorkItemData->WorkItem);
 222         ExFreePoolWithTag(WorkItemData, I8042PRT_TAG);
 223 }
 224
 225 static VOID NTAPI
 226 i8042StartIo(
 227         IN PDEVICE_OBJECT DeviceObject,
 228         IN PIRP Irp)
 229 {
 230         PFDO_DEVICE_EXTENSION DeviceExtension;
 231
 232         DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 233         switch (DeviceExtension->Type)
 234         {
 235                 case Keyboard:
 236                         i8042KbdStartIo(DeviceObject, Irp);
 237                         break;
 238                 default:
 239                         ERR_(I8042PRT, "Unknown FDO type %u\n", DeviceExtension->Type);
 240                         ASSERT(FALSE);
 241                         break;
 242         }
 243 }
 244
 245 /* Write the current byte of the packet. Returns FALSE in case
 246  * of problems.
 247  */
 248 static BOOLEAN
 249 i8042PacketWrite(
 250         IN PPORT_DEVICE_EXTENSION DeviceExtension)
 251 {
 252         UCHAR Port = DeviceExtension->PacketPort;
 253
 254         if (Port)
 255         {
 256                 if (!i8042Write(DeviceExtension,
 257                                 DeviceExtension->ControlPort,
 258                                 Port))
 259                 {
 260                         /* something is really wrong! */
 261                         WARN_(I8042PRT, "Failed to send packet byte!\n");
 262                         return FALSE;
 263                 }
 264         }
 265
 266         return i8042Write(DeviceExtension,
 267                           DeviceExtension->DataPort,
 268                           DeviceExtension->Packet.Bytes[DeviceExtension->Packet.CurrentByte]);
 269 }
 270
 271 BOOLEAN
 272 i8042PacketIsr(
 273         IN PPORT_DEVICE_EXTENSION DeviceExtension,
 274         IN UCHAR Output)
 275 {
 276         if (DeviceExtension->Packet.State == Idle)
 277                 return FALSE;
 278
 279         switch (Output)
 280         {
 281                 case KBD_RESEND:
 282                         DeviceExtension->PacketResends++;
 283                         if (DeviceExtension->PacketResends > DeviceExtension->Settings.ResendIterations)
 284                         {
 285                                 DeviceExtension->Packet.State = Idle;
 286                                 DeviceExtension->PacketComplete = TRUE;
 287                                 DeviceExtension->PacketResult = STATUS_IO_TIMEOUT;
 288                                 DeviceExtension->PacketResends = 0;
 289                                 return TRUE;
 290                         }
 291                         DeviceExtension->Packet.CurrentByte--;
 292                         break;
 293
 294                 case KBD_NACK:
 295                         DeviceExtension->Packet.State = Idle;
 296                         DeviceExtension->PacketComplete = TRUE;
 297                         DeviceExtension->PacketResult = STATUS_UNEXPECTED_IO_ERROR;
 298                         DeviceExtension->PacketResends = 0;
 299                         return TRUE;
 300
 301                 default:
 302                         DeviceExtension->PacketResends = 0;
 303         }
 304
 305         if (DeviceExtension->Packet.CurrentByte >= DeviceExtension->Packet.ByteCount)
 306         {
 307                 DeviceExtension->Packet.State = Idle;
 308                 DeviceExtension->PacketComplete = TRUE;
 309                 DeviceExtension->PacketResult = STATUS_SUCCESS;
 310                 return TRUE;
 311         }
 312
 313         if (!i8042PacketWrite(DeviceExtension))
 314         {
 315                 DeviceExtension->Packet.State = Idle;
 316                 DeviceExtension->PacketComplete = TRUE;
 317                 DeviceExtension->PacketResult = STATUS_IO_TIMEOUT;
 318                 return TRUE;
 319         }
 320         DeviceExtension->Packet.CurrentByte++;
 321
 322         return TRUE;
 323 }
 324
 325 /*
 326  * This function starts a packet. It must be called with the
 327  * correct DIRQL.
 328  */
 329 NTSTATUS
 330 i8042StartPacket(
 331         IN PPORT_DEVICE_EXTENSION DeviceExtension,
 332         IN PFDO_DEVICE_EXTENSION FdoDeviceExtension,
 333         IN PUCHAR Bytes,
 334         IN ULONG ByteCount,
 335         IN PIRP Irp)
 336 {
 337         KIRQL Irql;
 338         NTSTATUS Status;
 339
 340         Irql = KeAcquireInterruptSpinLock(DeviceExtension->HighestDIRQLInterrupt);
 341
 342         if (DeviceExtension->Packet.State != Idle)
 343         {
 344                 Status = STATUS_DEVICE_BUSY;
 345                 goto done;
 346         }
 347
 348         switch (FdoDeviceExtension->Type)
 349         {
 350                 case Keyboard: DeviceExtension->PacketPort = 0; break;
 351                 case Mouse: DeviceExtension->PacketPort = CTRL_WRITE_MOUSE; break;
 352                 default:
 353                         ERR_(I8042PRT, "Unknown FDO type %u\n", FdoDeviceExtension->Type);
 354                         ASSERT(FALSE);
 355                         Status = STATUS_INTERNAL_ERROR;
 356                         goto done;
 357         }
 358
 359         DeviceExtension->Packet.Bytes = Bytes;
 360         DeviceExtension->Packet.CurrentByte = 0;
 361         DeviceExtension->Packet.ByteCount = ByteCount;
 362         DeviceExtension->Packet.State = SendingBytes;
 363         DeviceExtension->PacketResult = Status = STATUS_PENDING;
 364         DeviceExtension->CurrentIrp = Irp;
 365         DeviceExtension->CurrentIrpDevice = FdoDeviceExtension->Fdo;
 366
 367         if (!i8042PacketWrite(DeviceExtension))
 368         {
 369                 Status = STATUS_IO_TIMEOUT;
 370                 DeviceExtension->Packet.State = Idle;
 371                 DeviceExtension->PacketResult = STATUS_ABANDONED;
 372                 goto done;
 373         }
 374
 375         DeviceExtension->Packet.CurrentByte++;
 376
 377 done:
 378         KeReleaseInterruptSpinLock(DeviceExtension->HighestDIRQLInterrupt, Irql);
 379
 380         if (Status != STATUS_PENDING)
 381         {
 382                 DeviceExtension->CurrentIrp = NULL;
 383                 DeviceExtension->CurrentIrpDevice = NULL;
 384                 Irp->IoStatus.Status = Status;
 385                 IoCompleteRequest(Irp, IO_NO_INCREMENT);
 386         }
 387         return Status;
 388 }
 389
 390 static NTSTATUS NTAPI
 391 IrpStub(
 392         IN PDEVICE_OBJECT DeviceObject,
 393         IN PIRP Irp)
 394 {
 395         NTSTATUS Status = Irp->IoStatus.Status;
 396
 397         UNREFERENCED_PARAMETER(DeviceObject);
 398
 399         /* Do nothing */
 400         ASSERT(FALSE);
 401         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 402         return Status;
 403 }
 404
 405 static NTSTATUS NTAPI
 406 i8042DeviceControl(
 407         IN PDEVICE_OBJECT DeviceObject,
 408         IN PIRP Irp)
 409 {
 410         PFDO_DEVICE_EXTENSION DeviceExtension;
 411
 412         TRACE_(I8042PRT, "i8042DeviceControl(%p %p)\n", DeviceObject, Irp);
 413         DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 414
 415         switch (DeviceExtension->Type)
 416         {
 417                 case Keyboard:
 418                         return i8042KbdDeviceControl(DeviceObject, Irp);
 419                         break;
 420                 default:
 421                         return IrpStub(DeviceObject, Irp);
 422         }
 423 }
 424
 425 static NTSTATUS NTAPI
 426 i8042InternalDeviceControl(
 427         IN PDEVICE_OBJECT DeviceObject,
 428         IN PIRP Irp)
 429 {
 430         PFDO_DEVICE_EXTENSION DeviceExtension;
 431         ULONG ControlCode;
 432         NTSTATUS Status;
 433
 434         TRACE_(I8042PRT, "i8042InternalDeviceControl(%p %p)\n", DeviceObject, Irp);
 435         DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 436
 437         switch (DeviceExtension->Type)
 438         {
 439                 case Unknown:
 440                 {
 441                         ControlCode = IoGetCurrentIrpStackLocation(Irp)->Parameters.DeviceIoControl.IoControlCode;
 442                         switch (ControlCode)
 443                         {
 444                                 case IOCTL_INTERNAL_KEYBOARD_CONNECT:
 445                                         Status = i8042KbdInternalDeviceControl(DeviceObject, Irp);
 446                                         break;
 447                                 case IOCTL_INTERNAL_MOUSE_CONNECT:
 448                                         Status = i8042MouInternalDeviceControl(DeviceObject, Irp);
 449                                         break;
 450                                 default:
 451                                         ERR_(I8042PRT, "Unknown IO control code 0x%lx\n", ControlCode);
 452                                         ASSERT(FALSE);
 453                                         Status = STATUS_INVALID_DEVICE_REQUEST;
 454                                         break;
 455                         }
 456                         break;
 457                 }
 458                 case Keyboard:
 459                         Status = i8042KbdInternalDeviceControl(DeviceObject, Irp);
 460                         break;
 461                 case Mouse:
 462                         Status = i8042MouInternalDeviceControl(DeviceObject, Irp);
 463                         break;
 464                 default:
 465                         ERR_(I8042PRT, "Unknown FDO type %u\n", DeviceExtension->Type);
 466                         ASSERT(FALSE);
 467                         Status = STATUS_INTERNAL_ERROR;
 468                         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 469                         break;
 470         }
 471
 472         return Status;
 473 }
 474
 475 static NTSTATUS NTAPI
 476 i8042Power(
 477         IN PDEVICE_OBJECT DeviceObject,
 478         IN PIRP Irp)
 479 {
 480         PFDO_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
 481         PDEVICE_OBJECT LowerDevice = DeviceExtension->LowerDevice;
 482
 483         PoStartNextPowerIrp(Irp);
 484         IoSkipCurrentIrpStackLocation(Irp);
 485         return PoCallDriver(LowerDevice, Irp);
 486 }
 487
 488 static NTSTATUS NTAPI
 489 i8042SystemControl(
 490         IN PDEVICE_OBJECT DeviceObject,
 491         IN PIRP Irp)
 492 {
 493         return ForwardIrpAndForget(DeviceObject, Irp);
 494 }
 495
 496 NTSTATUS NTAPI
 497 DriverEntry(
 498         IN PDRIVER_OBJECT DriverObject,
 499         IN PUNICODE_STRING RegistryPath)
 500 {
 501         PI8042_DRIVER_EXTENSION DriverExtension;
 502         ULONG i;
 503         NTSTATUS Status;
 504
 505         /* ROS Hack: ideally, we shouldn't have to initialize debug level this way,
 506            but since the only way is to change it via KDBG, it's better to leave
 507            it here too. */
 508 #if 0
 509         DbgSetDebugFilterState(
 510                 DPFLTR_I8042PRT_ID,
 511                 (1 << DPFLTR_ERROR_LEVEL) | (1 << DPFLTR_WARNING_LEVEL) |
 512                 (1 << DPFLTR_TRACE_LEVEL) /*| (1 << DPFLTR_INFO_LEVEL)*/ | DPFLTR_MASK,
 513                 TRUE);
 514 #endif
 515
 516         Status = IoAllocateDriverObjectExtension(
 517                 DriverObject,
 518                 DriverObject,
 519                 sizeof(I8042_DRIVER_EXTENSION),
 520                 (PVOID*)&DriverExtension);
 521         if (!NT_SUCCESS(Status))
 522         {
 523                 WARN_(I8042PRT, "IoAllocateDriverObjectExtension() failed with status 0x%08lx\n", Status);
 524                 return Status;
 525         }
 526         RtlZeroMemory(DriverExtension, sizeof(I8042_DRIVER_EXTENSION));
 527         KeInitializeSpinLock(&DriverExtension->Port.SpinLock);
 528         InitializeListHead(&DriverExtension->DeviceListHead);
 529         KeInitializeSpinLock(&DriverExtension->DeviceListLock);
 530
 531         Status = DuplicateUnicodeString(
 532                 RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
 533                 RegistryPath,
 534                 &DriverExtension->RegistryPath);
 535         if (!NT_SUCCESS(Status))
 536         {
 537                 WARN_(I8042PRT, "DuplicateUnicodeString() failed with status 0x%08lx\n", Status);
 538                 return Status;
 539         }
 540
 541         Status = ReadRegistryEntries(RegistryPath, &DriverExtension->Port.Settings);
 542         if (!NT_SUCCESS(Status))
 543         {
 544                 WARN_(I8042PRT, "ReadRegistryEntries() failed with status 0x%08lx\n", Status);
 545                 return Status;
 546         }
 547
 548         DriverObject->DriverExtension->AddDevice = i8042AddDevice;
 549         DriverObject->DriverStartIo = i8042StartIo;
 550
 551         for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
 552                 DriverObject->MajorFunction[i] = IrpStub;
 553
 554         DriverObject->MajorFunction[IRP_MJ_CREATE]  = i8042Create;
 555         DriverObject->MajorFunction[IRP_MJ_CLEANUP] = i8042Cleanup;
 556         DriverObject->MajorFunction[IRP_MJ_CLOSE]   = i8042Close;
 557         DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = i8042DeviceControl;
 558         DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = i8042InternalDeviceControl;
 559         DriverObject->MajorFunction[IRP_MJ_POWER]   = i8042Power;
 560         DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = i8042SystemControl;
 561         DriverObject->MajorFunction[IRP_MJ_PNP]     = i8042Pnp;
 562
 563         return STATUS_SUCCESS;
 564 }