reactos/drivers/input/i8042prt/pnp.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/pnp.c
   5  * PURPOSE:     IRP_MJ_PNP operations
   6  * PROGRAMMERS: Copyright 2006-2007 Hervé Poussineau (hpoussin@reactos.org)
   7  *              Copyright 2008 Colin Finck (mail@colinfinck.de)
   8  */
   9
  10 /* INCLUDES ******************************************************************/
  11
  12 #include "i8042prt.h"
  13
  14 #include <debug.h>
  15
  16 /* FUNCTIONS *****************************************************************/
  17
  18 /* This is all pretty confusing. There's more than one way to
  19  * disable/enable the keyboard. You can send KBD_ENABLE to the
  20  * keyboard, and it will start scanning keys. Sending KBD_DISABLE
  21  * will disable the key scanning but also reset the parameters to
  22  * defaults.
  23  *
  24  * You can also send 0xAE to the controller for enabling the
  25  * keyboard clock line and 0xAD for disabling it. Then it'll
  26  * automatically get turned on at the next command. The last
  27  * way is by modifying the bit that drives the clock line in the
  28  * 'command byte' of the controller. This is almost, but not quite,
  29  * the same as the AE/AD thing. The difference can be used to detect
  30  * some really old broken keyboard controllers which I hope won't be
  31  * necessary.
  32  *
  33  * We change the command byte, sending KBD_ENABLE/DISABLE seems to confuse
  34  * some kvm switches.
  35  */
  36 BOOLEAN
  37 i8042ChangeMode(
  38     IN PPORT_DEVICE_EXTENSION DeviceExtension,
  39     IN UCHAR FlagsToDisable,
  40     IN UCHAR FlagsToEnable)
  41 {
  42     UCHAR Value;
  43     NTSTATUS Status;
  44
  45     if (!i8042Write(DeviceExtension, DeviceExtension->ControlPort, KBD_READ_MODE))
  46     {
  47         WARN_(I8042PRT, "Can't read i8042 mode\n");
  48         return FALSE;
  49     }
  50
  51     Status = i8042ReadDataWait(DeviceExtension, &Value);
  52     if (!NT_SUCCESS(Status))
  53     {
  54         WARN_(I8042PRT, "No response after read i8042 mode\n");
  55         return FALSE;
  56     }
  57
  58     Value &= ~FlagsToDisable;
  59     Value |= FlagsToEnable;
  60
  61     if (!i8042Write(DeviceExtension, DeviceExtension->ControlPort, KBD_WRITE_MODE))
  62     {
  63         WARN_(I8042PRT, "Can't set i8042 mode\n");
  64         return FALSE;
  65     }
  66
  67     if (!i8042Write(DeviceExtension, DeviceExtension->DataPort, Value))
  68     {
  69         WARN_(I8042PRT, "Can't send i8042 mode\n");
  70         return FALSE;
  71     }
  72
  73     return TRUE;
  74 }
  75
  76 static NTSTATUS
  77 i8042BasicDetect(
  78     IN PPORT_DEVICE_EXTENSION DeviceExtension)
  79 {
  80     NTSTATUS Status;
  81     ULONG ResendIterations;
  82     UCHAR Value = 0;
  83
  84     /* Don't enable keyboard and mouse interrupts, disable keyboard/mouse */
  85     i8042Flush(DeviceExtension);
  86     if (!i8042ChangeMode(DeviceExtension, CCB_KBD_INT_ENAB | CCB_MOUSE_INT_ENAB, CCB_KBD_DISAB | CCB_MOUSE_DISAB))
  87         return STATUS_IO_DEVICE_ERROR;
  88
  89     i8042Flush(DeviceExtension);
  90
  91     /* Issue a CTRL_SELF_TEST command to check if this is really an i8042 controller */
  92     ResendIterations = DeviceExtension->Settings.ResendIterations + 1;
  93     while (ResendIterations--)
  94     {
  95         if (!i8042Write(DeviceExtension, DeviceExtension->ControlPort, CTRL_SELF_TEST))
  96         {
  97             WARN_(I8042PRT, "Writing CTRL_SELF_TEST command failed\n");
  98             return STATUS_IO_TIMEOUT;
  99         }
 100
 101         Status = i8042ReadDataWait(DeviceExtension, &Value);
 102         if (!NT_SUCCESS(Status))
 103         {
 104             WARN_(I8042PRT, "Failed to read CTRL_SELF_TEST response, status 0x%08lx\n", Status);
 105             return Status;
 106         }
 107
 108         if (Value == KBD_SELF_TEST_OK)
 109         {
 110             INFO_(I8042PRT, "CTRL_SELF_TEST completed successfully!\n");
 111             break;
 112         }
 113         else if (Value == KBD_RESEND)
 114         {
 115             TRACE_(I8042PRT, "Resending...\n", Value);
 116             KeStallExecutionProcessor(50);
 117         }
 118         else
 119         {
 120             WARN_(I8042PRT, "Got 0x%02x instead of 0x55\n", Value);
 121             return STATUS_IO_DEVICE_ERROR;
 122         }
 123     }
 124
 125     return STATUS_SUCCESS;
 126 }
 127
 128 static VOID
 129 i8042DetectKeyboard(
 130     IN PPORT_DEVICE_EXTENSION DeviceExtension)
 131 {
 132     NTSTATUS Status;
 133
 134     /* Set LEDs (that is not fatal if some error occurs) */
 135     Status = i8042SynchWritePort(DeviceExtension, 0, KBD_CMD_SET_LEDS, TRUE);
 136     if (NT_SUCCESS(Status))
 137     {
 138         Status = i8042SynchWritePort(DeviceExtension, 0, 0, TRUE);
 139         if (!NT_SUCCESS(Status))
 140         {
 141             WARN_(I8042PRT, "Can't finish SET_LEDS (0x%08lx)\n", Status);
 142             return;
 143         }
 144     }
 145     else
 146     {
 147         WARN_(I8042PRT, "Warning: can't write SET_LEDS (0x%08lx)\n", Status);
 148     }
 149
 150     /* Turn on translation and SF (Some machines don't reboot if SF is not set, see ReactOS bug #1842) */
 151     if (!i8042ChangeMode(DeviceExtension, 0, CCB_TRANSLATE | CCB_SYSTEM_FLAG))
 152         return;
 153
 154     /*
 155      * We used to send a KBD_LINE_TEST (0xAB) command, but on at least HP
 156      * Pavilion notebooks the response to that command was incorrect.
 157      * So now we just assume that a keyboard is attached.
 158      */
 159     DeviceExtension->Flags |= KEYBOARD_PRESENT;
 160
 161     INFO_(I8042PRT, "Keyboard detected\n");
 162 }
 163
 164 static VOID
 165 i8042DetectMouse(
 166     IN PPORT_DEVICE_EXTENSION DeviceExtension)
 167 {
 168     NTSTATUS Status;
 169     UCHAR Value;
 170     UCHAR ExpectedReply[] = { MOUSE_ACK, 0xAA };
 171     UCHAR ReplyByte;
 172
 173     /* First do a mouse line test */
 174     if (i8042Write(DeviceExtension, DeviceExtension->ControlPort, MOUSE_LINE_TEST))
 175     {
 176         Status = i8042ReadDataWait(DeviceExtension, &Value);
 177
 178         if (!NT_SUCCESS(Status) || Value != 0)
 179         {
 180             WARN_(I8042PRT, "Mouse line test failed\n");
 181             goto failure;
 182         }
 183     }
 184
 185     /* Now reset the mouse */
 186     i8042Flush(DeviceExtension);
 187
 188     if(!i8042IsrWritePort(DeviceExtension, MOU_CMD_RESET, CTRL_WRITE_MOUSE))
 189     {
 190         WARN_(I8042PRT, "Failed to write reset command to mouse\n");
 191         goto failure;
 192     }
 193
 194     /* The implementation of the "Mouse Reset" command differs much from chip to chip.
 195
 196        By default, the first byte is an ACK, when the mouse is plugged in and working and NACK when it's not.
 197        On success, the next bytes are 0xAA and 0x00.
 198
 199        But on some systems (like ECS K7S5A Pro, SiS 735 chipset), we always get an ACK and 0xAA.
 200        Only the last byte indicates, whether a mouse is plugged in.
 201        It is either sent or not, so there is no byte, which indicates a failure here.
 202
 203        After the Mouse Reset command was issued, it usually takes some time until we get a response.
 204        So get the first two bytes in a loop. */
 205     for (ReplyByte = 0;
 206          ReplyByte < sizeof(ExpectedReply) / sizeof(ExpectedReply[0]);
 207          ReplyByte++)
 208     {
 209         ULONG Counter = 500;
 210
 211         do
 212         {
 213             Status = i8042ReadDataWait(DeviceExtension, &Value);
 214
 215             if(!NT_SUCCESS(Status))
 216             {
 217                 /* Wait some time before trying again */
 218                 KeStallExecutionProcessor(50);
 219             }
 220         } while (Status == STATUS_IO_TIMEOUT && Counter--);
 221
 222         if (!NT_SUCCESS(Status))
 223         {
 224             WARN_(I8042PRT, "No ACK after mouse reset, status 0x%08lx\n", Status);
 225             goto failure;
 226         }
 227         else if (Value != ExpectedReply[ReplyByte])
 228         {
 229             WARN_(I8042PRT, "Unexpected reply: 0x%02x (expected 0x%02x)\n", Value, ExpectedReply[ReplyByte]);
 230             goto failure;
 231         }
 232     }
 233
 234     /* Finally get the third byte, but only try it one time (see above).
 235        Otherwise this takes around 45 seconds on a K7S5A Pro, when no mouse is plugged in. */
 236     Status = i8042ReadDataWait(DeviceExtension, &Value);
 237
 238     if(!NT_SUCCESS(Status))
 239     {
 240         WARN_(I8042PRT, "Last byte was not transmitted after mouse reset, status 0x%08lx\n", Status);
 241         goto failure;
 242     }
 243     else if(Value != 0x00)
 244     {
 245         WARN_(I8042PRT, "Last byte after mouse reset was not 0x00, but 0x%02x\n", Value);
 246         goto failure;
 247     }
 248
 249     DeviceExtension->Flags |= MOUSE_PRESENT;
 250     INFO_(I8042PRT, "Mouse detected\n");
 251     return;
 252
 253 failure:
 254     /* There is probably no mouse present. On some systems,
 255        the probe locks the entire keyboard controller. Let's
 256        try to get access to the keyboard again by sending a
 257        reset */
 258     i8042Flush(DeviceExtension);
 259     i8042Write(DeviceExtension, DeviceExtension->ControlPort, CTRL_SELF_TEST);
 260     i8042ReadDataWait(DeviceExtension, &Value);
 261     i8042Flush(DeviceExtension);
 262
 263     INFO_(I8042PRT, "Mouse not detected\n");
 264 }
 265
 266 static NTSTATUS
 267 i8042ConnectKeyboardInterrupt(
 268     IN PI8042_KEYBOARD_EXTENSION DeviceExtension)
 269 {
 270     PPORT_DEVICE_EXTENSION PortDeviceExtension;
 271     KIRQL DirqlMax;
 272     NTSTATUS Status;
 273
 274     TRACE_(I8042PRT, "i8042ConnectKeyboardInterrupt()\n");
 275
 276     PortDeviceExtension = DeviceExtension->Common.PortDeviceExtension;
 277     DirqlMax = MAX(
 278         PortDeviceExtension->KeyboardInterrupt.Dirql,
 279         PortDeviceExtension->MouseInterrupt.Dirql);
 280
 281     INFO_(I8042PRT, "KeyboardInterrupt.Vector         %lu\n",
 282         PortDeviceExtension->KeyboardInterrupt.Vector);
 283     INFO_(I8042PRT, "KeyboardInterrupt.Dirql          %lu\n",
 284         PortDeviceExtension->KeyboardInterrupt.Dirql);
 285     INFO_(I8042PRT, "KeyboardInterrupt.DirqlMax       %lu\n",
 286         DirqlMax);
 287     INFO_(I8042PRT, "KeyboardInterrupt.InterruptMode  %s\n",
 288         PortDeviceExtension->KeyboardInterrupt.InterruptMode == LevelSensitive ? "LevelSensitive" : "Latched");
 289     INFO_(I8042PRT, "KeyboardInterrupt.ShareInterrupt %s\n",
 290         PortDeviceExtension->KeyboardInterrupt.ShareInterrupt ? "yes" : "no");
 291     INFO_(I8042PRT, "KeyboardInterrupt.Affinity       0x%lx\n",
 292         PortDeviceExtension->KeyboardInterrupt.Affinity);
 293     Status = IoConnectInterrupt(
 294         &PortDeviceExtension->KeyboardInterrupt.Object,
 295         i8042KbdInterruptService,
 296         DeviceExtension, &PortDeviceExtension->SpinLock,
 297         PortDeviceExtension->KeyboardInterrupt.Vector, PortDeviceExtension->KeyboardInterrupt.Dirql, DirqlMax,
 298         PortDeviceExtension->KeyboardInterrupt.InterruptMode, PortDeviceExtension->KeyboardInterrupt.ShareInterrupt,
 299         PortDeviceExtension->KeyboardInterrupt.Affinity, FALSE);
 300     if (!NT_SUCCESS(Status))
 301     {
 302         WARN_(I8042PRT, "IoConnectInterrupt() failed with status 0x%08x\n", Status);
 303         return Status;
 304     }
 305
 306     if (DirqlMax == PortDeviceExtension->KeyboardInterrupt.Dirql)
 307         PortDeviceExtension->HighestDIRQLInterrupt = PortDeviceExtension->KeyboardInterrupt.Object;
 308     PortDeviceExtension->Flags |= KEYBOARD_INITIALIZED;
 309     return STATUS_SUCCESS;
 310 }
 311
 312 static NTSTATUS
 313 i8042ConnectMouseInterrupt(
 314     IN PI8042_MOUSE_EXTENSION DeviceExtension)
 315 {
 316     PPORT_DEVICE_EXTENSION PortDeviceExtension;
 317     KIRQL DirqlMax;
 318     NTSTATUS Status;
 319
 320     TRACE_(I8042PRT, "i8042ConnectMouseInterrupt()\n");
 321
 322     Status = i8042MouInitialize(DeviceExtension);
 323     if (!NT_SUCCESS(Status))
 324         return Status;
 325
 326     PortDeviceExtension = DeviceExtension->Common.PortDeviceExtension;
 327     DirqlMax = MAX(
 328         PortDeviceExtension->KeyboardInterrupt.Dirql,
 329         PortDeviceExtension->MouseInterrupt.Dirql);
 330
 331     INFO_(I8042PRT, "MouseInterrupt.Vector         %lu\n",
 332         PortDeviceExtension->MouseInterrupt.Vector);
 333     INFO_(I8042PRT, "MouseInterrupt.Dirql          %lu\n",
 334         PortDeviceExtension->MouseInterrupt.Dirql);
 335     INFO_(I8042PRT, "MouseInterrupt.DirqlMax       %lu\n",
 336         DirqlMax);
 337     INFO_(I8042PRT, "MouseInterrupt.InterruptMode  %s\n",
 338         PortDeviceExtension->MouseInterrupt.InterruptMode == LevelSensitive ? "LevelSensitive" : "Latched");
 339     INFO_(I8042PRT, "MouseInterrupt.ShareInterrupt %s\n",
 340         PortDeviceExtension->MouseInterrupt.ShareInterrupt ? "yes" : "no");
 341     INFO_(I8042PRT, "MouseInterrupt.Affinity       0x%lx\n",
 342         PortDeviceExtension->MouseInterrupt.Affinity);
 343     Status = IoConnectInterrupt(
 344         &PortDeviceExtension->MouseInterrupt.Object,
 345         i8042MouInterruptService,
 346         DeviceExtension, &PortDeviceExtension->SpinLock,
 347         PortDeviceExtension->MouseInterrupt.Vector, PortDeviceExtension->MouseInterrupt.Dirql, DirqlMax,
 348         PortDeviceExtension->MouseInterrupt.InterruptMode, PortDeviceExtension->MouseInterrupt.ShareInterrupt,
 349         PortDeviceExtension->MouseInterrupt.Affinity, FALSE);
 350     if (!NT_SUCCESS(Status))
 351     {
 352         WARN_(I8042PRT, "IoConnectInterrupt() failed with status 0x%08x\n", Status);
 353         goto cleanup;
 354     }
 355
 356     if (DirqlMax == PortDeviceExtension->MouseInterrupt.Dirql)
 357         PortDeviceExtension->HighestDIRQLInterrupt = PortDeviceExtension->MouseInterrupt.Object;
 358
 359     PortDeviceExtension->Flags |= MOUSE_INITIALIZED;
 360     Status = STATUS_SUCCESS;
 361
 362 cleanup:
 363     if (!NT_SUCCESS(Status))
 364     {
 365         PortDeviceExtension->Flags &= ~MOUSE_INITIALIZED;
 366         if (PortDeviceExtension->MouseInterrupt.Object)
 367         {
 368             IoDisconnectInterrupt(PortDeviceExtension->MouseInterrupt.Object);
 369             PortDeviceExtension->HighestDIRQLInterrupt = PortDeviceExtension->KeyboardInterrupt.Object;
 370         }
 371     }
 372     return Status;
 373 }
 374
 375 static NTSTATUS
 376 EnableInterrupts(
 377     IN PPORT_DEVICE_EXTENSION DeviceExtension,
 378     IN UCHAR FlagsToDisable,
 379     IN UCHAR FlagsToEnable)
 380 {
 381     i8042Flush(DeviceExtension);
 382
 383     if (!i8042ChangeMode(DeviceExtension, FlagsToDisable, FlagsToEnable))
 384         return STATUS_UNSUCCESSFUL;
 385
 386     return STATUS_SUCCESS;
 387 }
 388
 389 static NTSTATUS
 390 StartProcedure(
 391     IN PPORT_DEVICE_EXTENSION DeviceExtension)
 392 {
 393     NTSTATUS Status;
 394     UCHAR FlagsToDisable = 0;
 395     UCHAR FlagsToEnable = 0;
 396     KIRQL Irql;
 397
 398     if (DeviceExtension->DataPort == 0)
 399     {
 400         /* Unable to do something at the moment */
 401         return STATUS_SUCCESS;
 402     }
 403
 404     if (!(DeviceExtension->Flags & (KEYBOARD_PRESENT | MOUSE_PRESENT)))
 405     {
 406         /* Try to detect them */
 407         TRACE_(I8042PRT, "Check if the controller is really a i8042\n");
 408         Status = i8042BasicDetect(DeviceExtension);
 409         if (!NT_SUCCESS(Status))
 410         {
 411             WARN_(I8042PRT, "i8042BasicDetect() failed with status 0x%08lx\n", Status);
 412             return STATUS_UNSUCCESSFUL;
 413         }
 414
 415         /* First detect the mouse and then the keyboard!
 416            If we do it the other way round, some systems throw away settings like the keyboard translation, when detecting the mouse. */
 417         TRACE_(I8042PRT, "Detecting mouse\n");
 418         i8042DetectMouse(DeviceExtension);
 419         TRACE_(I8042PRT, "Detecting keyboard\n");
 420         i8042DetectKeyboard(DeviceExtension);
 421
 422         INFO_(I8042PRT, "Keyboard present: %s\n", DeviceExtension->Flags & KEYBOARD_PRESENT ? "YES" : "NO");
 423         INFO_(I8042PRT, "Mouse present   : %s\n", DeviceExtension->Flags & MOUSE_PRESENT ? "YES" : "NO");
 424
 425         TRACE_(I8042PRT, "Enabling i8042 interrupts\n");
 426         if (DeviceExtension->Flags & KEYBOARD_PRESENT)
 427         {
 428             FlagsToDisable |= CCB_KBD_DISAB;
 429             FlagsToEnable |= CCB_KBD_INT_ENAB;
 430         }
 431         if (DeviceExtension->Flags & MOUSE_PRESENT)
 432         {
 433             FlagsToDisable |= CCB_MOUSE_DISAB;
 434             FlagsToEnable |= CCB_MOUSE_INT_ENAB;
 435         }
 436
 437         Status = EnableInterrupts(DeviceExtension, FlagsToDisable, FlagsToEnable);
 438         if (!NT_SUCCESS(Status))
 439         {
 440             DeviceExtension->Flags &= ~(KEYBOARD_PRESENT | MOUSE_PRESENT);
 441             return Status;
 442         }
 443     }
 444
 445     /* Connect interrupts */
 446     if (DeviceExtension->Flags & KEYBOARD_PRESENT &&
 447         DeviceExtension->Flags & KEYBOARD_CONNECTED &&
 448         DeviceExtension->Flags & KEYBOARD_STARTED &&
 449         !(DeviceExtension->Flags & KEYBOARD_INITIALIZED))
 450     {
 451         /* Keyboard is ready to be initialized */
 452         Status = i8042ConnectKeyboardInterrupt(DeviceExtension->KeyboardExtension);
 453         if (NT_SUCCESS(Status))
 454         {
 455             DeviceExtension->Flags |= KEYBOARD_INITIALIZED;
 456         }
 457     }
 458
 459     if (DeviceExtension->Flags & MOUSE_PRESENT &&
 460         DeviceExtension->Flags & MOUSE_CONNECTED &&
 461         DeviceExtension->Flags & MOUSE_STARTED &&
 462         !(DeviceExtension->Flags & MOUSE_INITIALIZED))
 463     {
 464         /* Mouse is ready to be initialized */
 465         Status = i8042ConnectMouseInterrupt(DeviceExtension->MouseExtension);
 466         if (NT_SUCCESS(Status))
 467         {
 468             DeviceExtension->Flags |= MOUSE_INITIALIZED;
 469         }
 470
 471         /* Start the mouse */
 472         Irql = KeAcquireInterruptSpinLock(DeviceExtension->HighestDIRQLInterrupt);
 473         i8042IsrWritePort(DeviceExtension, MOU_CMD_RESET, CTRL_WRITE_MOUSE);
 474         KeReleaseInterruptSpinLock(DeviceExtension->HighestDIRQLInterrupt, Irql);
 475     }
 476
 477     return Status;
 478 }
 479
 480 static NTSTATUS
 481 i8042PnpStartDevice(
 482     IN PDEVICE_OBJECT DeviceObject,
 483     IN PCM_RESOURCE_LIST AllocatedResources,
 484     IN PCM_RESOURCE_LIST AllocatedResourcesTranslated)
 485 {
 486     PFDO_DEVICE_EXTENSION DeviceExtension;
 487     PPORT_DEVICE_EXTENSION PortDeviceExtension;
 488     PCM_PARTIAL_RESOURCE_DESCRIPTOR ResourceDescriptor, ResourceDescriptorTranslated;
 489     INTERRUPT_DATA InterruptData;
 490     BOOLEAN FoundDataPort = FALSE;
 491     BOOLEAN FoundControlPort = FALSE;
 492     BOOLEAN FoundIrq = FALSE;
 493     ULONG i;
 494     NTSTATUS Status;
 495
 496     TRACE_(I8042PRT, "i8042PnpStartDevice(%p)\n", DeviceObject);
 497     DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 498     PortDeviceExtension = DeviceExtension->PortDeviceExtension;
 499
 500     ASSERT(DeviceExtension->PnpState == dsStopped);
 501
 502     if (!AllocatedResources)
 503     {
 504         WARN_(I8042PRT, "No allocated resources sent to driver\n");
 505         return STATUS_INSUFFICIENT_RESOURCES;
 506     }
 507     if (AllocatedResources->Count != 1)
 508     {
 509         WARN_(I8042PRT, "Wrong number of allocated resources sent to driver\n");
 510         return STATUS_INSUFFICIENT_RESOURCES;
 511     }
 512     if (AllocatedResources->List[0].PartialResourceList.Version != 1
 513      || AllocatedResources->List[0].PartialResourceList.Revision != 1
 514      || AllocatedResourcesTranslated->List[0].PartialResourceList.Version != 1
 515      || AllocatedResourcesTranslated->List[0].PartialResourceList.Revision != 1)
 516     {
 517         WARN_(I8042PRT, "Revision mismatch: %u.%u != 1.1 or %u.%u != 1.1\n",
 518             AllocatedResources->List[0].PartialResourceList.Version,
 519             AllocatedResources->List[0].PartialResourceList.Revision,
 520             AllocatedResourcesTranslated->List[0].PartialResourceList.Version,
 521             AllocatedResourcesTranslated->List[0].PartialResourceList.Revision);
 522         return STATUS_REVISION_MISMATCH;
 523     }
 524
 525     /* Get Irq and optionally control port and data port */
 526     for (i = 0; i < AllocatedResources->List[0].PartialResourceList.Count; i++)
 527     {
 528         ResourceDescriptor = &AllocatedResources->List[0].PartialResourceList.PartialDescriptors[i];
 529         ResourceDescriptorTranslated = &AllocatedResourcesTranslated->List[0].PartialResourceList.PartialDescriptors[i];
 530         switch (ResourceDescriptor->Type)
 531         {
 532             case CmResourceTypePort:
 533             {
 534                 if (ResourceDescriptor->u.Port.Length == 1)
 535                 {
 536                     /* We assume that the first ressource will
 537                      * be the control port and the second one
 538                      * will be the data port...
 539                      */
 540                     if (!FoundDataPort)
 541                     {
 542                         PortDeviceExtension->DataPort = ULongToPtr(ResourceDescriptor->u.Port.Start.u.LowPart);
 543                         INFO_(I8042PRT, "Found data port: %p\n", PortDeviceExtension->DataPort);
 544                         FoundDataPort = TRUE;
 545                     }
 546                     else if (!FoundControlPort)
 547                     {
 548                         PortDeviceExtension->ControlPort = ULongToPtr(ResourceDescriptor->u.Port.Start.u.LowPart);
 549                         INFO_(I8042PRT, "Found control port: %p\n", PortDeviceExtension->ControlPort);
 550                         FoundControlPort = TRUE;
 551                     }
 552                     else
 553                     {
 554                         WARN_(I8042PRT, "Too much I/O ranges provided: 0x%lx\n", ResourceDescriptor->u.Port.Length);
 555                         return STATUS_INVALID_PARAMETER;
 556                     }
 557                 }
 558                 else
 559                     WARN_(I8042PRT, "Invalid I/O range length: 0x%lx\n", ResourceDescriptor->u.Port.Length);
 560                 break;
 561             }
 562             case CmResourceTypeInterrupt:
 563             {
 564                 if (FoundIrq)
 565                     return STATUS_INVALID_PARAMETER;
 566                 InterruptData.Dirql = (KIRQL)ResourceDescriptorTranslated->u.Interrupt.Level;
 567                 InterruptData.Vector = ResourceDescriptorTranslated->u.Interrupt.Vector;
 568                 InterruptData.Affinity = ResourceDescriptorTranslated->u.Interrupt.Affinity;
 569                 if (ResourceDescriptorTranslated->Flags & CM_RESOURCE_INTERRUPT_LATCHED)
 570                     InterruptData.InterruptMode = Latched;
 571                 else
 572                     InterruptData.InterruptMode = LevelSensitive;
 573                 InterruptData.ShareInterrupt = (ResourceDescriptorTranslated->ShareDisposition == CmResourceShareShared);
 574                 INFO_(I8042PRT, "Found irq resource: %lu\n", ResourceDescriptor->u.Interrupt.Level);
 575                 FoundIrq = TRUE;
 576                 break;
 577             }
 578             default:
 579                 WARN_(I8042PRT, "Unknown resource descriptor type 0x%x\n", ResourceDescriptor->Type);
 580         }
 581     }
 582
 583     if (!FoundIrq)
 584     {
 585         WARN_(I8042PRT, "Interrupt resource was not found in allocated resources list\n");
 586         return STATUS_INSUFFICIENT_RESOURCES;
 587     }
 588     else if (DeviceExtension->Type == Keyboard && (!FoundDataPort || !FoundControlPort))
 589     {
 590         WARN_(I8042PRT, "Some required resources were not found in allocated resources list\n");
 591         return STATUS_INSUFFICIENT_RESOURCES;
 592     }
 593     else if (DeviceExtension->Type == Mouse && (FoundDataPort || FoundControlPort))
 594     {
 595         WARN_(I8042PRT, "Too much resources were provided in allocated resources list\n");
 596         return STATUS_INVALID_PARAMETER;
 597     }
 598
 599     switch (DeviceExtension->Type)
 600     {
 601         case Keyboard:
 602         {
 603             RtlCopyMemory(
 604                 &PortDeviceExtension->KeyboardInterrupt,
 605                 &InterruptData,
 606                 sizeof(INTERRUPT_DATA));
 607             PortDeviceExtension->Flags |= KEYBOARD_STARTED;
 608             Status = StartProcedure(PortDeviceExtension);
 609             break;
 610         }
 611         case Mouse:
 612         {
 613             RtlCopyMemory(
 614                 &PortDeviceExtension->MouseInterrupt,
 615                 &InterruptData,
 616                 sizeof(INTERRUPT_DATA));
 617             PortDeviceExtension->Flags |= MOUSE_STARTED;
 618             Status = StartProcedure(PortDeviceExtension);
 619             break;
 620         }
 621         default:
 622         {
 623             WARN_(I8042PRT, "Unknown FDO type %u\n", DeviceExtension->Type);
 624             ASSERT(!(PortDeviceExtension->Flags & KEYBOARD_CONNECTED) || !(PortDeviceExtension->Flags & MOUSE_CONNECTED));
 625             Status = STATUS_INVALID_DEVICE_REQUEST;
 626         }
 627     }
 628
 629     if (NT_SUCCESS(Status))
 630         DeviceExtension->PnpState = dsStarted;
 631
 632     return Status;
 633 }
 634
 635 NTSTATUS NTAPI
 636 i8042Pnp(
 637     IN PDEVICE_OBJECT DeviceObject,
 638     IN PIRP Irp)
 639 {
 640     PIO_STACK_LOCATION Stack;
 641     ULONG MinorFunction;
 642     I8042_DEVICE_TYPE DeviceType;
 643     ULONG_PTR Information = 0;
 644     NTSTATUS Status;
 645
 646     Stack = IoGetCurrentIrpStackLocation(Irp);
 647     MinorFunction = Stack->MinorFunction;
 648     DeviceType = ((PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->Type;
 649
 650     switch (MinorFunction)
 651     {
 652         case IRP_MN_START_DEVICE: /* 0x00 */
 653         {
 654             TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
 655
 656             /* Call lower driver (if any) */
 657             if (DeviceType != PhysicalDeviceObject)
 658             {
 659                 Status = ForwardIrpAndWait(DeviceObject, Irp);
 660                 if (NT_SUCCESS(Status))
 661                     Status = i8042PnpStartDevice(
 662                         DeviceObject,
 663                         Stack->Parameters.StartDevice.AllocatedResources,
 664                         Stack->Parameters.StartDevice.AllocatedResourcesTranslated);
 665             }
 666             else
 667                 Status = STATUS_SUCCESS;
 668             break;
 669         }
 670         case IRP_MN_QUERY_DEVICE_RELATIONS: /* (optional) 0x07 */
 671         {
 672             switch (Stack->Parameters.QueryDeviceRelations.Type)
 673             {
 674                 case BusRelations:
 675                 {
 676                     PDEVICE_RELATIONS DeviceRelations;
 677
 678                     TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / BusRelations\n");
 679                     DeviceRelations = ExAllocatePool(PagedPool, sizeof(DEVICE_RELATIONS));
 680                     if (DeviceRelations)
 681                     {
 682                         DeviceRelations->Count = 0;
 683                         Information = (ULONG_PTR)DeviceRelations;
 684                         Status = STATUS_SUCCESS;
 685                     }
 686                     else
 687                         Status = STATUS_INSUFFICIENT_RESOURCES;
 688                     break;
 689                 }
 690                 case RemovalRelations:
 691                 {
 692                     TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / RemovalRelations\n");
 693                     return ForwardIrpAndForget(DeviceObject, Irp);
 694                 }
 695                 default:
 696                     ERR_(I8042PRT, "IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / Unknown type 0x%lx\n",
 697                         Stack->Parameters.QueryDeviceRelations.Type);
 698                     ASSERT(FALSE);
 699                     return ForwardIrpAndForget(DeviceObject, Irp);
 700             }
 701             break;
 702         }
 703         case IRP_MN_FILTER_RESOURCE_REQUIREMENTS: /* (optional) 0x0d */
 704         {
 705             TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
 706             /* Nothing to do */
 707             Status = Irp->IoStatus.Status;
 708             break;
 709         }
 710         case IRP_MN_QUERY_PNP_DEVICE_STATE: /* 0x14 */
 711         {
 712             TRACE_(I8042PRT, "IRP_MJ_PNP / IRP_MN_QUERY_PNP_DEVICE_STATE\n");
 713             /* Nothing much to tell */
 714             Information = 0;
 715             Status = STATUS_SUCCESS;
 716             break;
 717         }
 718         default:
 719         {
 720             ERR_(I8042PRT, "IRP_MJ_PNP / unknown minor function 0x%x\n", MinorFunction);
 721             return ForwardIrpAndForget(DeviceObject, Irp);
 722         }
 723     }
 724
 725     Irp->IoStatus.Information = Information;
 726     Irp->IoStatus.Status = Status;
 727     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 728     return Status;
 729 }